From fd3a1ffc21027f8c37745fa92780befb0b0abcd5 Mon Sep 17 00:00:00 2001
From: morris <maoshengrong@espressif.com>
Date: Sat, 28 May 2022 17:02:07 +0800
Subject: [PATCH 1/8] mcpwm: deprecate legacy driver

---
 components/driver/Kconfig                     |  14 +
 .../{include => deprecated}/driver/mcpwm.h    | 292 +----------------
 .../deprecated/driver/mcpwm_types_legacy.h    | 307 ++++++++++++++++++
 .../{mcpwm.c => deprecated/mcpwm_legacy.c}    |  37 ++-
 .../legacy_mcpwm_driver/CMakeLists.txt        |   5 +
 .../test_apps/legacy_mcpwm_driver/README.md   |   2 +
 .../legacy_mcpwm_driver/main/CMakeLists.txt   |   7 +
 .../legacy_mcpwm_driver/main/test_app_main.c  |  40 +++
 .../main/test_legacy_mcpwm.c}                 |   3 -
 .../pytest_legacy_mcpwm.py                    |  21 ++
 .../legacy_mcpwm_driver/sdkconfig.ci.release  |   5 +
 .../legacy_mcpwm_driver/sdkconfig.defaults    |   3 +
 12 files changed, 436 insertions(+), 300 deletions(-)
 rename components/driver/{include => deprecated}/driver/mcpwm.h (59%)
 create mode 100644 components/driver/deprecated/driver/mcpwm_types_legacy.h
 rename components/driver/{mcpwm.c => deprecated/mcpwm_legacy.c} (97%)
 create mode 100644 components/driver/test_apps/legacy_mcpwm_driver/CMakeLists.txt
 create mode 100644 components/driver/test_apps/legacy_mcpwm_driver/README.md
 create mode 100644 components/driver/test_apps/legacy_mcpwm_driver/main/CMakeLists.txt
 create mode 100644 components/driver/test_apps/legacy_mcpwm_driver/main/test_app_main.c
 rename components/driver/{test/test_pwm.c => test_apps/legacy_mcpwm_driver/main/test_legacy_mcpwm.c} (99%)
 create mode 100644 components/driver/test_apps/legacy_mcpwm_driver/pytest_legacy_mcpwm.py
 create mode 100644 components/driver/test_apps/legacy_mcpwm_driver/sdkconfig.ci.release
 create mode 100644 components/driver/test_apps/legacy_mcpwm_driver/sdkconfig.defaults

diff --git a/components/driver/Kconfig b/components/driver/Kconfig
index bb46a084f6..8def437f13 100644
--- a/components/driver/Kconfig
+++ b/components/driver/Kconfig
@@ -352,6 +352,20 @@ menu "Driver Configurations"
                 cache misses, and also be able to run whilst the cache is disabled.
                 (e.g. SPI Flash write)
 
+        config MCPWM_SUPPRESS_DEPRECATE_WARN
+            bool "Suppress leagcy driver deprecated warning"
+            default n
+            help
+                Wether to suppress the deprecation warnings when using legacy MCPWM driver (driver/mcpwm.h).
+                If you want to continue using the legacy driver, and don't want to see related deprecation warnings,
+                you can enable this option.
+
+        config MCPWM_ENABLE_DEBUG_LOG
+            bool "Enable debug log"
+            default n
+            help
+                Wether to enable the debug log message for MCPWM driver.
+                Note that, this option only controls the MCPWM driver log, won't affect other drivers.
     endmenu # MCPWM Configuration
 
     menu "I2S Configuration"
diff --git a/components/driver/include/driver/mcpwm.h b/components/driver/deprecated/driver/mcpwm.h
similarity index 59%
rename from components/driver/include/driver/mcpwm.h
rename to components/driver/deprecated/driver/mcpwm.h
index 08f4adc8b1..e8ff38778f 100644
--- a/components/driver/include/driver/mcpwm.h
+++ b/components/driver/deprecated/driver/mcpwm.h
@@ -9,298 +9,16 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include "esp_err.h"
-#include "esp_bit_defs.h"
-#include "esp_intr_alloc.h"
-#include "soc/soc_caps.h"
-#include "hal/mcpwm_types.h"
+#include "driver/mcpwm_types_legacy.h"
+
+#if !CONFIG_MCPWM_SUPPRESS_DEPRECATE_WARN
+#warning "legacy MCPWM driver is deprecated, please migrate to the new driver (include driver/mcpwm_prelude.h)"
+#endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/**
- * @brief IO signals for the MCPWM
- *
- *        - 6 MCPWM output pins that generate PWM signals
- *        - 3 MCPWM fault input pins to detect faults like overcurrent, overvoltage, etc.
- *        - 3 MCPWM sync input pins to synchronize MCPWM outputs signals
- *        - 3 MCPWM capture input pins to gather feedback from controlled motors, using e.g. hall sensors
- */
-typedef enum {
-    MCPWM0A = 0,        /*!<PWM0A output pin*/
-    MCPWM0B,            /*!<PWM0B output pin*/
-    MCPWM1A,            /*!<PWM1A output pin*/
-    MCPWM1B,            /*!<PWM1B output pin*/
-    MCPWM2A,            /*!<PWM2A output pin*/
-    MCPWM2B,            /*!<PWM2B output pin*/
-    MCPWM_SYNC_0,       /*!<SYNC0  input pin*/
-    MCPWM_SYNC_1,       /*!<SYNC1  input pin*/
-    MCPWM_SYNC_2,       /*!<SYNC2  input pin*/
-    MCPWM_FAULT_0,      /*!<FAULT0 input pin*/
-    MCPWM_FAULT_1,      /*!<FAULT1 input pin*/
-    MCPWM_FAULT_2,      /*!<FAULT2 input pin*/
-    MCPWM_CAP_0 = 84,   /*!<CAP0   input pin*/
-    MCPWM_CAP_1,        /*!<CAP1   input pin*/
-    MCPWM_CAP_2,        /*!<CAP2   input pin*/
-} mcpwm_io_signals_t;
-
-/**
- * @brief pin number for MCPWM
- */
-typedef struct {
-    int mcpwm0a_out_num;       /*!<MCPWM0A out pin*/
-    int mcpwm0b_out_num;       /*!<MCPWM0A out pin*/
-    int mcpwm1a_out_num;       /*!<MCPWM0A out pin*/
-    int mcpwm1b_out_num;       /*!<MCPWM0A out pin*/
-    int mcpwm2a_out_num;       /*!<MCPWM0A out pin*/
-    int mcpwm2b_out_num;       /*!<MCPWM0A out pin*/
-    int mcpwm_sync0_in_num;    /*!<SYNC0  in pin*/
-    int mcpwm_sync1_in_num;    /*!<SYNC1  in pin*/
-    int mcpwm_sync2_in_num;    /*!<SYNC2  in pin*/
-    int mcpwm_fault0_in_num;   /*!<FAULT0 in pin*/
-    int mcpwm_fault1_in_num;   /*!<FAULT1 in pin*/
-    int mcpwm_fault2_in_num;   /*!<FAULT2 in pin*/
-    int mcpwm_cap0_in_num;     /*!<CAP0   in pin*/
-    int mcpwm_cap1_in_num;     /*!<CAP1   in pin*/
-    int mcpwm_cap2_in_num;     /*!<CAP2   in pin*/
-} mcpwm_pin_config_t;
-
-/**
- * @brief Select MCPWM unit
- */
-typedef enum {
-    MCPWM_UNIT_0,   /*!<MCPWM unit0 selected*/
-    MCPWM_UNIT_1,   /*!<MCPWM unit1 selected*/
-    MCPWM_UNIT_MAX, /*!<Max number of MCPWM units*/
-} mcpwm_unit_t;
-
-/**
- * @brief Select MCPWM timer
- */
-typedef enum {
-    MCPWM_TIMER_0,   /*!<Select MCPWM timer0*/
-    MCPWM_TIMER_1,   /*!<Select MCPWM timer1*/
-    MCPWM_TIMER_2,   /*!<Select MCPWM timer2*/
-    MCPWM_TIMER_MAX, /*!<Max number of timers in a unit*/
-} mcpwm_timer_t;
-
-/**
- * @brief Select MCPWM operator
- */
-typedef enum {
-    MCPWM_GEN_A,   /*!<Select MCPWMXA, where 'X' is operator number*/
-    MCPWM_GEN_B,   /*!<Select MCPWMXB, where 'X' is operator number*/
-    MCPWM_GEN_MAX, /*!<Num of generators to each operator of MCPWM*/
-} mcpwm_generator_t;
-
-//definitions and macros to be back-compatible before IDFv4.1
-#define MCPWM_OPR_A     MCPWM_GEN_A         ///< @deprecated
-#define MCPWM_OPR_B     MCPWM_GEN_B         ///< @deprecated
-#define MCPWM_OPR_MAX   MCPWM_GEN_MAX       ///< @deprecated
-typedef mcpwm_generator_t mcpwm_operator_t; ///< @deprecated
-
-/**
- * @brief MCPWM carrier output inversion, high frequency carrier signal active with MCPWM signal is high
- */
-typedef enum {
-    MCPWM_CARRIER_OUT_IVT_DIS, /*!<Enable  carrier output inversion*/
-    MCPWM_CARRIER_OUT_IVT_EN,  /*!<Disable carrier output inversion*/
-} mcpwm_carrier_out_ivt_t;
-
-/**
- * @brief MCPWM select fault signal input
- */
-typedef enum {
-    MCPWM_SELECT_F0, /*!<Select F0 as input*/
-    MCPWM_SELECT_F1, /*!<Select F1 as input*/
-    MCPWM_SELECT_F2, /*!<Select F2 as input*/
-} mcpwm_fault_signal_t;
-
-/**
- * @brief MCPWM select sync signal input
- */
-typedef enum {
-    MCPWM_SELECT_NO_INPUT,        /*!<No sync input selected*/
-    MCPWM_SELECT_TIMER0_SYNC,     /*!<Select software sync signal from timer0 as input*/
-    MCPWM_SELECT_TIMER1_SYNC,     /*!<Select software sync signal from timer1 as input*/
-    MCPWM_SELECT_TIMER2_SYNC,     /*!<Select software sync signal from timer2 as input*/
-    MCPWM_SELECT_GPIO_SYNC0,      /*!<Select GPIO SYNC0 as input*/
-    MCPWM_SELECT_GPIO_SYNC1,      /*!<Select GPIO SYNC1 as input*/
-    MCPWM_SELECT_GPIO_SYNC2,      /*!<Select GPIO SYNC2 as input*/
-} mcpwm_sync_signal_t;
-
-// 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
-
-/**
- * @brief MCPWM timer sync event trigger
- */
-typedef enum {
-    MCPWM_SWSYNC_SOURCE_SYNCIN,      /*!<the input sync signal will be routed to its sync output path*/
-    MCPWM_SWSYNC_SOURCE_TEZ,         /*!<sync signal generated when timer counts to zero*/
-    MCPWM_SWSYNC_SOURCE_TEP,         /*!<sync signal generated when timer counts to peak*/
-    MCPWM_SWSYNC_SOURCE_DISABLED,    /*!<timer does not generate sync signals*/
-} mcpwm_timer_sync_trigger_t;
-
-/**
- * @brief MCPWM select triggering level of fault signal
- */
-typedef enum {
-    MCPWM_LOW_LEVEL_TGR,  /*!<Fault condition occurs when fault input signal goes from high to low*/
-    MCPWM_HIGH_LEVEL_TGR, /*!<Fault condition occurs when fault input signal goes low to high*/
-} mcpwm_fault_input_level_t;
-
-/**
- * @brief MCPWM select capture starts from which edge
- */
-typedef enum {
-    MCPWM_NEG_EDGE = BIT(0),           /*!<Capture the negative edge*/
-    MCPWM_POS_EDGE = BIT(1),           /*!<Capture the positive edge*/
-    MCPWM_BOTH_EDGE = BIT(1) | BIT(0), /*!<Capture both edges*/
-} mcpwm_capture_on_edge_t;
-
-/**
- * @brief Select type of MCPWM counter
- */
-typedef enum {
-    MCPWM_FREEZE_COUNTER,   /*!<Counter freeze */
-    MCPWM_UP_COUNTER,       /*!<For asymmetric MCPWM*/
-    MCPWM_DOWN_COUNTER,     /*!<For asymmetric MCPWM*/
-    MCPWM_UP_DOWN_COUNTER,  /*!<For symmetric MCPWM, frequency is half of MCPWM frequency set*/
-    MCPWM_COUNTER_MAX,      /*!<Maximum counter mode*/
-} mcpwm_counter_type_t;
-
-/**
- * @brief Select type of MCPWM duty cycle mode
- */
-typedef enum {
-    MCPWM_DUTY_MODE_0 = 0, /*!<Active high duty, i.e. duty cycle proportional to high time for asymmetric MCPWM*/
-    MCPWM_DUTY_MODE_1,     /*!<Active low duty,  i.e. duty cycle proportional to low  time for asymmetric MCPWM, out of phase(inverted) MCPWM*/
-    MCPWM_HAL_GENERATOR_MODE_FORCE_LOW,
-    MCPWM_HAL_GENERATOR_MODE_FORCE_HIGH,
-    MCPWM_DUTY_MODE_MAX,   /*!<Num of duty cycle modes*/
-} mcpwm_duty_type_t;
-
-/**
- * @brief MCPWM deadtime types, used to generate deadtime, RED refers to rising edge delay and FED refers to falling edge delay
- */
-typedef enum {
-    MCPWM_DEADTIME_BYPASS = 0,          /*!<Bypass the deadtime*/
-    MCPWM_BYPASS_RED,                   /*!<MCPWMXA Out = MCPWMXA In with no delay, MCPWMXB Out = MCPWMXA In with falling edge delay*/
-    MCPWM_BYPASS_FED,                   /*!<MCPWMXA Out = MCPWMXA In with rising edge delay, MCPWMXB Out = MCPWMXB In with no delay*/
-    MCPWM_ACTIVE_HIGH_MODE,             /*!<MCPWMXA Out = MCPWMXA In with rising edge delay,  MCPWMXB Out = MCPWMXA In with falling edge delay*/
-    MCPWM_ACTIVE_LOW_MODE,              /*!<MCPWMXA Out = MCPWMXA In with compliment of rising edge delay,  MCPWMXB Out = MCPWMXA In with compliment of falling edge delay*/
-    MCPWM_ACTIVE_HIGH_COMPLIMENT_MODE,  /*!<MCPWMXA Out = MCPWMXA In with rising edge delay,  MCPWMXB = MCPWMXA In with compliment of falling edge delay*/
-    MCPWM_ACTIVE_LOW_COMPLIMENT_MODE,   /*!<MCPWMXA Out = MCPWMXA In with compliment of rising edge delay,  MCPWMXB Out = MCPWMXA In with falling edge delay*/
-    MCPWM_ACTIVE_RED_FED_FROM_PWMXA,    /*!<MCPWMXA Out = MCPWMXB Out = MCPWMXA In with rising edge delay as well as falling edge delay*/
-    MCPWM_ACTIVE_RED_FED_FROM_PWMXB,    /*!<MCPWMXA Out = MCPWMXB Out = MCPWMXB In with rising edge delay as well as falling edge delay*/
-    MCPWM_DEADTIME_TYPE_MAX,            /*!<Maximum number of supported dead time modes*/
-} mcpwm_deadtime_type_t;
-
-/**
- * @brief MCPWM select action to be taken on the output when event happens
- */
-typedef enum {
-    MCPWM_ACTION_NO_CHANGE = 0,  /*!<No change in the output*/
-    MCPWM_ACTION_FORCE_LOW,      /*!<Make output low*/
-    MCPWM_ACTION_FORCE_HIGH,     /*!<Make output high*/
-    MCPWM_ACTION_TOGGLE,         /*!<Make output toggle*/
-} mcpwm_output_action_t;
-
-/// @deprecated MCPWM select action to be taken on MCPWMXA when fault occurs
-typedef mcpwm_output_action_t mcpwm_action_on_pwmxa_t;
-#define MCPWM_NO_CHANGE_IN_MCPWMXA  MCPWM_ACTION_NO_CHANGE      /*!< @deprecated No change in MCPWMXA output*/
-#define MCPWM_FORCE_MCPWMXA_LOW     MCPWM_ACTION_FORCE_LOW      /*!< @deprecated Make MCPWMXA output low*/
-#define MCPWM_FORCE_MCPWMXA_HIGH    MCPWM_ACTION_FORCE_HIGH     /*!< @deprecated Make MCPWMXA output high*/
-#define MCPWM_TOG_MCPWMXA           MCPWM_ACTION_TOGGLE         /*!< @deprecated Make MCPWMXA output toggle*/
-
-/// @deprecated MCPWM select action to be taken on MCPWMXB when fault occurs
-typedef mcpwm_output_action_t mcpwm_action_on_pwmxb_t;
-#define MCPWM_NO_CHANGE_IN_MCPWMXB  MCPWM_ACTION_NO_CHANGE      /*!< @deprecated No change in MCPWMXB output*/
-#define MCPWM_FORCE_MCPWMXB_LOW     MCPWM_ACTION_FORCE_LOW      /*!< @deprecated Make MCPWMXB output low*/
-#define MCPWM_FORCE_MCPWMXB_HIGH    MCPWM_ACTION_FORCE_HIGH     /*!< @deprecated Make MCPWMXB output high*/
-#define MCPWM_TOG_MCPWMXB           MCPWM_ACTION_TOGGLE         /*!< @deprecated Make MCPWMXB output toggle*/
-
-/**
- * @brief MCPWM select capture signal input
- */
-typedef enum {
-    MCPWM_SELECT_CAP0, /*!<Select CAP0 as input*/
-    MCPWM_SELECT_CAP1, /*!<Select CAP1 as input*/
-    MCPWM_SELECT_CAP2, /*!<Select CAP2 as input*/
-} mcpwm_capture_signal_t;
-
-/**
- * @brief MCPWM capture channel ID alias
- */
-typedef mcpwm_capture_signal_t mcpwm_capture_channel_id_t;
-
-/**
- * @brief event data that will be passed into ISR callback
- */
-typedef struct {
-    mcpwm_capture_on_edge_t cap_edge;   /*!<Which signal edge is detected*/
-    uint32_t cap_value;                 /*!<Corresponding timestamp when event occurs. Clock rate = APB(usually 80M)*/
-} cap_event_data_t;
-
-/**
- * @brief Type of capture event callback
- * @param mcpwm MCPWM unit(0-1)
- * @param cap_channel capture channel ID
- * @param edata Capture event data, contains capture edge and capture value, fed by the driver
- * @param user_data User registered data, passed from `mcpwm_capture_config_t`
- *
- * @note Since this an ISR callback so do not do anything that may block and call APIs that is designed to be used within ISR(usually has '_ISR' postfix)
- *
- * @return Whether a task switch is needed after the callback function returns,
- *         this is usually due to the callback wakes up some high priority task.
- *
- */
-typedef bool (*cap_isr_cb_t)(mcpwm_unit_t mcpwm, mcpwm_capture_channel_id_t cap_channel, const cap_event_data_t *edata,
-                             void *user_data);
-
-/**
- * @brief MCPWM config structure
- */
-typedef struct {
-    uint32_t frequency;              /*!<Set frequency of MCPWM in Hz*/
-    float cmpr_a;                    /*!<Set % duty cycle for operator a(MCPWMXA), i.e for 62.3% duty cycle, duty_a = 62.3*/
-    float cmpr_b;                    /*!<Set % duty cycle for operator b(MCPWMXB), i.e for 48% duty cycle, duty_b = 48.0*/
-    mcpwm_duty_type_t duty_mode;     /*!<Set type of duty cycle*/
-    mcpwm_counter_type_t counter_mode;  /*!<Set  type of MCPWM counter*/
-} mcpwm_config_t;
-
-/**
- * @brief MCPWM carrier configuration structure
- */
-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_out_ivt_t carrier_ivt_mode;  /*!<Invert output of carrier*/
-} mcpwm_carrier_config_t;
-
-/**
- * @brief MCPWM config capture structure
- */
-typedef struct {
-    mcpwm_capture_on_edge_t cap_edge;      /*!<Set capture edge*/
-    uint32_t cap_prescale;                 /*!<Prescale of capture signal, ranging from 1 to 256*/
-    cap_isr_cb_t capture_cb;               /*!<User defined capture event callback, running under interrupt context */
-    void *user_data;                       /*!<User defined ISR callback function args*/
-} mcpwm_capture_config_t;
-
-/**
- * @brief MCPWM config sync structure
- */
-typedef struct {
-    mcpwm_sync_signal_t sync_sig;              /*!<Set sync input signal that will cause timer to sync*/
-    uint32_t timer_val;                        /*!<Counter value to be set after sync, in 0 ~ 999, unit: 1 / 1000 * peak*/
-    mcpwm_timer_direction_t count_direction;   /*!<Counting direction to be set after sync */
-} mcpwm_sync_config_t;
-
 /**
  * @brief This function initializes each gpio signal for MCPWM
  *
diff --git a/components/driver/deprecated/driver/mcpwm_types_legacy.h b/components/driver/deprecated/driver/mcpwm_types_legacy.h
new file mode 100644
index 0000000000..38f94dddfe
--- /dev/null
+++ b/components/driver/deprecated/driver/mcpwm_types_legacy.h
@@ -0,0 +1,307 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "esp_bit_defs.h"
+#include "soc/soc_caps.h"
+#include "hal/mcpwm_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief IO signals for the MCPWM
+ *
+ *        - 6 MCPWM output pins that generate PWM signals
+ *        - 3 MCPWM fault input pins to detect faults like over-current, over-voltage, etc.
+ *        - 3 MCPWM sync input pins to synchronize MCPWM outputs signals
+ *        - 3 MCPWM capture input pins to gather feedback from controlled motors, using e.g. hall sensors
+ */
+typedef enum {
+    MCPWM0A = 0,        /*!<PWM0A output pin*/
+    MCPWM0B,            /*!<PWM0B output pin*/
+    MCPWM1A,            /*!<PWM1A output pin*/
+    MCPWM1B,            /*!<PWM1B output pin*/
+    MCPWM2A,            /*!<PWM2A output pin*/
+    MCPWM2B,            /*!<PWM2B output pin*/
+    MCPWM_SYNC_0,       /*!<SYNC0  input pin*/
+    MCPWM_SYNC_1,       /*!<SYNC1  input pin*/
+    MCPWM_SYNC_2,       /*!<SYNC2  input pin*/
+    MCPWM_FAULT_0,      /*!<FAULT0 input pin*/
+    MCPWM_FAULT_1,      /*!<FAULT1 input pin*/
+    MCPWM_FAULT_2,      /*!<FAULT2 input pin*/
+    MCPWM_CAP_0 = 84,   /*!<CAP0   input pin*/
+    MCPWM_CAP_1,        /*!<CAP1   input pin*/
+    MCPWM_CAP_2,        /*!<CAP2   input pin*/
+} mcpwm_io_signals_t;
+
+/**
+ * @brief pin number for MCPWM
+ */
+typedef struct {
+    int mcpwm0a_out_num;       /*!<MCPWM0A out pin*/
+    int mcpwm0b_out_num;       /*!<MCPWM0A out pin*/
+    int mcpwm1a_out_num;       /*!<MCPWM0A out pin*/
+    int mcpwm1b_out_num;       /*!<MCPWM0A out pin*/
+    int mcpwm2a_out_num;       /*!<MCPWM0A out pin*/
+    int mcpwm2b_out_num;       /*!<MCPWM0A out pin*/
+    int mcpwm_sync0_in_num;    /*!<SYNC0  in pin*/
+    int mcpwm_sync1_in_num;    /*!<SYNC1  in pin*/
+    int mcpwm_sync2_in_num;    /*!<SYNC2  in pin*/
+    int mcpwm_fault0_in_num;   /*!<FAULT0 in pin*/
+    int mcpwm_fault1_in_num;   /*!<FAULT1 in pin*/
+    int mcpwm_fault2_in_num;   /*!<FAULT2 in pin*/
+    int mcpwm_cap0_in_num;     /*!<CAP0   in pin*/
+    int mcpwm_cap1_in_num;     /*!<CAP1   in pin*/
+    int mcpwm_cap2_in_num;     /*!<CAP2   in pin*/
+} mcpwm_pin_config_t;
+
+/**
+ * @brief Select MCPWM unit
+ */
+typedef enum {
+    MCPWM_UNIT_0,   /*!<MCPWM unit0 selected*/
+    MCPWM_UNIT_1,   /*!<MCPWM unit1 selected*/
+    MCPWM_UNIT_MAX, /*!<Max number of MCPWM units*/
+} mcpwm_unit_t;
+
+/**
+ * @brief Select MCPWM timer
+ */
+typedef enum {
+    MCPWM_TIMER_0,   /*!<Select MCPWM timer0*/
+    MCPWM_TIMER_1,   /*!<Select MCPWM timer1*/
+    MCPWM_TIMER_2,   /*!<Select MCPWM timer2*/
+    MCPWM_TIMER_MAX, /*!<Max number of timers in a unit*/
+} mcpwm_timer_t;
+
+/**
+ * @brief Select MCPWM operator
+ */
+typedef enum {
+    MCPWM_GEN_A,   /*!<Select MCPWMXA, where 'X' is operator number*/
+    MCPWM_GEN_B,   /*!<Select MCPWMXB, where 'X' is operator number*/
+    MCPWM_GEN_MAX, /*!<Num of generators to each operator of MCPWM*/
+} mcpwm_generator_t;
+
+//definitions and macros to be back-compatible before IDFv4.1
+#define MCPWM_OPR_A     MCPWM_GEN_A         ///< @deprecated
+#define MCPWM_OPR_B     MCPWM_GEN_B         ///< @deprecated
+#define MCPWM_OPR_MAX   MCPWM_GEN_MAX       ///< @deprecated
+typedef mcpwm_generator_t mcpwm_operator_t; ///< @deprecated
+
+/**
+ * @brief MCPWM carrier output inversion, high frequency carrier signal active with MCPWM signal is high
+ */
+typedef enum {
+    MCPWM_CARRIER_OUT_IVT_DIS, /*!<Enable  carrier output inversion*/
+    MCPWM_CARRIER_OUT_IVT_EN,  /*!<Disable carrier output inversion*/
+} mcpwm_carrier_out_ivt_t;
+
+/**
+ * @brief MCPWM select fault signal input
+ */
+typedef enum {
+    MCPWM_SELECT_F0, /*!<Select F0 as input*/
+    MCPWM_SELECT_F1, /*!<Select F1 as input*/
+    MCPWM_SELECT_F2, /*!<Select F2 as input*/
+} mcpwm_fault_signal_t;
+
+/**
+ * @brief MCPWM select sync signal input
+ */
+typedef enum {
+    MCPWM_SELECT_NO_INPUT,        /*!<No sync input selected*/
+    MCPWM_SELECT_TIMER0_SYNC,     /*!<Select software sync signal from timer0 as input*/
+    MCPWM_SELECT_TIMER1_SYNC,     /*!<Select software sync signal from timer1 as input*/
+    MCPWM_SELECT_TIMER2_SYNC,     /*!<Select software sync signal from timer2 as input*/
+    MCPWM_SELECT_GPIO_SYNC0,      /*!<Select GPIO SYNC0 as input*/
+    MCPWM_SELECT_GPIO_SYNC1,      /*!<Select GPIO SYNC1 as input*/
+    MCPWM_SELECT_GPIO_SYNC2,      /*!<Select GPIO SYNC2 as input*/
+} mcpwm_sync_signal_t;
+
+// 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
+
+/**
+ * @brief MCPWM timer sync event trigger
+ */
+typedef enum {
+    MCPWM_SWSYNC_SOURCE_SYNCIN,      /*!<the input sync signal will be routed to its sync output path*/
+    MCPWM_SWSYNC_SOURCE_TEZ,         /*!<sync signal generated when timer counts to zero*/
+    MCPWM_SWSYNC_SOURCE_TEP,         /*!<sync signal generated when timer counts to peak*/
+    MCPWM_SWSYNC_SOURCE_DISABLED,    /*!<timer does not generate sync signals*/
+} mcpwm_timer_sync_trigger_t;
+
+/**
+ * @brief MCPWM select triggering level of fault signal
+ */
+typedef enum {
+    MCPWM_LOW_LEVEL_TGR,  /*!<Fault condition occurs when fault input signal goes from high to low*/
+    MCPWM_HIGH_LEVEL_TGR, /*!<Fault condition occurs when fault input signal goes low to high*/
+} mcpwm_fault_input_level_t;
+
+/**
+ * @brief MCPWM select capture starts from which edge
+ */
+typedef enum {
+    MCPWM_NEG_EDGE = BIT(0),           /*!<Capture the negative edge*/
+    MCPWM_POS_EDGE = BIT(1),           /*!<Capture the positive edge*/
+    MCPWM_BOTH_EDGE = BIT(1) | BIT(0), /*!<Capture both edges*/
+} mcpwm_capture_on_edge_t;
+
+/**
+ * @brief Select type of MCPWM counter
+ */
+typedef enum {
+    MCPWM_FREEZE_COUNTER,   /*!<Counter freeze */
+    MCPWM_UP_COUNTER,       /*!<For asymmetric MCPWM*/
+    MCPWM_DOWN_COUNTER,     /*!<For asymmetric MCPWM*/
+    MCPWM_UP_DOWN_COUNTER,  /*!<For symmetric MCPWM, frequency is half of MCPWM frequency set*/
+    MCPWM_COUNTER_MAX,      /*!<Maximum counter mode*/
+} mcpwm_counter_type_t;
+
+/**
+ * @brief Select type of MCPWM duty cycle mode
+ */
+typedef enum {
+    MCPWM_DUTY_MODE_0 = 0,      /*!<Active high duty, i.e. duty cycle proportional to high time for asymmetric MCPWM*/
+    MCPWM_DUTY_MODE_1,          /*!<Active low duty,  i.e. duty cycle proportional to low  time for asymmetric MCPWM, out of phase(inverted) MCPWM*/
+    MCPWM_DUTY_MODE_FORCE_LOW,  /*!< Forced to output low level */
+    MCPWM_DUTY_MODE_FORCE_HIGH, /*!< Forced to output high level */
+    MCPWM_DUTY_MODE_MAX,        /*!<Num of duty cycle modes*/
+} mcpwm_duty_type_t;
+
+#define MCPWM_HAL_GENERATOR_MODE_FORCE_LOW MCPWM_DUTY_MODE_FORCE_LOW    /*!< @deprecated Forced to output low level */
+#define MCPWM_HAL_GENERATOR_MODE_FORCE_HIGH MCPWM_DUTY_MODE_FORCE_HIGH  /*!< @deprecated Forced to output low level */
+
+/**
+ * @brief MCPWM deadtime types, used to generate deadtime, RED refers to rising edge delay and FED refers to falling edge delay
+ */
+typedef enum {
+    MCPWM_DEADTIME_BYPASS = 0,          /*!<Bypass the deadtime*/
+    MCPWM_BYPASS_RED,                   /*!<MCPWMXA Out = MCPWMXA In with no delay, MCPWMXB Out = MCPWMXA In with falling edge delay*/
+    MCPWM_BYPASS_FED,                   /*!<MCPWMXA Out = MCPWMXA In with rising edge delay, MCPWMXB Out = MCPWMXB In with no delay*/
+    MCPWM_ACTIVE_HIGH_MODE,             /*!<MCPWMXA Out = MCPWMXA In with rising edge delay,  MCPWMXB Out = MCPWMXA In with falling edge delay*/
+    MCPWM_ACTIVE_LOW_MODE,              /*!<MCPWMXA Out = MCPWMXA In with compliment of rising edge delay,  MCPWMXB Out = MCPWMXA In with compliment of falling edge delay*/
+    MCPWM_ACTIVE_HIGH_COMPLIMENT_MODE,  /*!<MCPWMXA Out = MCPWMXA In with rising edge delay,  MCPWMXB = MCPWMXA In with compliment of falling edge delay*/
+    MCPWM_ACTIVE_LOW_COMPLIMENT_MODE,   /*!<MCPWMXA Out = MCPWMXA In with compliment of rising edge delay,  MCPWMXB Out = MCPWMXA In with falling edge delay*/
+    MCPWM_ACTIVE_RED_FED_FROM_PWMXA,    /*!<MCPWMXA Out = MCPWMXB Out = MCPWMXA In with rising edge delay as well as falling edge delay*/
+    MCPWM_ACTIVE_RED_FED_FROM_PWMXB,    /*!<MCPWMXA Out = MCPWMXB Out = MCPWMXB In with rising edge delay as well as falling edge delay*/
+    MCPWM_DEADTIME_TYPE_MAX,            /*!<Maximum number of supported dead time modes*/
+} mcpwm_deadtime_type_t;
+
+/**
+ * @brief MCPWM select action to be taken on the output when event happens
+ */
+typedef enum {
+    MCPWM_ACTION_NO_CHANGE = 0,  /*!<No change in the output*/
+    MCPWM_ACTION_FORCE_LOW,      /*!<Make output low*/
+    MCPWM_ACTION_FORCE_HIGH,     /*!<Make output high*/
+    MCPWM_ACTION_TOGGLE,         /*!<Make output toggle*/
+} mcpwm_output_action_t;
+
+/// @deprecated MCPWM select action to be taken on MCPWMXA when fault occurs
+typedef mcpwm_output_action_t mcpwm_action_on_pwmxa_t;
+#define MCPWM_NO_CHANGE_IN_MCPWMXA  MCPWM_ACTION_NO_CHANGE      /*!< @deprecated No change in MCPWMXA output*/
+#define MCPWM_FORCE_MCPWMXA_LOW     MCPWM_ACTION_FORCE_LOW      /*!< @deprecated Make MCPWMXA output low*/
+#define MCPWM_FORCE_MCPWMXA_HIGH    MCPWM_ACTION_FORCE_HIGH     /*!< @deprecated Make MCPWMXA output high*/
+#define MCPWM_TOG_MCPWMXA           MCPWM_ACTION_TOGGLE         /*!< @deprecated Make MCPWMXA output toggle*/
+
+/// @deprecated MCPWM select action to be taken on MCPWMXB when fault occurs
+typedef mcpwm_output_action_t mcpwm_action_on_pwmxb_t;
+#define MCPWM_NO_CHANGE_IN_MCPWMXB  MCPWM_ACTION_NO_CHANGE      /*!< @deprecated No change in MCPWMXB output*/
+#define MCPWM_FORCE_MCPWMXB_LOW     MCPWM_ACTION_FORCE_LOW      /*!< @deprecated Make MCPWMXB output low*/
+#define MCPWM_FORCE_MCPWMXB_HIGH    MCPWM_ACTION_FORCE_HIGH     /*!< @deprecated Make MCPWMXB output high*/
+#define MCPWM_TOG_MCPWMXB           MCPWM_ACTION_TOGGLE         /*!< @deprecated Make MCPWMXB output toggle*/
+
+/**
+ * @brief MCPWM select capture signal input
+ */
+typedef enum {
+    MCPWM_SELECT_CAP0, /*!<Select CAP0 as input*/
+    MCPWM_SELECT_CAP1, /*!<Select CAP1 as input*/
+    MCPWM_SELECT_CAP2, /*!<Select CAP2 as input*/
+} mcpwm_capture_signal_t;
+
+/**
+ * @brief MCPWM capture channel ID alias
+ */
+typedef mcpwm_capture_signal_t mcpwm_capture_channel_id_t;
+
+/**
+ * @brief event data that will be passed into ISR callback
+ */
+typedef struct {
+    mcpwm_capture_on_edge_t cap_edge;   /*!<Which signal edge is detected*/
+    uint32_t cap_value;                 /*!<Corresponding timestamp when event occurs. Clock rate = APB(usually 80M)*/
+} cap_event_data_t;
+
+/**
+ * @brief Type of capture event callback
+ * @param mcpwm MCPWM unit(0-1)
+ * @param cap_channel capture channel ID
+ * @param edata Capture event data, contains capture edge and capture value, fed by the driver
+ * @param user_data User registered data, passed from `mcpwm_capture_config_t`
+ *
+ * @note Since this an ISR callback so do not do anything that may block and call APIs that is designed to be used within ISR(usually has '_ISR' postfix)
+ *
+ * @return Whether a task switch is needed after the callback function returns,
+ *         this is usually due to the callback wakes up some high priority task.
+ *
+ */
+typedef bool (*cap_isr_cb_t)(mcpwm_unit_t mcpwm, mcpwm_capture_channel_id_t cap_channel, const cap_event_data_t *edata,
+                             void *user_data);
+
+/**
+ * @brief MCPWM config structure
+ */
+typedef struct {
+    uint32_t frequency;              /*!<Set frequency of MCPWM in Hz*/
+    float cmpr_a;                    /*!<Set % duty cycle for operator a(MCPWMXA), i.e for 62.3% duty cycle, duty_a = 62.3*/
+    float cmpr_b;                    /*!<Set % duty cycle for operator b(MCPWMXB), i.e for 48% duty cycle, duty_b = 48.0*/
+    mcpwm_duty_type_t duty_mode;     /*!<Set type of duty cycle*/
+    mcpwm_counter_type_t counter_mode;  /*!<Set  type of MCPWM counter*/
+} mcpwm_config_t;
+
+/**
+ * @brief MCPWM carrier configuration structure
+ */
+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_out_ivt_t carrier_ivt_mode;  /*!<Invert output of carrier*/
+} mcpwm_carrier_config_t;
+
+/**
+ * @brief MCPWM config capture structure
+ */
+typedef struct {
+    mcpwm_capture_on_edge_t cap_edge;      /*!<Set capture edge*/
+    uint32_t cap_prescale;                 /*!<Prescale of capture signal, ranging from 1 to 256*/
+    cap_isr_cb_t capture_cb;               /*!<User defined capture event callback, running under interrupt context */
+    void *user_data;                       /*!<User defined ISR callback function args*/
+} mcpwm_capture_config_t;
+
+/**
+ * @brief MCPWM config sync structure
+ */
+typedef struct {
+    mcpwm_sync_signal_t sync_sig;              /*!<Set sync input signal that will cause timer to sync*/
+    uint32_t timer_val;                        /*!<Counter value to be set after sync, in 0 ~ 999, unit: 1 / 1000 * peak*/
+    mcpwm_timer_direction_t count_direction;   /*!<Counting direction to be set after sync */
+} mcpwm_sync_config_t;
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/components/driver/mcpwm.c b/components/driver/deprecated/mcpwm_legacy.c
similarity index 97%
rename from components/driver/mcpwm.c
rename to components/driver/deprecated/mcpwm_legacy.c
index 8ffcd7f984..51a501563d 100644
--- a/components/driver/mcpwm.c
+++ b/components/driver/deprecated/mcpwm_legacy.c
@@ -14,16 +14,17 @@
 #include "esp_err.h"
 #include "esp_check.h"
 #include "esp_rom_gpio.h"
+#include "esp_intr_alloc.h"
 #include "soc/gpio_periph.h"
 #include "soc/mcpwm_periph.h"
 #include "hal/mcpwm_hal.h"
 #include "hal/gpio_hal.h"
 #include "hal/mcpwm_ll.h"
+#include "driver/mcpwm_types_legacy.h"
 #include "driver/gpio.h"
-#include "driver/mcpwm.h"
 #include "esp_private/periph_ctrl.h"
 
-static const char *TAG = "mcpwm";
+static const char *TAG = "mcpwm(legacy)";
 
 _Static_assert(MCPWM_UNIT_MAX == SOC_MCPWM_GROUPS, "MCPWM unit number not equal to chip capabilities");
 
@@ -326,11 +327,11 @@ esp_err_t mcpwm_set_duty_type(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, m
             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) {
+        } else if (duty_type == MCPWM_DUTY_MODE_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) {
+        } else if (duty_type == MCPWM_DUTY_MODE_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);
@@ -345,11 +346,11 @@ esp_err_t mcpwm_set_duty_type(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, m
             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) {
+        } else if (duty_type == MCPWM_DUTY_MODE_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) {
+        } else if (duty_type == MCPWM_DUTY_MODE_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);
@@ -364,14 +365,14 @@ esp_err_t mcpwm_set_duty_type(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, m
             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) {
+        } else if (duty_type == MCPWM_DUTY_MODE_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) {
+        } else if (duty_type == MCPWM_DUTY_MODE_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);
@@ -463,13 +464,13 @@ uint32_t mcpwm_get_duty_in_us(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, m
 esp_err_t mcpwm_set_signal_high(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, mcpwm_generator_t gen)
 {
     //the driver currently always use the timer x for operator x
-    return mcpwm_set_duty_type(mcpwm_num, timer_num, gen, MCPWM_HAL_GENERATOR_MODE_FORCE_HIGH);
+    return mcpwm_set_duty_type(mcpwm_num, timer_num, gen, MCPWM_DUTY_MODE_FORCE_HIGH);
 }
 
 esp_err_t mcpwm_set_signal_low(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, mcpwm_generator_t gen)
 {
     //the driver currently always use the timer x for operator x
-    return mcpwm_set_duty_type(mcpwm_num, timer_num, gen, MCPWM_HAL_GENERATOR_MODE_FORCE_LOW);
+    return mcpwm_set_duty_type(mcpwm_num, timer_num, gen, MCPWM_DUTY_MODE_FORCE_LOW);
 }
 
 esp_err_t mcpwm_carrier_enable(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num)
@@ -943,3 +944,19 @@ esp_err_t mcpwm_set_timer_sync_output(mcpwm_unit_t mcpwm_num, mcpwm_timer_t time
     mcpwm_critical_exit(mcpwm_num);
     return ESP_OK;
 }
+
+/**
+ * @brief This function will be called during start up, to check that this legacy mcpwm driver is not running along with the new MCPWM driver
+ */
+__attribute__((constructor))
+static void check_mcpwm_driver_conflict(void)
+{
+    // This function was declared as weak here. The new MCPWM driver has the implementation.
+    // So if the new MCPWM driver is not linked in, then `mcpwm_acquire_group_handle()` should be NULL at runtime.
+    extern __attribute__((weak)) void *mcpwm_acquire_group_handle(int group_id);
+    if ((void *)mcpwm_acquire_group_handle != NULL) {
+        ESP_EARLY_LOGE(TAG, "CONFLICT! driver_ng is not allowed to be used with the legacy driver");
+        abort();
+    }
+    ESP_EARLY_LOGW(TAG, "legacy driver is deprecated, please migrate to `driver/mcpwm_prelude.h`");
+}
diff --git a/components/driver/test_apps/legacy_mcpwm_driver/CMakeLists.txt b/components/driver/test_apps/legacy_mcpwm_driver/CMakeLists.txt
new file mode 100644
index 0000000000..6a6fac6b51
--- /dev/null
+++ b/components/driver/test_apps/legacy_mcpwm_driver/CMakeLists.txt
@@ -0,0 +1,5 @@
+# This is the project CMakeLists.txt file for the test subproject
+cmake_minimum_required(VERSION 3.16)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(legacy_mcpwm_driver_test)
diff --git a/components/driver/test_apps/legacy_mcpwm_driver/README.md b/components/driver/test_apps/legacy_mcpwm_driver/README.md
new file mode 100644
index 0000000000..5ab630aafd
--- /dev/null
+++ b/components/driver/test_apps/legacy_mcpwm_driver/README.md
@@ -0,0 +1,2 @@
+| Supported Targets | ESP32 | ESP32-S3 |
+| ----------------- | ----- | -------- |
diff --git a/components/driver/test_apps/legacy_mcpwm_driver/main/CMakeLists.txt b/components/driver/test_apps/legacy_mcpwm_driver/main/CMakeLists.txt
new file mode 100644
index 0000000000..f5ad62dfcf
--- /dev/null
+++ b/components/driver/test_apps/legacy_mcpwm_driver/main/CMakeLists.txt
@@ -0,0 +1,7 @@
+set(srcs "test_app_main.c"
+         "test_legacy_mcpwm.c")
+
+# In order for the cases defined by `TEST_CASE` to be linked into the final elf,
+# the component can be registered as WHOLE_ARCHIVE
+idf_component_register(SRCS ${srcs}
+                       WHOLE_ARCHIVE)
diff --git a/components/driver/test_apps/legacy_mcpwm_driver/main/test_app_main.c b/components/driver/test_apps/legacy_mcpwm_driver/main/test_app_main.c
new file mode 100644
index 0000000000..027d2b69c0
--- /dev/null
+++ b/components/driver/test_apps/legacy_mcpwm_driver/main/test_app_main.c
@@ -0,0 +1,40 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "unity.h"
+#include "unity_test_runner.h"
+#include "esp_heap_caps.h"
+
+#define TEST_MEMORY_LEAK_THRESHOLD (-300)
+
+static size_t before_free_8bit;
+static size_t before_free_32bit;
+
+static void check_leak(size_t before_free, size_t after_free, const char *type)
+{
+    ssize_t delta = after_free - before_free;
+    printf("MALLOC_CAP_%s: Before %u bytes free, After %u bytes free (delta %d)\n", type, before_free, after_free, delta);
+    TEST_ASSERT_MESSAGE(delta >= TEST_MEMORY_LEAK_THRESHOLD, "memory leak");
+}
+
+void setUp(void)
+{
+    before_free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
+    before_free_32bit = heap_caps_get_free_size(MALLOC_CAP_32BIT);
+}
+
+void tearDown(void)
+{
+    size_t after_free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
+    size_t after_free_32bit = heap_caps_get_free_size(MALLOC_CAP_32BIT);
+    check_leak(before_free_8bit, after_free_8bit, "8BIT");
+    check_leak(before_free_32bit, after_free_32bit, "32BIT");
+}
+
+void app_main(void)
+{
+    unity_run_menu();
+}
diff --git a/components/driver/test/test_pwm.c b/components/driver/test_apps/legacy_mcpwm_driver/main/test_legacy_mcpwm.c
similarity index 99%
rename from components/driver/test/test_pwm.c
rename to components/driver/test_apps/legacy_mcpwm_driver/main/test_legacy_mcpwm.c
index 0a3240b01c..72a41a7bc8 100644
--- a/components/driver/test/test_pwm.c
+++ b/components/driver/test_apps/legacy_mcpwm_driver/main/test_legacy_mcpwm.c
@@ -12,7 +12,6 @@
 #include "hal/gpio_hal.h"
 #include "esp_rom_gpio.h"
 #include "esp_private/esp_clk.h"
-#if SOC_MCPWM_SUPPORTED
 #include "soc/mcpwm_periph.h"
 #include "driver/pulse_cnt.h"
 #include "driver/mcpwm.h"
@@ -568,5 +567,3 @@ TEST_CASE("MCPWM capture test", "[mcpwm]")
         }
     }
 }
-
-#endif // SOC_MCPWM_SUPPORTED
diff --git a/components/driver/test_apps/legacy_mcpwm_driver/pytest_legacy_mcpwm.py b/components/driver/test_apps/legacy_mcpwm_driver/pytest_legacy_mcpwm.py
new file mode 100644
index 0000000000..25da5646d2
--- /dev/null
+++ b/components/driver/test_apps/legacy_mcpwm_driver/pytest_legacy_mcpwm.py
@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: CC0-1.0
+
+import pytest
+from pytest_embedded import Dut
+
+
+@pytest.mark.esp32
+@pytest.mark.esp32s3
+@pytest.mark.generic
+@pytest.mark.parametrize(
+    'config',
+    [
+        'release',
+    ],
+    indirect=True,
+)
+def test_legacy_mcpwm(dut: Dut) -> None:
+    dut.expect('Press ENTER to see the list of tests')
+    dut.write('*')
+    dut.expect_unity_test_output()
diff --git a/components/driver/test_apps/legacy_mcpwm_driver/sdkconfig.ci.release b/components/driver/test_apps/legacy_mcpwm_driver/sdkconfig.ci.release
new file mode 100644
index 0000000000..91d93f163e
--- /dev/null
+++ b/components/driver/test_apps/legacy_mcpwm_driver/sdkconfig.ci.release
@@ -0,0 +1,5 @@
+CONFIG_PM_ENABLE=y
+CONFIG_FREERTOS_USE_TICKLESS_IDLE=y
+CONFIG_COMPILER_OPTIMIZATION_SIZE=y
+CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y
+CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT=y
diff --git a/components/driver/test_apps/legacy_mcpwm_driver/sdkconfig.defaults b/components/driver/test_apps/legacy_mcpwm_driver/sdkconfig.defaults
new file mode 100644
index 0000000000..4c808e5adc
--- /dev/null
+++ b/components/driver/test_apps/legacy_mcpwm_driver/sdkconfig.defaults
@@ -0,0 +1,3 @@
+CONFIG_FREERTOS_HZ=1000
+CONFIG_ESP_TASK_WDT=n
+CONFIG_MCPWM_SUPPRESS_DEPRECATE_WARN=y

From 1571417679fe73c94ed82d55d106ef94ea8e6eb6 Mon Sep 17 00:00:00 2001
From: morris <maoshengrong@espressif.com>
Date: Sat, 28 May 2022 17:03:05 +0800
Subject: [PATCH 2/8] mcpwm: new driver implementation

---
 components/driver/.build-test-rules.yml       |   8 +
 components/driver/CMakeLists.txt              |  15 +-
 components/driver/include/driver/mcpwm_cap.h  | 194 ++++++
 components/driver/include/driver/mcpwm_cmpr.h |  91 +++
 .../driver/include/driver/mcpwm_fault.h       | 112 +++
 components/driver/include/driver/mcpwm_gen.h  | 187 +++++
 components/driver/include/driver/mcpwm_oper.h | 159 +++++
 .../driver/include/driver/mcpwm_prelude.h     |  20 +
 components/driver/include/driver/mcpwm_sync.h | 114 ++++
 .../driver/include/driver/mcpwm_timer.h       | 144 ++++
 .../driver/include/driver/mcpwm_types.h       | 145 ++++
 components/driver/include/esp_private/mcpwm.h |  36 +
 components/driver/mcpwm/mcpwm_cap.c           | 420 ++++++++++++
 components/driver/mcpwm/mcpwm_cmpr.c          | 210 ++++++
 components/driver/mcpwm/mcpwm_com.c           | 135 ++++
 components/driver/mcpwm/mcpwm_fault.c         | 302 ++++++++
 components/driver/mcpwm/mcpwm_gen.c           | 264 +++++++
 components/driver/mcpwm/mcpwm_oper.c          | 363 ++++++++++
 components/driver/mcpwm/mcpwm_private.h       | 221 ++++++
 components/driver/mcpwm/mcpwm_sync.c          | 297 ++++++++
 components/driver/mcpwm/mcpwm_timer.c         | 364 ++++++++++
 .../driver/test_apps/mcpwm/CMakeLists.txt     |  18 +
 components/driver/test_apps/mcpwm/README.md   |   2 +
 .../test_apps/mcpwm/main/CMakeLists.txt       |  14 +
 .../test_apps/mcpwm/main/test_app_main.c      |  51 ++
 .../test_apps/mcpwm/main/test_mcpwm_cap.c     | 238 +++++++
 .../test_apps/mcpwm/main/test_mcpwm_cmpr.c    | 113 +++
 .../test_apps/mcpwm/main/test_mcpwm_fault.c   |  93 +++
 .../test_apps/mcpwm/main/test_mcpwm_gen.c     | 646 ++++++++++++++++++
 .../test_apps/mcpwm/main/test_mcpwm_oper.c    | 380 +++++++++++
 .../test_apps/mcpwm/main/test_mcpwm_sync.c    | 204 ++++++
 .../test_apps/mcpwm/main/test_mcpwm_timer.c   | 186 +++++
 .../test_apps/mcpwm/main/test_mcpwm_utils.c   |  20 +
 .../test_apps/mcpwm/main/test_mcpwm_utils.h   |  17 +
 .../driver/test_apps/mcpwm/pytest_mcpwm.py    |  22 +
 .../test_apps/mcpwm/sdkconfig.ci.iram_safe    |   5 +
 .../test_apps/mcpwm/sdkconfig.ci.release      |   5 +
 .../driver/test_apps/mcpwm/sdkconfig.defaults |   2 +
 38 files changed, 5815 insertions(+), 2 deletions(-)
 create mode 100644 components/driver/include/driver/mcpwm_cap.h
 create mode 100644 components/driver/include/driver/mcpwm_cmpr.h
 create mode 100644 components/driver/include/driver/mcpwm_fault.h
 create mode 100644 components/driver/include/driver/mcpwm_gen.h
 create mode 100644 components/driver/include/driver/mcpwm_oper.h
 create mode 100644 components/driver/include/driver/mcpwm_prelude.h
 create mode 100644 components/driver/include/driver/mcpwm_sync.h
 create mode 100644 components/driver/include/driver/mcpwm_timer.h
 create mode 100644 components/driver/include/driver/mcpwm_types.h
 create mode 100644 components/driver/include/esp_private/mcpwm.h
 create mode 100644 components/driver/mcpwm/mcpwm_cap.c
 create mode 100644 components/driver/mcpwm/mcpwm_cmpr.c
 create mode 100644 components/driver/mcpwm/mcpwm_com.c
 create mode 100644 components/driver/mcpwm/mcpwm_fault.c
 create mode 100644 components/driver/mcpwm/mcpwm_gen.c
 create mode 100644 components/driver/mcpwm/mcpwm_oper.c
 create mode 100644 components/driver/mcpwm/mcpwm_private.h
 create mode 100644 components/driver/mcpwm/mcpwm_sync.c
 create mode 100644 components/driver/mcpwm/mcpwm_timer.c
 create mode 100644 components/driver/test_apps/mcpwm/CMakeLists.txt
 create mode 100644 components/driver/test_apps/mcpwm/README.md
 create mode 100644 components/driver/test_apps/mcpwm/main/CMakeLists.txt
 create mode 100644 components/driver/test_apps/mcpwm/main/test_app_main.c
 create mode 100644 components/driver/test_apps/mcpwm/main/test_mcpwm_cap.c
 create mode 100644 components/driver/test_apps/mcpwm/main/test_mcpwm_cmpr.c
 create mode 100644 components/driver/test_apps/mcpwm/main/test_mcpwm_fault.c
 create mode 100644 components/driver/test_apps/mcpwm/main/test_mcpwm_gen.c
 create mode 100644 components/driver/test_apps/mcpwm/main/test_mcpwm_oper.c
 create mode 100644 components/driver/test_apps/mcpwm/main/test_mcpwm_sync.c
 create mode 100644 components/driver/test_apps/mcpwm/main/test_mcpwm_timer.c
 create mode 100644 components/driver/test_apps/mcpwm/main/test_mcpwm_utils.c
 create mode 100644 components/driver/test_apps/mcpwm/main/test_mcpwm_utils.h
 create mode 100644 components/driver/test_apps/mcpwm/pytest_mcpwm.py
 create mode 100644 components/driver/test_apps/mcpwm/sdkconfig.ci.iram_safe
 create mode 100644 components/driver/test_apps/mcpwm/sdkconfig.ci.release
 create mode 100644 components/driver/test_apps/mcpwm/sdkconfig.defaults

diff --git a/components/driver/.build-test-rules.yml b/components/driver/.build-test-rules.yml
index d25382f32d..69fef02250 100644
--- a/components/driver/.build-test-rules.yml
+++ b/components/driver/.build-test-rules.yml
@@ -8,6 +8,10 @@ components/driver/test_apps/i2s_test_apps/legacy_i2s_adc_dac:
   disable:
     - if: SOC_I2S_SUPPORTS_ADC_DAC != 1
 
+components/driver/test_apps/legacy_mcpwm_driver:
+  disable:
+    - if: SOC_MCPWM_SUPPORTED != 1
+
 components/driver/test_apps/legacy_pcnt_driver:
   disable:
     - if: SOC_PCNT_SUPPORTED != 1
@@ -20,6 +24,10 @@ components/driver/test_apps/legacy_rtc_temp_driver:
   disable:
     - if: SOC_TEMP_SENSOR_SUPPORTED != 1
 
+components/driver/test_apps/mcpwm:
+  disable:
+    - if: SOC_MCPWM_SUPPORTED != 1
+
 components/driver/test_apps/pulse_cnt:
   disable:
     - if: SOC_PCNT_SUPPORTED != 1
diff --git a/components/driver/CMakeLists.txt b/components/driver/CMakeLists.txt
index c4c6e852be..5dc25f9776 100644
--- a/components/driver/CMakeLists.txt
+++ b/components/driver/CMakeLists.txt
@@ -32,7 +32,15 @@ if(CONFIG_SOC_ADC_DMA_SUPPORTED)
 endif()
 
 if(CONFIG_SOC_MCPWM_SUPPORTED)
-    list(APPEND srcs "mcpwm.c")
+    list(APPEND srcs "mcpwm/mcpwm_cap.c"
+                     "mcpwm/mcpwm_cmpr.c"
+                     "mcpwm/mcpwm_com.c"
+                     "mcpwm/mcpwm_fault.c"
+                     "mcpwm/mcpwm_gen.c"
+                     "mcpwm/mcpwm_oper.c"
+                     "mcpwm/mcpwm_sync.c"
+                     "mcpwm/mcpwm_timer.c"
+                     "deprecated/mcpwm_legacy.c")
 endif()
 
 if(CONFIG_SOC_DEDICATED_GPIO_SUPPORTED)
@@ -88,9 +96,12 @@ if(CONFIG_SOC_TOUCH_SENSOR_SUPPORTED)
     list(APPEND srcs "touch_sensor_common.c" "${target}/touch_sensor.c")
 endif()
 
+if(CONFIG_SOC_SDIO_SLAVE_SUPPORTED)
+    list(APPEND srcs "sdio_slave.c")
+endif()
+
 if(${target} STREQUAL "esp32")
     list(APPEND srcs "dac_common.c"
-                     "sdio_slave.c"
                      "deprecated/adc_i2s_deprecated.c"
                      "esp32/dac.c")
 endif()
diff --git a/components/driver/include/driver/mcpwm_cap.h b/components/driver/include/driver/mcpwm_cap.h
new file mode 100644
index 0000000000..54aa3db59b
--- /dev/null
+++ b/components/driver/include/driver/mcpwm_cap.h
@@ -0,0 +1,194 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "esp_err.h"
+#include "driver/mcpwm_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief MCPWM capture timer configuration structure
+ */
+typedef struct {
+    int group_id;                         /*!< Specify from which group to allocate the capture timer */
+    mcpwm_capture_clock_source_t clk_src; /*!< MCPWM capture timer clock source */
+} mcpwm_capture_timer_config_t;
+
+/**
+ * @brief Create MCPWM capture timer
+ *
+ * @param[in] config MCPWM capture timer configuration
+ * @param[out] ret_cap_timer Returned MCPWM capture timer handle
+ * @return
+ *      - ESP_OK: Create MCPWM capture timer successfully
+ *      - ESP_ERR_INVALID_ARG: Create MCPWM capture timer failed because of invalid argument
+ *      - ESP_ERR_NO_MEM: Create MCPWM capture timer failed because out of memory
+ *      - ESP_ERR_NOT_FOUND: Create MCPWM capture timer failed because can't find free resource
+ *      - ESP_FAIL: Create MCPWM capture timer failed because of other error
+ */
+esp_err_t mcpwm_new_capture_timer(const mcpwm_capture_timer_config_t *config, mcpwm_cap_timer_handle_t *ret_cap_timer);
+
+/**
+ * @brief Delete MCPWM capture timer
+ *
+ * @param[in] cap_timer MCPWM capture timer, allocated by `mcpwm_new_capture_timer()`
+ * @return
+ *      - ESP_OK: Delete MCPWM capture timer successfully
+ *      - ESP_ERR_INVALID_ARG: Delete MCPWM capture timer failed because of invalid argument
+ *      - ESP_FAIL: Delete MCPWM capture timer failed because of other error
+ */
+esp_err_t mcpwm_del_capture_timer(mcpwm_cap_timer_handle_t cap_timer);
+
+/**
+ * @brief Enable MCPWM capture timer
+ *
+ * @param[in] cap_timer MCPWM capture timer handle, allocated by `mcpwm_new_capture_timer()`
+ * @return
+ *      - ESP_OK: Enable MCPWM capture timer successfully
+ *      - ESP_ERR_INVALID_ARG: Enable MCPWM capture timer failed because of invalid argument
+ *      - ESP_ERR_INVALID_STATE: Enable MCPWM capture timer failed because timer is enabled already
+ *      - ESP_FAIL: Enable MCPWM capture timer failed because of other error
+ */
+esp_err_t mcpwm_capture_timer_enable(mcpwm_cap_timer_handle_t cap_timer);
+
+/**
+ * @brief Disable MCPWM capture timer
+ *
+ * @param[in] cap_timer MCPWM capture timer handle, allocated by `mcpwm_new_capture_timer()`
+ * @return
+ *      - ESP_OK: Disable MCPWM capture timer successfully
+ *      - ESP_ERR_INVALID_ARG: Disable MCPWM capture timer failed because of invalid argument
+ *      - ESP_ERR_INVALID_STATE: Disable MCPWM capture timer failed because timer is disabled already
+ *      - ESP_FAIL: Disable MCPWM capture timer failed because of other error
+ */
+esp_err_t mcpwm_capture_timer_disable(mcpwm_cap_timer_handle_t cap_timer);
+
+/**
+ * @brief Start MCPWM capture timer
+ *
+ * @param[in] cap_timer MCPWM capture timer, allocated by `mcpwm_new_capture_timer()`
+ * @return
+ *      - ESP_OK: Start MCPWM capture timer successfully
+ *      - ESP_ERR_INVALID_ARG: Start MCPWM capture timer failed because of invalid argument
+ *      - ESP_FAIL: Start MCPWM capture timer failed because of other error
+ */
+esp_err_t mcpwm_capture_timer_start(mcpwm_cap_timer_handle_t cap_timer);
+
+/**
+ * @brief Start MCPWM capture timer
+ *
+ * @param[in] cap_timer MCPWM capture timer, allocated by `mcpwm_new_capture_timer()`
+ * @return
+ *      - ESP_OK: Stop MCPWM capture timer successfully
+ *      - ESP_ERR_INVALID_ARG: Stop MCPWM capture timer failed because of invalid argument
+ *      - ESP_FAIL: Stop MCPWM capture timer failed because of other error
+ */
+esp_err_t mcpwm_capture_timer_stop(mcpwm_cap_timer_handle_t cap_timer);
+
+/**
+ * @brief MCPWM Capture timer sync phase configuration
+ */
+typedef struct {
+    mcpwm_sync_handle_t sync_src;      /*!< The sync event source */
+    uint32_t count_value;              /*!< The count value that should lock to upon sync event */
+    mcpwm_timer_direction_t direction; /*!< The count direction that should lock to upon sync event */
+} mcpwm_capture_timer_sync_phase_config_t;
+
+/**
+ * @brief Set sync phase for MCPWM capture timer
+ *
+ * @param[in] cap_timer MCPWM capture timer, allocated by `mcpwm_new_capture_timer()`
+ * @param[in] config MCPWM capture timer sync phase configuration
+ * @return
+ *      - ESP_OK: Set sync phase for MCPWM capture timer successfully
+ *      - ESP_ERR_INVALID_ARG: Set sync phase for MCPWM capture timer failed because of invalid argument
+ *      - ESP_FAIL: Set sync phase for MCPWM capture timer failed because of other error
+ */
+esp_err_t mcpwm_capture_timer_set_phase_on_sync(mcpwm_cap_timer_handle_t cap_timer, const mcpwm_capture_timer_sync_phase_config_t *config);
+
+/**
+ * @brief MCPWM capture channel configuration structure
+ */
+typedef struct {
+    int gpio_num;                /*!< GPIO used capturing input signal */
+    uint32_t prescale;               /*!< Prescale of input signal, effective frequency = cap_input_clk/prescale */
+    struct {
+        uint32_t pos_edge: 1;          /*!< Whether to capture on positive edge */
+        uint32_t neg_edge: 1;          /*!< Whether to capture on negative edge */
+        uint32_t pull_up: 1;           /*!< Whether to pull up internally */
+        uint32_t pull_down: 1;         /*!< Whether to pull down internally */
+        uint32_t invert_cap_signal: 1; /*!< Invert the input capture signal */
+        uint32_t io_loop_back: 1;      /*!< For debug/test, the signal output from the GPIO will be fed to the input path as well */
+    } flags;                           /*!< Extra configuration flags for capture channel */
+} mcpwm_capture_channel_config_t;
+
+/**
+ * @brief Create MCPWM capture channel
+ *
+ * @param[in] cap_timer MCPWM capture timer, allocated by `mcpwm_new_capture_timer()`, will be connected to the new capture channel
+ * @param[in] config MCPWM capture channel configuration
+ * @param[out] ret_cap_channel Returned MCPWM capture channel
+ * @return
+ *      - ESP_OK: Create MCPWM capture channel successfully
+ *      - ESP_ERR_INVALID_ARG: Create MCPWM capture channel failed because of invalid argument
+ *      - ESP_ERR_NO_MEM: Create MCPWM capture channel failed because out of memory
+ *      - ESP_ERR_NOT_FOUND: Create MCPWM capture channel failed because can't find free resource
+ *      - ESP_FAIL: Create MCPWM capture channel failed because of other error
+ */
+esp_err_t mcpwm_new_capture_channel(mcpwm_cap_timer_handle_t cap_timer, const mcpwm_capture_channel_config_t *config, mcpwm_cap_channel_handle_t *ret_cap_channel);
+
+/**
+ * @brief Delete MCPWM capture channel
+ *
+ * @param[in] cap_channel MCPWM capture channel handle, allocated by `mcpwm_new_capture_channel()`
+ * @return
+ *      - ESP_OK: Delete MCPWM capture channel successfully
+ *      - ESP_ERR_INVALID_ARG: Delete MCPWM capture channel failed because of invalid argument
+ *      - ESP_FAIL: Delete MCPWM capture channel failed because of other error
+ */
+esp_err_t mcpwm_del_capture_channel(mcpwm_cap_channel_handle_t cap_channel);
+
+/**
+ * @brief Group of supported MCPWM capture event callbacks
+ * @note The callbacks are all running under ISR environment
+ */
+typedef struct {
+    mcpwm_capture_event_cb_t on_cap; /*!< Callback function that would be invoked when capture event occurred */
+} mcpwm_capture_event_callbacks_t;
+
+/**
+ * @brief Set event callbacks for MCPWM capture channel
+ *
+ * @param[in] cap_channel MCPWM capture channel handle, allocated by `mcpwm_new_capture_channel()`
+ * @param[in] cbs Group of callback functions
+ * @param[in] user_data User data, which will be passed to callback functions directly
+ * @return
+ *      - ESP_OK: Set event callbacks successfully
+ *      - ESP_ERR_INVALID_ARG: Set event callbacks failed because of invalid argument
+ *      - ESP_FAIL: Set event callbacks failed because of other error
+ */
+esp_err_t mcpwm_capture_channel_register_event_callbacks(mcpwm_cap_channel_handle_t cap_channel, const mcpwm_capture_event_callbacks_t *cbs, void *user_data);
+
+/**
+ * @brief Trigger a catch by software
+ *
+ * @param[in] cap_channel MCPWM capture channel handle, allocated by `mcpwm_new_capture_channel()`
+ * @return
+ *      - ESP_OK: Trigger software catch successfully
+ *      - ESP_ERR_INVALID_ARG: Trigger software catch failed because of invalid argument
+ *      - ESP_FAIL: Trigger software catch failed because of other error
+ */
+esp_err_t mcpwm_capture_channel_trigger_soft_catch(mcpwm_cap_channel_handle_t cap_channel);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/components/driver/include/driver/mcpwm_cmpr.h b/components/driver/include/driver/mcpwm_cmpr.h
new file mode 100644
index 0000000000..d539f8a220
--- /dev/null
+++ b/components/driver/include/driver/mcpwm_cmpr.h
@@ -0,0 +1,91 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "esp_err.h"
+#include "driver/mcpwm_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief MCPWM comparator configuration
+ */
+typedef struct {
+    struct {
+        uint32_t update_cmp_on_tez: 1;  /*!< Whether to update compare value when timer count equals to zero (tez) */
+        uint32_t update_cmp_on_tep: 1;  /*!< Whether to update compare value when timer count equals to peak (tep) */
+        uint32_t update_cmp_on_sync: 1; /*!< Whether to update compare value on sync event */
+    } flags;                            /*!< Extra configuration flags for comparator */
+} mcpwm_comparator_config_t;
+
+/**
+ * @brief Create MCPWM comparator
+ *
+ * @param[in] oper MCPWM operator, allocated by `mcpwm_new_operator()`, the new comparator will be allocated from this operator
+ * @param[in] config MCPWM comparator configuration
+ * @param[out] ret_cmpr Returned MCPWM comparator
+ * @return
+ *      - ESP_OK: Create MCPWM comparator successfully
+ *      - ESP_ERR_INVALID_ARG: Create MCPWM comparator failed because of invalid argument
+ *      - ESP_ERR_NO_MEM: Create MCPWM comparator failed because out of memory
+ *      - ESP_ERR_NOT_FOUND: Create MCPWM comparator failed because can't find free resource
+ *      - ESP_FAIL: Create MCPWM comparator failed because of other error
+ */
+esp_err_t mcpwm_new_comparator(mcpwm_oper_handle_t oper, const mcpwm_comparator_config_t *config, mcpwm_cmpr_handle_t *ret_cmpr);
+
+/**
+ * @brief Delete MCPWM comparator
+ *
+ * @param[in] cmpr MCPWM comparator handle, allocated by `mcpwm_new_comparator()`
+ * @return
+ *      - ESP_OK: Delete MCPWM comparator successfully
+ *      - ESP_ERR_INVALID_ARG: Delete MCPWM comparator failed because of invalid argument
+ *      - ESP_FAIL: Delete MCPWM comparator failed because of other error
+ */
+esp_err_t mcpwm_del_comparator(mcpwm_cmpr_handle_t cmpr);
+
+/**
+ * @brief Group of supported MCPWM compare event callbacks
+ * @note The callbacks are all running under ISR environment
+ */
+typedef struct {
+    mcpwm_compare_event_cb_t on_reach; /*!< ISR callback function which would be invoked when counter reaches compare value */
+} mcpwm_comparator_event_callbacks_t;
+
+/**
+ * @brief Set event callbacks for MCPWM comparator
+ *
+ * @param[in] cmpr MCPWM comparator handle, allocated by `mcpwm_new_comparator()`
+ * @param[in] cbs Group of callback functions
+ * @param[in] user_data User data, which will be passed to callback functions directly
+ * @return
+ *      - ESP_OK: Set event callbacks successfully
+ *      - ESP_ERR_INVALID_ARG: Set event callbacks failed because of invalid argument
+ *      - ESP_FAIL: Set event callbacks failed because of other error
+ */
+esp_err_t mcpwm_comparator_register_event_callbacks(mcpwm_cmpr_handle_t cmpr, const mcpwm_comparator_event_callbacks_t *cbs, void *user_data);
+
+/**
+ * @brief Set MCPWM comparator's compare value
+ *
+ * @param[in] cmpr MCPWM comparator handle, allocated by `mcpwm_new_comparator()`
+ * @param[in] cmp_ticks The new compare value
+ * @return
+ *      - ESP_OK: Set MCPWM compare value successfully
+ *      - ESP_ERR_INVALID_ARG: Set MCPWM compare value failed because of invalid argument (e.g. the cmp_ticks is out of range)
+ *      - ESP_ERR_INVALID_STATE: Set MCPWM compare value failed because the operator doesn't have a timer connected
+ *      - ESP_FAIL: Set MCPWM compare value failed because of other error
+ */
+esp_err_t mcpwm_comparator_set_compare_value(mcpwm_cmpr_handle_t cmpr, uint32_t cmp_ticks);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/components/driver/include/driver/mcpwm_fault.h b/components/driver/include/driver/mcpwm_fault.h
new file mode 100644
index 0000000000..ddc635c679
--- /dev/null
+++ b/components/driver/include/driver/mcpwm_fault.h
@@ -0,0 +1,112 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include "esp_err.h"
+#include "driver/mcpwm_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief MCPWM GPIO fault configuration structure
+ */
+typedef struct {
+    int group_id; /*!< In which MCPWM group that the GPIO fault belongs to */
+    int gpio_num; /*!< GPIO used by the fault signal */
+    struct {
+        uint32_t active_level: 1; /*!< On which level the fault signal is treated as active */
+        uint32_t io_loop_back: 1; /*!< For debug/test, the signal output from the GPIO will be fed to the input path as well */
+        uint32_t pull_up: 1;      /*!< Whether to pull up internally */
+        uint32_t pull_down: 1;    /*!< Whether to pull down internally */
+    } flags;                      /*!< Extra configuration flags for GPIO fault */
+} mcpwm_gpio_fault_config_t;
+
+/**
+ * @brief Create MCPWM GPIO fault
+ *
+ * @param[in] config MCPWM GPIO fault configuration
+ * @param[out] ret_fault Returned GPIO fault handle
+ * @return
+ *      - ESP_OK: Create MCPWM GPIO fault successfully
+ *      - ESP_ERR_INVALID_ARG: Create MCPWM GPIO fault failed because of invalid argument
+ *      - ESP_ERR_NO_MEM: Create MCPWM GPIO fault failed because out of memory
+ *      - ESP_ERR_NOT_FOUND: Create MCPWM GPIO fault failed because can't find free resource
+ *      - ESP_FAIL: Create MCPWM GPIO fault failed because of other error
+ */
+esp_err_t mcpwm_new_gpio_fault(const mcpwm_gpio_fault_config_t *config, mcpwm_fault_handle_t *ret_fault);
+
+/**
+ * @brief MCPWM software fault configuration structure
+ */
+typedef struct {
+} mcpwm_soft_fault_config_t;
+
+/**
+ * @brief Create MCPWM software fault
+ *
+ * @param[in] config MCPWM software fault configuration
+ * @param[out] ret_fault Returned software fault handle
+ * @return
+ *      - ESP_OK: Create MCPWM software fault successfully
+ *      - ESP_ERR_INVALID_ARG: Create MCPWM software fault failed because of invalid argument
+ *      - ESP_ERR_NO_MEM: Create MCPWM software fault failed because out of memory
+ *      - ESP_FAIL: Create MCPWM software fault failed because of other error
+ */
+esp_err_t mcpwm_new_soft_fault(const mcpwm_soft_fault_config_t *config, mcpwm_fault_handle_t *ret_fault);
+
+/**
+ * @brief Delete MCPWM fault
+ *
+ * @param[in] fault MCPWM fault handle allocated by `mcpwm_new_gpio_fault()` or `mcpwm_new_soft_fault()`
+ * @return
+ *      - ESP_OK: Delete MCPWM fault successfully
+ *      - ESP_ERR_INVALID_ARG: Delete MCPWM fault failed because of invalid argument
+ *      - ESP_FAIL: Delete MCPWM fault failed because of other error
+ */
+esp_err_t mcpwm_del_fault(mcpwm_fault_handle_t fault);
+
+/**
+ * @brief Activate the software fault, trigger the fault event for once
+ *
+ * @param[in] fault MCPWM soft fault, allocated by `mcpwm_new_soft_fault()`
+ * @return
+ *      - ESP_OK: Trigger MCPWM software fault event successfully
+ *      - ESP_ERR_INVALID_ARG: Trigger MCPWM software fault event failed because of invalid argument
+ *      - ESP_FAIL: Trigger MCPWM software fault event failed because of other error
+ */
+esp_err_t mcpwm_soft_fault_activate(mcpwm_fault_handle_t fault);
+
+/**
+ * @brief Group of supported MCPWM fault event callbacks
+ * @note The callbacks are all running under ISR environment
+ */
+typedef struct {
+    mcpwm_fault_event_cb_t on_fault_enter; /*!< ISR callback function that would be invoked when fault signal becomes active */
+    mcpwm_fault_event_cb_t on_fault_exit;  /*!< ISR callback function that would be invoked when fault signal becomes inactive */
+} mcpwm_fault_event_callbacks_t;
+
+/**
+ * @brief Set event callbacks for MCPWM fault
+ *
+ * @param[in] fault MCPWM GPIO fault handle, allocated by `mcpwm_new_gpio_fault()`
+ * @param[in] cbs Group of callback functions
+ * @param[in] user_data User data, which will be passed to callback functions directly
+ * @return
+ *      - ESP_OK: Set event callbacks successfully
+ *      - ESP_ERR_INVALID_ARG: Set event callbacks failed because of invalid argument
+ *      - ESP_FAIL: Set event callbacks failed because of other error
+ */
+esp_err_t mcpwm_fault_register_event_callbacks(mcpwm_fault_handle_t fault, const mcpwm_fault_event_callbacks_t *cbs, void *user_data);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/components/driver/include/driver/mcpwm_gen.h b/components/driver/include/driver/mcpwm_gen.h
new file mode 100644
index 0000000000..96b31e9b96
--- /dev/null
+++ b/components/driver/include/driver/mcpwm_gen.h
@@ -0,0 +1,187 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include "esp_err.h"
+#include "driver/mcpwm_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief MCPWM generator configuration
+ */
+typedef struct {
+    int gen_gpio_num;           /*!< The GPIO number used to output the PWM signal */
+    struct {
+        uint32_t invert_pwm: 1;   /*!< Whether to invert the PWM signal (done by GPIO matrix) */
+        uint32_t io_loop_back: 1; /*!< For debug/test, the signal output from the GPIO will be fed to the input path as well */
+    } flags;                      /*!< Extra configuration flags for generator */
+} mcpwm_generator_config_t;
+
+/**
+ * @brief Allocate MCPWM generator from given operator
+ *
+ * @param[in] oper MCPWM operator, allocated by `mcpwm_new_operator()`
+ * @param[in] config MCPWM generator configuration
+ * @param[out] ret_gen Returned MCPWM generator
+ * @return
+ *      - ESP_OK: Create MCPWM generator successfully
+ *      - ESP_ERR_INVALID_ARG: Create MCPWM generator failed because of invalid argument
+ *      - ESP_ERR_NO_MEM: Create MCPWM generator failed because out of memory
+ *      - ESP_ERR_NOT_FOUND: Create MCPWM generator failed because can't find free resource
+ *      - ESP_FAIL: Create MCPWM generator failed because of other error
+ */
+esp_err_t mcpwm_new_generator(mcpwm_oper_handle_t oper, const mcpwm_generator_config_t *config, mcpwm_gen_handle_t *ret_gen);
+
+/**
+ * @brief Delete MCPWM generator
+ *
+ * @param[in] gen MCPWM generator handle, allocated by `mcpwm_new_generator()`
+ * @return
+ *      - ESP_OK: Delete MCPWM generator successfully
+ *      - ESP_ERR_INVALID_ARG: Delete MCPWM generator failed because of invalid argument
+ *      - ESP_FAIL: Delete MCPWM generator failed because of other error
+ */
+esp_err_t mcpwm_del_generator(mcpwm_gen_handle_t gen);
+
+/**
+ * @brief Set force level for MCPWM generator
+ *
+ * @note The force level will be applied to the generator immediately, regardless any other events that would change the generator's behaviour.
+ * @note If the `hold_on` is true, the force level will retain forever, until user removes the force level by setting the force level to `-1`.
+ * @note If the `hold_on` is false, the force level can be overridden by the next event action.
+ *
+ * @param[in] gen MCPWM generator handle, allocated by `mcpwm_new_generator()`
+ * @param[in] level GPIO level to be applied to MCPWM generator, specially, -1 means to remove the force level
+ * @param[in] hold_on Whether the forced PWM level should retain (i.e. will remain unchanged until manually remove the force level)
+ * @return
+ *      - ESP_OK: Set force level for MCPWM generator successfully
+ *      - ESP_ERR_INVALID_ARG: Set force level for MCPWM generator failed because of invalid argument
+ *      - ESP_FAIL: Set force level for MCPWM generator failed because of other error
+ */
+esp_err_t mcpwm_generator_set_force_level(mcpwm_gen_handle_t gen, int level, bool hold_on);
+
+/**
+ * @brief Generator action on specific timer event
+ */
+typedef struct {
+    mcpwm_timer_direction_t direction; /*!< Timer direction */
+    mcpwm_timer_event_t event;         /*!< Timer event */
+    mcpwm_generator_action_t action;   /*!< Generator action should perform */
+} mcpwm_gen_timer_event_action_t;
+
+/**
+ * @brief Help macros to construct a mcpwm_gen_timer_event_action_t entry
+ */
+#define MCPWM_GEN_TIMER_EVENT_ACTION(dir, ev, act) \
+    (mcpwm_gen_timer_event_action_t) { .direction = dir, .event = ev, .action = act }
+#define MCPWM_GEN_TIMER_EVENT_ACTION_END() \
+    (mcpwm_gen_timer_event_action_t) { .event = MCPWM_TIMER_EVENT_INVALID }
+
+/**
+ * @brief Set generator actions on different MCPWM timer events
+ *
+ * @param[in] gen MCPWM generator handle, allocated by `mcpwm_new_generator()`
+ * @param[in] ev_act MCPWM timer event action list, must be terminated by `MCPWM_GEN_TIMER_EVENT_ACTION_END()`
+ * @return
+ *      - ESP_OK: Set generator actions successfully
+ *      - ESP_ERR_INVALID_ARG: Set generator actions failed because of invalid argument
+ *      - ESP_ERR_INVALID_STATE: Set generator actions failed because of timer is not connected to operator
+ *      - ESP_FAIL: Set generator actions failed because of other error
+ */
+esp_err_t mcpwm_generator_set_actions_on_timer_event(mcpwm_gen_handle_t gen, mcpwm_gen_timer_event_action_t ev_act, ...);
+
+/**
+ * @brief Generator action on specific comparator event
+ */
+typedef struct {
+    mcpwm_timer_direction_t direction; /*!< Timer direction */
+    mcpwm_cmpr_handle_t comparator;    /*!< Comparator handle */
+    mcpwm_generator_action_t action;   /*!< Generator action should perform */
+} mcpwm_gen_compare_event_action_t;
+
+/**
+ * @brief Help macros to construct a mcpwm_gen_compare_event_action_t entry
+ */
+#define MCPWM_GEN_COMPARE_EVENT_ACTION(dir, cmp, act) \
+    (mcpwm_gen_compare_event_action_t) { .direction = dir, .comparator = cmp, .action = act }
+#define MCPWM_GEN_COMPARE_EVENT_ACTION_END() \
+    (mcpwm_gen_compare_event_action_t) { .comparator = NULL }
+
+/**
+ * @brief Set generator actions on different MCPWM compare events
+ *
+ * @param[in] generator MCPWM generator handle, allocated by `mcpwm_new_generator()`
+ * @param[in] ev_act MCPWM compare event action list, must be terminated by `MCPWM_GEN_COMPARE_EVENT_ACTION_END()`
+ * @return
+ *      - ESP_OK: Set generator actions successfully
+ *      - ESP_ERR_INVALID_ARG: Set generator actions failed because of invalid argument
+ *      - ESP_FAIL: Set generator actions failed because of other error
+ */
+esp_err_t mcpwm_generator_set_actions_on_compare_event(mcpwm_gen_handle_t generator, mcpwm_gen_compare_event_action_t ev_act, ...);
+
+/**
+ * @brief Generator action on specific brake event
+ */
+typedef struct {
+    mcpwm_timer_direction_t direction;       /*!< Timer direction */
+    mcpwm_operator_brake_mode_t brake_mode;  /*!< Brake mode */
+    mcpwm_generator_action_t action;         /*!< Generator action should perform */
+} mcpwm_gen_brake_event_action_t;
+
+/**
+ * @brief Help macros to construct a mcpwm_gen_brake_event_action_t entry
+ */
+#define MCPWM_GEN_BRAKE_EVENT_ACTION(dir, mode, act) \
+    (mcpwm_gen_brake_event_action_t) { .direction = dir, .brake_mode = mode, .action = act }
+#define MCPWM_GEN_BRAKE_EVENT_ACTION_END() \
+    (mcpwm_gen_brake_event_action_t) { .brake_mode = MCPWM_OPER_BRAKE_MODE_INVALID }
+
+/**
+ * @brief Set generator actions on different MCPWM brake events
+ *
+ * @param[in] generator MCPWM generator handle, allocated by `mcpwm_new_generator()`
+ * @param[in] ev_act MCPWM brake event action list, must be terminated by `MCPWM_GEN_BRAKE_EVENT_ACTION_END()`
+ * @return
+ *      - ESP_OK: Set generator actions successfully
+ *      - ESP_ERR_INVALID_ARG: Set generator actions failed because of invalid argument
+ *      - ESP_FAIL: Set generator actions failed because of other error
+ */
+esp_err_t mcpwm_generator_set_actions_on_brake_event(mcpwm_gen_handle_t generator, mcpwm_gen_brake_event_action_t ev_act, ...);
+
+/**
+ * @brief MCPWM dead time configuration structure
+ */
+typedef struct {
+    uint32_t posedge_delay_ticks; /*!< delay time applied to rising edge, 0 means no rising delay time */
+    uint32_t negedge_delay_ticks; /*!< delay time applied to falling edge, 0 means no falling delay time */
+    struct {
+        uint32_t invert_output: 1; /*!< Invert the signal after applied the dead time */
+    } flags;                       /*!< Extra flags for dead time configuration */
+} mcpwm_dead_time_config_t;
+
+/**
+ * @brief Set dead time for MCPWM generator
+ *
+ * @param[in] in_generator MCPWM generator, before adding the dead time
+ * @param[in] out_generator MCPWM generator, after adding the dead time
+ * @param[in] config MCPWM dead time configuration
+ * @return
+ *      - ESP_OK: Set dead time for MCPWM generator successfully
+ *      - ESP_ERR_INVALID_ARG: Set dead time for MCPWM generator failed because of invalid argument
+ *      - ESP_FAIL: Set dead time for MCPWM generator failed because of other error
+ */
+esp_err_t mcpwm_generator_set_dead_time(mcpwm_gen_handle_t in_generator, mcpwm_gen_handle_t out_generator, const mcpwm_dead_time_config_t *config);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/components/driver/include/driver/mcpwm_oper.h b/components/driver/include/driver/mcpwm_oper.h
new file mode 100644
index 0000000000..5f89f806fc
--- /dev/null
+++ b/components/driver/include/driver/mcpwm_oper.h
@@ -0,0 +1,159 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "esp_err.h"
+#include "driver/mcpwm_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief MCPWM operator configuration
+ */
+typedef struct {
+    int group_id; /*!< Specify from which group to allocate the MCPWM operator */
+    struct {
+        uint32_t update_gen_action_on_tez: 1;  /*!< Whether to update generator action when timer counts to zero */
+        uint32_t update_gen_action_on_tep: 1;  /*!< Whether to update generator action when timer counts to peak */
+        uint32_t update_gen_action_on_sync: 1; /*!< Whether to update generator action on sync event */
+        uint32_t update_dead_time_on_tez: 1;   /*!< Whether to update dead time when timer counts to zero */
+        uint32_t update_dead_time_on_tep: 1;   /*!< Whether to update dead time when timer counts to peak */
+        uint32_t update_dead_time_on_sync: 1;  /*!< Whether to update dead time on sync event */
+    } flags;                                   /*!< Extra configuration flags for operator */
+} mcpwm_operator_config_t;
+
+/**
+ * @brief Create MCPWM operator
+ *
+ * @param[in] config MCPWM operator configuration
+ * @param[out] ret_oper Returned MCPWM operator handle
+ * @return
+ *      - ESP_OK: Create MCPWM operator successfully
+ *      - ESP_ERR_INVALID_ARG: Create MCPWM operator failed because of invalid argument
+ *      - ESP_ERR_NO_MEM: Create MCPWM operator failed because out of memory
+ *      - ESP_ERR_NOT_FOUND: Create MCPWM operator failed because can't find free resource
+ *      - ESP_FAIL: Create MCPWM operator failed because of other error
+ */
+esp_err_t mcpwm_new_operator(const mcpwm_operator_config_t *config, mcpwm_oper_handle_t *ret_oper);
+
+/**
+ * @brief Delete MCPWM operator
+ *
+ * @param[in] oper MCPWM operator, allocated by `mcpwm_new_operator()`
+ * @return
+ *      - ESP_OK: Delete MCPWM operator successfully
+ *      - ESP_ERR_INVALID_ARG: Delete MCPWM operator failed because of invalid argument
+ *      - ESP_FAIL: Delete MCPWM operator failed because of other error
+ */
+esp_err_t mcpwm_del_operator(mcpwm_oper_handle_t oper);
+
+/**
+ * @brief Connect MCPWM operator and timer, so that the operator can be driven by the timer
+ *
+ * @param[in] oper MCPWM operator handle, allocated by `mcpwm_new_operator()`
+ * @param[in] timer MCPWM timer handle, allocated by `mcpwm_new_timer()`
+ * @return
+ *      - ESP_OK: Connect MCPWM operator and timer successfully
+ *      - ESP_ERR_INVALID_ARG: Connect MCPWM operator and timer failed because of invalid argument
+ *      - ESP_FAIL: Connect MCPWM operator and timer failed because of other error
+ */
+esp_err_t mcpwm_operator_connect_timer(mcpwm_oper_handle_t oper, mcpwm_timer_handle_t timer);
+
+/**
+ * @brief MCPWM brake configuration structure
+ */
+typedef struct {
+    mcpwm_fault_handle_t fault;             /*!< Which fault causes the operator to brake */
+    mcpwm_operator_brake_mode_t brake_mode; /*!< Brake mode */
+    struct {
+        uint32_t cbc_recover_on_tez: 1; /*!< Recovery CBC brake state on tez event */
+        uint32_t cbc_recover_on_tep: 1; /*!< Recovery CBC brake state on tep event */
+    } flags;                            /*!< Extra flags for brake configuration */
+} mcpwm_brake_config_t;
+
+/**
+ * @brief Set brake method for MCPWM operator
+ *
+ * @param[in] operator MCPWM operator, allocated by `mcpwm_new_operator()`
+ * @param[in] config MCPWM brake configuration
+ * @return
+ *      - ESP_OK: Set trip for operator successfully
+ *      - ESP_ERR_INVALID_ARG: Set trip for operator failed because of invalid argument
+ *      - ESP_FAIL: Set trip for operator failed because of other error
+ */
+esp_err_t mcpwm_operator_set_brake_on_fault(mcpwm_oper_handle_t operator, const mcpwm_brake_config_t *config);
+
+/**
+ * @brief Try to make the operator recover from fault
+ *
+ * @note To recover from fault or escape from trip, you make sure the fault signal has dissappeared already.
+ *       Otherwise the recovery can't succeed.
+ *
+ * @param[in] operator MCPWM operator, allocated by `mcpwm_new_operator()`
+ * @param[in] fault MCPWM fault handle
+ * @return
+ *      - ESP_OK: Recover from fault successfully
+ *      - ESP_ERR_INVALID_ARG: Recover from fault failed because of invalid argument
+ *      - ESP_ERR_INVALID_STATE: Recover from fault failed because the fault source is still active
+ *      - ESP_FAIL: Recover from fault failed because of other error
+ */
+esp_err_t mcpwm_operator_recover_from_fault(mcpwm_oper_handle_t operator, mcpwm_fault_handle_t fault);
+
+/**
+ * @brief Group of supported MCPWM operator event callbacks
+ * @note The callbacks are all running under ISR environment
+ */
+typedef struct {
+    mcpwm_brake_event_cb_t on_brake_cbc; /*!< callback function when mcpwm operator brakes in CBC */
+    mcpwm_brake_event_cb_t on_brake_ost; /*!< callback function when mcpwm operator brakes in OST */
+} mcpwm_operator_event_callbacks_t;
+
+/**
+ * @brief Set event callbacks for MCPWM operator
+ *
+ * @param[in] oper MCPWM operator handle, allocated by `mcpwm_new_operator()`
+ * @param[in] cbs Group of callback functions
+ * @param[in] user_data User data, which will be passed to callback functions directly
+ * @return
+ *      - ESP_OK: Set event callbacks successfully
+ *      - ESP_ERR_INVALID_ARG: Set event callbacks failed because of invalid argument
+ *      - ESP_FAIL: Set event callbacks failed because of other error
+ */
+esp_err_t mcpwm_operator_register_event_callbacks(mcpwm_oper_handle_t oper, const mcpwm_operator_event_callbacks_t *cbs, void *user_data);
+
+/**
+ * @brief MCPWM carrier configuration structure
+ */
+typedef struct {
+    uint32_t frequency_hz;            /*!< Carrier frequency in Hz */
+    uint32_t first_pulse_duration_us; /*!< The duration of the first PWM pulse, in us */
+    float duty_cycle;                 /*!< Carrier duty cycle */
+    struct {
+        uint32_t invert_before_modulate: 1; /*!< Invert the raw signal */
+        uint32_t invert_after_modulate: 1;  /*!< Invert the modulated signal */
+    } flags;                                /*!< Extra flags for carrier configuration */
+} mcpwm_carrier_config_t;
+
+/**
+ * @brief Apply carrier feature for MCPWM operator
+ *
+ * @param[in] oper MCPWM operator, allocated by `mcpwm_new_operator()`
+ * @param[in] config MCPWM carrier specific configuration
+ * @return
+ *      - ESP_OK: Set carrier for operator successfully
+ *      - ESP_ERR_INVALID_ARG: Set carrier for operator failed because of invalid argument
+ *      - ESP_FAIL: Set carrier for operator failed because of other error
+ */
+esp_err_t mcpwm_operator_apply_carrier(mcpwm_oper_handle_t oper, const mcpwm_carrier_config_t *config);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/components/driver/include/driver/mcpwm_prelude.h b/components/driver/include/driver/mcpwm_prelude.h
new file mode 100644
index 0000000000..fd460ece38
--- /dev/null
+++ b/components/driver/include/driver/mcpwm_prelude.h
@@ -0,0 +1,20 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @brief MCPWM peripheral contains many submodules, whose drivers are scattered in different header files.
+ *        This header file serves as a prelude, contains every thing that is needed to work with the MCPWM peripheral.
+ */
+
+#pragma once
+
+#include "driver/mcpwm_timer.h"
+#include "driver/mcpwm_oper.h"
+#include "driver/mcpwm_cmpr.h"
+#include "driver/mcpwm_gen.h"
+#include "driver/mcpwm_fault.h"
+#include "driver/mcpwm_sync.h"
+#include "driver/mcpwm_cap.h"
diff --git a/components/driver/include/driver/mcpwm_sync.h b/components/driver/include/driver/mcpwm_sync.h
new file mode 100644
index 0000000000..7f691e9fa6
--- /dev/null
+++ b/components/driver/include/driver/mcpwm_sync.h
@@ -0,0 +1,114 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "esp_err.h"
+#include "driver/mcpwm_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief MCPWM timer sync source configuration
+ */
+typedef struct {
+    mcpwm_timer_event_t timer_event; /*!< Timer event, upon which MCPWM timer will generate the sync signal */
+    struct {
+        uint32_t propagate_input_sync: 1; /*!< The input sync signal would be routed to its sync output */
+    } flags;                          /*!< Extra configuration flags for timer sync source */
+} mcpwm_timer_sync_src_config_t;
+
+/**
+ * @brief Create MCPWM timer sync source
+ *
+ * @param[in] timer MCPWM timer handle, allocated by `mcpwm_new_timer()`
+ * @param[in] config MCPWM timer sync source configuration
+ * @param[out] ret_sync Returned MCPWM sync handle
+ * @return
+ *      - ESP_OK: Create MCPWM timer sync source successfully
+ *      - ESP_ERR_INVALID_ARG: Create MCPWM timer sync source failed because of invalid argument
+ *      - ESP_ERR_NO_MEM: Create MCPWM timer sync source failed because out of memory
+ *      - ESP_ERR_INVALID_STATE: Create MCPWM timer sync source failed because the timer has created a sync source before
+ *      - ESP_FAIL: Create MCPWM timer sync source failed because of other error
+ */
+esp_err_t mcpwm_new_timer_sync_src(mcpwm_timer_handle_t timer, const mcpwm_timer_sync_src_config_t *config, mcpwm_sync_handle_t *ret_sync);
+
+/**
+ * @brief MCPWM GPIO sync source configuration
+ */
+typedef struct {
+    int group_id; /*!< MCPWM group ID */
+    int gpio_num; /*!< GPIO used by sync source */
+    struct {
+        uint32_t active_neg: 1;   /*!< Whether the sync signal is active on negedge, by default, the sync signal's posedge is treated as active */
+        uint32_t io_loop_back: 1; /*!< For debug/test, the signal output from the GPIO will be fed to the input path as well */
+        uint32_t pull_up: 1;      /*!< Whether to pull up internally */
+        uint32_t pull_down: 1;    /*!< Whether to pull down internally */
+    } flags;                      /*!< Extra configuration flags for GPIO sync source */
+} mcpwm_gpio_sync_src_config_t;
+
+/**
+ * @brief Create MCPWM GPIO sync source
+ *
+ * @param[in] config MCPWM GPIO sync source configuration
+ * @param[out] ret_sync Returned MCPWM GPIO sync handle
+ * @return
+ *      - ESP_OK: Create MCPWM GPIO sync source successfully
+ *      - ESP_ERR_INVALID_ARG: Create MCPWM GPIO sync source failed because of invalid argument
+ *      - ESP_ERR_NO_MEM: Create MCPWM GPIO sync source failed because out of memory
+ *      - ESP_ERR_NOT_FOUND: Create MCPWM GPIO sync source failed because can't find free resource
+ *      - ESP_FAIL: Create MCPWM GPIO sync source failed because of other error
+ */
+esp_err_t mcpwm_new_gpio_sync_src(const mcpwm_gpio_sync_src_config_t *config, mcpwm_sync_handle_t *ret_sync);
+
+/**
+ * @brief MCPWM software sync configuration structure
+ */
+typedef struct {
+} mcpwm_soft_sync_config_t;
+
+/**
+ * @brief Create MCPWM software sync source
+ *
+ * @param[in] config MCPWM software sync source configuration
+ * @param[out] ret_sync Returned software sync handle
+ * @return
+ *      - ESP_OK: Create MCPWM software sync successfully
+ *      - ESP_ERR_INVALID_ARG: Create MCPWM software sync failed because of invalid argument
+ *      - ESP_ERR_NO_MEM: Create MCPWM software sync failed because out of memory
+ *      - ESP_FAIL: Create MCPWM software sync failed because of other error
+ */
+esp_err_t mcpwm_new_soft_sync_src(const mcpwm_soft_sync_config_t *config, mcpwm_sync_handle_t *ret_sync);
+
+/**
+ * @brief Delete MCPWM sync source
+ *
+ * @param[in] sync MCPWM sync handle, allocated by `mcpwm_new_timer_sync_src()` or `mcpwm_new_gpio_sync_src()` or `mcpwm_new_soft_sync_src()`
+ * @return
+ *      - ESP_OK: Delete MCPWM sync source successfully
+ *      - ESP_ERR_INVALID_ARG: Delete MCPWM sync source failed because of invalid argument
+ *      - ESP_FAIL: Delete MCPWM sync source failed because of other error
+ */
+esp_err_t mcpwm_del_sync_src(mcpwm_sync_handle_t sync);
+
+/**
+ * @brief Activate the software sync, trigger the sync event for once
+ *
+ * @param[in] sync MCPWM soft sync handle, allocated by `mcpwm_new_soft_sync_src()`
+ * @return
+ *      - ESP_OK: Trigger MCPWM software sync event successfully
+ *      - ESP_ERR_INVALID_ARG: Trigger MCPWM software sync event failed because of invalid argument
+ *      - ESP_FAIL: Trigger MCPWM software sync event failed because of other error
+ */
+esp_err_t mcpwm_soft_sync_activate(mcpwm_sync_handle_t sync);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/components/driver/include/driver/mcpwm_timer.h b/components/driver/include/driver/mcpwm_timer.h
new file mode 100644
index 0000000000..3bcec03ab5
--- /dev/null
+++ b/components/driver/include/driver/mcpwm_timer.h
@@ -0,0 +1,144 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "esp_err.h"
+#include "driver/mcpwm_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Group of supported MCPWM timer event callbacks
+ * @note The callbacks are all running under ISR environment
+ */
+typedef struct {
+    mcpwm_timer_event_cb_t on_full;  /*!< callback function when MCPWM timer counts to peak value */
+    mcpwm_timer_event_cb_t on_empty; /*!< callback function when MCPWM timer counts to zero */
+    mcpwm_timer_event_cb_t on_stop;  /*!< callback function when MCPWM timer stops */
+} mcpwm_timer_event_callbacks_t;
+
+/**
+ * @brief MCPWM timer configuration
+ */
+typedef struct {
+    int group_id;                        /*!< Specify from which group to allocate the MCPWM timer */
+    mcpwm_timer_clock_source_t clk_src;  /*!< MCPWM timer clock source */
+    uint32_t resolution_hz;              /*!< Counter resolution in Hz, ranges from around 300KHz to 80MHz.
+                                              The step size of each count tick equals to (1 / resolution_hz) seconds */
+    mcpwm_timer_count_mode_t count_mode; /*!< Count mode */
+    uint32_t period_ticks;               /*!< Number of count ticks within a period */
+    struct {
+        uint32_t update_period_on_empty: 1; /*!< Whether to update period when timer counts to zero */
+        uint32_t update_period_on_sync: 1;  /*!< Whether to update period on sync event */
+    } flags;                                /*!< Extra configuration flags for timer */
+} mcpwm_timer_config_t;
+
+/**
+ * @brief Create MCPWM timer
+ *
+ * @param[in] config MCPWM timer configuration
+ * @param[out] ret_timer Returned MCPWM timer handle
+ * @return
+ *      - ESP_OK: Create MCPWM timer successfully
+ *      - ESP_ERR_INVALID_ARG: Create MCPWM timer failed because of invalid argument
+ *      - ESP_ERR_NO_MEM: Create MCPWM timer failed because out of memory
+ *      - ESP_ERR_NOT_FOUND: Create MCPWM timer failed because all hardware timers are used up and no more free one
+ *      - ESP_FAIL: Create MCPWM timer failed because of other error
+ */
+esp_err_t mcpwm_new_timer(const mcpwm_timer_config_t *config, mcpwm_timer_handle_t *ret_timer);
+
+/**
+ * @brief Delete MCPWM timer
+ *
+ * @param[in] timer MCPWM timer handle, allocated by `mcpwm_new_timer()`
+ * @return
+ *      - ESP_OK: Delete MCPWM timer successfully
+ *      - ESP_ERR_INVALID_ARG: Delete MCPWM timer failed because of invalid argument
+ *      - ESP_ERR_INVALID_STATE: Delete MCPWM timer failed because timer is not in init state
+ *      - ESP_FAIL: Delete MCPWM timer failed because of other error
+ */
+esp_err_t mcpwm_del_timer(mcpwm_timer_handle_t timer);
+
+/**
+ * @brief Enable MCPWM timer
+ *
+ * @param[in] timer MCPWM timer handle, allocated by `mcpwm_new_timer()`
+ * @return
+ *      - ESP_OK: Enable MCPWM timer successfully
+ *      - ESP_ERR_INVALID_ARG: Enable MCPWM timer failed because of invalid argument
+ *      - ESP_ERR_INVALID_STATE: Enable MCPWM timer failed because timer is enabled already
+ *      - ESP_FAIL: Enable MCPWM timer failed because of other error
+ */
+esp_err_t mcpwm_timer_enable(mcpwm_timer_handle_t timer);
+
+/**
+ * @brief Disable MCPWM timer
+ *
+ * @param[in] timer MCPWM timer handle, allocated by `mcpwm_new_timer()`
+ * @return
+ *      - ESP_OK: Disable MCPWM timer successfully
+ *      - ESP_ERR_INVALID_ARG: Disable MCPWM timer failed because of invalid argument
+ *      - ESP_ERR_INVALID_STATE: Disable MCPWM timer failed because timer is disabled already
+ *      - ESP_FAIL: Disable MCPWM timer failed because of other error
+ */
+esp_err_t mcpwm_timer_disable(mcpwm_timer_handle_t timer);
+
+/**
+ * @brief Send specific start/stop commands to MCPWM timer
+ *
+ * @param[in] timer MCPWM timer handle, allocated by `mcpwm_new_timer()`
+ * @param[in] command Supported command list for MCPWM timer
+ * @return
+ *      - ESP_OK: Start or stop MCPWM timer successfully
+ *      - ESP_ERR_INVALID_ARG: Start or stop MCPWM timer failed because of invalid argument
+ *      - ESP_ERR_INVALID_STATE: Start or stop MCPWM timer failed because timer is not enabled
+ *      - ESP_FAIL: Start or stop MCPWM timer failed because of other error
+ */
+esp_err_t mcpwm_timer_start_stop(mcpwm_timer_handle_t timer, mcpwm_timer_start_stop_cmd_t command);
+
+/**
+ * @brief Set event callbacks for MCPWM timer
+ *
+ * @param[in] timer MCPWM timer handle, allocated by `mcpwm_new_timer()`
+ * @param[in] cbs Group of callback functions
+ * @param[in] user_data User data, which will be passed to callback functions directly
+ * @return
+ *      - ESP_OK: Set event callbacks successfully
+ *      - ESP_ERR_INVALID_ARG: Set event callbacks failed because of invalid argument
+ *      - ESP_ERR_INVALID_STATE: Set event callbacks failed because timer is not in init state
+ *      - ESP_FAIL: Set event callbacks failed because of other error
+ */
+esp_err_t mcpwm_timer_register_event_callbacks(mcpwm_timer_handle_t timer, const mcpwm_timer_event_callbacks_t *cbs, void *user_data);
+
+/**
+ * @brief MCPWM Timer sync phase configuration
+ */
+typedef struct {
+    mcpwm_sync_handle_t sync_src;      /*!< The sync event source. Set to NULL will disable the timer being synced by others */
+    uint32_t count_value;              /*!< The count value that should lock to upon sync event */
+    mcpwm_timer_direction_t direction; /*!< The count direction that should lock to upon sync event */
+} mcpwm_timer_sync_phase_config_t;
+
+/**
+ * @brief Set sync phase for MCPWM timer
+ *
+ * @param[in] timer MCPWM timer handle, allocated by `mcpwm_new_timer()`
+ * @param[in] config MCPWM timer sync phase configuration
+ * @return
+ *      - ESP_OK: Set sync phase for MCPWM timer successfully
+ *      - ESP_ERR_INVALID_ARG: Set sync phase for MCPWM timer failed because of invalid argument
+ *      - ESP_FAIL: Set sync phase for MCPWM timer failed because of other error
+ */
+esp_err_t mcpwm_timer_set_phase_on_sync(mcpwm_timer_handle_t timer, const mcpwm_timer_sync_phase_config_t *config);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/components/driver/include/driver/mcpwm_types.h b/components/driver/include/driver/mcpwm_types.h
new file mode 100644
index 0000000000..d25cff5614
--- /dev/null
+++ b/components/driver/include/driver/mcpwm_types.h
@@ -0,0 +1,145 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "hal/mcpwm_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Type of MCPWM timer handle
+ */
+typedef struct mcpwm_timer_t *mcpwm_timer_handle_t;
+
+/**
+ * @brief Type of MCPWM operator handle
+ */
+typedef struct mcpwm_oper_t *mcpwm_oper_handle_t;
+
+/**
+ * @brief Type of MCPWM comparator handle
+ */
+typedef struct mcpwm_cmpr_t *mcpwm_cmpr_handle_t;
+
+/**
+ * @brief Type of MCPWM generator handle
+ */
+typedef struct mcpwm_gen_t *mcpwm_gen_handle_t;
+
+/**
+ * @brief Type of MCPWM fault handle
+ */
+typedef struct mcpwm_fault_t *mcpwm_fault_handle_t;
+
+/**
+ * @brief Type of MCPWM sync handle
+ */
+typedef struct mcpwm_sync_t *mcpwm_sync_handle_t;
+
+/**
+ * @brief Type of MCPWM capture timer handle
+ */
+typedef struct mcpwm_cap_timer_t *mcpwm_cap_timer_handle_t;
+
+/**
+ * @brief Type of MCPWM capture channel handle
+ */
+typedef struct mcpwm_cap_channel_t *mcpwm_cap_channel_handle_t;
+
+/**
+ * @brief MCPWM timer event data
+ */
+typedef struct {
+    uint32_t count_value;              /*!< MCPWM timer count value */
+    mcpwm_timer_direction_t direction; /*!< MCPWM timer count direction */
+} mcpwm_timer_event_data_t;
+
+/**
+ * @brief MCPWM timer event callback function
+ *
+ * @param[in] timer MCPWM timer handle
+ * @param[in] edata MCPWM timer event data, fed by driver
+ * @param[in] user_ctx User data, set in `mcpwm_timer_register_event_callbacks()`
+ * @return Whether a high priority task has been waken up by this function
+ */
+typedef bool (*mcpwm_timer_event_cb_t)(mcpwm_timer_handle_t timer, const mcpwm_timer_event_data_t *edata, void *user_ctx);
+
+/**
+ * @brief MCPWM brake event data
+ */
+typedef struct {
+} mcpwm_brake_event_data_t;
+
+/**
+ * @brief MCPWM operator brake event callback function
+ *
+ * @param[in] operator MCPWM operator handle
+ * @param[in] edata MCPWM brake event data, fed by driver
+ * @param[in] user_ctx User data, set in `mcpwm_operator_register_event_callbacks()`
+ * @return Whether a high priority task has been waken up by this function
+ */
+typedef bool (*mcpwm_brake_event_cb_t)(mcpwm_oper_handle_t operator, const mcpwm_brake_event_data_t *edata, void *user_ctx);
+
+/**
+ * @brief MCPWM fault event data
+ */
+typedef struct {
+} mcpwm_fault_event_data_t;
+
+/**
+ * @brief MCPWM fault event callback function
+ *
+ * @param fault MCPWM fault handle
+ * @param ev_data MCPWM fault event data, fed by driver
+ * @param user_ctx User data, set in `mcpwm_fault_register_event_callbacks()`
+ * @return whether a task switch is needed after the callback returns
+ */
+typedef bool (*mcpwm_fault_event_cb_t)(mcpwm_fault_handle_t fault, const mcpwm_fault_event_data_t *ev_data, void *user_ctx);
+
+/**
+ * @brief MCPWM compare event data
+ */
+typedef struct {
+    uint32_t compare_ticks;            /*!< Compare value */
+    mcpwm_timer_direction_t direction; /*!< Count direction */
+} mcpwm_compare_event_data_t;
+
+/**
+ * @brief MCPWM comparator event callback function
+ *
+ * @param comparator MCPWM comparator handle
+ * @param edata MCPWM comparator event data, fed by driver
+ * @param user_ctx User data, set in `mcpwm_comparator_register_event_callbacks()`
+ * @return Whether a high priority task has been waken up by this function
+ */
+typedef bool (*mcpwm_compare_event_cb_t)(mcpwm_cmpr_handle_t comparator, const mcpwm_compare_event_data_t *edata, void *user_ctx);
+
+/**
+ * @brief MCPWM capture event data
+ */
+typedef struct {
+    uint32_t cap_value;            /*!< Captured value */
+    mcpwm_capture_edge_t cap_edge; /*!< Capture edge */
+} mcpwm_capture_event_data_t;
+
+/**
+ * @brief MCPWM capture event callback function
+ *
+ * @param cap_channel MCPWM capture channel handle
+ * @param ev_data MCPWM capture event data, fed by driver
+ * @param user_ctx User data, set in `mcpwm_capture_channel_register_event_callbacks()`
+ * @return Whether a high priority task has been waken up by this function
+ */
+typedef bool (*mcpwm_capture_event_cb_t)(mcpwm_cap_channel_handle_t cap_channel, const mcpwm_capture_event_data_t *edata, void *user_ctx);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/components/driver/include/esp_private/mcpwm.h b/components/driver/include/esp_private/mcpwm.h
new file mode 100644
index 0000000000..62f44ce435
--- /dev/null
+++ b/components/driver/include/esp_private/mcpwm.h
@@ -0,0 +1,36 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// DO NOT USE THESE APIS IN YOUR APPLICATIONS
+// The following APIs are for internal use, public to other IDF components, but not for users' applications.
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "esp_err.h"
+#include "driver/mcpwm_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Get MCPWM timer phase
+ *
+ * @param[in] timer MCPWM timer handle, allocated by `mcpwm_new_timer()`
+ * @param[out] count_value Returned MCPWM timer phase
+ * @param[out] direction Returned MCPWM timer counting direction
+ * @return
+ *      - ESP_OK: Get MCPWM timer status successfully
+ *      - ESP_ERR_INVALID_ARG: Get MCPWM timer status failed because of invalid argument
+ *      - ESP_FAIL: Get MCPWM timer status failed because of other error
+ */
+esp_err_t mcpwm_timer_get_phase(mcpwm_timer_handle_t timer, uint32_t *count_value, mcpwm_timer_direction_t *direction);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/components/driver/mcpwm/mcpwm_cap.c b/components/driver/mcpwm/mcpwm_cap.c
new file mode 100644
index 0000000000..94667a6f14
--- /dev/null
+++ b/components/driver/mcpwm/mcpwm_cap.c
@@ -0,0 +1,420 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <sys/cdefs.h>
+#include "sdkconfig.h"
+#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
+// The local log level must be defined before including esp_log.h
+// Set the maximum log level for this source file
+#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
+#endif
+#include "freertos/FreeRTOS.h"
+#include "esp_attr.h"
+#include "esp_check.h"
+#include "esp_private/esp_clk.h"
+#include "esp_err.h"
+#include "esp_log.h"
+#include "esp_memory_utils.h"
+#include "soc/soc_caps.h"
+#include "soc/mcpwm_periph.h"
+#include "hal/mcpwm_ll.h"
+#include "driver/mcpwm_cap.h"
+#include "driver/gpio.h"
+#include "mcpwm_private.h"
+
+static const char *TAG = "mcpwm";
+
+static void mcpwm_capture_default_isr(void *args);
+
+static esp_err_t mcpwm_cap_timer_register_to_group(mcpwm_cap_timer_t *cap_timer, int group_id)
+{
+    mcpwm_group_t *group = mcpwm_acquire_group_handle(group_id);
+    ESP_RETURN_ON_FALSE(group, ESP_ERR_NO_MEM, TAG, "no mem for group (%d)", group_id);
+
+    bool new_timer = false;
+    portENTER_CRITICAL(&group->spinlock);
+    if (!group->cap_timer) {
+        group->cap_timer = cap_timer;
+        new_timer = true;
+    }
+    portEXIT_CRITICAL(&group->spinlock);
+
+    if (!new_timer) {
+        mcpwm_release_group_handle(group);
+        group = NULL;
+    } else {
+        cap_timer->group = group;
+    }
+    ESP_RETURN_ON_FALSE(new_timer, ESP_ERR_NOT_FOUND, TAG, "no free cap timer in group (%d)", group_id);
+    return ESP_OK;
+}
+
+static void mcpwm_cap_timer_unregister_from_group(mcpwm_cap_timer_t *cap_timer)
+{
+    mcpwm_group_t *group = cap_timer->group;
+
+    portENTER_CRITICAL(&group->spinlock);
+    group->cap_timer = NULL;
+    portEXIT_CRITICAL(&group->spinlock);
+
+    // capture timer has a reference on group, release it now
+    mcpwm_release_group_handle(group);
+}
+
+static esp_err_t mcpwm_cap_timer_destory(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");
+    }
+    if (cap_timer->group) {
+        mcpwm_cap_timer_unregister_from_group(cap_timer);
+    }
+    free(cap_timer);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_new_capture_timer(const mcpwm_capture_timer_config_t *config, mcpwm_cap_timer_handle_t *ret_cap_timer)
+{
+#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
+    esp_log_level_set(TAG, ESP_LOG_DEBUG);
+#endif
+    esp_err_t ret = ESP_OK;
+    mcpwm_cap_timer_t *cap_timer = NULL;
+    ESP_GOTO_ON_FALSE(config && ret_cap_timer, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    ESP_GOTO_ON_FALSE(config->group_id < SOC_MCPWM_GROUPS && config->group_id >= 0, ESP_ERR_INVALID_ARG,
+                      err, TAG, "invalid group ID:%d", config->group_id);
+
+    cap_timer = heap_caps_calloc(1, sizeof(mcpwm_cap_timer_t), MCPWM_MEM_ALLOC_CAPS);
+    ESP_GOTO_ON_FALSE(cap_timer, ESP_ERR_NO_MEM, err, TAG, "no mem for capture timer");
+
+    switch (config->clk_src) {
+    case MCPWM_CAPTURE_CLK_SRC_APB:
+        cap_timer->resolution_hz = esp_clk_apb_freq();
+#if CONFIG_PM_ENABLE
+        ret  = esp_pm_lock_create(ESP_PM_APB_FREQ_MAX, 0, "mcpwm_cap_timer", &cap_timer->pm_lock);
+        ESP_GOTO_ON_ERROR(ret, err, TAG, "create ESP_PM_APB_FREQ_MAX lock failed");
+#endif // CONFIG_PM_ENABLE
+        break;
+    default:
+        ESP_GOTO_ON_FALSE(false, ESP_ERR_INVALID_ARG, err, TAG, "invalid clock source:%d", config->clk_src);
+    }
+
+    ESP_GOTO_ON_ERROR(mcpwm_cap_timer_register_to_group(cap_timer, config->group_id), err, TAG, "register timer failed");
+    mcpwm_group_t *group = cap_timer->group;
+    int group_id = group->group_id;
+
+    // fill in other capture timer specific members
+    cap_timer->spinlock = (portMUX_TYPE)portMUX_INITIALIZER_UNLOCKED;
+    cap_timer->fsm = MCPWM_CAP_TIMER_FSM_INIT;
+    *ret_cap_timer = cap_timer;
+    ESP_LOGD(TAG, "new capture timer at %p, in group (%d)", cap_timer, group_id);
+    return ESP_OK;
+
+err:
+    if (cap_timer) {
+        mcpwm_cap_timer_destory(cap_timer);
+    }
+    return ret;
+}
+
+esp_err_t mcpwm_del_capture_timer(mcpwm_cap_timer_handle_t cap_timer)
+{
+    ESP_RETURN_ON_FALSE(cap_timer, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    ESP_RETURN_ON_FALSE(cap_timer->fsm == MCPWM_CAP_TIMER_FSM_INIT, ESP_ERR_INVALID_STATE, TAG, "timer not in init state");
+    for (int i = 0; i < SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER; i++) {
+        ESP_RETURN_ON_FALSE(!cap_timer->cap_channels[i], ESP_ERR_INVALID_STATE, TAG, "cap channel still in working");
+    }
+    mcpwm_group_t *group = cap_timer->group;
+
+    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");
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_capture_timer_enable(mcpwm_cap_timer_handle_t cap_timer)
+{
+    ESP_RETURN_ON_FALSE(cap_timer, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    ESP_RETURN_ON_FALSE(cap_timer->fsm == MCPWM_CAP_TIMER_FSM_INIT, ESP_ERR_INVALID_STATE, TAG, "timer not in init state");
+    if (cap_timer->pm_lock) {
+        ESP_RETURN_ON_ERROR(esp_pm_lock_acquire(cap_timer->pm_lock), TAG, "acquire pm_lock failed");
+    }
+    cap_timer->fsm = MCPWM_CAP_TIMER_FSM_ENABLE;
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_capture_timer_disable(mcpwm_cap_timer_handle_t cap_timer)
+{
+    ESP_RETURN_ON_FALSE(cap_timer, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    ESP_RETURN_ON_FALSE(cap_timer->fsm == MCPWM_CAP_TIMER_FSM_ENABLE, ESP_ERR_INVALID_STATE, TAG, "timer not in enable state");
+    if (cap_timer->pm_lock) {
+        ESP_RETURN_ON_ERROR(esp_pm_lock_release(cap_timer->pm_lock), TAG, "release pm_lock failed");
+    }
+    cap_timer->fsm = MCPWM_CAP_TIMER_FSM_INIT;
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_capture_timer_start(mcpwm_cap_timer_handle_t cap_timer)
+{
+    ESP_RETURN_ON_FALSE(cap_timer, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    ESP_RETURN_ON_FALSE(cap_timer->fsm == MCPWM_CAP_TIMER_FSM_ENABLE, ESP_ERR_INVALID_STATE, TAG, "timer not enabled yet");
+    mcpwm_group_t *group = cap_timer->group;
+
+    portENTER_CRITICAL_SAFE(&cap_timer->spinlock);
+    mcpwm_ll_capture_enable_timer(group->hal.dev, true);
+    portEXIT_CRITICAL_SAFE(&cap_timer->spinlock);
+
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_capture_timer_stop(mcpwm_cap_timer_handle_t cap_timer)
+{
+    ESP_RETURN_ON_FALSE(cap_timer, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    ESP_RETURN_ON_FALSE(cap_timer->fsm == MCPWM_CAP_TIMER_FSM_ENABLE, ESP_ERR_INVALID_STATE, TAG, "timer not enabled yet");
+    mcpwm_group_t *group = cap_timer->group;
+
+    portENTER_CRITICAL_SAFE(&cap_timer->spinlock);
+    mcpwm_ll_capture_enable_timer(group->hal.dev, false);
+    portEXIT_CRITICAL_SAFE(&cap_timer->spinlock);
+
+    return ESP_OK;
+}
+
+static esp_err_t mcpwm_capture_channel_register_to_timer(mcpwm_cap_channel_t *cap_channel, mcpwm_cap_timer_t *cap_timer)
+{
+    int cap_chan_id = -1;
+    portENTER_CRITICAL(&cap_timer->spinlock);
+    for (int i = 0; i < SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER; i++) {
+        if (!cap_timer->cap_channels[i]) {
+            cap_timer->cap_channels[i] = cap_channel;
+            cap_chan_id = i;
+            break;
+        }
+    }
+    portEXIT_CRITICAL(&cap_timer->spinlock);
+    ESP_RETURN_ON_FALSE(cap_chan_id >= 0, ESP_ERR_NOT_FOUND, TAG, "no free channel in the timer (%d)", cap_timer->group->group_id);
+
+    cap_channel->cap_chan_id = cap_chan_id;
+    cap_channel->cap_timer = cap_timer;
+    return ESP_OK;
+}
+
+static void mcpwm_capture_channel_unregister_from_timer(mcpwm_cap_channel_t *cap_chan)
+{
+    mcpwm_cap_timer_t *cap_timer = cap_chan->cap_timer;
+    int cap_chan_id = cap_chan->cap_chan_id;
+
+    portENTER_CRITICAL(&cap_timer->spinlock);
+    cap_timer->cap_channels[cap_chan_id] = NULL;
+    portEXIT_CRITICAL(&cap_timer->spinlock);
+}
+
+static esp_err_t mcpwm_capture_channel_destory(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");
+    }
+    if (cap_chan->cap_timer) {
+        mcpwm_capture_channel_unregister_from_timer(cap_chan);
+    }
+    free(cap_chan);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_new_capture_channel(mcpwm_cap_timer_handle_t cap_timer, const mcpwm_capture_channel_config_t *config, mcpwm_cap_channel_handle_t *ret_cap_channel)
+{
+    esp_err_t ret = ESP_OK;
+    mcpwm_cap_channel_t *cap_chan = NULL;
+    ESP_GOTO_ON_FALSE(cap_timer && config && ret_cap_channel, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    ESP_GOTO_ON_FALSE(config->prescale && config->prescale <= MCPWM_LL_MAX_CAPTURE_PRESCALE, ESP_ERR_INVALID_ARG, err, TAG, "invalid prescale");
+
+    // create instance firstly, then install onto platform
+    cap_chan = calloc(1, sizeof(mcpwm_cap_channel_t));
+    ESP_GOTO_ON_FALSE(cap_chan, ESP_ERR_NO_MEM, err, TAG, "no mem for capture channel");
+
+    ESP_GOTO_ON_ERROR(mcpwm_capture_channel_register_to_timer(cap_chan, cap_timer), err, TAG, "register channel failed");
+    mcpwm_group_t *group = cap_timer->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int cap_chan_id = cap_chan->cap_chan_id;
+
+    mcpwm_ll_capture_enable_channel(hal->dev, cap_chan_id, true); // enable channel
+    mcpwm_ll_capture_enable_negedge(hal->dev, cap_chan_id, config->flags.neg_edge);
+    mcpwm_ll_capture_enable_posedge(hal->dev, cap_chan_id, config->flags.pos_edge);
+    mcpwm_ll_invert_input(hal->dev, cap_chan_id, config->flags.invert_cap_signal);
+    mcpwm_ll_capture_set_prescale(hal->dev, cap_chan_id, config->prescale);
+
+    if (config->gpio_num >= 0) {
+        // GPIO configuration
+        gpio_config_t gpio_conf = {
+            .intr_type = GPIO_INTR_DISABLE,
+            .mode = GPIO_MODE_INPUT | (config->flags.io_loop_back ? GPIO_MODE_OUTPUT : 0), // also enable the output path if `io_loop_back` is enabled
+            .pin_bit_mask = (1ULL << config->gpio_num),
+            .pull_down_en = config->flags.pull_down,
+            .pull_up_en = config->flags.pull_up,
+        };
+        ESP_GOTO_ON_ERROR(gpio_config(&gpio_conf), err, TAG, "config capture GPIO failed");
+        esp_rom_gpio_connect_in_signal(config->gpio_num, mcpwm_periph_signals.groups[group->group_id].captures[cap_chan_id].cap_sig, 0);
+    }
+
+    cap_chan->gpio_num = config->gpio_num;
+    *ret_cap_channel = cap_chan;
+    ESP_LOGD(TAG, "new capture channel (%d,%d) at %p", group->group_id, cap_chan_id, cap_chan);
+    return ESP_OK;
+err:
+    if (cap_chan) {
+        mcpwm_capture_channel_destory(cap_chan);
+    }
+    return ret;
+}
+
+esp_err_t mcpwm_del_capture_channel(mcpwm_cap_channel_handle_t cap_channel)
+{
+    ESP_RETURN_ON_FALSE(cap_channel, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_cap_timer_t *cap_timer = cap_channel->cap_timer;
+    mcpwm_group_t *group = cap_timer->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int cap_chan_id = cap_channel->cap_chan_id;
+
+    ESP_LOGD(TAG, "del capture channel (%d,%d)", group->group_id, cap_channel->cap_chan_id);
+    if (cap_channel->gpio_num >= 0) {
+        gpio_reset_pin(cap_channel->gpio_num);
+    }
+
+    portENTER_CRITICAL(&group->spinlock);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_CAPTURE(cap_chan_id), false);
+    mcpwm_ll_intr_clear_status(hal->dev, MCPWM_LL_EVENT_CAPTURE(cap_chan_id));
+    portEXIT_CRITICAL(&group->spinlock);
+
+    // disable capture channel
+    mcpwm_ll_capture_enable_channel(group->hal.dev, cap_channel->cap_chan_id, false);
+
+    // recycle memory resource
+    ESP_RETURN_ON_ERROR(mcpwm_capture_channel_destory(cap_channel), TAG, "destory capture channel failed");
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_capture_channel_register_event_callbacks(mcpwm_cap_channel_handle_t cap_channel, const mcpwm_capture_event_callbacks_t *cbs, void *user_data)
+{
+    ESP_RETURN_ON_FALSE(cap_channel && cbs, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_group_t *group = cap_channel->cap_timer->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int group_id = group->group_id;
+    int cap_chan_id = cap_channel->cap_chan_id;
+
+#if CONFIG_MCWPM_ISR_IRAM_SAFE
+    if (cbs->on_cap) {
+        ESP_RETURN_ON_FALSE(esp_ptr_in_iram(cbs->on_cap), ESP_ERR_INVALID_ARG, TAG, "on_cap callback not in IRAM");
+    }
+    if (user_data) {
+        ESP_RETURN_ON_FALSE(esp_ptr_internal(user_data), ESP_ERR_INVALID_ARG, TAG, "user context not in internal RAM");
+    }
+#endif
+
+    // lazy install interrupt service
+    if (!cap_channel->intr) {
+        // we want the interrupt servie to be enabled after allocation successfully
+        int isr_flags = MCPWM_INTR_ALLOC_FLAG & ~ ESP_INTR_FLAG_INTRDISABLED;
+        ESP_RETURN_ON_ERROR(esp_intr_alloc_intrstatus(mcpwm_periph_signals.groups[group_id].irq_id, isr_flags,
+                            (uint32_t)mcpwm_ll_intr_get_status_reg(hal->dev), MCPWM_LL_EVENT_CAPTURE(cap_chan_id),
+                            mcpwm_capture_default_isr, cap_channel, &cap_channel->intr), TAG, "install interrupt service for cap channel failed");
+    }
+
+    portENTER_CRITICAL(&group->spinlock);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_CAPTURE(cap_chan_id), cbs->on_cap != NULL);
+    portEXIT_CRITICAL(&group->spinlock);
+
+    cap_channel->on_cap = cbs->on_cap;
+    cap_channel->user_data = user_data;
+
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_capture_channel_trigger_soft_catch(mcpwm_cap_channel_handle_t cap_channel)
+{
+    ESP_RETURN_ON_FALSE(cap_channel, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_cap_timer_t *cap_timer = cap_channel->cap_timer;
+    mcpwm_group_t *group = cap_timer->group;
+
+    // note: soft capture can also triggers the interrupt routine
+    mcpwm_ll_trigger_soft_capture(group->hal.dev, cap_channel->cap_chan_id);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_capture_timer_set_phase_on_sync(mcpwm_cap_timer_handle_t cap_timer, const mcpwm_capture_timer_sync_phase_config_t *config)
+{
+    ESP_RETURN_ON_FALSE(cap_timer, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    // capture timer only support count up
+    ESP_RETURN_ON_FALSE(config->direction == MCPWM_TIMER_DIRECTION_UP, ESP_ERR_INVALID_ARG, TAG, "invalid sync direction");
+    mcpwm_group_t *group = cap_timer->group;
+    mcpwm_sync_t *sync_source = config->sync_src;
+
+    // a non-NULL sync_src means to enable sync feature
+    if (sync_source) {
+        switch (sync_source->type) {
+        case MCPWM_SYNC_TYPE_GPIO: {
+            ESP_RETURN_ON_FALSE(group == sync_source->group, ESP_ERR_INVALID_ARG, TAG, "capture timer and sync source are not in the same group");
+            mcpwm_gpio_sync_src_t *gpio_sync_src = __containerof(sync_source, mcpwm_gpio_sync_src_t, base);
+            mcpwm_ll_capture_set_gpio_sync(group->hal.dev, gpio_sync_src->sync_id);
+            ESP_LOGD(TAG, "enable sync to GPIO (%d,%d) for cap timer (%d)",
+                     group->group_id, gpio_sync_src->sync_id, group->group_id);
+            break;
+        }
+        case MCPWM_SYNC_TYPE_TIMER: {
+            ESP_RETURN_ON_FALSE(group == sync_source->group, ESP_ERR_INVALID_ARG, TAG, "capture timer and sync source are not in the same group");
+            mcpwm_timer_sync_src_t *timer_sync_src = __containerof(sync_source, mcpwm_timer_sync_src_t, base);
+            mcpwm_ll_capture_set_timer_sync(group->hal.dev, timer_sync_src->timer->timer_id);
+            ESP_LOGD(TAG, "enable sync to pwm timer (%d,%d) for cap timer (%d)",
+                     group->group_id, timer_sync_src->timer->timer_id, group->group_id);
+            break;
+        }
+        case MCPWM_SYNC_TYPE_SOFT: {
+            mcpwm_soft_sync_src_t *soft_sync = __containerof(sync_source, mcpwm_soft_sync_src_t, base);
+            soft_sync->soft_sync_from = MCPWM_SOFT_SYNC_FROM_CAP;
+            soft_sync->cap_timer = cap_timer;
+            soft_sync->base.group = group;
+            break;
+        }
+        }
+        mcpwm_ll_capture_enable_timer_sync(group->hal.dev, true);
+        mcpwm_ll_capture_set_sync_phase_value(group->hal.dev, config->count_value);
+    } else { // disable sync feature
+        mcpwm_ll_capture_enable_timer_sync(group->hal.dev, false);
+        ESP_LOGD(TAG, "disable sync for cap timer (%d)", group->group_id);
+    }
+    return ESP_OK;
+}
+
+IRAM_ATTR static void mcpwm_capture_default_isr(void *args)
+{
+    mcpwm_cap_channel_t *cap_chan = (mcpwm_cap_channel_t *)args;
+    mcpwm_group_t *group = cap_chan->cap_timer->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int cap_id = cap_chan->cap_chan_id;
+    bool need_yield = false;
+
+    uint32_t status = mcpwm_ll_intr_get_status(hal->dev);
+    mcpwm_ll_intr_clear_status(hal->dev, status & MCPWM_LL_EVENT_CAPTURE(cap_id));
+
+    // read capture value and pass to user
+    mcpwm_capture_event_data_t data = {
+        .cap_value = mcpwm_ll_capture_get_value(hal->dev, cap_id),
+        .cap_edge = mcpwm_ll_capture_get_edge(hal->dev, cap_id),
+    };
+    if (status & MCPWM_LL_EVENT_CAPTURE(cap_id)) {
+        mcpwm_capture_event_cb_t cb = cap_chan->on_cap;
+        if (cb) {
+            if (cb(cap_chan, &data, cap_chan->user_data)) {
+                need_yield = true;
+            }
+        }
+    }
+
+    if (need_yield) {
+        portYIELD_FROM_ISR();
+    }
+}
diff --git a/components/driver/mcpwm/mcpwm_cmpr.c b/components/driver/mcpwm/mcpwm_cmpr.c
new file mode 100644
index 0000000000..c0f9e82aad
--- /dev/null
+++ b/components/driver/mcpwm/mcpwm_cmpr.c
@@ -0,0 +1,210 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <sys/cdefs.h>
+#include "sdkconfig.h"
+#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
+// The local log level must be defined before including esp_log.h
+// Set the maximum log level for this source file
+#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
+#endif
+#include "freertos/FreeRTOS.h"
+#include "esp_attr.h"
+#include "esp_check.h"
+#include "esp_err.h"
+#include "esp_log.h"
+#include "esp_memory_utils.h"
+#include "soc/soc_caps.h"
+#include "soc/mcpwm_periph.h"
+#include "hal/mcpwm_ll.h"
+#include "driver/mcpwm_cmpr.h"
+#include "mcpwm_private.h"
+
+static const char *TAG = "mcpwm";
+
+static void mcpwm_comparator_default_isr(void *args);
+
+static esp_err_t mcpwm_comparator_register_to_operator(mcpwm_cmpr_t *cmpr, mcpwm_oper_t *oper)
+{
+    int cmpr_id = -1;
+    portENTER_CRITICAL(&oper->spinlock);
+    for (int i = 0; i < SOC_MCPWM_COMPARATORS_PER_OPERATOR; i++) {
+        if (!oper->comparators[i]) {
+            oper->comparators[i] = cmpr;
+            cmpr_id = i;
+            break;
+        }
+    }
+    portEXIT_CRITICAL(&oper->spinlock);
+    ESP_RETURN_ON_FALSE(cmpr_id >= 0, ESP_ERR_NOT_FOUND, TAG, "no free comparator in operator (%d,%d)", oper->group->group_id, oper->oper_id);
+
+    cmpr->cmpr_id = cmpr_id;
+    cmpr->operator = oper;
+    return ESP_OK;
+}
+
+static void mcpwm_comparator_unregister_from_operator(mcpwm_cmpr_t *cmpr)
+{
+    mcpwm_oper_t *oper = cmpr->operator;
+    int cmpr_id = cmpr->cmpr_id;
+
+    portENTER_CRITICAL(&oper->spinlock);
+    oper->comparators[cmpr_id] = NULL;
+    portEXIT_CRITICAL(&oper->spinlock);
+}
+
+static esp_err_t mcpwm_comparator_destory(mcpwm_cmpr_t *cmpr)
+{
+    if (cmpr->intr) {
+        ESP_RETURN_ON_ERROR(esp_intr_free(cmpr->intr), TAG, "uninstall interrupt service failed");
+    }
+    if (cmpr->operator) {
+        mcpwm_comparator_unregister_from_operator(cmpr);
+    }
+    free(cmpr);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_new_comparator(mcpwm_oper_handle_t oper, const mcpwm_comparator_config_t *config, mcpwm_cmpr_handle_t *ret_cmpr)
+{
+    esp_err_t ret = ESP_OK;
+    mcpwm_cmpr_t *cmpr = NULL;
+    ESP_GOTO_ON_FALSE(oper && config && ret_cmpr, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+
+    cmpr = heap_caps_calloc(1, sizeof(mcpwm_cmpr_t), MCPWM_MEM_ALLOC_CAPS);
+    ESP_GOTO_ON_FALSE(cmpr, ESP_ERR_NO_MEM, err, TAG, "no mem for comparator");
+
+    ESP_GOTO_ON_ERROR(mcpwm_comparator_register_to_operator(cmpr, oper), err, TAG, "register comparator failed");
+    mcpwm_group_t *group = oper->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int oper_id = oper->oper_id;
+    int cmpr_id = cmpr->cmpr_id;
+
+    mcpwm_ll_operator_enable_update_compare_on_tez(hal->dev, oper_id, cmpr_id, config->flags.update_cmp_on_tez);
+    mcpwm_ll_operator_enable_update_compare_on_tep(hal->dev, oper_id, cmpr_id, config->flags.update_cmp_on_tep);
+    mcpwm_ll_operator_enable_update_compare_on_sync(hal->dev, oper_id, cmpr_id, config->flags.update_cmp_on_sync);
+
+    // fill in other comparator members
+    cmpr->spinlock = (portMUX_TYPE)portMUX_INITIALIZER_UNLOCKED;
+    *ret_cmpr = cmpr;
+    ESP_LOGD(TAG, "new comparator (%d,%d,%d) at %p", group->group_id, oper_id, cmpr_id, cmpr);
+    return ESP_OK;
+
+err:
+    if (cmpr) {
+        mcpwm_comparator_destory(cmpr);
+    }
+    return ret;
+}
+
+esp_err_t mcpwm_del_comparator(mcpwm_cmpr_handle_t cmpr)
+{
+    ESP_RETURN_ON_FALSE(cmpr, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_oper_t *operator= cmpr->operator;
+    mcpwm_group_t *group = operator->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int oper_id = operator->oper_id;
+    int cmpr_id = cmpr->cmpr_id;
+
+    portENTER_CRITICAL(&group->spinlock);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_CMP_EQUAL(oper_id, cmpr_id), false);
+    mcpwm_ll_intr_clear_status(hal->dev, MCPWM_LL_EVENT_CMP_EQUAL(oper_id, cmpr_id));
+    portEXIT_CRITICAL(&group->spinlock);
+
+    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");
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_comparator_set_compare_value(mcpwm_cmpr_handle_t cmpr, uint32_t cmp_ticks)
+{
+    ESP_RETURN_ON_FALSE(cmpr, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_oper_t *oper = cmpr->operator;
+    mcpwm_group_t *group = oper->group;
+    mcpwm_timer_t *timer = oper->timer;
+    ESP_RETURN_ON_FALSE(timer, ESP_ERR_INVALID_STATE, TAG, "timer and operator are not connected");
+    ESP_RETURN_ON_FALSE(cmp_ticks < timer->peak_ticks, ESP_ERR_INVALID_ARG, TAG, "compare value out of range");
+
+    portENTER_CRITICAL_SAFE(&cmpr->spinlock);
+    mcpwm_ll_operator_set_compare_value(group->hal.dev, oper->oper_id, cmpr->cmpr_id, cmp_ticks);
+    portEXIT_CRITICAL_SAFE(&cmpr->spinlock);
+
+    cmpr->compare_ticks = cmp_ticks;
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_comparator_register_event_callbacks(mcpwm_cmpr_handle_t cmpr, const mcpwm_comparator_event_callbacks_t *cbs, void *user_data)
+{
+    ESP_RETURN_ON_FALSE(cmpr && cbs, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_oper_t *oper = cmpr->operator;
+    mcpwm_group_t *group = oper->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int group_id = group->group_id;
+    int oper_id = oper->oper_id;
+    int cmpr_id = cmpr->cmpr_id;
+
+#if CONFIG_MCWPM_ISR_IRAM_SAFE
+    if (cbs->on_reach) {
+        ESP_RETURN_ON_FALSE(esp_ptr_in_iram(cbs->on_reach), ESP_ERR_INVALID_ARG, TAG, "on_reach callback not in IRAM");
+    }
+    if (user_data) {
+        ESP_RETURN_ON_FALSE(esp_ptr_internal(user_data), ESP_ERR_INVALID_ARG, TAG, "user context not in internal RAM");
+    }
+#endif
+
+    // lazy install interrupt service
+    if (!cmpr->intr) {
+        // we want the interrupt servie to be enabled after allocation successfully
+        int isr_flags = MCPWM_INTR_ALLOC_FLAG & ~ ESP_INTR_FLAG_INTRDISABLED;
+        ESP_RETURN_ON_ERROR(esp_intr_alloc_intrstatus(mcpwm_periph_signals.groups[group_id].irq_id, isr_flags,
+                            (uint32_t)mcpwm_ll_intr_get_status_reg(hal->dev), MCPWM_LL_EVENT_CMP_EQUAL(oper_id, cmpr_id),
+                            mcpwm_comparator_default_isr, cmpr, &cmpr->intr), TAG, "install interrupt service for comparator failed");
+    }
+
+    portENTER_CRITICAL(&group->spinlock);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_CMP_EQUAL(oper_id, cmpr_id), cbs->on_reach != NULL);
+    portEXIT_CRITICAL(&group->spinlock);
+
+    cmpr->on_reach = cbs->on_reach;
+    cmpr->user_data = user_data;
+
+    return ESP_OK;
+}
+
+static void IRAM_ATTR mcpwm_comparator_default_isr(void *args)
+{
+    mcpwm_cmpr_t *cmpr = (mcpwm_cmpr_t *)args;
+    mcpwm_oper_t *oper = cmpr->operator;
+    mcpwm_group_t *group = oper->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int oper_id = oper->oper_id;
+    int cmpr_id = cmpr->cmpr_id;
+    bool need_yield = false;
+
+    uint32_t status = mcpwm_ll_intr_get_status(hal->dev);
+    mcpwm_ll_intr_clear_status(hal->dev, status & MCPWM_LL_EVENT_CMP_EQUAL(oper_id, cmpr_id));
+
+    mcpwm_compare_event_data_t edata = {
+        .compare_ticks = cmpr->compare_ticks,
+        // .direction = TODO
+    };
+
+    if (status & MCPWM_LL_EVENT_CMP_EQUAL(oper_id, cmpr_id)) {
+        mcpwm_compare_event_cb_t cb = cmpr->on_reach;
+        if (cb) {
+            if (cb(cmpr, &edata, cmpr->user_data)) {
+                need_yield = true;
+            }
+        }
+    }
+
+    if (need_yield) {
+        portYIELD_FROM_ISR();
+    }
+}
diff --git a/components/driver/mcpwm/mcpwm_com.c b/components/driver/mcpwm/mcpwm_com.c
new file mode 100644
index 0000000000..7d9e555e32
--- /dev/null
+++ b/components/driver/mcpwm/mcpwm_com.c
@@ -0,0 +1,135 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdint.h>
+#include <sys/lock.h>
+#include "sdkconfig.h"
+#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
+// The local log level must be defined before including esp_log.h
+// Set the maximum log level for this source file
+#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
+#endif
+#include "esp_log.h"
+#include "esp_check.h"
+#include "esp_private/periph_ctrl.h"
+#include "soc/mcpwm_periph.h"
+#include "hal/mcpwm_ll.h"
+#include "mcpwm_private.h"
+
+static const char *TAG = "mcpwm";
+
+typedef struct {
+    _lock_t mutex;                           // platform level mutex lock
+    mcpwm_group_t *groups[SOC_MCPWM_GROUPS]; // array of MCPWM group instances
+    int group_ref_counts[SOC_MCPWM_GROUPS];  // reference count used to protect group install/uninstall
+} mcpwm_platform_t;
+
+static mcpwm_platform_t s_platform; // singleton platform
+
+mcpwm_group_t *mcpwm_acquire_group_handle(int group_id)
+{
+    bool new_group = false;
+    mcpwm_group_t *group = NULL;
+
+    // prevent install mcpwm group concurrently
+    _lock_acquire(&s_platform.mutex);
+    if (!s_platform.groups[group_id]) {
+        group = heap_caps_calloc(1, sizeof(mcpwm_group_t), MCPWM_MEM_ALLOC_CAPS);
+        if (group) {
+            new_group = true;
+            s_platform.groups[group_id] = group;
+            group->group_id = group_id;
+            group->spinlock = (portMUX_TYPE)portMUX_INITIALIZER_UNLOCKED;
+            // enable APB to access MCPWM registers
+            periph_module_enable(mcpwm_periph_signals.groups[group_id].module);
+            periph_module_reset(mcpwm_periph_signals.groups[group_id].module);
+            // initialize HAL context
+            mcpwm_hal_init_config_t hal_config = {
+                .group_id = group_id
+            };
+            mcpwm_hal_context_t *hal = &group->hal;
+            mcpwm_hal_init(hal, &hal_config);
+            // disable all interrupts and clear pending status
+            mcpwm_ll_intr_enable(hal->dev, UINT32_MAX, false);
+            mcpwm_ll_intr_clear_status(hal->dev, UINT32_MAX);
+        }
+    } else { // group already install
+        group = s_platform.groups[group_id];
+    }
+    if (group) {
+        // someone acquired the group handle means we have a new object that refer to this group
+        s_platform.group_ref_counts[group_id]++;
+    }
+    _lock_release(&s_platform.mutex);
+
+    if (new_group) {
+        ESP_LOGD(TAG, "new group(%d) at %p", group_id, group);
+    }
+    return group;
+}
+
+void mcpwm_release_group_handle(mcpwm_group_t *group)
+{
+    int group_id = group->group_id;
+    bool do_deinitialize = false;
+
+    _lock_acquire(&s_platform.mutex);
+    s_platform.group_ref_counts[group_id]--;
+    if (s_platform.group_ref_counts[group_id] == 0) {
+        do_deinitialize = true;
+        s_platform.groups[group_id] = NULL; // deregister from platfrom
+        // hal layer deinitialize
+        mcpwm_hal_deinit(&group->hal);
+        periph_module_disable(mcpwm_periph_signals.groups[group_id].module);
+        free(group);
+    }
+    _lock_release(&s_platform.mutex);
+
+    if (do_deinitialize) {
+        ESP_LOGD(TAG, "del group(%d)", group_id);
+    }
+}
+
+esp_err_t mcpwm_select_periph_clock(mcpwm_group_t *group, mcpwm_timer_clock_source_t clk_src)
+{
+    esp_err_t ret = ESP_OK;
+    uint32_t periph_src_clk_hz = 0;
+    bool clock_selection_conflict = false;
+    bool do_clock_init = false;
+    // check if we need to update the group clock source, group clock source is shared by all mcpwm objects
+    portENTER_CRITICAL(&group->spinlock);
+    if (group->clk_src == 0) {
+        group->clk_src = clk_src;
+        do_clock_init = true;
+    } else {
+        clock_selection_conflict = (group->clk_src != clk_src);
+    }
+    portEXIT_CRITICAL(&group->spinlock);
+    ESP_RETURN_ON_FALSE(!clock_selection_conflict, ESP_ERR_INVALID_STATE, TAG,
+                        "group clock conflict, already is %d but attempt to %d", group->clk_src, clk_src);
+
+    if (do_clock_init) {
+        // [clk_tree] ToDo: replace the following switch-case table by clock_tree APIs
+        switch (clk_src) {
+        case MCPWM_TIMER_CLK_SRC_DEFAULT:
+            periph_src_clk_hz = 160000000;
+#if CONFIG_PM_ENABLE
+            sprintf(group->pm_lock_name, "mcpwm_%d", group->group_id); // e.g. mcpwm_0
+            ret  = esp_pm_lock_create(ESP_PM_APB_FREQ_MAX, 0, group->pm_lock_name, &group->pm_lock);
+            ESP_RETURN_ON_ERROR(ret, TAG, "create ESP_PM_APB_FREQ_MAX lock failed");
+            ESP_LOGD(TAG, "install ESP_PM_APB_FREQ_MAX lock for MCPWM group(%d)", group->group_id);
+#endif // CONFIG_PM_ENABLE
+            break;
+        default:
+            ESP_RETURN_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, TAG, "clock source %d is not supported", clk_src);
+            break;
+        }
+        mcpwm_ll_group_set_clock_prescale(group->hal.dev, MCPWM_PERIPH_CLOCK_PRE_SCALE);
+        group->resolution_hz = periph_src_clk_hz / MCPWM_PERIPH_CLOCK_PRE_SCALE;
+        ESP_LOGD(TAG, "group (%d) clock resolution:%uHz", group->group_id, group->resolution_hz);
+    }
+    return ret;
+}
diff --git a/components/driver/mcpwm/mcpwm_fault.c b/components/driver/mcpwm/mcpwm_fault.c
new file mode 100644
index 0000000000..44936d7215
--- /dev/null
+++ b/components/driver/mcpwm/mcpwm_fault.c
@@ -0,0 +1,302 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <sys/cdefs.h>
+#include "sdkconfig.h"
+#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
+// The local log level must be defined before including esp_log.h
+// Set the maximum log level for this source file
+#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
+#endif
+#include "freertos/FreeRTOS.h"
+#include "esp_attr.h"
+#include "esp_check.h"
+#include "esp_err.h"
+#include "esp_log.h"
+#include "esp_memory_utils.h"
+#include "soc/soc_caps.h"
+#include "soc/mcpwm_periph.h"
+#include "hal/mcpwm_ll.h"
+#include "driver/mcpwm_fault.h"
+#include "driver/gpio.h"
+#include "mcpwm_private.h"
+
+static const char *TAG = "mcpwm";
+
+static void mcpwm_gpio_fault_default_isr(void *args);
+static esp_err_t mcpwm_del_gpio_fault(mcpwm_fault_handle_t fault);
+static esp_err_t mcpwm_del_soft_fault(mcpwm_fault_handle_t fault);
+
+static esp_err_t mcpwm_gpio_fault_register_to_group(mcpwm_gpio_fault_t *fault, int group_id)
+{
+    mcpwm_group_t *group = mcpwm_acquire_group_handle(group_id);
+    ESP_RETURN_ON_FALSE(group, ESP_ERR_NO_MEM, TAG, "no mem for group (%d)", group_id);
+
+    int fault_id = -1;
+    portENTER_CRITICAL(&group->spinlock);
+    for (int i = 0; i < SOC_MCPWM_GPIO_FAULTS_PER_GROUP; i++) {
+        if (!group->gpio_faults[i]) {
+            fault_id = i;
+            group->gpio_faults[i] = fault;
+            break;
+        }
+    }
+    portEXIT_CRITICAL(&group->spinlock);
+    if (fault_id < 0) {
+        mcpwm_release_group_handle(group);
+        group = NULL;
+    } else {
+        fault->base.group = group;
+        fault->fault_id = fault_id;
+    }
+    ESP_RETURN_ON_FALSE(fault_id >= 0, ESP_ERR_NOT_FOUND, TAG, "no free gpio fault in group (%d)", group_id);
+    return ESP_OK;
+}
+
+static void mcpwm_gpio_fault_unregister_from_group(mcpwm_gpio_fault_t *fault)
+{
+    mcpwm_group_t *group = fault->base.group;
+    int fault_id = fault->fault_id;
+
+    portENTER_CRITICAL(&group->spinlock);
+    group->gpio_faults[fault_id] = NULL;
+    portEXIT_CRITICAL(&group->spinlock);
+
+    // fault has a reference on group, release it now
+    mcpwm_release_group_handle(group);
+}
+
+static esp_err_t mcpwm_gpio_fault_destory(mcpwm_gpio_fault_t *fault)
+{
+    if (fault->intr) {
+        ESP_RETURN_ON_ERROR(esp_intr_free(fault->intr), TAG, "uninstall interrupt service failed");
+    }
+    if (fault->base.group) {
+        mcpwm_gpio_fault_unregister_from_group(fault);
+    }
+    free(fault);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_new_gpio_fault(const mcpwm_gpio_fault_config_t *config, mcpwm_fault_handle_t *ret_fault)
+{
+#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
+    esp_log_level_set(TAG, ESP_LOG_DEBUG);
+#endif
+    esp_err_t ret = ESP_OK;
+    mcpwm_gpio_fault_t *fault = NULL;
+    ESP_GOTO_ON_FALSE(config && ret_fault, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    ESP_GOTO_ON_FALSE(config->group_id < SOC_MCPWM_GROUPS && config->group_id >= 0, ESP_ERR_INVALID_ARG,
+                      err, TAG, "invalid group ID:%d", config->group_id);
+
+    fault = heap_caps_calloc(1, sizeof(mcpwm_gpio_fault_t), MCPWM_MEM_ALLOC_CAPS);
+    ESP_GOTO_ON_FALSE(fault, ESP_ERR_NO_MEM, err, TAG, "no mem for gpio fault");
+
+    ESP_GOTO_ON_ERROR(mcpwm_gpio_fault_register_to_group(fault, config->group_id), err, TAG, "register gpio fault failed");
+    mcpwm_group_t *group = fault->base.group;
+    int group_id = group->group_id;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int fault_id = fault->fault_id;
+
+    // GPIO configuration
+    gpio_config_t gpio_conf = {
+        .intr_type = GPIO_INTR_DISABLE,
+        .mode = GPIO_MODE_INPUT | (config->flags.io_loop_back ? GPIO_MODE_OUTPUT : 0), // also enable the output path if `io_loop_back` is enabled
+        .pin_bit_mask = (1ULL << config->gpio_num),
+        .pull_down_en = config->flags.pull_down,
+        .pull_up_en = config->flags.pull_up,
+    };
+    ESP_GOTO_ON_ERROR(gpio_config(&gpio_conf), err, TAG, "config fault GPIO failed");
+    esp_rom_gpio_connect_in_signal(config->gpio_num, mcpwm_periph_signals.groups[group_id].gpio_faults[fault_id].fault_sig, 0);
+
+    // set fault detection polarity
+    // different gpio faults share the same config register, using a group level spin lock
+    portENTER_CRITICAL(&group->spinlock);
+    mcpwm_ll_fault_set_active_level(hal->dev, fault_id, config->flags.active_level);
+    portEXIT_CRITICAL(&group->spinlock);
+
+    // enable fault detection
+    mcpwm_ll_fault_enable_detection(hal->dev, fault_id, true);
+
+    // fill in other operator members
+    fault->base.type = MCPWM_FAULT_TYPE_GPIO;
+    fault->gpio_num = config->gpio_num;
+    fault->base.del = mcpwm_del_gpio_fault;
+    *ret_fault = &fault->base;
+    ESP_LOGD(TAG, "new gpio fault (%d,%d) at %p, GPIO: %d", group_id, fault_id, fault, config->gpio_num);
+    return ESP_OK;
+
+err:
+    if (fault) {
+        mcpwm_gpio_fault_destory(fault);
+    }
+    return ret;
+}
+
+static esp_err_t mcpwm_del_gpio_fault(mcpwm_fault_handle_t fault)
+{
+    mcpwm_gpio_fault_t *gpio_fault = __containerof(fault, mcpwm_gpio_fault_t, base);
+    mcpwm_group_t *group = fault->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int fault_id = gpio_fault->fault_id;
+
+    ESP_LOGD(TAG, "del GPIO fault (%d,%d)", group->group_id, fault_id);
+    gpio_reset_pin(gpio_fault->gpio_num);
+
+    portENTER_CRITICAL(&group->spinlock);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_FAULT_MASK(fault_id), false);
+    mcpwm_ll_intr_clear_status(hal->dev, MCPWM_LL_EVENT_FAULT_MASK(fault_id));
+    portEXIT_CRITICAL(&group->spinlock);
+
+    // disable fault detection
+    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");
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_new_soft_fault(const mcpwm_soft_fault_config_t *config, mcpwm_fault_handle_t *ret_fault)
+{
+    esp_err_t ret = ESP_OK;
+    mcpwm_soft_fault_t *soft_fault = NULL;
+    ESP_GOTO_ON_FALSE(config && ret_fault, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    soft_fault = heap_caps_calloc(1, sizeof(mcpwm_soft_fault_t), MCPWM_MEM_ALLOC_CAPS);
+    ESP_GOTO_ON_FALSE(soft_fault, ESP_ERR_NO_MEM, err, TAG, "no mem for soft fault");
+
+    // fill in other fault members
+    soft_fault->base.type = MCPWM_FAULT_TYPE_SOFT;
+    soft_fault->base.del = mcpwm_del_soft_fault;
+    *ret_fault = &soft_fault->base;
+    ESP_LOGD(TAG, "new soft fault at %p", soft_fault);
+    return ESP_OK;
+
+err:
+    if (soft_fault) {
+        free(soft_fault);
+    }
+    return ret;
+}
+
+static esp_err_t mcpwm_del_soft_fault(mcpwm_fault_handle_t fault)
+{
+    mcpwm_soft_fault_t *soft_fault = __containerof(fault, mcpwm_soft_fault_t, base);
+    ESP_LOGD(TAG, "del soft fault %p", soft_fault);
+    free(soft_fault);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_soft_fault_activate(mcpwm_fault_handle_t fault)
+{
+    ESP_RETURN_ON_FALSE(fault, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    ESP_RETURN_ON_FALSE(fault->type == MCPWM_FAULT_TYPE_SOFT, ESP_ERR_INVALID_ARG, TAG, "not a valid soft fault");
+    mcpwm_group_t *group = fault->group;
+    mcpwm_soft_fault_t *soft_fault = __containerof(fault, mcpwm_soft_fault_t, base);
+    mcpwm_oper_t *operator = soft_fault->operator;
+    ESP_RETURN_ON_FALSE(operator, ESP_ERR_INVALID_STATE, TAG, "no operator is assigned to the fault");
+
+    switch (operator->brake_mode_on_soft_fault) {
+    case MCPWM_OPER_BRAKE_MODE_CBC:
+        mcpwm_ll_brake_trigger_soft_cbc(group->hal.dev, operator->oper_id);
+        break;
+    case MCPWM_OPER_BRAKE_MODE_OST:
+        mcpwm_ll_brake_trigger_soft_ost(group->hal.dev, operator->oper_id);
+        break;
+    default:
+        ESP_RETURN_ON_FALSE(false, ESP_ERR_INVALID_STATE, TAG, "unknown brake mode:%d", operator->brake_mode_on_soft_fault);
+        break;
+    }
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_del_fault(mcpwm_fault_handle_t fault)
+{
+    ESP_RETURN_ON_FALSE(fault, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    return fault->del(fault);
+}
+
+esp_err_t mcpwm_fault_register_event_callbacks(mcpwm_fault_handle_t fault, const mcpwm_fault_event_callbacks_t *cbs, void *user_data)
+{
+    ESP_RETURN_ON_FALSE(fault && cbs, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    ESP_RETURN_ON_FALSE(fault->type == MCPWM_FAULT_TYPE_GPIO, ESP_ERR_INVALID_ARG, TAG, "only gpio fault can register event callback");
+    mcpwm_gpio_fault_t *gpio_fault = __containerof(fault, mcpwm_gpio_fault_t, base);
+    mcpwm_group_t *group = fault->group;
+    int group_id = group->group_id;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int fault_id = gpio_fault->fault_id;
+
+#if CONFIG_MCWPM_ISR_IRAM_SAFE
+    if (cbs->on_fault_enter) {
+        ESP_RETURN_ON_FALSE(esp_ptr_in_iram(cbs->on_fault_enter), ESP_ERR_INVALID_ARG, TAG, "on_fault_enter callback not in IRAM");
+    }
+    if (cbs->on_fault_exit) {
+        ESP_RETURN_ON_FALSE(esp_ptr_in_iram(cbs->on_fault_exit), ESP_ERR_INVALID_ARG, TAG, "on_fault_exit callback not in IRAM");
+    }
+    if (user_data) {
+        ESP_RETURN_ON_FALSE(esp_ptr_internal(user_data), ESP_ERR_INVALID_ARG, TAG, "user context not in internal RAM");
+    }
+#endif
+
+    // lazy install interrupt service
+    if (!gpio_fault->intr) {
+        // we want the interrupt servie to be enabled after allocation successfully
+        int isr_flags = MCPWM_INTR_ALLOC_FLAG & ~ESP_INTR_FLAG_INTRDISABLED;
+        ESP_RETURN_ON_ERROR(esp_intr_alloc_intrstatus(mcpwm_periph_signals.groups[group_id].irq_id, isr_flags,
+                            (uint32_t)mcpwm_ll_intr_get_status_reg(hal->dev), MCPWM_LL_EVENT_FAULT_MASK(fault_id),
+                            mcpwm_gpio_fault_default_isr, gpio_fault, &gpio_fault->intr), TAG, "install interrupt service for gpio fault failed");
+    }
+
+    // different mcpwm events share the same interrupt control register
+    portENTER_CRITICAL(&group->spinlock);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_FAULT_ENTER(fault_id), cbs->on_fault_enter != NULL);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_FAULT_EXIT(fault_id), cbs->on_fault_exit != NULL);
+    portEXIT_CRITICAL(&group->spinlock);
+
+    gpio_fault->on_fault_enter = cbs->on_fault_enter;
+    gpio_fault->on_fault_exit = cbs->on_fault_exit;
+    gpio_fault->user_data = user_data;
+    return ESP_OK;
+}
+
+static void IRAM_ATTR mcpwm_gpio_fault_default_isr(void *args)
+{
+    mcpwm_gpio_fault_t *fault = (mcpwm_gpio_fault_t *)args;
+    mcpwm_group_t *group = fault->base.group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int fault_id = fault->fault_id;
+    bool need_yield = false;
+
+    uint32_t status = mcpwm_ll_intr_get_status(hal->dev);
+    mcpwm_ll_intr_clear_status(hal->dev, status & MCPWM_LL_EVENT_FAULT_MASK(fault_id));
+
+    mcpwm_fault_event_data_t edata = {
+        // TODO
+    };
+
+    if (status & MCPWM_LL_EVENT_FAULT_ENTER(fault_id)) {
+        mcpwm_fault_event_cb_t cb = fault->on_fault_enter;
+        if (cb) {
+            if (cb(&fault->base, &edata, fault->user_data)) {
+                need_yield = true;
+            }
+        }
+    }
+
+    if (status & MCPWM_LL_EVENT_FAULT_EXIT(fault_id)) {
+        mcpwm_fault_event_cb_t cb = fault->on_fault_exit;
+        if (cb) {
+            if (cb(&fault->base, &edata, fault->user_data)) {
+                need_yield = true;
+            }
+        }
+    }
+
+    if (need_yield) {
+        portYIELD_FROM_ISR();
+    }
+}
diff --git a/components/driver/mcpwm/mcpwm_gen.c b/components/driver/mcpwm/mcpwm_gen.c
new file mode 100644
index 0000000000..41ec7c2f62
--- /dev/null
+++ b/components/driver/mcpwm/mcpwm_gen.c
@@ -0,0 +1,264 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <sys/cdefs.h>
+#include "sdkconfig.h"
+#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
+// The local log level must be defined before including esp_log.h
+// Set the maximum log level for this source file
+#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
+#endif
+#include "freertos/FreeRTOS.h"
+#include "esp_attr.h"
+#include "esp_check.h"
+#include "esp_err.h"
+#include "esp_log.h"
+#include "soc/soc_caps.h"
+#include "soc/mcpwm_periph.h"
+#include "hal/mcpwm_ll.h"
+#include "driver/gpio.h"
+#include "driver/mcpwm_gen.h"
+#include "mcpwm_private.h"
+
+static const char *TAG = "mcpwm";
+
+static esp_err_t mcpwm_generator_register_to_operator(mcpwm_gen_t *gen, mcpwm_oper_t *oper)
+{
+    int gen_id = -1;
+    portENTER_CRITICAL(&oper->spinlock);
+    for (int i = 0; i < SOC_MCPWM_GENERATORS_PER_OPERATOR; i++) {
+        if (!oper->generators[i]) {
+            oper->generators[i] = gen;
+            gen_id = i;
+            break;
+        }
+    }
+    portEXIT_CRITICAL(&oper->spinlock);
+    ESP_RETURN_ON_FALSE(gen_id >= 0, ESP_ERR_NOT_FOUND, TAG, "no free generator in operator (%d,%d)", oper->group->group_id, oper->oper_id);
+
+    gen->gen_id = gen_id;
+    gen->operator = oper;
+    return ESP_OK;
+}
+
+static void mcpwm_generator_unregister_from_operator(mcpwm_gen_t *gen)
+{
+    mcpwm_oper_t *oper = gen->operator;
+    int gen_id = gen->gen_id;
+
+    portENTER_CRITICAL(&oper->spinlock);
+    oper->generators[gen_id] = NULL;
+    portEXIT_CRITICAL(&oper->spinlock);
+}
+
+static esp_err_t mcpwm_generator_destory(mcpwm_gen_t *gen)
+{
+    if (gen->operator) {
+        mcpwm_generator_unregister_from_operator(gen);
+    }
+    free(gen);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_new_generator(mcpwm_oper_handle_t oper, const mcpwm_generator_config_t *config, mcpwm_gen_handle_t *ret_gen)
+{
+    esp_err_t ret = ESP_OK;
+    mcpwm_gen_t *gen = NULL;
+    ESP_GOTO_ON_FALSE(oper && config && ret_gen, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+
+    gen = heap_caps_calloc(1, sizeof(mcpwm_gen_t), MCPWM_MEM_ALLOC_CAPS);
+    ESP_GOTO_ON_FALSE(gen, ESP_ERR_NO_MEM, err, TAG, "no mem for generator");
+
+    ESP_GOTO_ON_ERROR(mcpwm_generator_register_to_operator(gen, oper), err, TAG, "register generator failed");
+    mcpwm_group_t *group = oper->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int oper_id = oper->oper_id;
+    int gen_id = gen->gen_id;
+
+    // reset generator
+    mcpwm_hal_generator_reset(hal, oper_id, gen_id);
+
+    // GPIO configuration
+    gpio_config_t gpio_conf = {
+        .intr_type = GPIO_INTR_DISABLE,
+        .mode = GPIO_MODE_OUTPUT | (config->flags.io_loop_back ? GPIO_MODE_INPUT : 0), // also enable the input path if `io_loop_back` is enabled
+        .pin_bit_mask = (1ULL << config->gen_gpio_num),
+        .pull_down_en = false,
+        .pull_up_en = true,
+    };
+    ESP_GOTO_ON_ERROR(gpio_config(&gpio_conf), err, TAG, "config gen GPIO failed");
+    esp_rom_gpio_connect_out_signal(config->gen_gpio_num,
+                                    mcpwm_periph_signals.groups[group->group_id].operators[oper_id].generators[gen_id].pwm_sig,
+                                    config->flags.invert_pwm, 0);
+
+    // fill in other generator members
+    gen->gen_gpio_num = config->gen_gpio_num;
+    gen->spinlock = (portMUX_TYPE)portMUX_INITIALIZER_UNLOCKED;
+    *ret_gen = gen;
+    ESP_LOGD(TAG, "new generator (%d,%d,%d) at %p, GPIO %d", group->group_id, oper_id, gen_id, gen, gen->gen_gpio_num);
+    return ESP_OK;
+
+err:
+    if (gen) {
+        mcpwm_generator_destory(gen);
+    }
+    return ret;
+}
+
+esp_err_t mcpwm_del_generator(mcpwm_gen_handle_t gen)
+{
+    ESP_RETURN_ON_FALSE(gen, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_oper_t *oper = gen->operator;
+    mcpwm_group_t *group = oper->group;
+
+    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");
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_generator_set_force_level(mcpwm_gen_handle_t gen, int level, bool hold_on)
+{
+    ESP_RETURN_ON_FALSE(gen && level <= 1, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_oper_t *oper = gen->operator;
+    mcpwm_group_t *group = oper->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int oper_id = oper->oper_id;
+    int gen_id = gen->gen_id;
+
+    if (level < 0) { // to remove the force level
+        if (hold_on) {
+            mcpwm_ll_gen_disable_continue_force_action(hal->dev, oper_id, gen_id);
+        } else {
+            mcpwm_ll_gen_disable_noncontinue_force_action(hal->dev, oper_id, gen_id);
+        }
+    } else { // to enable the force output level
+        if (hold_on) {
+            mcpwm_ll_gen_set_continue_force_level(hal->dev, oper_id, gen_id, level);
+        } else {
+            mcpwm_ll_gen_set_noncontinue_force_level(hal->dev, oper_id, gen_id, level);
+            mcpwm_ll_gen_trigger_noncontinue_force_action(hal->dev, oper_id, gen_id);
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_generator_set_actions_on_timer_event(mcpwm_gen_handle_t gen, mcpwm_gen_timer_event_action_t ev_act, ...)
+{
+    ESP_RETURN_ON_FALSE(gen, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_oper_t *operator= gen->operator;
+    mcpwm_group_t *group = operator->group;
+    mcpwm_timer_t *timer = operator->timer;
+    ESP_RETURN_ON_FALSE(timer, ESP_ERR_INVALID_STATE, TAG, "no timer is connected to the operator");
+    mcpwm_gen_timer_event_action_t ev_act_itor = ev_act;
+    bool invalid_utep = false;
+    bool invalid_dtez = false;
+    va_list it;
+    va_start(it, ev_act);
+    while (ev_act_itor.event != MCPWM_TIMER_EVENT_INVALID) {
+        invalid_utep = (timer->count_mode == MCPWM_TIMER_COUNT_MODE_UP_DOWN) &&
+                       (ev_act_itor.direction == MCPWM_TIMER_DIRECTION_UP) &&
+                       (ev_act_itor.event == MCPWM_TIMER_EVENT_FULL);
+        invalid_dtez = (timer->count_mode == MCPWM_TIMER_COUNT_MODE_UP_DOWN) &&
+                       (ev_act_itor.direction == MCPWM_TIMER_DIRECTION_DOWN) &&
+                       (ev_act_itor.event == MCPWM_TIMER_EVENT_EMPTY);
+        if (invalid_utep || invalid_dtez) {
+            va_end(it);
+            ESP_RETURN_ON_FALSE(false, ESP_ERR_INVALID_ARG, TAG, "UTEP and DTEZ can't be reached under MCPWM_TIMER_COUNT_MODE_UP_DOWN mode");
+        }
+        mcpwm_ll_generator_set_action_on_timer_event(group->hal.dev, operator->oper_id, gen->gen_id,
+                ev_act_itor.direction, ev_act_itor.event, ev_act_itor.action);
+        ev_act_itor = va_arg(it, mcpwm_gen_timer_event_action_t);
+    }
+    va_end(it);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_generator_set_actions_on_compare_event(mcpwm_gen_handle_t gen, mcpwm_gen_compare_event_action_t ev_act, ...)
+{
+    ESP_RETURN_ON_FALSE(gen, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_oper_t *operator= gen->operator;
+    mcpwm_group_t *group = operator->group;
+    mcpwm_gen_compare_event_action_t ev_act_itor = ev_act;
+    va_list it;
+    va_start(it, ev_act);
+    while (ev_act_itor.comparator) {
+        mcpwm_ll_generator_set_action_on_compare_event(group->hal.dev, operator->oper_id, gen->gen_id,
+                ev_act_itor.direction, ev_act_itor.comparator->cmpr_id, ev_act_itor.action);
+        ev_act_itor = va_arg(it, mcpwm_gen_compare_event_action_t);
+    }
+    va_end(it);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_generator_set_actions_on_brake_event(mcpwm_gen_handle_t gen, mcpwm_gen_brake_event_action_t ev_act, ...)
+{
+    ESP_RETURN_ON_FALSE(gen, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_oper_t *operator= gen->operator;
+    mcpwm_group_t *group = operator->group;
+    mcpwm_gen_brake_event_action_t ev_act_itor = ev_act;
+    va_list it;
+    va_start(it, ev_act);
+    while (ev_act_itor.brake_mode != MCPWM_OPER_BRAKE_MODE_INVALID) {
+        mcpwm_ll_generator_set_action_on_brake_event(group->hal.dev, operator->oper_id, gen->gen_id,
+                ev_act_itor.direction, ev_act_itor.brake_mode, ev_act_itor.action);
+        ev_act_itor = va_arg(it, mcpwm_gen_brake_event_action_t);
+    }
+    va_end(it);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_generator_set_dead_time(mcpwm_gen_handle_t in_generator, mcpwm_gen_handle_t out_generator, const mcpwm_dead_time_config_t *config)
+{
+    ESP_RETURN_ON_FALSE(in_generator && out_generator && config, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    ESP_RETURN_ON_FALSE(in_generator->operator == out_generator->operator, ESP_ERR_INVALID_ARG, TAG, "in/out generator are not derived from the same operator");
+    ESP_RETURN_ON_FALSE(config->negedge_delay_ticks < MCPWM_LL_MAX_DEAD_DELAY && config->posedge_delay_ticks < MCPWM_LL_MAX_DEAD_DELAY,
+                        ESP_ERR_INVALID_ARG, TAG, "delay time out of range");
+    mcpwm_oper_t *operator= in_generator->operator;
+    mcpwm_group_t *group = operator->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int oper_id = operator->oper_id;
+
+    // Note: to better understand the following code, you should read the deadtime module topology diagram in the TRM
+    // check if we want to bypass the deadtime module
+    bool bypass = (config->negedge_delay_ticks == 0) && (config->posedge_delay_ticks == 0);
+    // check is we want to delay on the both edge
+    bool delay_on_both_edge = config->posedge_delay_ticks && config->negedge_delay_ticks;
+    int out_path_id = -1;
+    if (bypass) {
+        // out path is same to the input path of generator
+        out_path_id = in_generator->gen_id;
+    } else if (config->negedge_delay_ticks) {
+        out_path_id = 1; // FED path
+    } else {
+        out_path_id = 0; // RED path
+    }
+    bool swap_path = out_path_id != out_generator->gen_id;
+    mcpwm_ll_deadtime_bypass_path(hal->dev, oper_id, out_path_id, bypass); // S0/1
+    if (!bypass) {
+        if (config->posedge_delay_ticks) {
+            mcpwm_ll_deadtime_red_select_generator(hal->dev, oper_id, in_generator->gen_id); // S4
+        } else {
+            mcpwm_ll_deadtime_fed_select_generator(hal->dev, oper_id, in_generator->gen_id); // S5
+        }
+        mcpwm_ll_deadtime_enable_deb(hal->dev, oper_id, delay_on_both_edge); // S8
+        mcpwm_ll_deadtime_invert_outpath(hal->dev, oper_id, out_path_id, config->flags.invert_output); // S2/3
+        mcpwm_ll_deadtime_swap_out_path(hal->dev, oper_id, out_generator->gen_id, swap_path); // S6/S7
+    }
+    // set delay time
+    if (config->posedge_delay_ticks) {
+        mcpwm_ll_deadtime_set_rising_delay(hal->dev, oper_id, config->posedge_delay_ticks);
+    }
+    if (config->negedge_delay_ticks) {
+        mcpwm_ll_deadtime_set_falling_delay(hal->dev, oper_id, config->negedge_delay_ticks);
+    }
+
+    ESP_LOGD(TAG, "operator (%d,%d) dead time (R:%u,F:%u), topology code:%x", group->group_id, oper_id,
+             config->posedge_delay_ticks, config->negedge_delay_ticks, mcpwm_ll_deadtime_get_switch_topology(hal->dev, oper_id));
+    return ESP_OK;
+}
diff --git a/components/driver/mcpwm/mcpwm_oper.c b/components/driver/mcpwm/mcpwm_oper.c
new file mode 100644
index 0000000000..cbf3219dea
--- /dev/null
+++ b/components/driver/mcpwm/mcpwm_oper.c
@@ -0,0 +1,363 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <sys/cdefs.h>
+#include "sdkconfig.h"
+#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
+// The local log level must be defined before including esp_log.h
+// Set the maximum log level for this source file
+#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
+#endif
+#include "freertos/FreeRTOS.h"
+#include "esp_attr.h"
+#include "esp_check.h"
+#include "esp_err.h"
+#include "esp_log.h"
+#include "esp_memory_utils.h"
+#include "soc/soc_caps.h"
+#include "soc/mcpwm_periph.h"
+#include "hal/mcpwm_ll.h"
+#include "driver/mcpwm_oper.h"
+#include "mcpwm_private.h"
+
+static const char *TAG = "mcpwm";
+
+static void mcpwm_operator_default_isr(void *args);
+
+static esp_err_t mcpwm_operator_register_to_group(mcpwm_oper_t *oper, int group_id)
+{
+    mcpwm_group_t *group = mcpwm_acquire_group_handle(group_id);
+    ESP_RETURN_ON_FALSE(group, ESP_ERR_NO_MEM, TAG, "no mem for group (%d)", group_id);
+
+    int oper_id = -1;
+    portENTER_CRITICAL(&group->spinlock);
+    for (int i = 0; i < SOC_MCPWM_OPERATORS_PER_GROUP; i++) {
+        if (!group->operators[i]) {
+            oper_id = i;
+            group->operators[i] = oper;
+            break;
+        }
+    }
+    portEXIT_CRITICAL(&group->spinlock);
+    if (oper_id < 0) {
+        mcpwm_release_group_handle(group);
+        group = NULL;
+    } else {
+        oper->group = group;
+        oper->oper_id = oper_id;
+    }
+    ESP_RETURN_ON_FALSE(oper_id >= 0, ESP_ERR_NOT_FOUND, TAG, "no free operators in group (%d)", group_id);
+    return ESP_OK;
+}
+
+static void mcpwm_operator_unregister_from_group(mcpwm_oper_t *oper)
+{
+    mcpwm_group_t *group = oper->group;
+    int oper_id =  oper->oper_id;
+
+    portENTER_CRITICAL(&group->spinlock);
+    group->operators[oper_id] = NULL;
+    portEXIT_CRITICAL(&group->spinlock);
+
+    // operator has a reference on group, release it now
+    mcpwm_release_group_handle(group);
+}
+
+static esp_err_t mcpwm_operator_destory(mcpwm_oper_t *oper)
+{
+    if (oper->intr) {
+        ESP_RETURN_ON_ERROR(esp_intr_free(oper->intr), TAG, "uninstall interrupt service failed");
+    }
+    if (oper->group) {
+        mcpwm_operator_unregister_from_group(oper);
+    }
+    free(oper);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_new_operator(const mcpwm_operator_config_t *config, mcpwm_oper_handle_t *ret_oper)
+{
+#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
+    esp_log_level_set(TAG, ESP_LOG_DEBUG);
+#endif
+    esp_err_t ret = ESP_OK;
+    mcpwm_oper_t *operator= NULL;
+    ESP_GOTO_ON_FALSE(config && ret_oper, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    ESP_GOTO_ON_FALSE(config->group_id < SOC_MCPWM_GROUPS && config->group_id >= 0, ESP_ERR_INVALID_ARG,
+                      err, TAG, "invalid group ID:%d", config->group_id);
+
+    operator= heap_caps_calloc(1, sizeof(mcpwm_oper_t), MCPWM_MEM_ALLOC_CAPS);
+    ESP_GOTO_ON_FALSE(operator, ESP_ERR_NO_MEM, err, TAG, "no mem for operator");
+
+    ESP_GOTO_ON_ERROR(mcpwm_operator_register_to_group(operator, config->group_id), err, TAG, "register operator failed");
+    mcpwm_group_t *group = operator->group;
+    int group_id = group->group_id;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int oper_id = operator->oper_id;
+
+    // reset MCPWM operator
+    mcpwm_hal_operator_reset(hal, oper_id);
+
+    // set the time point that the generator can update the action
+    mcpwm_ll_operator_enable_update_action_on_tez(hal->dev, oper_id, config->flags.update_gen_action_on_tez);
+    mcpwm_ll_operator_enable_update_action_on_tep(hal->dev, oper_id, config->flags.update_gen_action_on_tep);
+    mcpwm_ll_operator_enable_update_action_on_sync(hal->dev, oper_id, config->flags.update_gen_action_on_sync);
+    // set the time point that the deadtime can update the delay parameter
+    mcpwm_ll_deadtime_enable_update_delay_on_tez(hal->dev, oper_id, config->flags.update_dead_time_on_tez);
+    mcpwm_ll_deadtime_enable_update_delay_on_tep(hal->dev, oper_id, config->flags.update_dead_time_on_tep);
+    mcpwm_ll_deadtime_enable_update_delay_on_sync(hal->dev, oper_id, config->flags.update_dead_time_on_sync);
+    // set the clock source for dead time submodule, the resolution is the same to the MCPWM group
+    mcpwm_ll_operator_set_deadtime_clock_src(hal->dev, oper_id, MCPWM_LL_DEADTIME_CLK_SRC_GROUP);
+    operator->deadtime_resolution_hz = group->resolution_hz;
+
+    // fill in other operator members
+    operator->spinlock = (portMUX_TYPE)portMUX_INITIALIZER_UNLOCKED;
+    *ret_oper = operator;
+    ESP_LOGD(TAG, "new operator (%d,%d) at %p", group_id, oper_id, operator);
+    return ESP_OK;
+
+err:
+    if (operator) {
+        mcpwm_operator_destory(operator);
+    }
+    return ret;
+}
+
+esp_err_t mcpwm_del_operator(mcpwm_oper_handle_t oper)
+{
+    ESP_RETURN_ON_FALSE(oper, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    for (int i = 0; i < SOC_MCPWM_COMPARATORS_PER_OPERATOR; i++) {
+        ESP_RETURN_ON_FALSE(!oper->comparators[i], ESP_ERR_INVALID_STATE, TAG, "comparator still in working");
+    }
+    for (int i = 0; i < SOC_MCPWM_GENERATORS_PER_OPERATOR; i++) {
+        ESP_RETURN_ON_FALSE(!oper->generators[i], ESP_ERR_INVALID_STATE, TAG, "generator still in working");
+    }
+    ESP_RETURN_ON_FALSE(!oper->soft_fault, ESP_ERR_INVALID_STATE, TAG, "soft fault still in working");
+    mcpwm_group_t *group = oper->group;
+    int oper_id = oper->oper_id;
+    mcpwm_hal_context_t *hal = &group->hal;
+
+    portENTER_CRITICAL(&group->spinlock);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_OPER_MASK(oper_id), false);
+    mcpwm_ll_intr_clear_status(hal->dev, MCPWM_LL_EVENT_OPER_MASK(oper_id));
+    portEXIT_CRITICAL(&group->spinlock);
+
+    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");
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_operator_connect_timer(mcpwm_oper_handle_t oper, mcpwm_timer_handle_t timer)
+{
+    ESP_RETURN_ON_FALSE(oper && timer, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    ESP_RETURN_ON_FALSE(oper->group == timer->group, ESP_ERR_INVALID_ARG, TAG, "operator and timer should reside in the same group");
+    mcpwm_group_t *group = oper->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+
+    // connect operator and timer
+    mcpwm_ll_operator_connect_timer(hal->dev, oper->oper_id, timer->timer_id);
+    // change the the clock source of deadtime submodule to use MCPWM timer
+    mcpwm_ll_operator_set_deadtime_clock_src(hal->dev, oper->oper_id, MCPWM_LL_DEADTIME_CLK_SRC_TIMER);
+    oper->deadtime_resolution_hz = timer->resolution_hz;
+
+    oper->timer = timer;
+    ESP_LOGD(TAG, "connect operator (%d) and timer (%d) in group (%d)", oper->oper_id, timer->timer_id, group->group_id);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_operator_apply_carrier(mcpwm_oper_handle_t oper, const mcpwm_carrier_config_t *config)
+{
+    ESP_RETURN_ON_FALSE(oper, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_group_t *group = oper->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int oper_id = oper->oper_id;
+    uint32_t real_frequency = 0;
+    uint32_t real_fpd = 0;
+    float real_duty = 0.0;
+
+    if (config && config->frequency_hz) {
+        uint8_t pre_scale = group->resolution_hz / 8 / config->frequency_hz;
+        mcpwm_ll_carrier_set_prescale(hal->dev, oper_id, pre_scale);
+        real_frequency = group->resolution_hz / 8 / pre_scale;
+
+        uint8_t duty = (uint8_t)(config->duty_cycle * 8);
+        mcpwm_ll_carrier_set_duty(hal->dev, oper_id, duty);
+        real_duty = (float) duty / 8.0F;
+
+        uint8_t first_pulse_ticks = (uint8_t)(config->first_pulse_duration_us * real_frequency / 1000000UL);
+        ESP_RETURN_ON_FALSE(first_pulse_ticks > 0 && first_pulse_ticks <= MCPWM_LL_MAX_CARRIER_ONESHOT,
+                            ESP_ERR_INVALID_ARG, TAG, "invalid first pulse duration");
+        mcpwm_ll_carrier_set_first_pulse_width(hal->dev, oper_id, first_pulse_ticks);
+        real_fpd = first_pulse_ticks * 1000000UL / real_frequency;
+
+        mcpwm_ll_carrier_in_invert(hal->dev, oper_id, config->flags.invert_before_modulate);
+        mcpwm_ll_carrier_out_invert(hal->dev, oper_id, config->flags.invert_after_modulate);
+    }
+
+    mcpwm_ll_carrier_enable(hal->dev, oper_id, real_frequency > 0);
+
+    if (real_frequency > 0) {
+        ESP_LOGD(TAG, "enable carrier modulation for operator(%d,%d), freq=%uHz, duty=%.2f, FPD=%dus",
+                 group->group_id, oper_id, real_frequency, real_duty, real_fpd);
+    } else {
+        ESP_LOGD(TAG, "disable carrier for operator (%d,%d)", group->group_id, oper_id);
+    }
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_operator_register_event_callbacks(mcpwm_oper_handle_t oper, const mcpwm_operator_event_callbacks_t *cbs, void *user_data)
+{
+    ESP_RETURN_ON_FALSE(oper && cbs, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_group_t *group = oper->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int group_id = group->group_id;
+    int oper_id = oper->oper_id;
+
+#if CONFIG_MCWPM_ISR_IRAM_SAFE
+    if (cbs->on_brake_cbc) {
+        ESP_RETURN_ON_FALSE(esp_ptr_in_iram(cbs->on_brake_cbc), ESP_ERR_INVALID_ARG, TAG, "on_brake_cbc callback not in IRAM");
+    }
+    if (cbs->on_brake_ost) {
+        ESP_RETURN_ON_FALSE(esp_ptr_in_iram(cbs->on_brake_ost), ESP_ERR_INVALID_ARG, TAG, "on_brake_ost callback not in IRAM");
+    }
+    if (user_data) {
+        ESP_RETURN_ON_FALSE(esp_ptr_internal(user_data), ESP_ERR_INVALID_ARG, TAG, "user context not in internal RAM");
+    }
+#endif
+
+    // lazy install interrupt service
+    if (!oper->intr) {
+        // we want the interrupt servie to be enabled after allocation successfully
+        int isr_flags = MCPWM_INTR_ALLOC_FLAG & ~ ESP_INTR_FLAG_INTRDISABLED;
+        ESP_RETURN_ON_ERROR(esp_intr_alloc_intrstatus(mcpwm_periph_signals.groups[group_id].irq_id, isr_flags,
+                            (uint32_t)mcpwm_ll_intr_get_status_reg(hal->dev), MCPWM_LL_EVENT_OPER_MASK(oper_id),
+                            mcpwm_operator_default_isr, oper, &oper->intr), TAG, "install interrupt service for operator failed");
+    }
+
+    // enable/disable interrupt events
+    portENTER_CRITICAL(&group->spinlock);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_OPER_BRAKE_CBC(oper_id), cbs->on_brake_cbc != NULL);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_OPER_BRAKE_OST(oper_id), cbs->on_brake_ost != NULL);
+    portEXIT_CRITICAL(&group->spinlock);
+
+    oper->on_brake_cbc = cbs->on_brake_cbc;
+    oper->on_brake_ost = cbs->on_brake_ost;
+    oper->user_data = user_data;
+
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_operator_set_brake_on_fault(mcpwm_oper_handle_t operator, const mcpwm_brake_config_t *config)
+{
+    ESP_RETURN_ON_FALSE(operator && config, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_group_t *group = operator->group;
+    mcpwm_fault_t *fault = config->fault;
+
+    int oper_id = operator->oper_id;
+    mcpwm_ll_brake_enable_cbc_refresh_on_tez(group->hal.dev, oper_id, config->flags.cbc_recover_on_tez);
+    mcpwm_ll_fault_enable_cbc_refresh_on_tep(group->hal.dev, oper_id, config->flags.cbc_recover_on_tep);
+
+    switch (fault->type) {
+    case MCPWM_FAULT_TYPE_GPIO: {
+        ESP_RETURN_ON_FALSE(group == fault->group, ESP_ERR_INVALID_ARG, TAG, "fault and operator not in the same group");
+        mcpwm_gpio_fault_t *gpio_fault = __containerof(fault, mcpwm_gpio_fault_t, base);
+        mcpwm_ll_brake_enable_cbc_mode(group->hal.dev, oper_id, gpio_fault->fault_id, config->brake_mode == MCPWM_OPER_BRAKE_MODE_CBC);
+        mcpwm_ll_brake_enable_oneshot_mode(group->hal.dev, oper_id, gpio_fault->fault_id, config->brake_mode  == MCPWM_OPER_BRAKE_MODE_OST);
+        operator->brake_mode_on_gpio_fault[gpio_fault->fault_id] = config->brake_mode;
+        break;
+    }
+    case MCPWM_FAULT_TYPE_SOFT: {
+        mcpwm_soft_fault_t *soft_fault = __containerof(fault, mcpwm_soft_fault_t, base);
+        ESP_RETURN_ON_FALSE(!soft_fault->operator || soft_fault->operator == operator, ESP_ERR_INVALID_STATE, TAG, "soft fault already used by another operator");
+        soft_fault->operator = operator;
+        soft_fault->base.group = operator->group;
+        mcpwm_ll_brake_enable_soft_cbc(group->hal.dev, oper_id, config->brake_mode == MCPWM_OPER_BRAKE_MODE_CBC);
+        mcpwm_ll_brake_enable_soft_ost(group->hal.dev, oper_id, config->brake_mode == MCPWM_OPER_BRAKE_MODE_OST);
+        operator->brake_mode_on_soft_fault = config->brake_mode;
+        break;
+    }
+    default:
+        ESP_RETURN_ON_FALSE(false, ESP_ERR_INVALID_ARG, TAG, "unknown fault type:%d", fault->type);
+        break;
+    }
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_operator_recover_from_fault(mcpwm_oper_handle_t operator, mcpwm_fault_handle_t fault)
+{
+    ESP_RETURN_ON_FALSE(operator && fault, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_group_t *group = operator->group;
+    mcpwm_operator_brake_mode_t brake_mode;
+
+    // check the brake mode on the fault event
+    switch (fault->type) {
+    case MCPWM_FAULT_TYPE_GPIO: {
+        mcpwm_gpio_fault_t *gpio_fault = __containerof(fault, mcpwm_gpio_fault_t, base);
+        brake_mode = operator->brake_mode_on_gpio_fault[gpio_fault->fault_id];
+        break;
+    }
+    case MCPWM_FAULT_TYPE_SOFT:
+        brake_mode = operator->brake_mode_on_soft_fault;
+        break;
+    default:
+        ESP_RETURN_ON_FALSE(false, ESP_ERR_INVALID_ARG, TAG, "unknown fault type:%d", fault->type);
+        break;
+    }
+
+    bool fault_signal_is_active = false;
+    if (brake_mode == MCPWM_OPER_BRAKE_MODE_OST) {
+        fault_signal_is_active = mcpwm_ll_ost_brake_active(group->hal.dev, operator->oper_id);
+        // OST brake can't recover automatically, need to manually recovery the operator
+        if (!fault_signal_is_active) {
+            mcpwm_ll_brake_clear_ost(group->hal.dev, operator->oper_id);
+        }
+    } else {
+        fault_signal_is_active = mcpwm_ll_cbc_brake_active(group->hal.dev, operator->oper_id);
+        // CBC brake can recover automatically after deactivating the fault signal
+    }
+
+    ESP_RETURN_ON_FALSE(!fault_signal_is_active, ESP_ERR_INVALID_STATE, TAG, "recover fail, fault signal still active");
+    return ESP_OK;
+}
+
+static void IRAM_ATTR mcpwm_operator_default_isr(void *args)
+{
+    mcpwm_oper_t *oper = (mcpwm_oper_t *)args;
+    mcpwm_group_t *group = oper->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int oper_id = oper->oper_id;
+    bool need_yield = false;
+
+    uint32_t status = mcpwm_ll_intr_get_status(hal->dev);
+    mcpwm_ll_intr_clear_status(hal->dev, status & MCPWM_LL_EVENT_OPER_MASK(oper_id));
+
+    mcpwm_brake_event_data_t edata = {};
+
+    if (status & MCPWM_LL_EVENT_OPER_BRAKE_CBC(oper_id)) {
+        mcpwm_brake_event_cb_t cb = oper->on_brake_cbc;
+        if (cb) {
+            if (cb(oper, &edata, oper->user_data)) {
+                need_yield = true;
+            }
+        }
+    }
+
+    if (status & MCPWM_LL_EVENT_OPER_BRAKE_OST(oper_id)) {
+        mcpwm_brake_event_cb_t cb = oper->on_brake_ost;
+        if (cb) {
+            if (cb(oper, &edata, oper->user_data)) {
+                need_yield = true;
+            }
+        }
+    }
+
+    if (need_yield) {
+        portYIELD_FROM_ISR();
+    }
+}
diff --git a/components/driver/mcpwm/mcpwm_private.h b/components/driver/mcpwm/mcpwm_private.h
new file mode 100644
index 0000000000..b5881280f8
--- /dev/null
+++ b/components/driver/mcpwm/mcpwm_private.h
@@ -0,0 +1,221 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include "sdkconfig.h"
+#include "freertos/FreeRTOS.h"
+#include "esp_err.h"
+#include "esp_intr_alloc.h"
+#include "esp_heap_caps.h"
+#include "esp_pm.h"
+#include "soc/soc_caps.h"
+#include "hal/mcpwm_hal.h"
+#include "hal/mcpwm_types.h"
+#include "driver/mcpwm_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if CONFIG_MCPWM_ISR_IRAM_SAFE
+#define MCPWM_MEM_ALLOC_CAPS      (MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT)
+#else
+#define MCPWM_MEM_ALLOC_CAPS      MALLOC_CAP_DEFAULT
+#endif
+
+#if CONFIG_MCPWM_ISR_IRAM_SAFE
+#define MCPWM_INTR_ALLOC_FLAG     (ESP_INTR_FLAG_SHARED | ESP_INTR_FLAG_INTRDISABLED | ESP_INTR_FLAG_IRAM)
+#else
+#define MCPWM_INTR_ALLOC_FLAG     (ESP_INTR_FLAG_SHARED | ESP_INTR_FLAG_INTRDISABLED)
+#endif
+
+#define MCPWM_PERIPH_CLOCK_PRE_SCALE (2)
+#define MCPWM_PM_LOCK_NAME_LEN_MAX 16
+
+typedef struct mcpwm_group_t mcpwm_group_t;
+typedef struct mcpwm_timer_t mcpwm_timer_t;
+typedef struct mcpwm_cap_timer_t mcpwm_cap_timer_t;
+typedef struct mcpwm_oper_t mcpwm_oper_t;
+typedef struct mcpwm_cmpr_t mcpwm_cmpr_t;
+typedef struct mcpwm_gen_t mcpwm_gen_t;
+typedef struct mcpwm_fault_t mcpwm_fault_t;
+typedef struct mcpwm_gpio_fault_t mcpwm_gpio_fault_t;
+typedef struct mcpwm_soft_fault_t mcpwm_soft_fault_t;
+typedef struct mcpwm_sync_t mcpwm_sync_t;
+typedef struct mcpwm_gpio_sync_src_t mcpwm_gpio_sync_src_t;
+typedef struct mcpwm_timer_sync_src_t mcpwm_timer_sync_src_t;
+typedef struct mcpwm_soft_sync_src_t mcpwm_soft_sync_src_t;
+typedef struct mcpwm_cap_channel_t mcpwm_cap_channel_t;
+
+struct mcpwm_group_t {
+    int group_id;            // group ID, index from 0
+    mcpwm_hal_context_t hal; // HAL instance is at group level
+    portMUX_TYPE spinlock;   // group level spinlock
+    uint32_t resolution_hz;  // MCPWM group clock resolution
+    esp_pm_lock_handle_t pm_lock;       // power management lock
+    mcpwm_timer_clock_source_t clk_src; // source clock
+    mcpwm_cap_timer_t *cap_timer; // mcpwm capture timers
+    mcpwm_timer_t *timers[SOC_MCPWM_TIMERS_PER_GROUP]; // mcpwm timer array
+    mcpwm_oper_t *operators[SOC_MCPWM_OPERATORS_PER_GROUP]; // mcpwm operator array
+    mcpwm_gpio_fault_t *gpio_faults[SOC_MCPWM_GPIO_FAULTS_PER_GROUP]; // mcpwm fault detectors array
+    mcpwm_gpio_sync_src_t *gpio_sync_srcs[SOC_MCPWM_GPIO_SYNCHROS_PER_GROUP];  // mcpwm gpio sync array
+#if CONFIG_PM_ENABLE
+    char pm_lock_name[MCPWM_PM_LOCK_NAME_LEN_MAX]; // pm lock name
+#endif
+};
+
+typedef enum {
+    MCPWM_TIMER_FSM_INIT,
+    MCPWM_TIMER_FSM_ENABLE,
+} mcpwm_timer_fsm_t;
+
+struct mcpwm_timer_t {
+    int timer_id;           // timer ID, index from 0
+    mcpwm_group_t *group;   // which group the timer belongs to
+    mcpwm_timer_fsm_t fsm;  // driver FSM
+    portMUX_TYPE spinlock;  // spin lock
+    intr_handle_t intr;     // interrupt handle
+    uint32_t resolution_hz; // resolution of the timer
+    uint32_t peak_ticks;    // peak ticks that the timer could reach to
+    mcpwm_timer_sync_src_t *sync_src;      // timer sync_src
+    mcpwm_timer_count_mode_t count_mode; // count mode
+    mcpwm_timer_event_cb_t on_full;      // callback function when MCPWM timer counts to peak value
+    mcpwm_timer_event_cb_t on_empty;     // callback function when MCPWM timer counts to zero
+    mcpwm_timer_event_cb_t on_stop;      // callback function when MCPWM timer stops
+    void *user_data;                     // user data which would be passed to the timer callbacks
+};
+
+struct mcpwm_oper_t {
+    int oper_id;           // operator ID, index from 0
+    mcpwm_group_t *group;  // which group the timer belongs to
+    mcpwm_timer_t *timer;  // which timer is connected to this operator
+    portMUX_TYPE spinlock; // spin lock
+    intr_handle_t intr;    // interrupt handle
+    mcpwm_gen_t *generators[SOC_MCPWM_GENERATORS_PER_OPERATOR];    // mcpwm generator array
+    mcpwm_cmpr_t *comparators[SOC_MCPWM_COMPARATORS_PER_OPERATOR]; // mcpwm comparator array
+    mcpwm_soft_fault_t *soft_fault;                                // mcpwm software fault
+    mcpwm_operator_brake_mode_t brake_mode_on_soft_fault;          // brake mode on software triggered fault
+    mcpwm_operator_brake_mode_t brake_mode_on_gpio_fault[SOC_MCPWM_GPIO_FAULTS_PER_GROUP]; // brake mode on GPIO triggered faults
+    uint32_t deadtime_resolution_hz;     // resolution of deadtime submodule
+    mcpwm_brake_event_cb_t on_brake_cbc; // callback function which would be invoked when mcpwm operator goes into trip zone
+    mcpwm_brake_event_cb_t on_brake_ost; // callback function which would be invoked when mcpwm operator goes into trip zone
+    void *user_data;                     // user data which would be passed to the trip zone callback
+};
+
+struct mcpwm_cmpr_t {
+    int cmpr_id;                       // comparator ID, index from 0
+    mcpwm_oper_t *operator;            // which operator that the comparator resides in
+    intr_handle_t intr;                // interrupt handle
+    portMUX_TYPE spinlock;             // spin lock
+    uint32_t compare_ticks;            // compare value of this comparator
+    mcpwm_compare_event_cb_t on_reach; // ISR callback function  which would be invoked on timer counter reaches compare value
+    void *user_data;                   // user data which would be passed to the comparator callbacks
+};
+
+struct mcpwm_gen_t {
+    int gen_id;             // generator ID, index from 0
+    mcpwm_oper_t *operator; // which operator that the generator resides in
+    int gen_gpio_num;       // GPIO number used by the generator
+    portMUX_TYPE spinlock;  // spin lock
+};
+
+typedef enum {
+    MCPWM_FAULT_TYPE_GPIO, // external GPIO fault
+    MCPWM_FAULT_TYPE_SOFT, // software fault
+} mcpwm_fault_type_t;
+
+struct mcpwm_fault_t {
+    mcpwm_group_t *group;    // which group the fault belongs to
+    mcpwm_fault_type_t type; // fault type
+    esp_err_t (*del)(mcpwm_fault_t *fault);
+};
+
+struct mcpwm_gpio_fault_t {
+    mcpwm_fault_t base;  // base class
+    int fault_id;        // fault detector ID, index from 0
+    int gpio_num;  // GPIO number of fault detector
+    intr_handle_t intr;  // interrupt handle
+    mcpwm_fault_event_cb_t on_fault_enter; // ISR callback function that would be invoked when fault signal got triggered
+    mcpwm_fault_event_cb_t on_fault_exit;  // ISR callback function that would be invoked when fault signal got clear
+    void *user_data;      // user data which would be passed to the isr_cb
+};
+
+struct mcpwm_soft_fault_t {
+    mcpwm_fault_t base;     // base class
+    mcpwm_oper_t *operator; // the operator where the soft fault allocated from
+};
+
+typedef enum {
+    MCPWM_SYNC_TYPE_TIMER, // sync event generated by MCPWM timer count event
+    MCPWM_SYNC_TYPE_GPIO,  // sync event generated by GPIO
+    MCPWM_SYNC_TYPE_SOFT,  // sync event generated by software
+} mcpwm_sync_src_type_t;
+
+struct mcpwm_sync_t {
+    mcpwm_group_t *group;      // which group the sync_src belongs to
+    mcpwm_sync_src_type_t type; // sync_src type
+    esp_err_t (*del)(mcpwm_sync_t *sync_src);
+};
+
+struct mcpwm_gpio_sync_src_t {
+    mcpwm_sync_t base; // base class
+    int sync_id;       // sync signal ID
+    int gpio_num; // GPIO number
+};
+
+struct mcpwm_timer_sync_src_t {
+    mcpwm_sync_t base;    // base class
+    mcpwm_timer_t *timer; // timer handle, where this sync_src allocated from
+};
+
+typedef enum {
+    MCPWM_SOFT_SYNC_FROM_NONE,  // the software sync event generator has not been assigned
+    MCPWM_SOFT_SYNC_FROM_TIMER, // the software sync event is generated by MCPWM timer
+    MCPWM_SOFT_SYNC_FROM_CAP,   // the software sync event is generated by MCPWM capture timer
+} mcpwm_soft_sync_source_t;
+
+struct mcpwm_soft_sync_src_t {
+    mcpwm_sync_t base;                       // base class
+    mcpwm_soft_sync_source_t soft_sync_from; // where the software sync event is generated by
+    union {
+        mcpwm_timer_t *timer;                // soft sync is generated by which MCPWM timer
+        mcpwm_cap_timer_t *cap_timer;        // soft sync is generated by which MCPWM capture timer
+    };
+};
+
+typedef enum {
+    MCPWM_CAP_TIMER_FSM_INIT,
+    MCPWM_CAP_TIMER_FSM_ENABLE,
+} mcpwm_cap_timer_fsm_t;
+
+struct mcpwm_cap_timer_t {
+    mcpwm_group_t *group;   // which group the capture timer belongs to
+    portMUX_TYPE spinlock;  // spin lock, to prevent concurrently accessing capture timer level resources, including registers
+    uint32_t resolution_hz; // resolution of capture timer
+    mcpwm_cap_timer_fsm_t fsm;    // driver FSM
+    esp_pm_lock_handle_t pm_lock; // power management lock
+    mcpwm_cap_channel_t *cap_channels[SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER]; // capture channel array
+};
+
+struct mcpwm_cap_channel_t {
+    int cap_chan_id;                  // capture channel ID, index from 0
+    mcpwm_cap_timer_t *cap_timer;     // which capture timer that the channel resides in
+    uint32_t prescale;                // prescale of capture signal
+    int gpio_num;                 // GPIO number used by the channel
+    intr_handle_t intr;               // Interrupt handle
+    mcpwm_capture_event_cb_t on_cap;  // Callback function which would be invoked in capture interrupt routine
+    void *user_data;                  // user data which would be passed to the capture callback
+};
+
+mcpwm_group_t *mcpwm_acquire_group_handle(int group_id);
+void mcpwm_release_group_handle(mcpwm_group_t *group);
+esp_err_t mcpwm_select_periph_clock(mcpwm_group_t *group, mcpwm_timer_clock_source_t clk_src);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/components/driver/mcpwm/mcpwm_sync.c b/components/driver/mcpwm/mcpwm_sync.c
new file mode 100644
index 0000000000..164c36d9ee
--- /dev/null
+++ b/components/driver/mcpwm/mcpwm_sync.c
@@ -0,0 +1,297 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <sys/cdefs.h>
+#include "sdkconfig.h"
+#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
+// The local log level must be defined before including esp_log.h
+// Set the maximum log level for this source file
+#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
+#endif
+#include "freertos/FreeRTOS.h"
+#include "esp_attr.h"
+#include "esp_check.h"
+#include "esp_err.h"
+#include "esp_log.h"
+#include "esp_memory_utils.h"
+#include "soc/soc_caps.h"
+#include "soc/mcpwm_periph.h"
+#include "hal/mcpwm_ll.h"
+#include "driver/mcpwm_sync.h"
+#include "driver/gpio.h"
+#include "mcpwm_private.h"
+
+static const char *TAG = "mcpwm";
+
+static esp_err_t mcpwm_del_timer_sync_src(mcpwm_sync_t *sync_src);
+static esp_err_t mcpwm_del_gpio_sync_src(mcpwm_sync_t *sync_src);
+static esp_err_t mcpwm_del_soft_sync_src(mcpwm_sync_t *sync_src);
+
+static esp_err_t mcpwm_timer_sync_src_register_to_timer(mcpwm_timer_sync_src_t *timer_sync_src, mcpwm_timer_t *timer)
+{
+    bool new_sync = false;
+    portENTER_CRITICAL(&timer->spinlock);
+    if (!timer->sync_src) {
+        new_sync = true;
+        timer->sync_src = timer_sync_src;
+    }
+    portEXIT_CRITICAL(&timer->spinlock);
+    ESP_RETURN_ON_FALSE(new_sync, ESP_ERR_INVALID_STATE, TAG, "timer sync_src already installed for timer (%d,%d)",
+                        timer->group->group_id, timer->timer_id);
+
+    timer_sync_src->timer = timer;
+    return ESP_OK;
+}
+
+static void mcpwm_timer_sync_src_unregister_from_timer(mcpwm_timer_sync_src_t *timer_sync_src)
+{
+    mcpwm_timer_t *timer = timer_sync_src->timer;
+
+    portENTER_CRITICAL(&timer->spinlock);
+    timer->sync_src = NULL;
+    portEXIT_CRITICAL(&timer->spinlock);
+}
+
+static esp_err_t mcpwm_timer_sync_src_destory(mcpwm_timer_sync_src_t *timer_sync_src)
+{
+    if (timer_sync_src->timer) {
+        mcpwm_timer_sync_src_unregister_from_timer(timer_sync_src);
+    }
+    free(timer_sync_src);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_new_timer_sync_src(mcpwm_timer_handle_t timer, const mcpwm_timer_sync_src_config_t *config, mcpwm_sync_handle_t *ret_sync)
+{
+    esp_err_t ret = ESP_OK;
+    mcpwm_timer_sync_src_t *timer_sync_src = NULL;
+    ESP_GOTO_ON_FALSE(timer && config && ret_sync, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    timer_sync_src = heap_caps_calloc(1, sizeof(mcpwm_timer_sync_src_t), MCPWM_MEM_ALLOC_CAPS);
+    ESP_GOTO_ON_FALSE(timer_sync_src, ESP_ERR_NO_MEM, err, TAG, "no mem for timer sync_src");
+
+    ESP_GOTO_ON_ERROR(mcpwm_timer_sync_src_register_to_timer(timer_sync_src, timer), err, TAG, "register timer sync_src failed");
+    mcpwm_group_t *group = timer->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int timer_id = timer->timer_id;
+
+    if (config->flags.propagate_input_sync) {
+        mcpwm_ll_timer_propagate_input_sync(hal->dev, timer_id);
+    } else {
+        switch (config->timer_event) {
+        case MCPWM_TIMER_EVENT_EMPTY:
+            mcpwm_ll_timer_sync_out_on_timer_event(hal->dev, timer_id, MCPWM_TIMER_EVENT_EMPTY);
+            break;
+        case MCPWM_TIMER_EVENT_FULL:
+            mcpwm_ll_timer_sync_out_on_timer_event(hal->dev, timer_id, MCPWM_TIMER_EVENT_FULL);
+            break;
+        default:
+            ESP_GOTO_ON_FALSE(false, ESP_ERR_INVALID_ARG, err, TAG, "unknown timer sync event:%d", config->timer_event);
+            break;
+        }
+    }
+
+    timer_sync_src->base.group = group;
+    timer_sync_src->base.type = MCPWM_SYNC_TYPE_TIMER;
+    timer_sync_src->base.del = mcpwm_del_timer_sync_src;
+    *ret_sync = &timer_sync_src->base;
+    ESP_LOGD(TAG, "new timer sync_src at %p in timer (%d,%d), event:%c", timer_sync_src, group->group_id, timer_id, "EP?"[config->timer_event]);
+    return ESP_OK;
+
+err:
+    if (timer_sync_src) {
+        mcpwm_timer_sync_src_destory(timer_sync_src);
+    }
+    return ret;
+}
+
+static esp_err_t mcpwm_del_timer_sync_src(mcpwm_sync_t *sync_src)
+{
+    mcpwm_timer_sync_src_t *timer_sync_src = __containerof(sync_src, mcpwm_timer_sync_src_t, base);
+    mcpwm_timer_t *timer = timer_sync_src->timer;
+    int timer_id = timer->timer_id;
+    mcpwm_group_t *group = sync_src->group;
+
+    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");
+    return ESP_OK;
+}
+
+static esp_err_t mcpwm_gpio_sync_src_register_to_group(mcpwm_gpio_sync_src_t *gpio_sync_src, int group_id)
+{
+    mcpwm_group_t *group = mcpwm_acquire_group_handle(group_id);
+    ESP_RETURN_ON_FALSE(group, ESP_ERR_NO_MEM, TAG, "no mem for group (%d)", group_id);
+
+    int sync_id = -1;
+    portENTER_CRITICAL(&group->spinlock);
+    for (int i = 0; i < SOC_MCPWM_GPIO_SYNCHROS_PER_GROUP; i++) {
+        if (!group->gpio_sync_srcs[i]) {
+            sync_id = i;
+            group->gpio_sync_srcs[i] = gpio_sync_src;
+            break;
+        }
+    }
+    portEXIT_CRITICAL(&group->spinlock);
+
+    if (sync_id < 0) {
+        mcpwm_release_group_handle(group);
+        group = NULL;
+    } else {
+        gpio_sync_src->base.group = group;
+        gpio_sync_src->sync_id = sync_id;
+    }
+    ESP_RETURN_ON_FALSE(sync_id >= 0, ESP_ERR_NOT_FOUND, TAG, "no free gpio sync_src in group (%d)", group_id);
+
+    return ESP_OK;
+}
+
+static void mcpwm_gpio_sync_src_unregister_from_group(mcpwm_gpio_sync_src_t *gpio_sync_src)
+{
+    mcpwm_group_t *group = gpio_sync_src->base.group;
+    int sync_id = gpio_sync_src->sync_id;
+
+    portENTER_CRITICAL(&group->spinlock);
+    group->gpio_sync_srcs[sync_id] = NULL;
+    portEXIT_CRITICAL(&group->spinlock);
+
+    // sync_src has a reference on group, release it now
+    mcpwm_release_group_handle(group);
+}
+
+static esp_err_t mcpwm_gpio_sync_src_destory(mcpwm_gpio_sync_src_t *gpio_sync_src)
+{
+    if (gpio_sync_src->base.group) {
+        mcpwm_gpio_sync_src_unregister_from_group(gpio_sync_src);
+    }
+    free(gpio_sync_src);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_new_gpio_sync_src(const mcpwm_gpio_sync_src_config_t *config, mcpwm_sync_handle_t *ret_sync)
+{
+#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
+    esp_log_level_set(TAG, ESP_LOG_DEBUG);
+#endif
+    esp_err_t ret = ESP_OK;
+    mcpwm_gpio_sync_src_t *gpio_sync_src = NULL;
+    ESP_GOTO_ON_FALSE(config && ret_sync, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    ESP_GOTO_ON_FALSE(config->group_id < SOC_MCPWM_GROUPS && config->group_id >= 0, ESP_ERR_INVALID_ARG,
+                      err, TAG, "invalid group ID:%d", config->group_id);
+
+    gpio_sync_src = heap_caps_calloc(1, sizeof(mcpwm_gpio_sync_src_t), MCPWM_MEM_ALLOC_CAPS);
+    ESP_GOTO_ON_FALSE(gpio_sync_src, ESP_ERR_NO_MEM, err, TAG, "no mem for gpio sync_src");
+
+    ESP_GOTO_ON_ERROR(mcpwm_gpio_sync_src_register_to_group(gpio_sync_src, config->group_id), err, TAG, "register gpio sync_src failed");
+    mcpwm_group_t *group = gpio_sync_src->base.group;
+    int group_id = group->group_id;
+    int sync_id = gpio_sync_src->sync_id;
+
+    // GPIO configuration
+    gpio_config_t gpio_conf = {
+        .intr_type = GPIO_INTR_DISABLE,
+        .mode = GPIO_MODE_INPUT | (config->flags.io_loop_back ? GPIO_MODE_OUTPUT : 0), // also enable the output path if `io_loop_back` is enabled
+        .pin_bit_mask = (1ULL << config->gpio_num),
+        .pull_down_en = config->flags.pull_down,
+        .pull_up_en = config->flags.pull_up,
+    };
+    ESP_GOTO_ON_ERROR(gpio_config(&gpio_conf), err, TAG, "config sync GPIO failed");
+    esp_rom_gpio_connect_in_signal(config->gpio_num, mcpwm_periph_signals.groups[group_id].gpio_synchros[sync_id].sync_sig, 0);
+
+    // different ext sync share the same config register, using a group level spin lock
+    portENTER_CRITICAL(&group->spinlock);
+    mcpwm_ll_invert_gpio_sync_input(group->hal.dev, sync_id, config->flags.active_neg);
+    portEXIT_CRITICAL(&group->spinlock);
+
+    // fill in other operator members
+    gpio_sync_src->base.type = MCPWM_SYNC_TYPE_GPIO;
+    gpio_sync_src->gpio_num = config->gpio_num;
+    gpio_sync_src->base.del = mcpwm_del_gpio_sync_src;
+    *ret_sync = &gpio_sync_src->base;
+    ESP_LOGD(TAG, "new gpio sync_src (%d,%d) at %p, GPIO:%d", group_id, sync_id, gpio_sync_src, config->gpio_num);
+    return ESP_OK;
+
+err:
+    if (gpio_sync_src) {
+        mcpwm_gpio_sync_src_destory(gpio_sync_src);
+    }
+    return ret;
+}
+
+static esp_err_t mcpwm_del_gpio_sync_src(mcpwm_sync_t *sync_src)
+{
+    mcpwm_gpio_sync_src_t *gpio_sync_src = __containerof(sync_src, mcpwm_gpio_sync_src_t, base);
+    mcpwm_group_t *group = sync_src->group;
+
+    ESP_LOGD(TAG, "del gpio sync_src (%d,%d)", group->group_id, gpio_sync_src->sync_id);
+    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");
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_new_soft_sync_src(const mcpwm_soft_sync_config_t *config, mcpwm_sync_handle_t *ret_sync)
+{
+    esp_err_t ret = ESP_OK;
+    mcpwm_soft_sync_src_t *soft_sync = NULL;
+    ESP_GOTO_ON_FALSE(config && ret_sync, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    soft_sync = heap_caps_calloc(1, sizeof(mcpwm_soft_sync_src_t), MCPWM_MEM_ALLOC_CAPS);
+    ESP_GOTO_ON_FALSE(soft_sync, ESP_ERR_NO_MEM, err, TAG, "no mem for soft sync");
+
+    // fill in other sync member
+    soft_sync->soft_sync_from = MCPWM_SOFT_SYNC_FROM_NONE;
+    soft_sync->base.type = MCPWM_SYNC_TYPE_SOFT;
+    soft_sync->base.del = mcpwm_del_soft_sync_src;
+    *ret_sync = &soft_sync->base;
+    ESP_LOGD(TAG, "new soft sync at %p", soft_sync);
+    return ESP_OK;
+
+err:
+    if (soft_sync) {
+        free(soft_sync);
+    }
+    return ret;
+}
+
+static esp_err_t mcpwm_del_soft_sync_src(mcpwm_sync_t *sync_src)
+{
+    mcpwm_soft_sync_src_t *soft_sync = __containerof(sync_src, mcpwm_soft_sync_src_t, base);
+    ESP_LOGD(TAG, "del soft sync %p", soft_sync);
+    free(soft_sync);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_del_sync_src(mcpwm_sync_handle_t sync_src)
+{
+    ESP_RETURN_ON_FALSE(sync_src, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    return sync_src->del(sync_src);
+}
+
+esp_err_t mcpwm_soft_sync_activate(mcpwm_sync_handle_t sync_src)
+{
+    ESP_RETURN_ON_FALSE(sync_src, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    ESP_RETURN_ON_FALSE(sync_src->type == MCPWM_SYNC_TYPE_SOFT, ESP_ERR_INVALID_ARG, TAG, "not a valid soft sync");
+    mcpwm_group_t *group = sync_src->group;
+    mcpwm_soft_sync_src_t *soft_sync = __containerof(sync_src, mcpwm_soft_sync_src_t, base);
+
+    switch (soft_sync->soft_sync_from) {
+    case MCPWM_SOFT_SYNC_FROM_TIMER: {
+        mcpwm_timer_t *timer = soft_sync->timer;
+        mcpwm_ll_timer_trigger_soft_sync(group->hal.dev, timer->timer_id);
+        break;
+    }
+    case MCPWM_SOFT_SYNC_FROM_CAP: {
+        mcpwm_ll_capture_trigger_sw_sync(group->hal.dev);
+        break;
+    }
+    default:
+        ESP_RETURN_ON_FALSE(false, ESP_ERR_INVALID_STATE, TAG, "no soft sync generator is assigned");
+        break;
+    }
+    return ESP_OK;
+}
diff --git a/components/driver/mcpwm/mcpwm_timer.c b/components/driver/mcpwm/mcpwm_timer.c
new file mode 100644
index 0000000000..e816a7db7a
--- /dev/null
+++ b/components/driver/mcpwm/mcpwm_timer.c
@@ -0,0 +1,364 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <sys/cdefs.h>
+#include "sdkconfig.h"
+#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
+// The local log level must be defined before including esp_log.h
+// Set the maximum log level for this source file
+#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
+#endif
+#include "freertos/FreeRTOS.h"
+#include "esp_attr.h"
+#include "esp_check.h"
+#include "esp_err.h"
+#include "esp_log.h"
+#include "esp_memory_utils.h"
+#include "soc/soc_caps.h"
+#include "soc/mcpwm_periph.h"
+#include "hal/mcpwm_ll.h"
+#include "driver/mcpwm_timer.h"
+#include "esp_private/mcpwm.h"
+#include "mcpwm_private.h"
+
+static const char *TAG = "mcpwm";
+
+static void mcpwm_timer_default_isr(void *args);
+
+static esp_err_t mcpwm_timer_register_to_group(mcpwm_timer_t *timer, int group_id)
+{
+    mcpwm_group_t *group = mcpwm_acquire_group_handle(group_id);
+    ESP_RETURN_ON_FALSE(group, ESP_ERR_NO_MEM, TAG, "no mem for group (%d)", group_id);
+
+    int timer_id = -1;
+    portENTER_CRITICAL(&group->spinlock);
+    for (int i = 0; i < SOC_MCPWM_TIMERS_PER_GROUP; i++) {
+        if (!group->timers[i]) {
+            timer_id = i;
+            group->timers[i] = timer;
+            break;
+        }
+    }
+    portEXIT_CRITICAL(&group->spinlock);
+    if (timer_id < 0) {
+        mcpwm_release_group_handle(group);
+        group = NULL;
+    } else {
+        timer->group = group;
+        timer->timer_id = timer_id;
+    }
+    ESP_RETURN_ON_FALSE(timer_id >= 0, ESP_ERR_NOT_FOUND, TAG, "no free timer in group (%d)", group_id);
+    return ESP_OK;
+}
+
+static void mcpwm_timer_unregister_from_group(mcpwm_timer_t *timer)
+{
+    mcpwm_group_t *group = timer->group;
+    int timer_id = timer->timer_id;
+
+    portENTER_CRITICAL(&group->spinlock);
+    group->timers[timer_id] = NULL;
+    portEXIT_CRITICAL(&group->spinlock);
+
+    // timer has a reference on group, release it now
+    mcpwm_release_group_handle(group);
+}
+
+static esp_err_t mcpwm_timer_destory(mcpwm_timer_t *timer)
+{
+    if (timer->intr) {
+        ESP_RETURN_ON_ERROR(esp_intr_free(timer->intr), TAG, "uninstall interrupt service failed");
+    }
+    if (timer->group) {
+        mcpwm_timer_unregister_from_group(timer);
+    }
+    free(timer);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_new_timer(const mcpwm_timer_config_t *config, mcpwm_timer_handle_t *ret_timer)
+{
+#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
+    esp_log_level_set(TAG, ESP_LOG_DEBUG);
+#endif
+    esp_err_t ret = ESP_OK;
+    mcpwm_timer_t *timer = NULL;
+    ESP_GOTO_ON_FALSE(config && ret_timer, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    ESP_GOTO_ON_FALSE(config->group_id < SOC_MCPWM_GROUPS && config->group_id >= 0, ESP_ERR_INVALID_ARG,
+                      err, TAG, "invalid group ID:%d", config->group_id);
+
+    timer = heap_caps_calloc(1, sizeof(mcpwm_timer_t), MCPWM_MEM_ALLOC_CAPS);
+    ESP_GOTO_ON_FALSE(timer, ESP_ERR_NO_MEM, err, TAG, "no mem for timer");
+
+    ESP_GOTO_ON_ERROR(mcpwm_timer_register_to_group(timer, config->group_id), err, TAG, "register timer failed");
+    mcpwm_group_t *group = timer->group;
+    int group_id = group->group_id;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int timer_id = timer->timer_id;
+    // select the clock source
+    ESP_GOTO_ON_ERROR(mcpwm_select_periph_clock(group, config->clk_src), err, TAG, "set group clock failed");
+    // reset the timer to a determined state
+    mcpwm_hal_timer_reset(hal, timer_id);
+    // set timer resolution
+    uint32_t prescale = group->resolution_hz / config->resolution_hz;
+    mcpwm_ll_timer_set_clock_prescale(hal->dev, timer_id, prescale);
+    timer->resolution_hz = group->resolution_hz / prescale;
+    if (timer->resolution_hz != config->resolution_hz) {
+        ESP_LOGW(TAG, "adjust timer resolution to %uHz", timer->resolution_hz);
+    }
+
+    // set the peak tickes that the timer can reach to
+    timer->count_mode = config->count_mode;
+    uint32_t peak_ticks = config->period_ticks;
+    if (timer->count_mode == MCPWM_TIMER_COUNT_MODE_UP_DOWN) {
+        peak_ticks /= 2; // in symmetric mode, peak_ticks = period_ticks / 2
+    }
+    timer->peak_ticks = peak_ticks;
+    mcpwm_ll_timer_set_peak(hal->dev, timer_id, peak_ticks, timer->count_mode == MCPWM_TIMER_COUNT_MODE_UP_DOWN);
+    // set count direction
+    mcpwm_ll_timer_set_count_mode(hal->dev, timer_id, timer->count_mode);
+    // what time is allowed to update the period
+    mcpwm_ll_timer_enable_update_period_on_sync(hal->dev, timer_id, config->flags.update_period_on_sync);
+    mcpwm_ll_timer_enable_update_period_on_tez(hal->dev, timer_id, config->flags.update_period_on_empty);
+
+    // fill in other timer specific members
+    timer->spinlock = (portMUX_TYPE)portMUX_INITIALIZER_UNLOCKED;
+    timer->fsm = MCPWM_TIMER_FSM_INIT;
+    *ret_timer = timer;
+    ESP_LOGD(TAG, "new timer(%d,%d) at %p, resolution:%uHz, peak:%u, count_mod:%c",
+             group_id, timer_id, timer, timer->resolution_hz, timer->peak_ticks, "SUDB"[timer->count_mode]);
+    return ESP_OK;
+
+err:
+    if (timer) {
+        mcpwm_timer_destory(timer);
+    }
+    return ret;
+}
+
+esp_err_t mcpwm_del_timer(mcpwm_timer_handle_t timer)
+{
+    ESP_RETURN_ON_FALSE(timer, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    // check child resources are in free state
+    ESP_RETURN_ON_FALSE(!timer->sync_src, ESP_ERR_INVALID_STATE, TAG, "timer sync_src still in working");
+    ESP_RETURN_ON_FALSE(timer->fsm == MCPWM_TIMER_FSM_INIT, ESP_ERR_INVALID_STATE, TAG, "timer not in init state");
+    mcpwm_group_t *group = timer->group;
+    int timer_id = timer->timer_id;
+    mcpwm_hal_context_t *hal = &group->hal;
+
+    // disable and clear the pending interrupt
+    portENTER_CRITICAL(&group->spinlock);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_TIMER_MASK(timer_id), false);
+    mcpwm_ll_intr_clear_status(hal->dev, MCPWM_LL_EVENT_TIMER_MASK(timer_id));
+    portEXIT_CRITICAL(&group->spinlock);
+
+    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");
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_timer_register_event_callbacks(mcpwm_timer_handle_t timer, const mcpwm_timer_event_callbacks_t *cbs, void *user_data)
+{
+    ESP_RETURN_ON_FALSE(timer && cbs, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    ESP_RETURN_ON_FALSE(timer->fsm == MCPWM_TIMER_FSM_INIT, ESP_ERR_INVALID_STATE, TAG, "timer not in init state");
+    mcpwm_group_t *group = timer->group;
+    int group_id = group->group_id;
+    int timer_id = timer->timer_id;
+    mcpwm_hal_context_t *hal = &group->hal;
+
+#if CONFIG_MCWPM_ISR_IRAM_SAFE
+    if (cbs->on_empty) {
+        ESP_RETURN_ON_FALSE(esp_ptr_in_iram(cbs->on_empty), ESP_ERR_INVALID_ARG, TAG, "on_empty callback not in IRAM");
+    }
+    if (cbs->on_full) {
+        ESP_RETURN_ON_FALSE(esp_ptr_in_iram(cbs->on_full), ESP_ERR_INVALID_ARG, TAG, "on_full callback not in IRAM");
+    }
+    if (cbs->on_stop) {
+        ESP_RETURN_ON_FALSE(esp_ptr_in_iram(cbs->on_stop), ESP_ERR_INVALID_ARG, TAG, "on_stop callback not in IRAM");
+    }
+    if (user_data) {
+        ESP_RETURN_ON_FALSE(esp_ptr_internal(user_data), ESP_ERR_INVALID_ARG, TAG, "user context not in internal RAM");
+    }
+#endif
+
+    // lazy install interrupt service
+    if (!timer->intr) {
+        int isr_flags = MCPWM_INTR_ALLOC_FLAG;
+        ESP_RETURN_ON_ERROR(esp_intr_alloc_intrstatus(mcpwm_periph_signals.groups[group_id].irq_id, isr_flags,
+                            (uint32_t)mcpwm_ll_intr_get_status_reg(hal->dev), MCPWM_LL_EVENT_TIMER_MASK(timer_id),
+                            mcpwm_timer_default_isr, timer, &timer->intr), TAG, "install interrupt service for timer failed");
+    }
+
+    // enable/disable interrupt events
+    portENTER_CRITICAL(&group->spinlock);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_TIMER_FULL(timer_id), cbs->on_full != NULL);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_TIMER_EMPTY(timer_id), cbs->on_empty != NULL);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_TIMER_STOP(timer_id), cbs->on_stop != NULL);
+    portEXIT_CRITICAL(&group->spinlock);
+
+    timer->on_stop = cbs->on_stop;
+    timer->on_full = cbs->on_full;
+    timer->on_empty = cbs->on_empty;
+    timer->user_data = user_data;
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_timer_get_phase(mcpwm_timer_handle_t timer, uint32_t *count_value, mcpwm_timer_direction_t *direction)
+{
+    ESP_RETURN_ON_FALSE(timer && count_value && direction, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_group_t *group = timer->group;
+    int timer_id = timer->timer_id;
+    mcpwm_hal_context_t *hal = &group->hal;
+
+    portENTER_CRITICAL(&timer->spinlock);
+    *count_value = mcpwm_ll_timer_get_count_value(hal->dev, timer_id);
+    *direction = mcpwm_ll_timer_get_count_direction(hal->dev, timer_id);
+    portEXIT_CRITICAL(&timer->spinlock);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_timer_enable(mcpwm_timer_handle_t timer)
+{
+    ESP_RETURN_ON_FALSE(timer, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    ESP_RETURN_ON_FALSE(timer->fsm == MCPWM_TIMER_FSM_INIT, ESP_ERR_INVALID_STATE, TAG, "timer not in init state");
+    mcpwm_group_t *group = timer->group;
+    if (timer->intr) {
+        ESP_RETURN_ON_ERROR(esp_intr_enable(timer->intr), TAG, "enable interrupt failed");
+    }
+    if (group->pm_lock) {
+        ESP_RETURN_ON_ERROR(esp_pm_lock_acquire(group->pm_lock), TAG, "acquire pm lock failed");
+    }
+    timer->fsm = MCPWM_TIMER_FSM_ENABLE;
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_timer_disable(mcpwm_timer_handle_t timer)
+{
+    ESP_RETURN_ON_FALSE(timer, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    ESP_RETURN_ON_FALSE(timer->fsm == MCPWM_TIMER_FSM_ENABLE, ESP_ERR_INVALID_STATE, TAG, "timer not in enable state");
+    mcpwm_group_t *group = timer->group;
+    if (timer->intr) {
+        ESP_RETURN_ON_ERROR(esp_intr_disable(timer->intr), TAG, "disable interrupt failed");
+    }
+    if (group->pm_lock) {
+        ESP_RETURN_ON_ERROR(esp_pm_lock_release(group->pm_lock), TAG, "acquire pm lock failed");
+    }
+    timer->fsm = MCPWM_TIMER_FSM_INIT;
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_timer_start_stop(mcpwm_timer_handle_t timer, mcpwm_timer_start_stop_cmd_t command)
+{
+    ESP_RETURN_ON_FALSE(timer, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    ESP_RETURN_ON_FALSE(timer->fsm == MCPWM_TIMER_FSM_ENABLE, ESP_ERR_INVALID_STATE, TAG, "timer not in enable state");
+    mcpwm_group_t *group = timer->group;
+
+    portENTER_CRITICAL_SAFE(&timer->spinlock);
+    mcpwm_ll_timer_set_start_stop_command(group->hal.dev, timer->timer_id, command);
+    portEXIT_CRITICAL_SAFE(&timer->spinlock);
+    return ESP_OK;
+}
+
+esp_err_t mcpwm_timer_set_phase_on_sync(mcpwm_timer_handle_t timer, const mcpwm_timer_sync_phase_config_t *config)
+{
+    ESP_RETURN_ON_FALSE(timer && config, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    mcpwm_group_t *group = timer->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int group_id = group->group_id;
+    int timer_id = timer->timer_id;
+    mcpwm_sync_handle_t sync_source = config->sync_src;
+
+    // enable sync feature and set sync phase
+    if (sync_source) {
+        ESP_RETURN_ON_FALSE(config->count_value < MCPWM_LL_MAX_COUNT_VALUE, ESP_ERR_INVALID_ARG, TAG, "invalid sync count value");
+        switch (sync_source->type) {
+        case MCPWM_SYNC_TYPE_TIMER: {
+            ESP_RETURN_ON_FALSE(group == sync_source->group, ESP_ERR_INVALID_ARG, TAG, "timer and sync source are not in the same group");
+            mcpwm_timer_sync_src_t *timer_sync_src = __containerof(sync_source, mcpwm_timer_sync_src_t, base);
+            mcpwm_ll_timer_set_timer_sync_input(hal->dev, timer_id, timer_sync_src->timer->timer_id);
+            ESP_LOGD(TAG, "enable sync to timer (%d,%d) for timer (%d,%d)",
+                     group_id, timer_sync_src->timer->timer_id, group_id, timer_id);
+            break;
+        }
+        case MCPWM_SYNC_TYPE_GPIO: {
+            ESP_RETURN_ON_FALSE(group == sync_source->group, ESP_ERR_INVALID_ARG, TAG, "timer and sync source are not in the same group");
+            mcpwm_gpio_sync_src_t *gpio_sync_src = __containerof(sync_source, mcpwm_gpio_sync_src_t, base);
+            mcpwm_ll_timer_set_gpio_sync_input(hal->dev, timer_id, gpio_sync_src->sync_id);
+            ESP_LOGD(TAG, "enable sync to gpio (%d) for timer (%d,%d)",
+                     gpio_sync_src->gpio_num, group_id, timer_id);
+            break;
+        }
+        case MCPWM_SYNC_TYPE_SOFT: {
+            mcpwm_soft_sync_src_t *soft_sync = __containerof(sync_source, mcpwm_soft_sync_src_t, base);
+            if (soft_sync->soft_sync_from == MCPWM_SOFT_SYNC_FROM_TIMER && soft_sync->timer != timer) {
+                ESP_RETURN_ON_FALSE(false, ESP_ERR_INVALID_STATE, TAG, "soft sync already used by another timer");
+            }
+            soft_sync->soft_sync_from = MCPWM_SOFT_SYNC_FROM_TIMER;
+            soft_sync->timer = timer;
+            soft_sync->base.group = group;
+            break;
+        }
+        }
+
+        mcpwm_ll_timer_set_sync_phase_direction(hal->dev, timer_id, config->direction);
+        mcpwm_ll_timer_set_sync_phase_value(hal->dev, timer_id, config->count_value);
+        mcpwm_ll_timer_enable_sync_input(hal->dev, timer_id, true);
+    } else { // disable sync feature
+        mcpwm_ll_timer_enable_sync_input(hal->dev, timer_id, false);
+        ESP_LOGD(TAG, "disable sync for timer (%d,%d)", group_id, timer_id);
+    }
+    return ESP_OK;
+}
+
+static void IRAM_ATTR mcpwm_timer_default_isr(void *args)
+{
+    mcpwm_timer_t *timer = (mcpwm_timer_t *)args;
+    mcpwm_group_t *group = timer->group;
+    mcpwm_hal_context_t *hal = &group->hal;
+    int timer_id = timer->timer_id;
+    bool need_yield = false;
+    uint32_t status = mcpwm_ll_intr_get_status(hal->dev);
+    mcpwm_ll_intr_clear_status(hal->dev, status & MCPWM_LL_EVENT_TIMER_MASK(timer_id));
+
+    mcpwm_timer_event_data_t edata = {
+        .direction = mcpwm_ll_timer_get_count_direction(hal->dev, timer_id),
+        .count_value = mcpwm_ll_timer_get_count_value(hal->dev, timer_id),
+    };
+
+    if (status & MCPWM_LL_EVENT_TIMER_STOP(timer_id)) {
+        mcpwm_timer_event_cb_t cb = timer->on_stop;
+        if (cb) {
+            if (cb(timer, &edata, timer->user_data)) {
+                need_yield = true;
+            }
+        }
+    }
+
+    if (status & MCPWM_LL_EVENT_TIMER_FULL(timer_id)) {
+        mcpwm_timer_event_cb_t cb = timer->on_full;
+        if (cb) {
+            if (cb(timer, &edata, timer->user_data)) {
+                need_yield = true;
+            }
+        }
+    }
+
+    if (status & MCPWM_LL_EVENT_TIMER_EMPTY(timer_id)) {
+        mcpwm_timer_event_cb_t cb = timer->on_empty;
+        if (cb) {
+            if (cb(timer, &edata, timer->user_data)) {
+                need_yield = true;
+            }
+        }
+    }
+
+    if (need_yield) {
+        portYIELD_FROM_ISR();
+    }
+}
diff --git a/components/driver/test_apps/mcpwm/CMakeLists.txt b/components/driver/test_apps/mcpwm/CMakeLists.txt
new file mode 100644
index 0000000000..ad15f86dc1
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/CMakeLists.txt
@@ -0,0 +1,18 @@
+# This is the project CMakeLists.txt file for the test subproject
+cmake_minimum_required(VERSION 3.16)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(mcpwm_test)
+
+if(CONFIG_COMPILER_DUMP_RTL_FILES)
+    add_custom_target(check_test_app_sections ALL
+                      COMMAND ${PYTHON} $ENV{IDF_PATH}/tools/ci/check_callgraph.py
+                      --rtl-dir ${CMAKE_BINARY_DIR}/esp-idf/driver/
+                      --elf-file ${CMAKE_BINARY_DIR}/mcpwm_test.elf
+                      find-refs
+                      --from-sections=.iram0.text
+                      --to-sections=.flash.text,.flash.rodata
+                      --exit-code
+                      DEPENDS ${elf}
+                      )
+endif()
diff --git a/components/driver/test_apps/mcpwm/README.md b/components/driver/test_apps/mcpwm/README.md
new file mode 100644
index 0000000000..5ab630aafd
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/README.md
@@ -0,0 +1,2 @@
+| Supported Targets | ESP32 | ESP32-S3 |
+| ----------------- | ----- | -------- |
diff --git a/components/driver/test_apps/mcpwm/main/CMakeLists.txt b/components/driver/test_apps/mcpwm/main/CMakeLists.txt
new file mode 100644
index 0000000000..a6eebbfd72
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/main/CMakeLists.txt
@@ -0,0 +1,14 @@
+set(srcs "test_app_main.c"
+         "test_mcpwm_cap.c"
+         "test_mcpwm_cmpr.c"
+         "test_mcpwm_fault.c"
+         "test_mcpwm_gen.c"
+         "test_mcpwm_oper.c"
+         "test_mcpwm_sync.c"
+         "test_mcpwm_timer.c"
+         "test_mcpwm_utils.c")
+
+# In order for the cases defined by `TEST_CASE` to be linked into the final elf,
+# the component can be registered as WHOLE_ARCHIVE
+idf_component_register(SRCS ${srcs}
+                       WHOLE_ARCHIVE)
diff --git a/components/driver/test_apps/mcpwm/main/test_app_main.c b/components/driver/test_apps/mcpwm/main/test_app_main.c
new file mode 100644
index 0000000000..6f449a0046
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/main/test_app_main.c
@@ -0,0 +1,51 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "unity.h"
+#include "unity_test_runner.h"
+#include "esp_heap_caps.h"
+
+// Some resources are lazy allocated in GPTimer driver, the threshold is left for that case
+#define TEST_MEMORY_LEAK_THRESHOLD (-300)
+
+static size_t before_free_8bit;
+static size_t before_free_32bit;
+
+static void check_leak(size_t before_free, size_t after_free, const char *type)
+{
+    ssize_t delta = after_free - before_free;
+    printf("MALLOC_CAP_%s: Before %u bytes free, After %u bytes free (delta %d)\n", type, before_free, after_free, delta);
+    TEST_ASSERT_MESSAGE(delta >= TEST_MEMORY_LEAK_THRESHOLD, "memory leak");
+}
+
+void setUp(void)
+{
+    before_free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
+    before_free_32bit = heap_caps_get_free_size(MALLOC_CAP_32BIT);
+}
+
+void tearDown(void)
+{
+    size_t after_free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
+    size_t after_free_32bit = heap_caps_get_free_size(MALLOC_CAP_32BIT);
+    check_leak(before_free_8bit, after_free_8bit, "8BIT");
+    check_leak(before_free_32bit, after_free_32bit, "32BIT");
+}
+
+void app_main(void)
+{
+    //  __  __  ____ ______        ____  __   _____         _
+    // |  \/  |/ ___|  _ \ \      / /  \/  | |_   _|__  ___| |_
+    // | |\/| | |   | |_) \ \ /\ / /| |\/| |   | |/ _ \/ __| __|
+    // | |  | | |___|  __/ \ V  V / | |  | |   | |  __/\__ \ |_
+    // |_|  |_|\____|_|     \_/\_/  |_|  |_|   |_|\___||___/\__|
+    printf(" __  __  ____ ______        ____  __   _____         _\r\n");
+    printf("|  \\/  |/ ___|  _ \\ \\      / /  \\/  | |_   _|__  ___| |_\r\n");
+    printf("| |\\/| | |   | |_) \\ \\ /\\ / /| |\\/| |   | |/ _ \\/ __| __|\r\n");
+    printf("| |  | | |___|  __/ \\ V  V / | |  | |   | |  __/\\__ \\ |_\r\n");
+    printf("|_|  |_|\\____|_|     \\_/\\_/  |_|  |_|   |_|\\___||___/\\__|\r\n");
+    unity_run_menu();
+}
diff --git a/components/driver/test_apps/mcpwm/main/test_mcpwm_cap.c b/components/driver/test_apps/mcpwm/main/test_mcpwm_cap.c
new file mode 100644
index 0000000000..2a6dd37943
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/main/test_mcpwm_cap.c
@@ -0,0 +1,238 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <stdio.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/event_groups.h"
+#include "unity.h"
+#include "soc/soc_caps.h"
+#include "esp_private/esp_clk.h"
+#include "driver/mcpwm_cap.h"
+#include "driver/mcpwm_sync.h"
+#include "driver/gpio.h"
+#include "test_mcpwm_utils.h"
+
+TEST_CASE("mcpwm_capture_install_uninstall", "[mcpwm]")
+{
+    printf("install mcpwm capture timers\r\n");
+    mcpwm_capture_timer_config_t cap_timer_config = {
+        .clk_src = MCPWM_CAPTURE_CLK_SRC_DEFAULT,
+    };
+    int total_cap_timers = SOC_MCPWM_GROUPS * SOC_MCPWM_CAPTURE_TIMERS_PER_GROUP;
+    mcpwm_cap_timer_handle_t cap_timers[total_cap_timers];
+    int k = 0;
+    for (int i = 0; i < SOC_MCPWM_GROUPS; i++) {
+        cap_timer_config.group_id = i;
+        for (int j = 0; j < SOC_MCPWM_CAPTURE_TIMERS_PER_GROUP; j++) {
+            TEST_ESP_OK(mcpwm_new_capture_timer(&cap_timer_config, &cap_timers[k++]));
+        }
+        TEST_ESP_ERR(ESP_ERR_NOT_FOUND, mcpwm_new_capture_timer(&cap_timer_config, &cap_timers[0]));
+    }
+
+    printf("install mcpwm capture channels\r\n");
+    mcpwm_capture_channel_config_t cap_chan_config = {
+        .gpio_num = 0,
+        .prescale = 2,
+        .flags.pos_edge = true,
+        .flags.pull_up = true,
+    };
+    mcpwm_cap_channel_handle_t cap_channels[total_cap_timers][SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER];
+    for (int i = 0; i < total_cap_timers; i++) {
+        for (int j = 0; j < SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER; j++) {
+            TEST_ESP_OK(mcpwm_new_capture_channel(cap_timers[i], &cap_chan_config, &cap_channels[i][j]));
+        }
+        TEST_ESP_ERR(ESP_ERR_NOT_FOUND, mcpwm_new_capture_channel(cap_timers[i], &cap_chan_config, &cap_channels[i][0]));
+    }
+
+    printf("uninstall mcpwm capture channels and timers\r\n");
+    for (int i = 0; i < total_cap_timers; i++) {
+        for (int j = 0; j < SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER; j++) {
+            TEST_ESP_OK(mcpwm_del_capture_channel(cap_channels[i][j]));
+        }
+        TEST_ESP_OK(mcpwm_del_capture_timer(cap_timers[i]));
+    }
+}
+
+TEST_MCPWM_CALLBACK_ATTR
+static bool test_capture_callback(mcpwm_cap_channel_handle_t cap_channel, const mcpwm_capture_event_data_t *edata, void *user_data)
+{
+    uint32_t *cap_value = (uint32_t *)user_data;
+    if (edata->cap_edge == MCPWM_CAP_EDGE_NEG) {
+        cap_value[1] = edata->cap_value;
+    } else {
+        cap_value[0] = edata->cap_value;
+    }
+    return false;
+}
+
+TEST_CASE("mcpwm_capture_ext_gpio", "[mcpwm]")
+{
+    printf("install mcpwm capture timer\r\n");
+    mcpwm_cap_timer_handle_t cap_timer = NULL;
+    mcpwm_capture_timer_config_t cap_timer_config = {
+        .clk_src = MCPWM_CAPTURE_CLK_SRC_APB,
+        .group_id = 0,
+    };
+    TEST_ESP_OK(mcpwm_new_capture_timer(&cap_timer_config, &cap_timer));
+
+    const int cap_gpio = 0;
+    // put the GPIO into a preset state
+    gpio_set_level(cap_gpio, 0);
+
+    printf("install mcpwm capture channel\r\n");
+    mcpwm_cap_channel_handle_t pps_channel;
+    mcpwm_capture_channel_config_t cap_chan_config = {
+        .gpio_num = cap_gpio,
+        .prescale = 1,
+        .flags.pos_edge = true,
+        .flags.neg_edge = true,
+        .flags.io_loop_back = true, // so we can use GPIO functions to simulate the external capture signal
+        .flags.pull_up = true,
+    };
+    TEST_ESP_OK(mcpwm_new_capture_channel(cap_timer, &cap_chan_config, &pps_channel));
+
+    printf("install callback for capture channel\r\n");
+    mcpwm_capture_event_callbacks_t cbs = {
+        .on_cap = test_capture_callback,
+    };
+    uint32_t cap_value[2] = {0};
+    TEST_ESP_OK(mcpwm_capture_channel_register_event_callbacks(pps_channel, &cbs, cap_value));
+
+    printf("enable and start capture timer\r\n");
+    TEST_ESP_OK(mcpwm_capture_timer_enable(cap_timer));
+    TEST_ESP_OK(mcpwm_capture_timer_start(cap_timer));
+
+    printf("simulate GPIO capture signal\r\n");
+    gpio_set_level(cap_gpio, 1);
+    vTaskDelay(pdMS_TO_TICKS(100));
+    gpio_set_level(cap_gpio, 0);
+    vTaskDelay(pdMS_TO_TICKS(100));
+    printf("capture value: Pos=%u, Neg=%u\r\n", cap_value[0], cap_value[1]);
+    // Capture timer is clocked from APB by default
+    uint32_t clk_src_res = esp_clk_apb_freq();
+    TEST_ASSERT_UINT_WITHIN(100000, clk_src_res / 10, cap_value[1] - cap_value[0]);
+
+    printf("uninstall capture channel and timer\r\n");
+    TEST_ESP_OK(mcpwm_del_capture_channel(pps_channel));
+    TEST_ESP_OK(mcpwm_capture_timer_disable(cap_timer));
+    TEST_ESP_OK(mcpwm_del_capture_timer(cap_timer));
+}
+
+typedef struct {
+    uint32_t cap_data[2];
+    int cap_data_index;
+} test_soft_catch_user_data_t;
+
+TEST_MCPWM_CALLBACK_ATTR
+static bool soft_cap_callback(mcpwm_cap_channel_handle_t cap_channel, const mcpwm_capture_event_data_t *data, void *user_data)
+{
+    test_soft_catch_user_data_t *cbdata = (test_soft_catch_user_data_t *)user_data;
+    cbdata->cap_data[cbdata->cap_data_index++] = data->cap_value;
+    return false;
+}
+
+TEST_CASE("mcpwm_capture_software_catch", "[mcpwm]")
+{
+    printf("install mcpwm capture timer\r\n");
+    mcpwm_cap_timer_handle_t cap_timer = NULL;
+    mcpwm_capture_timer_config_t cap_timer_config = {
+        .clk_src = MCPWM_CAPTURE_CLK_SRC_DEFAULT,
+        .group_id = 0,
+    };
+    TEST_ESP_OK(mcpwm_new_capture_timer(&cap_timer_config, &cap_timer));
+
+    printf("install mcpwm capture channel\r\n");
+    mcpwm_cap_channel_handle_t cap_channel = NULL;
+    mcpwm_capture_channel_config_t cap_chan_config = {
+        .gpio_num = -1, // don't need any GPIO, we use software to trigger a catch
+        .prescale = 2,
+    };
+    test_soft_catch_user_data_t test_callback_data = {};
+    TEST_ESP_OK(mcpwm_new_capture_channel(cap_timer, &cap_chan_config, &cap_channel));
+
+    printf("register event callback for capture channel\r\n");
+    mcpwm_capture_event_callbacks_t cbs = {
+        .on_cap = soft_cap_callback,
+    };
+    TEST_ESP_OK(mcpwm_capture_channel_register_event_callbacks(cap_channel, &cbs, &test_callback_data));
+
+    printf("enable and start capture timer\r\n");
+    TEST_ESP_OK(mcpwm_capture_timer_enable(cap_timer));
+    TEST_ESP_OK(mcpwm_capture_timer_start(cap_timer));
+
+    printf("trigger software catch\r\n");
+    TEST_ESP_OK(mcpwm_capture_channel_trigger_soft_catch(cap_channel));
+    vTaskDelay(pdMS_TO_TICKS(10));
+    TEST_ESP_OK(mcpwm_capture_channel_trigger_soft_catch(cap_channel));
+    vTaskDelay(pdMS_TO_TICKS(10));
+
+    // check user data
+    TEST_ASSERT_EQUAL(2, test_callback_data.cap_data_index);
+    uint32_t delta = test_callback_data.cap_data[1] - test_callback_data.cap_data[0];
+    esp_rom_printf("duration=%u ticks\r\n", delta);
+    // Capture timer is clocked from APB by default
+    uint32_t clk_src_res = esp_clk_apb_freq();
+    TEST_ASSERT_UINT_WITHIN(80000, clk_src_res / 100, delta);
+
+    printf("uninstall capture channel and timer\r\n");
+    TEST_ESP_OK(mcpwm_capture_timer_disable(cap_timer));
+    TEST_ESP_OK(mcpwm_del_capture_channel(cap_channel));
+    TEST_ESP_OK(mcpwm_del_capture_timer(cap_timer));
+}
+
+TEST_MCPWM_CALLBACK_ATTR
+static bool test_capture_after_sync_callback(mcpwm_cap_channel_handle_t cap_channel, const mcpwm_capture_event_data_t *data, void *user_data)
+{
+    uint32_t *cap_data = (uint32_t *)user_data;
+    *cap_data = data->cap_value;
+    return false;
+}
+
+TEST_CASE("mcpwm_capture_timer_sync_phase_lock", "[mcpwm]")
+{
+    mcpwm_capture_timer_config_t cap_timer_config = {
+        .group_id = 0,
+        .clk_src = MCPWM_CAPTURE_CLK_SRC_DEFAULT,
+    };
+    mcpwm_cap_timer_handle_t cap_timer = NULL;
+    TEST_ESP_OK(mcpwm_new_capture_timer(&cap_timer_config, &cap_timer));
+
+    mcpwm_sync_handle_t soft_sync = NULL;
+    mcpwm_soft_sync_config_t soft_sync_config = {};
+    TEST_ESP_OK(mcpwm_new_soft_sync_src(&soft_sync_config, &soft_sync));
+
+    mcpwm_capture_timer_sync_phase_config_t sync_config = {
+        .count_value = 1000,
+        .direction = MCPWM_TIMER_DIRECTION_UP,
+        .sync_src = soft_sync,
+    };
+    TEST_ESP_OK(mcpwm_capture_timer_set_phase_on_sync(cap_timer, &sync_config));
+    mcpwm_cap_channel_handle_t cap_channel = NULL;
+    mcpwm_capture_channel_config_t cap_chan_config = {
+        .gpio_num = -1, // don't need any GPIO, we use software to trigger a catch
+        .prescale = 1,
+    };
+    TEST_ESP_OK(mcpwm_new_capture_channel(cap_timer, &cap_chan_config, &cap_channel));
+
+    mcpwm_capture_event_callbacks_t cbs = {
+        .on_cap = test_capture_after_sync_callback,
+    };
+    uint32_t cap_data;
+    TEST_ESP_OK(mcpwm_capture_channel_register_event_callbacks(cap_channel, &cbs, &cap_data));
+
+    TEST_ESP_OK(mcpwm_capture_channel_trigger_soft_catch(cap_channel));
+    vTaskDelay(pdMS_TO_TICKS(10));
+    printf("capture data before sync: %u\r\n", cap_data);
+
+    TEST_ESP_OK(mcpwm_soft_sync_activate(soft_sync));
+    TEST_ESP_OK(mcpwm_capture_channel_trigger_soft_catch(cap_channel));
+    vTaskDelay(pdMS_TO_TICKS(10));
+    printf("capture data after sync: %u\r\n", cap_data);
+    TEST_ASSERT_EQUAL(1000, cap_data);
+    TEST_ESP_OK(mcpwm_del_capture_channel(cap_channel));
+    TEST_ESP_OK(mcpwm_del_capture_timer(cap_timer));
+    TEST_ESP_OK(mcpwm_del_sync_src(soft_sync));
+}
diff --git a/components/driver/test_apps/mcpwm/main/test_mcpwm_cmpr.c b/components/driver/test_apps/mcpwm/main/test_mcpwm_cmpr.c
new file mode 100644
index 0000000000..5e0404d18b
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/main/test_mcpwm_cmpr.c
@@ -0,0 +1,113 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "unity.h"
+#include "soc/soc_caps.h"
+#include "driver/mcpwm_timer.h"
+#include "driver/mcpwm_oper.h"
+#include "driver/mcpwm_cmpr.h"
+
+TEST_CASE("mcpwm_comparator_install_uninstall", "[mcpwm]")
+{
+    mcpwm_timer_handle_t timer;
+    mcpwm_oper_handle_t operator;
+    mcpwm_cmpr_handle_t comparators[SOC_MCPWM_COMPARATORS_PER_OPERATOR];
+
+    mcpwm_timer_config_t timer_config = {
+        .group_id = 0,
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .resolution_hz = 1 * 1000 * 1000,
+        .period_ticks = 10 * 1000,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+    };
+    mcpwm_operator_config_t operator_config = {
+        .group_id = 0,
+    };
+    printf("install timer and operator");
+    TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timer));
+    TEST_ESP_OK(mcpwm_new_operator(&operator_config, &operator));
+
+    printf("install comparator\r\n");
+    mcpwm_comparator_config_t comparator_config = {};
+    for (int i = 0; i < SOC_MCPWM_COMPARATORS_PER_OPERATOR; i++) {
+        TEST_ESP_OK(mcpwm_new_comparator(operator, &comparator_config, &comparators[i]));
+    }
+    TEST_ESP_ERR(ESP_ERR_NOT_FOUND, mcpwm_new_comparator(operator, &comparator_config, &comparators[0]));
+
+    printf("connect MCPWM timer and operators\r\n");
+    TEST_ESP_OK(mcpwm_operator_connect_timer(operator, timer));
+
+    printf("uninstall timer, operator and comparators\r\n");
+    // can't delete operator if the comparators are still in working
+    TEST_ESP_ERR(ESP_ERR_INVALID_STATE, mcpwm_del_operator(operator));
+    for (int i = 0; i < SOC_MCPWM_COMPARATORS_PER_OPERATOR; i++) {
+        TEST_ESP_OK(mcpwm_del_comparator(comparators[i]));
+    }
+    TEST_ESP_OK(mcpwm_del_operator(operator));
+    TEST_ESP_OK(mcpwm_del_timer(timer));
+}
+
+static bool test_compare_on_reach(mcpwm_cmpr_handle_t cmpr, const mcpwm_compare_event_data_t *ev_data, void *user_data)
+{
+    uint32_t *counts = (uint32_t *)user_data;
+    (*counts)++;
+    return false;
+}
+
+TEST_CASE("mcpwm_comparator_event_callback", "[mcpwm]")
+{
+    mcpwm_timer_handle_t timer;
+    mcpwm_oper_handle_t operator;
+    mcpwm_cmpr_handle_t comparator;
+
+    mcpwm_timer_config_t timer_config = {
+        .group_id = 0,
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .resolution_hz = 1 * 1000 * 1000,
+        .period_ticks = 10 * 1000, // 10ms
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+    };
+    mcpwm_operator_config_t operator_config = {
+        .group_id = 0,
+    };
+    mcpwm_comparator_config_t comparator_config = {};
+    printf("install timer, operator and comparator");
+    TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timer));
+    TEST_ESP_OK(mcpwm_new_operator(&operator_config, &operator));
+    TEST_ESP_OK(mcpwm_new_comparator(operator, &comparator_config, &comparator));
+
+    // set compare value before connecting timer and operator will fail
+    TEST_ESP_ERR(ESP_ERR_INVALID_STATE, mcpwm_comparator_set_compare_value(comparator, 5000));
+    printf("connect MCPWM timer and operators\r\n");
+    TEST_ESP_OK(mcpwm_operator_connect_timer(operator, timer));
+    // compare ticks can't exceed the timer's period ticks
+    TEST_ESP_ERR(ESP_ERR_INVALID_ARG, mcpwm_comparator_set_compare_value(comparator, 20 * 1000));
+    TEST_ESP_OK(mcpwm_comparator_set_compare_value(comparator, 5 * 1000));
+
+    printf("register compare event callback\r\n");
+    uint32_t compare_counts = 0;
+    mcpwm_comparator_event_callbacks_t cbs = {
+        .on_reach = test_compare_on_reach,
+    };
+    TEST_ESP_OK(mcpwm_comparator_register_event_callbacks(comparator, &cbs, &compare_counts));
+
+    printf("start timer\r\n");
+    TEST_ESP_OK(mcpwm_timer_enable(timer));
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+
+    vTaskDelay(pdMS_TO_TICKS(1000));
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_STOP_EMPTY));
+    printf("compare_counts=%u\r\n", compare_counts);
+    // the timer period is 10ms, the expected compare_counts = 1s/10ms = 100
+    TEST_ASSERT_INT_WITHIN(1, 100, compare_counts);
+
+    printf("uninstall timer, operator and comparator\r\n");
+    TEST_ESP_OK(mcpwm_timer_disable(timer));
+    TEST_ESP_OK(mcpwm_del_comparator(comparator));
+    TEST_ESP_OK(mcpwm_del_operator(operator));
+    TEST_ESP_OK(mcpwm_del_timer(timer));
+}
diff --git a/components/driver/test_apps/mcpwm/main/test_mcpwm_fault.c b/components/driver/test_apps/mcpwm/main/test_mcpwm_fault.c
new file mode 100644
index 0000000000..c516b34d0b
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/main/test_mcpwm_fault.c
@@ -0,0 +1,93 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "unity.h"
+#include "driver/mcpwm_fault.h"
+#include "driver/mcpwm_oper.h"
+#include "driver/gpio.h"
+
+TEST_CASE("mcpwm_fault_install_uninstall", "[mcpwm]")
+{
+    printf("install and uninstall gpio faults\r\n");
+    mcpwm_gpio_fault_config_t gpio_fault_config = {
+        .gpio_num = 0,
+    };
+    int total_gpio_faults = SOC_MCPWM_GPIO_FAULTS_PER_GROUP * SOC_MCPWM_GROUPS;
+    mcpwm_fault_handle_t gpio_faults[total_gpio_faults];
+    int fault_itor = 0;
+    for (int i = 0; i < SOC_MCPWM_GROUPS; i++) {
+        gpio_fault_config.group_id = i;
+        for (int j = 0; j < SOC_MCPWM_GPIO_FAULTS_PER_GROUP; j++) {
+            TEST_ESP_OK(mcpwm_new_gpio_fault(&gpio_fault_config, &gpio_faults[fault_itor++]));
+        }
+        TEST_ESP_ERR(ESP_ERR_NOT_FOUND, mcpwm_new_gpio_fault(&gpio_fault_config, &gpio_faults[0]));
+    }
+    for (int i = 0; i < total_gpio_faults; i++) {
+        TEST_ESP_OK(mcpwm_del_fault(gpio_faults[i]));
+    }
+
+    printf("install and uninstall software fault\r\n");
+    mcpwm_soft_fault_config_t soft_fault_config = {};
+    mcpwm_fault_handle_t soft_fault = NULL;
+    TEST_ESP_OK(mcpwm_new_soft_fault(&soft_fault_config, &soft_fault));
+    TEST_ESP_OK(mcpwm_del_fault(soft_fault));
+}
+
+static bool test_fault_enter_callback(mcpwm_fault_handle_t detector, const mcpwm_fault_event_data_t *status, void *user_data)
+{
+    TaskHandle_t task_handle = (TaskHandle_t)user_data;
+    BaseType_t high_task_wakeup = pdFALSE;
+    esp_rom_printf("fault found\r\n");
+    vTaskNotifyGiveFromISR(task_handle, &high_task_wakeup);
+    return high_task_wakeup == pdTRUE;
+}
+
+static bool test_fault_exit_callback(mcpwm_fault_handle_t detector, const mcpwm_fault_event_data_t *status, void *user_data)
+{
+    TaskHandle_t task_handle = (TaskHandle_t)user_data;
+    BaseType_t high_task_wakeup = pdFALSE;
+    esp_rom_printf("fault relieved\r\n");
+    vTaskNotifyGiveFromISR(task_handle, &high_task_wakeup);
+    return high_task_wakeup == pdTRUE;
+}
+
+TEST_CASE("mcpwm_gpio_fault_event_callbacks", "[mcpwm]")
+{
+    printf("create gpio fault\r\n");
+    const int fault_gpio = 0;
+    mcpwm_fault_handle_t fault = NULL;
+    mcpwm_gpio_fault_config_t gpio_fault_config = {
+        .group_id = 0,
+        .gpio_num = fault_gpio,
+        .flags.active_level = true, // active on high level
+        .flags.pull_down = true,
+        .flags.io_loop_back = true, // for debug, so that we can use gpio_set_level to mimic a fault source
+    };
+    TEST_ESP_OK(mcpwm_new_gpio_fault(&gpio_fault_config, &fault));
+
+    // put fault GPIO into a safe state
+    gpio_set_level(fault_gpio, 0);
+
+    printf("register callback for the gpio fault\r\n");
+    mcpwm_fault_event_callbacks_t cbs = {
+        .on_fault_enter = test_fault_enter_callback,
+        .on_fault_exit = test_fault_exit_callback,
+    };
+    TaskHandle_t task_to_notify = xTaskGetCurrentTaskHandle();
+    TEST_ESP_OK(mcpwm_fault_register_event_callbacks(fault, &cbs, task_to_notify));
+    TEST_ASSERT_EQUAL(0, ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(1000)));
+
+    printf("trigget a fault event\r\n");
+    gpio_set_level(fault_gpio, 1);
+    TEST_ASSERT_NOT_EQUAL(0, ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(10)));
+
+    printf("remove the fault source\r\n");
+    gpio_set_level(fault_gpio, 0);
+    TEST_ASSERT_NOT_EQUAL(0, ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(10)));
+
+    TEST_ESP_OK(mcpwm_del_fault(fault));
+}
diff --git a/components/driver/test_apps/mcpwm/main/test_mcpwm_gen.c b/components/driver/test_apps/mcpwm/main/test_mcpwm_gen.c
new file mode 100644
index 0000000000..1d397bd0e2
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/main/test_mcpwm_gen.c
@@ -0,0 +1,646 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "unity.h"
+#include "soc/soc_caps.h"
+#include "driver/mcpwm_timer.h"
+#include "driver/mcpwm_oper.h"
+#include "driver/mcpwm_cmpr.h"
+#include "driver/mcpwm_gen.h"
+#include "driver/gpio.h"
+
+TEST_CASE("mcpwm_generator_install_uninstall", "[mcpwm]")
+{
+    mcpwm_operator_config_t oper_config = {
+        .group_id = 0,
+    };
+    mcpwm_oper_handle_t oper = NULL;
+    printf("create a MCPWM operator\r\n");
+    TEST_ESP_OK(mcpwm_new_operator(&oper_config, &oper));
+
+    printf("create MCPWM generators from that operator\r\n");
+    mcpwm_gen_handle_t gens[SOC_MCPWM_GENERATORS_PER_OPERATOR];
+    mcpwm_generator_config_t gen_config = {
+        .gen_gpio_num = 0,
+    };
+    for (int i = 0; i < SOC_MCPWM_GENERATORS_PER_OPERATOR; i++) {
+        TEST_ESP_OK(mcpwm_new_generator(oper, &gen_config, &gens[i]));
+    }
+    TEST_ESP_ERR(ESP_ERR_NOT_FOUND, mcpwm_new_generator(oper, &gen_config, &gens[0]));
+
+    printf("delete generators and operator\r\n");
+    // can't delete operator if the generator is till in working
+    TEST_ESP_ERR(ESP_ERR_INVALID_STATE, mcpwm_del_operator(oper));
+    for (int i = 0; i < SOC_MCPWM_GENERATORS_PER_OPERATOR; i++) {
+        TEST_ESP_OK(mcpwm_del_generator(gens[i]));
+    }
+    TEST_ESP_OK(mcpwm_del_operator(oper));
+}
+
+TEST_CASE("mcpwm_generator_force_level_hold_on", "[mcpwm]")
+{
+    // The operator can even work without the timer
+    printf("create operator and generator\r\n");
+    mcpwm_oper_handle_t operator = NULL;
+    mcpwm_operator_config_t operator_config = {
+        .group_id = 0,
+    };
+    TEST_ESP_OK(mcpwm_new_operator(&operator_config, &operator));
+
+    mcpwm_gen_handle_t generator = NULL;
+    const int gen_gpio = 0;
+    mcpwm_generator_config_t generator_config = {
+        .gen_gpio_num = gen_gpio,
+        .flags.io_loop_back = true, // loop back for test
+    };
+    TEST_ESP_OK(mcpwm_new_generator(operator, &generator_config, &generator));
+
+    printf("add force level to the generator, hold on");
+    for (int i = 0; i < 10; i++) {
+        TEST_ESP_OK(mcpwm_generator_set_force_level(generator, 0, true));
+        vTaskDelay(pdMS_TO_TICKS(10));
+        TEST_ASSERT_EQUAL(0, gpio_get_level(gen_gpio));
+        TEST_ESP_OK(mcpwm_generator_set_force_level(generator, 1, true));
+        vTaskDelay(pdMS_TO_TICKS(10));
+        TEST_ASSERT_EQUAL(1, gpio_get_level(gen_gpio));
+    }
+
+    printf("remove the force level\r\n");
+    TEST_ESP_OK(mcpwm_generator_set_force_level(generator, -1, true));
+
+    printf("delete generator and operator\r\n");
+    TEST_ESP_OK(mcpwm_del_generator(generator));
+    TEST_ESP_OK(mcpwm_del_operator(operator));
+}
+
+TEST_CASE("mcpwm_generator_force_level_recovery", "[mcpwm]")
+{
+    printf("create mcpwm timer\r\n");
+    mcpwm_timer_config_t timer_config = {
+        .group_id = 0,
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+        .resolution_hz = 1000000,
+        .period_ticks = 50000,
+    };
+    mcpwm_timer_handle_t timer = NULL;
+    TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timer));
+    TEST_ESP_OK(mcpwm_timer_enable(timer));
+
+    printf("create operator\r\n");
+    mcpwm_oper_handle_t operator = NULL;
+    mcpwm_operator_config_t operator_config = {
+        .group_id = 0,
+        .flags.update_gen_action_on_tez = true,
+    };
+    TEST_ESP_OK(mcpwm_new_operator(&operator_config, &operator));
+    TEST_ESP_OK(mcpwm_operator_connect_timer(operator, timer));
+
+    printf("create generator\r\n");
+    mcpwm_gen_handle_t generator = NULL;
+    const int gen_gpio = 0;
+    mcpwm_generator_config_t generator_config = {
+        .gen_gpio_num = gen_gpio,
+        .flags.io_loop_back = true, // loop back for test
+    };
+    TEST_ESP_OK(mcpwm_new_generator(operator, &generator_config, &generator));
+
+    printf("add force level to the generator, and recovery by events");
+    TEST_ESP_OK(mcpwm_generator_set_force_level(generator, 0, false));
+    TEST_ASSERT_EQUAL(0, gpio_get_level(gen_gpio));
+    TEST_ESP_OK(mcpwm_generator_set_force_level(generator, 1, false));
+    TEST_ASSERT_EQUAL(1, gpio_get_level(gen_gpio));
+
+    TEST_ESP_OK(mcpwm_generator_set_force_level(generator, 0, false));
+    TEST_ASSERT_EQUAL(0, gpio_get_level(gen_gpio));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(generator,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    // generator should output high level on tez event, the previous force level should disappear
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+    vTaskDelay(pdMS_TO_TICKS(200));
+    TEST_ASSERT_EQUAL(1, gpio_get_level(gen_gpio));
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_STOP_EMPTY));
+    vTaskDelay(pdMS_TO_TICKS(100));
+
+    TEST_ESP_OK(mcpwm_generator_set_force_level(generator, 1, false));
+    TEST_ASSERT_EQUAL(1, gpio_get_level(gen_gpio));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(generator,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    // generator should output low level on tez event, the previous force level should disappear
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+    vTaskDelay(pdMS_TO_TICKS(200));
+    TEST_ASSERT_EQUAL(0, gpio_get_level(gen_gpio));
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_STOP_EMPTY));
+    vTaskDelay(pdMS_TO_TICKS(100));
+
+    printf("delete generator, operator and timer\r\n");
+    TEST_ESP_OK(mcpwm_timer_disable(timer));
+    TEST_ESP_OK(mcpwm_del_generator(generator));
+    TEST_ESP_OK(mcpwm_del_operator(operator));
+    TEST_ESP_OK(mcpwm_del_timer(timer));
+}
+
+TEST_CASE("mcpwm_generator_action_on_timer_event", "[mcpwm]")
+{
+    const int generator_gpio = 0;
+    printf("create timer and operator\r\n");
+    mcpwm_timer_config_t timer_config = {
+        .group_id = 0,
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .resolution_hz = 1000000,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+        .period_ticks = 1000,
+    };
+    mcpwm_timer_handle_t timer = NULL;
+    TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timer));
+    TEST_ESP_OK(mcpwm_timer_enable(timer));
+
+    mcpwm_operator_config_t oper_config = {
+        .group_id = 0,
+    };
+    mcpwm_oper_handle_t oper = NULL;
+    TEST_ESP_OK(mcpwm_new_operator(&oper_config, &oper));
+
+    printf("connect timer and operator\r\n");
+    TEST_ESP_OK(mcpwm_operator_connect_timer(oper, timer));
+
+    printf("create generator\r\n");
+    mcpwm_generator_config_t gen_config = {
+        .gen_gpio_num = generator_gpio,
+        .flags.io_loop_back = 1, // so that we can read the GPIO value by GPIO driver
+    };
+    mcpwm_gen_handle_t gen = NULL;
+    TEST_ESP_OK(mcpwm_new_generator(oper, &gen_config, &gen));
+
+    printf("set generator to output high on timer full\r\n");
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gen,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_FULL, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_KEEP),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    printf("start timer\r\n");
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+    vTaskDelay(pdMS_TO_TICKS(100));
+    printf("stop timer on full\r\n");
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_STOP_FULL));
+    TEST_ASSERT_EQUAL(1, gpio_get_level(generator_gpio));
+
+    printf("set generator to output low on timer full\r\n");
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gen,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_FULL, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_KEEP),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    printf("start timer\r\n");
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+    vTaskDelay(pdMS_TO_TICKS(100));
+    printf("stop timer on full\r\n");
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_STOP_FULL));
+    TEST_ASSERT_EQUAL(0, gpio_get_level(generator_gpio));
+
+    printf("delete timer, operator, generator\r\n");
+    TEST_ESP_OK(mcpwm_timer_disable(timer));
+    TEST_ESP_OK(mcpwm_del_generator(gen));
+    TEST_ESP_OK(mcpwm_del_operator(oper));
+    TEST_ESP_OK(mcpwm_del_timer(timer));
+}
+
+typedef void (*set_gen_actions_cb_t)(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb);
+
+static void mcpwm_gen_action_test_template(uint32_t timer_resolution, uint32_t period, mcpwm_timer_count_mode_t count_mode,
+        uint32_t cmpa, uint32_t cmpb, int gpioa, int gpiob, set_gen_actions_cb_t set_generator_actions)
+{
+    mcpwm_timer_config_t timer_config = {
+        .group_id = 0,
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .count_mode = count_mode,
+        .resolution_hz = timer_resolution,
+        .period_ticks = period,
+    };
+    mcpwm_timer_handle_t timer = NULL;
+    TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timer));
+
+    mcpwm_operator_config_t operator_config = {
+        .group_id = 0,
+    };
+    mcpwm_oper_handle_t operator = NULL;
+    TEST_ESP_OK(mcpwm_new_operator(&operator_config, &operator));
+    TEST_ESP_OK(mcpwm_operator_connect_timer(operator, timer));
+
+    TEST_ESP_OK(mcpwm_timer_enable(timer));
+
+    mcpwm_cmpr_handle_t comparator_a = NULL;
+    mcpwm_cmpr_handle_t comparator_b = NULL;
+    mcpwm_comparator_config_t comparator_config = {
+        .flags.update_cmp_on_tez = true,
+    };
+    TEST_ESP_OK(mcpwm_new_comparator(operator, &comparator_config, &comparator_a));
+    TEST_ESP_OK(mcpwm_new_comparator(operator, &comparator_config, &comparator_b));
+    TEST_ESP_OK(mcpwm_comparator_set_compare_value(comparator_a, cmpa));
+    TEST_ESP_OK(mcpwm_comparator_set_compare_value(comparator_b, cmpb));
+
+    mcpwm_gen_handle_t generator_a = NULL;
+    mcpwm_gen_handle_t generator_b = NULL;
+    mcpwm_generator_config_t generator_config = {
+        .gen_gpio_num = gpioa,
+    };
+    TEST_ESP_OK(mcpwm_new_generator(operator, &generator_config, &generator_a));
+    generator_config.gen_gpio_num = gpiob;
+    TEST_ESP_OK(mcpwm_new_generator(operator, &generator_config, &generator_b));
+
+    set_generator_actions(generator_a, generator_b, comparator_a, comparator_b);
+
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+    vTaskDelay(pdMS_TO_TICKS(100));
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_STOP_EMPTY));
+    vTaskDelay(pdMS_TO_TICKS(10));
+
+    TEST_ESP_OK(mcpwm_timer_disable(timer));
+    TEST_ESP_OK(mcpwm_del_generator(generator_a));
+    TEST_ESP_OK(mcpwm_del_generator(generator_b));
+    TEST_ESP_OK(mcpwm_del_comparator(comparator_a));
+    TEST_ESP_OK(mcpwm_del_comparator(comparator_b));
+    TEST_ESP_OK(mcpwm_del_operator(operator));
+    TEST_ESP_OK(mcpwm_del_timer(timer));
+}
+
+static void single_edge_active_high(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+{
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gena,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(gena,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(genb,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(genb,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+}
+
+static void single_edge_active_low(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+{
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gena,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_FULL, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(gena,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(genb,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_FULL, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(genb,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+}
+
+static void pulse_placement(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+{
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(gena,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(genb,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_TOGGLE),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+}
+
+static void dual_edge_active_low_asym(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+{
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(gena,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, cmpb, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(genb,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_FULL, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+}
+
+static void dual_edge_active_low_sym(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+{
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(gena,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, cmpa, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(genb,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, cmpb, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+}
+
+static void dual_edge_complementary(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+{
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(gena,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, cmpa, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(genb,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, cmpb, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+}
+
+TEST_CASE("mcpwm_generator_action_on_compare_event", "[mcpwm]")
+{
+    printf("[Asymmetric, SingleEdge, ActiveHigh]\r\n");
+    // PWMA: high = [1->350], low = [351->499,0]
+    // PWMB: high = [1->200], low = [201->499,0]
+    mcpwm_gen_action_test_template(1000000, 500, MCPWM_TIMER_COUNT_MODE_UP, 350, 200, 0, 2, single_edge_active_high);
+
+    printf("[Asymmetric, SingleEdge, ActiveLow]\r\n");
+    // PWMA: low = [0->300], high = [301->499]
+    // PWMB: low = [0->150], high = [151->499]
+    mcpwm_gen_action_test_template(1000000, 500, MCPWM_TIMER_COUNT_MODE_UP, 300, 150, 0, 2, single_edge_active_low);
+
+    printf("[Asymmetric, PulsePlacement]\r\n");
+    // PWMA: low = [0->200], high = [201->400], low = [401->599]
+    // PWMB: high = [0->599], low = [0->599]
+    mcpwm_gen_action_test_template(1000000, 600, MCPWM_TIMER_COUNT_MODE_UP, 200, 400, 0, 2, pulse_placement);
+
+    printf("[Asymmetric, DualEdge, ActiveLow]\r\n");
+    // PWMA: low = [0->250], high = [251->599, 600->450], low = [451->1]
+    // PWMB: low = [0->599], low = [600->1]
+    mcpwm_gen_action_test_template(1000000, 1200, MCPWM_TIMER_COUNT_MODE_UP_DOWN, 250, 450, 0, 2, dual_edge_active_low_asym);
+
+    printf("[Symmetric, DualEdge, ActiveLow]\r\n");
+    // PWMA: low = [0->400], high = [401->599, 600->400], low = [399->1]
+    // PWMB: low = [0->500], high = [501->599, 600->500], low = [499->1]
+    mcpwm_gen_action_test_template(1000000, 1200, MCPWM_TIMER_COUNT_MODE_UP_DOWN, 400, 500, 0, 2, dual_edge_active_low_sym);
+
+    printf("[Symmetric, DualEdge, Complementary]\r\n");
+    // PWMA: low = [0->350], high = [351->599, 600->350], low = [349->1]
+    // PWMB: low = [0->400], high = [401->599, 600->400], low = [399->1]
+    mcpwm_gen_action_test_template(1000000, 1200, MCPWM_TIMER_COUNT_MODE_UP_DOWN, 350, 400, 0, 2, dual_edge_complementary);
+}
+
+typedef void (*set_dead_time_cb_t)(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb);
+
+static void mcpwm_deadtime_test_template(uint32_t timer_resolution, uint32_t period, uint32_t cmpa, uint32_t cmpb, int gpioa, int gpiob,
+        set_gen_actions_cb_t set_generator_actions, set_dead_time_cb_t set_dead_time)
+{
+    mcpwm_timer_config_t timer_config = {
+        .group_id = 0,
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .resolution_hz = timer_resolution,
+        .period_ticks = period,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+    };
+    mcpwm_timer_handle_t timer = NULL;
+    TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timer));
+
+    mcpwm_operator_config_t operator_config = {
+        .group_id = 0,
+    };
+    mcpwm_oper_handle_t operator = NULL;
+    TEST_ESP_OK(mcpwm_new_operator(&operator_config, &operator));
+    TEST_ESP_OK(mcpwm_operator_connect_timer(operator, timer));
+
+    TEST_ESP_OK(mcpwm_timer_enable(timer));
+
+    mcpwm_cmpr_handle_t comparator_a = NULL;
+    mcpwm_cmpr_handle_t comparator_b = NULL;
+    mcpwm_comparator_config_t comparator_config = {
+        .flags.update_cmp_on_tez = true,
+    };
+    TEST_ESP_OK(mcpwm_new_comparator(operator, &comparator_config, &comparator_a));
+    TEST_ESP_OK(mcpwm_new_comparator(operator, &comparator_config, &comparator_b));
+    TEST_ESP_OK(mcpwm_comparator_set_compare_value(comparator_a, cmpa));
+    TEST_ESP_OK(mcpwm_comparator_set_compare_value(comparator_b, cmpb));
+
+    mcpwm_gen_handle_t generator_a = NULL;
+    mcpwm_gen_handle_t generator_b = NULL;
+    mcpwm_generator_config_t generator_config = {
+        .gen_gpio_num = gpioa,
+    };
+    TEST_ESP_OK(mcpwm_new_generator(operator, &generator_config, &generator_a));
+    generator_config.gen_gpio_num = gpiob;
+    TEST_ESP_OK(mcpwm_new_generator(operator, &generator_config, &generator_b));
+
+    set_generator_actions(generator_a, generator_b, comparator_a, comparator_b);
+    set_dead_time(generator_a, generator_b);
+
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+    vTaskDelay(pdMS_TO_TICKS(100));
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_STOP_EMPTY));
+    vTaskDelay(pdMS_TO_TICKS(10));
+
+    TEST_ESP_OK(mcpwm_timer_disable(timer));
+    TEST_ESP_OK(mcpwm_del_generator(generator_a));
+    TEST_ESP_OK(mcpwm_del_generator(generator_b));
+    TEST_ESP_OK(mcpwm_del_comparator(comparator_a));
+    TEST_ESP_OK(mcpwm_del_comparator(comparator_b));
+    TEST_ESP_OK(mcpwm_del_operator(operator));
+    TEST_ESP_OK(mcpwm_del_timer(timer));
+}
+
+static void ahc_set_generator_actions(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+{
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gena,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(gena,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+}
+
+static void ahc_set_dead_time(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb)
+{
+    mcpwm_dead_time_config_t dead_time_config = {
+        .posedge_delay_ticks = 50,
+        .negedge_delay_ticks = 0
+    };
+    TEST_ESP_OK(mcpwm_generator_set_dead_time(gena, gena, &dead_time_config));
+    dead_time_config.posedge_delay_ticks = 0;
+    dead_time_config.negedge_delay_ticks = 100;
+    dead_time_config.flags.invert_output = true;
+    TEST_ESP_OK(mcpwm_generator_set_dead_time(gena, genb, &dead_time_config));
+}
+
+static void alc_set_generator_actions(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+{
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gena,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(gena,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+}
+
+static void alc_set_dead_time(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb)
+{
+    mcpwm_dead_time_config_t dead_time_config = {
+        .posedge_delay_ticks = 50,
+        .negedge_delay_ticks = 0,
+        .flags.invert_output = true
+    };
+    TEST_ESP_OK(mcpwm_generator_set_dead_time(gena, gena, &dead_time_config));
+    dead_time_config.posedge_delay_ticks = 0;
+    dead_time_config.negedge_delay_ticks = 100;
+    dead_time_config.flags.invert_output = false;
+    TEST_ESP_OK(mcpwm_generator_set_dead_time(gena, genb, &dead_time_config));
+}
+
+static void ah_set_generator_actions(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+{
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gena,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(gena,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+}
+
+static void ah_set_dead_time(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb)
+{
+    mcpwm_dead_time_config_t dead_time_config = {
+        .posedge_delay_ticks = 50,
+        .negedge_delay_ticks = 0,
+    };
+    TEST_ESP_OK(mcpwm_generator_set_dead_time(gena, gena, &dead_time_config));
+    dead_time_config.posedge_delay_ticks = 0;
+    dead_time_config.negedge_delay_ticks = 100;
+    TEST_ESP_OK(mcpwm_generator_set_dead_time(gena, genb, &dead_time_config));
+}
+
+static void al_set_generator_actions(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+{
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gena,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(gena,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+}
+
+static void al_set_dead_time(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb)
+{
+    mcpwm_dead_time_config_t dead_time_config = {
+        .posedge_delay_ticks = 50,
+        .negedge_delay_ticks = 0,
+        .flags.invert_output = true
+    };
+    TEST_ESP_OK(mcpwm_generator_set_dead_time(gena, gena, &dead_time_config));
+    dead_time_config.posedge_delay_ticks = 0;
+    dead_time_config.negedge_delay_ticks = 100;
+    TEST_ESP_OK(mcpwm_generator_set_dead_time(gena, genb, &dead_time_config));
+}
+
+static void reda_only_set_generator_actions(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+{
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gena,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(gena,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(genb,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(genb,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+}
+
+static void reda_only_set_dead_time(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb)
+{
+    mcpwm_dead_time_config_t dead_time_config = {
+        .posedge_delay_ticks = 50,
+        .negedge_delay_ticks = 0,
+    };
+    // apply deadtime to generator_a
+    TEST_ESP_OK(mcpwm_generator_set_dead_time(gena, gena, &dead_time_config));
+    // bypass deadtime module for generator_b
+    dead_time_config.posedge_delay_ticks = 0;
+    TEST_ESP_OK(mcpwm_generator_set_dead_time(genb, genb, &dead_time_config));
+}
+
+static void fedb_only_set_generator_actions(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+{
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gena,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(gena,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(genb,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(genb,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+}
+
+static void fedb_only_set_dead_time(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb)
+{
+    mcpwm_dead_time_config_t dead_time_config = {
+        .posedge_delay_ticks = 0,
+        .negedge_delay_ticks = 0,
+    };
+    // generator_a bypass the deadtime module (no delay)
+    TEST_ESP_OK(mcpwm_generator_set_dead_time(gena, gena, &dead_time_config));
+    // apply dead time to generator_b
+    dead_time_config.negedge_delay_ticks = 50;
+    TEST_ESP_OK(mcpwm_generator_set_dead_time(genb, genb, &dead_time_config));
+
+}
+
+static void redfedb_only_set_generator_actions(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+{
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gena,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(gena,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(genb,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_compare_event(genb,
+                MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+}
+
+static void redfedb_only_set_dead_time(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb)
+{
+    mcpwm_dead_time_config_t dead_time_config = {
+        .posedge_delay_ticks = 0,
+        .negedge_delay_ticks = 0,
+    };
+    // generator_a bypass the deadtime module (no delay)
+    TEST_ESP_OK(mcpwm_generator_set_dead_time(gena, gena, &dead_time_config));
+    // apply dead time on both edge for generator_b
+    dead_time_config.negedge_delay_ticks = 50;
+    dead_time_config.posedge_delay_ticks = 50;
+    TEST_ESP_OK(mcpwm_generator_set_dead_time(genb, genb, &dead_time_config));
+}
+
+TEST_CASE("mcpwm_generator_deadtime_classical_configuration", "[mcpwm]")
+{
+    printf("Active High Complementary\r\n");
+    mcpwm_deadtime_test_template(1000000, 600, 200, 400, 0, 2, ahc_set_generator_actions, ahc_set_dead_time);
+
+    printf("Active Low Complementary\r\n");
+    mcpwm_deadtime_test_template(1000000, 600, 200, 400, 0, 2, alc_set_generator_actions, alc_set_dead_time);
+
+    printf("Active High\r\n");
+    mcpwm_deadtime_test_template(1000000, 600, 200, 400, 0, 2, ah_set_generator_actions, ah_set_dead_time);
+
+    printf("Active Low\r\n");
+    mcpwm_deadtime_test_template(1000000, 600, 200, 400, 0, 2, al_set_generator_actions, al_set_dead_time);
+
+    printf("RED on A, Bypass B\r\n");
+    mcpwm_deadtime_test_template(1000000, 500, 350, 350, 0, 2, reda_only_set_generator_actions, reda_only_set_dead_time);
+
+    printf("Bypass A, FED on B\r\n");
+    mcpwm_deadtime_test_template(1000000, 500, 350, 350, 0, 2, fedb_only_set_generator_actions, fedb_only_set_dead_time);
+
+    printf("Bypass A, RED + FED on B\r\n");
+    mcpwm_deadtime_test_template(1000000, 500, 350, 350, 0, 2, redfedb_only_set_generator_actions, redfedb_only_set_dead_time);
+}
diff --git a/components/driver/test_apps/mcpwm/main/test_mcpwm_oper.c b/components/driver/test_apps/mcpwm/main/test_mcpwm_oper.c
new file mode 100644
index 0000000000..6c013e705c
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/main/test_mcpwm_oper.c
@@ -0,0 +1,380 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "unity.h"
+#include "soc/soc_caps.h"
+#include "driver/mcpwm_oper.h"
+#include "driver/mcpwm_timer.h"
+#include "driver/mcpwm_gen.h"
+#include "driver/mcpwm_fault.h"
+#include "driver/gpio.h"
+
+TEST_CASE("mcpwm_operator_install_uninstall", "[mcpwm]")
+{
+    const int total_operators = SOC_MCPWM_OPERATORS_PER_GROUP * SOC_MCPWM_GROUPS;
+    mcpwm_timer_handle_t timers[SOC_MCPWM_GROUPS];
+    mcpwm_oper_handle_t operators[total_operators];
+
+    mcpwm_timer_config_t timer_config = {
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .resolution_hz = 1 * 1000 * 1000,
+        .period_ticks = 10 * 1000,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+    };
+    mcpwm_operator_config_t operator_config = {
+    };
+    printf("install one MCPWM timer for each group\r\n");
+    for (int i = 0; i < SOC_MCPWM_GROUPS; i++) {
+        timer_config.group_id = i;
+        TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timers[i]));
+    }
+    printf("install MCPWM operators for each group\r\n");
+    int k = 0;
+    for (int i = 0; i < SOC_MCPWM_GROUPS; i++) {
+        operator_config.group_id = i;
+        for (int j = 0; j < SOC_MCPWM_OPERATORS_PER_GROUP; j++) {
+            TEST_ESP_OK(mcpwm_new_operator(&operator_config, &operators[k++]));
+        }
+        TEST_ESP_ERR(ESP_ERR_NOT_FOUND, mcpwm_new_operator(&operator_config, &operators[0]));
+    }
+    printf("connect MCPWM timer and operators\r\n");
+    k = 0;
+    for (int i = 0; i < SOC_MCPWM_GROUPS; i++) {
+        for (int j = 0; j < SOC_MCPWM_OPERATORS_PER_GROUP; j++) {
+            TEST_ESP_OK(mcpwm_operator_connect_timer(operators[k++], timers[i]));
+        }
+    }
+    TEST_ESP_ERR(ESP_ERR_INVALID_ARG, mcpwm_operator_connect_timer(operators[0], timers[1]));
+    printf("uninstall operators and timers\r\n");
+    for (int i = 0; i < total_operators; i++) {
+        TEST_ESP_OK(mcpwm_del_operator(operators[i]));
+    }
+    for (int i = 0; i < SOC_MCPWM_GROUPS; i++) {
+        TEST_ESP_OK(mcpwm_del_timer(timers[i]));
+    }
+}
+
+TEST_CASE("mcpwm_operator_carrier", "[mcpwm]")
+{
+    mcpwm_timer_config_t timer_config = {
+        .group_id = 0,
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .resolution_hz = 1000000, // 1MHz, 1us per tick
+        .period_ticks = 20000,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+    };
+    mcpwm_timer_handle_t timer = NULL;
+    TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timer));
+
+    mcpwm_operator_config_t operator_config = {
+        .group_id = 0,
+    };
+    mcpwm_oper_handle_t operator = NULL;
+    TEST_ESP_OK(mcpwm_new_operator(&operator_config, &operator));
+    TEST_ESP_OK(mcpwm_operator_connect_timer(operator, timer));
+
+    mcpwm_generator_config_t generator_config = {
+        .gen_gpio_num = 0,
+    };
+    mcpwm_gen_handle_t generator = NULL;
+    TEST_ESP_OK(mcpwm_new_generator(operator, &generator_config, &generator));
+
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(generator,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_TOGGLE),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+
+    printf("add carrier to PWM wave\r\n");
+    mcpwm_carrier_config_t carrier_config = {
+        .frequency_hz = 1000000, // 1MHz carrier
+        .duty_cycle = 0.5,
+        .first_pulse_duration_us = 10,
+    };
+    TEST_ESP_OK(mcpwm_operator_apply_carrier(operator, &carrier_config));
+
+    TEST_ESP_OK(mcpwm_timer_enable(timer));
+
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+    vTaskDelay(pdMS_TO_TICKS(100));
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_STOP_EMPTY));
+    vTaskDelay(pdMS_TO_TICKS(100));
+
+    printf("remove carrier from PWM wave\r\n");
+    carrier_config.frequency_hz = 0;
+    TEST_ESP_OK(mcpwm_operator_apply_carrier(operator, &carrier_config));
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+    vTaskDelay(pdMS_TO_TICKS(200));
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_STOP_EMPTY));
+    vTaskDelay(pdMS_TO_TICKS(100));
+
+    TEST_ESP_OK(mcpwm_timer_disable(timer));
+    TEST_ESP_OK(mcpwm_del_generator(generator));
+    TEST_ESP_OK(mcpwm_del_operator(operator));
+    TEST_ESP_OK(mcpwm_del_timer(timer));
+}
+
+static bool test_cbc_brake_on_gpio_fault_callback(mcpwm_oper_handle_t operator, const mcpwm_brake_event_data_t *edata, void *user_data)
+{
+    esp_rom_printf("cbc brake\r\n");
+    return false;
+}
+
+static bool test_ost_brake_on_gpio_fault_callback(mcpwm_oper_handle_t operator, const mcpwm_brake_event_data_t *edata, void *user_data)
+{
+    esp_rom_printf("ost brake\r\n");
+    return false;
+}
+
+TEST_CASE("mcpwm_operator_brake_on_gpio_fault", "[mcpwm]")
+{
+    printf("install timer\r\n");
+    mcpwm_timer_config_t timer_config = {
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .group_id = 0,
+        .resolution_hz = 1000000, // 1MHz, 1us per tick
+        .period_ticks = 20000,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+    };
+    mcpwm_timer_handle_t timer = NULL;
+    TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timer));
+
+    printf("install operator\r\n");
+    mcpwm_operator_config_t operator_config = {
+        .group_id = 0,
+    };
+    mcpwm_oper_handle_t operator = NULL;
+    TEST_ESP_OK(mcpwm_new_operator(&operator_config, &operator));
+    TEST_ESP_OK(mcpwm_operator_connect_timer(operator, timer));
+
+    printf("set brake event callbacks for operator\r\n");
+    mcpwm_operator_event_callbacks_t cbs = {
+        .on_brake_cbc = test_cbc_brake_on_gpio_fault_callback,
+        .on_brake_ost = test_ost_brake_on_gpio_fault_callback,
+    };
+    TEST_ESP_OK(mcpwm_operator_register_event_callbacks(operator, &cbs, NULL));
+
+    printf("install gpio fault\r\n");
+    mcpwm_gpio_fault_config_t gpio_fault_config = {
+        .group_id = 0,
+        .flags.active_level = 1,
+        .flags.io_loop_back = true,
+        .flags.pull_down = true,
+    };
+    mcpwm_fault_handle_t gpio_cbc_fault = NULL;
+    mcpwm_fault_handle_t gpio_ost_fault = NULL;
+    const int cbc_fault_gpio = 4;
+    const int ost_fault_gpio = 5;
+
+    gpio_fault_config.gpio_num = cbc_fault_gpio;
+    TEST_ESP_OK(mcpwm_new_gpio_fault(&gpio_fault_config, &gpio_cbc_fault));
+    gpio_fault_config.gpio_num = ost_fault_gpio;
+    TEST_ESP_OK(mcpwm_new_gpio_fault(&gpio_fault_config, &gpio_ost_fault));
+
+    // put fault GPIO into a safe state
+    gpio_set_level(cbc_fault_gpio, 0);
+    gpio_set_level(ost_fault_gpio, 0);
+
+    printf("set brake mode on fault\r\n");
+    mcpwm_brake_config_t brake_config = {
+        .fault = gpio_cbc_fault,
+        .brake_mode = MCPWM_OPER_BRAKE_MODE_CBC,
+        .flags.cbc_recover_on_tez = true,
+    };
+    TEST_ESP_OK(mcpwm_operator_set_brake_on_fault(operator, &brake_config));
+    brake_config.fault = gpio_ost_fault;
+    brake_config.brake_mode = MCPWM_OPER_BRAKE_MODE_OST;
+    TEST_ESP_OK(mcpwm_operator_set_brake_on_fault(operator, &brake_config));
+
+    printf("create generators\r\n");
+    const int gen_a_gpio = 0;
+    const int gen_b_gpio = 2;
+    mcpwm_gen_handle_t gen_a = NULL;
+    mcpwm_gen_handle_t gen_b = NULL;
+    mcpwm_generator_config_t generator_config = {
+        .flags.io_loop_back = true,
+    };
+    generator_config.gen_gpio_num = gen_a_gpio;
+    TEST_ESP_OK(mcpwm_new_generator(operator, &generator_config, &gen_a));
+    generator_config.gen_gpio_num = gen_b_gpio;
+    TEST_ESP_OK(mcpwm_new_generator(operator, &generator_config, &gen_b));
+
+    printf("set generator actions on timer event\r\n");
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gen_a,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gen_b,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+
+    printf("set generator actions on brake event\r\n");
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_brake_event(gen_a,
+                MCPWM_GEN_BRAKE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_OPER_BRAKE_MODE_CBC, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_BRAKE_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_brake_event(gen_b,
+                MCPWM_GEN_BRAKE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_OPER_BRAKE_MODE_OST, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_BRAKE_EVENT_ACTION_END()));
+
+    printf("enable and start timer\r\n");
+    TEST_ESP_OK(mcpwm_timer_enable(timer));
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+
+    printf("trigger GPIO fault signal, brake in CBC mode\r\n");
+    for (int i = 0; i < 10; i++) {
+        gpio_set_level(cbc_fault_gpio, 1);
+        vTaskDelay(pdMS_TO_TICKS(10));
+        TEST_ASSERT_EQUAL(1, gpio_get_level(gen_a_gpio));
+        // remove the fault signal
+        gpio_set_level(cbc_fault_gpio, 0);
+        // recovery
+        TEST_ESP_OK(mcpwm_operator_recover_from_fault(operator, gpio_cbc_fault));
+        vTaskDelay(pdMS_TO_TICKS(40));
+        // should recovery automatically
+        TEST_ASSERT_EQUAL(0, gpio_get_level(gen_a_gpio));
+    }
+
+    printf("trigger GPIO fault signal, brake in OST mode\r\n");
+    for (int i = 0; i < 10; i++) {
+        gpio_set_level(ost_fault_gpio, 1);
+        vTaskDelay(pdMS_TO_TICKS(10));
+        TEST_ASSERT_EQUAL(1, gpio_get_level(gen_b_gpio));
+        // can't recover because fault signal is still active
+        TEST_ESP_ERR(ESP_ERR_INVALID_STATE, mcpwm_operator_recover_from_fault(operator, gpio_ost_fault));
+        // remove the fault signal
+        gpio_set_level(ost_fault_gpio, 0);
+        vTaskDelay(pdMS_TO_TICKS(40));
+        // for ost brake, the generator can't recover before we manually recover it
+        TEST_ASSERT_EQUAL(1, gpio_get_level(gen_b_gpio));
+        // now it's safe to recover the operator
+        TEST_ESP_OK(mcpwm_operator_recover_from_fault(operator, gpio_ost_fault));
+        vTaskDelay(pdMS_TO_TICKS(40));
+        // should recovery now
+        TEST_ASSERT_EQUAL(0, gpio_get_level(gen_b_gpio));
+    }
+
+    printf("delete all mcpwm objects\r\n");
+    TEST_ESP_OK(mcpwm_timer_disable(timer));
+    TEST_ESP_OK(mcpwm_del_fault(gpio_cbc_fault));
+    TEST_ESP_OK(mcpwm_del_fault(gpio_ost_fault));
+    TEST_ESP_OK(mcpwm_del_generator(gen_a));
+    TEST_ESP_OK(mcpwm_del_generator(gen_b));
+    TEST_ESP_OK(mcpwm_del_operator(operator));
+    TEST_ESP_OK(mcpwm_del_timer(timer));
+}
+
+TEST_CASE("mcpwm_operator_brake_on_soft_fault", "[mcpwm]")
+{
+    printf("install timer\r\n");
+    mcpwm_timer_config_t timer_config = {
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .group_id = 0,
+        .resolution_hz = 1000000, // 1MHz, 1us per tick
+        .period_ticks = 20000,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+    };
+    mcpwm_timer_handle_t timer = NULL;
+    TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timer));
+
+    printf("install operator\r\n");
+    mcpwm_operator_config_t operator_config = {
+        .group_id = 0,
+    };
+    mcpwm_oper_handle_t operator = NULL;
+    TEST_ESP_OK(mcpwm_new_operator(&operator_config, &operator));
+    TEST_ESP_OK(mcpwm_operator_connect_timer(operator, timer));
+
+    printf("install soft fault\r\n");
+    mcpwm_soft_fault_config_t soft_fault_config = {};
+    mcpwm_fault_handle_t soft_fault = NULL;
+    TEST_ESP_OK(mcpwm_new_soft_fault(&soft_fault_config, &soft_fault));
+
+    printf("set brake mode on fault\r\n");
+    mcpwm_brake_config_t brake_config = {
+        .fault = soft_fault,
+        .brake_mode = MCPWM_OPER_BRAKE_MODE_CBC,
+        .flags.cbc_recover_on_tez = true,
+    };
+    TEST_ESP_OK(mcpwm_operator_set_brake_on_fault(operator, &brake_config));
+
+    printf("create generators\r\n");
+    const int gen_a_gpio = 0;
+    const int gen_b_gpio = 2;
+    mcpwm_gen_handle_t gen_a = NULL;
+    mcpwm_gen_handle_t gen_b = NULL;
+    mcpwm_generator_config_t generator_config = {
+        .flags.io_loop_back = true,
+    };
+    generator_config.gen_gpio_num = gen_a_gpio;
+    TEST_ESP_OK(mcpwm_new_generator(operator, &generator_config, &gen_a));
+    generator_config.gen_gpio_num = gen_b_gpio;
+    TEST_ESP_OK(mcpwm_new_generator(operator, &generator_config, &gen_b));
+
+    printf("set generator actions on timer event\r\n");
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gen_a,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_timer_event(gen_b,
+                MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_LOW),
+                MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+
+    printf("set generator actions on brake event\r\n");
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_brake_event(gen_a,
+                MCPWM_GEN_BRAKE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_OPER_BRAKE_MODE_CBC, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_BRAKE_EVENT_ACTION_END()));
+    TEST_ESP_OK(mcpwm_generator_set_actions_on_brake_event(gen_b,
+                MCPWM_GEN_BRAKE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_OPER_BRAKE_MODE_OST, MCPWM_GEN_ACTION_HIGH),
+                MCPWM_GEN_BRAKE_EVENT_ACTION_END()));
+
+    printf("enable and start timer\r\n");
+    TEST_ESP_OK(mcpwm_timer_enable(timer));
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+
+    printf("trigger soft fault signal, brake in CBC mode\r\n");
+    for (int i = 0; i < 1; i++) {
+        // stop the timer, so the operator can't recover from fault automatically
+        TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_STOP_EMPTY));
+        vTaskDelay(pdMS_TO_TICKS(40));
+        // check initial generator output
+        TEST_ASSERT_EQUAL(0, gpio_get_level(gen_a_gpio));
+        TEST_ESP_OK(mcpwm_soft_fault_activate(soft_fault));
+        // check generate output on fault event
+        TEST_ASSERT_EQUAL(1, gpio_get_level(gen_a_gpio));
+        // start the timer, so that operator can recover at a specific event (e.g. tez)
+        TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+        // recover on tez
+        TEST_ESP_OK(mcpwm_operator_recover_from_fault(operator, soft_fault));
+        vTaskDelay(pdMS_TO_TICKS(40));
+        // the generator output should be recoverd automatically
+        TEST_ASSERT_EQUAL(0, gpio_get_level(gen_a_gpio));
+    }
+
+    printf("change the brake mode to ost\r\n");
+    brake_config.brake_mode = MCPWM_OPER_BRAKE_MODE_OST;
+    TEST_ESP_OK(mcpwm_operator_set_brake_on_fault(operator, &brake_config));
+
+    printf("trigger soft fault signal, brake in OST mode\r\n");
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+    for (int i = 0; i < 10; i++) {
+        // check initial generator output
+        TEST_ASSERT_EQUAL(0, gpio_get_level(gen_b_gpio));
+        TEST_ESP_OK(mcpwm_soft_fault_activate(soft_fault));
+        TEST_ASSERT_EQUAL(1, gpio_get_level(gen_b_gpio));
+        vTaskDelay(pdMS_TO_TICKS(40));
+        // don't recover without a manual recover
+        TEST_ASSERT_EQUAL(1, gpio_get_level(gen_b_gpio));
+        TEST_ESP_OK(mcpwm_operator_recover_from_fault(operator, soft_fault));
+        vTaskDelay(pdMS_TO_TICKS(10));
+        // should recovery now
+        TEST_ASSERT_EQUAL(0, gpio_get_level(gen_b_gpio));
+    }
+
+    printf("delete all mcpwm objects\r\n");
+    TEST_ESP_OK(mcpwm_timer_disable(timer));
+    TEST_ESP_OK(mcpwm_del_fault(soft_fault));
+    TEST_ESP_OK(mcpwm_del_generator(gen_a));
+    TEST_ESP_OK(mcpwm_del_generator(gen_b));
+    TEST_ESP_OK(mcpwm_del_operator(operator));
+    TEST_ESP_OK(mcpwm_del_timer(timer));
+}
diff --git a/components/driver/test_apps/mcpwm/main/test_mcpwm_sync.c b/components/driver/test_apps/mcpwm/main/test_mcpwm_sync.c
new file mode 100644
index 0000000000..27cd0f7f63
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/main/test_mcpwm_sync.c
@@ -0,0 +1,204 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "unity.h"
+#include "soc/soc_caps.h"
+#include "driver/mcpwm_timer.h"
+#include "driver/mcpwm_sync.h"
+#include "driver/gpio.h"
+#include "esp_private/mcpwm.h"
+#include "test_mcpwm_utils.h"
+
+TEST_CASE("mcpwm_sync_source_install_uninstall", "[mcpwm]")
+{
+    printf("install timer sync_src\r\n");
+    mcpwm_timer_config_t timer_config = {
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .resolution_hz = 1000000, // 1MHz
+        .period_ticks = 200,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+    };
+    const int total_timers = SOC_MCPWM_TIMERS_PER_GROUP * SOC_MCPWM_GROUPS;
+    mcpwm_timer_handle_t timers[total_timers];
+    int k = 0;
+    for (int i = 0; i < SOC_MCPWM_GROUPS; i++) {
+        timer_config.group_id = i;
+        for (int j = 0; j < SOC_MCPWM_TIMERS_PER_GROUP; j++) {
+            TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timers[k++]));
+        }
+    }
+    mcpwm_timer_sync_src_config_t timer_sync_src_config = {
+        .timer_event = MCPWM_TIMER_EVENT_EMPTY,
+    };
+    mcpwm_sync_handle_t timer_syncs[total_timers];
+    for (int i = 0; i < total_timers; i++) {
+        TEST_ESP_OK(mcpwm_new_timer_sync_src(timers[i], &timer_sync_src_config, &timer_syncs[i]));
+    }
+    TEST_ESP_ERR(ESP_ERR_INVALID_STATE, mcpwm_new_timer_sync_src(timers[0], &timer_sync_src_config, &timer_syncs[0]));
+
+    printf("install gpio sync_src\r\n");
+    mcpwm_gpio_sync_src_config_t gpio_sync_config = {
+        .gpio_num = 0,
+    };
+    const int total_gpio_sync_srcs = SOC_MCPWM_GROUPS * SOC_MCPWM_GPIO_SYNCHROS_PER_GROUP;
+    mcpwm_sync_handle_t gpio_sync_srcs[total_gpio_sync_srcs];
+    k = 0;
+    for (int i = 0; i < SOC_MCPWM_GROUPS; i++) {
+        gpio_sync_config.group_id = i;
+        for (int j = 0; j < SOC_MCPWM_GPIO_SYNCHROS_PER_GROUP; j++) {
+            TEST_ESP_OK(mcpwm_new_gpio_sync_src(&gpio_sync_config, &gpio_sync_srcs[k++]));
+        }
+    }
+    TEST_ESP_ERR(ESP_ERR_NOT_FOUND, mcpwm_new_gpio_sync_src(&gpio_sync_config, &gpio_sync_srcs[0]));
+
+    printf("delete synchors\r\n");
+    for (int i = 0; i < total_gpio_sync_srcs; i++) {
+        TEST_ESP_OK(mcpwm_del_sync_src(gpio_sync_srcs[i]));
+    }
+    for (int i = 0; i < total_timers; i++) {
+        TEST_ESP_OK(mcpwm_del_sync_src(timer_syncs[i]));
+        TEST_ESP_OK(mcpwm_del_timer(timers[i]));
+    }
+}
+
+TEST_CASE("mcpwm_soft_sync_timer_phase_lock", "[mcpwm]")
+{
+    mcpwm_timer_config_t timer_config = {
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .group_id = 0,
+        .resolution_hz = 1000000, // 1MHz
+        .period_ticks = 200,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP_DOWN,
+    };
+    mcpwm_timer_handle_t timer = NULL;
+    TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timer));
+    TEST_ESP_OK(mcpwm_timer_enable(timer));
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_STOP_FULL));
+    vTaskDelay(pdMS_TO_TICKS(10));
+    check_mcpwm_timer_phase(&timer, 1, timer_config.period_ticks / 2, MCPWM_TIMER_DIRECTION_DOWN);
+
+    printf("install soft sync source\r\n");
+    mcpwm_sync_handle_t soft_sync = NULL;
+    mcpwm_soft_sync_config_t soft_sync_config = {};
+    TEST_ESP_OK(mcpwm_new_soft_sync_src(&soft_sync_config, &soft_sync));
+
+    mcpwm_timer_sync_phase_config_t sync_phase_config = {
+        .count_value = 77,
+        .direction = MCPWM_TIMER_DIRECTION_UP,
+        .sync_src = soft_sync,
+    };
+    TEST_ESP_OK(mcpwm_timer_set_phase_on_sync(timer, &sync_phase_config));
+    TEST_ESP_OK(mcpwm_soft_sync_activate(soft_sync));
+    check_mcpwm_timer_phase(&timer, 1, 77, MCPWM_TIMER_DIRECTION_UP);
+
+    TEST_ESP_OK(mcpwm_timer_disable(timer));
+    TEST_ESP_OK(mcpwm_del_timer(timer));
+    TEST_ESP_OK(mcpwm_del_sync_src(soft_sync));
+}
+
+TEST_CASE("mcpwm_gpio_sync_timer_phase_lock", "[mcpwm]")
+{
+    //  GPIO
+    //   |
+    //   v
+    // timer0-->timer1-->timer2
+    mcpwm_timer_config_t timer_config = {
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .group_id = 0,
+        .resolution_hz = 1000000, // 1MHz, 1us per tick
+        .period_ticks = 500,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+    };
+    mcpwm_timer_sync_src_config_t sync_config = {
+        .flags.propagate_input_sync = 1, // reuse the input sync source as the output sync trigger
+    };
+    mcpwm_timer_handle_t timers[SOC_MCPWM_TIMERS_PER_GROUP];
+    mcpwm_sync_handle_t sync_srcs[SOC_MCPWM_TIMERS_PER_GROUP];
+    for (int i = 0; i < SOC_MCPWM_TIMERS_PER_GROUP; i++) {
+        TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timers[i]));
+        TEST_ESP_OK(mcpwm_new_timer_sync_src(timers[i], &sync_config, &sync_srcs[i]));
+    }
+    mcpwm_timer_sync_phase_config_t sync_phase_config = {
+        .count_value = 100,
+        .direction = MCPWM_TIMER_DIRECTION_UP,
+    };
+    mcpwm_sync_handle_t gpio_sync_src;
+    const int gpio_num = 0;
+    mcpwm_gpio_sync_src_config_t gpio_sync_config = {
+        .group_id = 0,
+        .gpio_num = gpio_num,
+        .flags.io_loop_back = true, // so that we can use gpio driver to simulate the sync signal
+        .flags.pull_down = true, // internally pull down
+    };
+    TEST_ESP_OK(mcpwm_new_gpio_sync_src(&gpio_sync_config, &gpio_sync_src));
+    // put the GPIO into initial state
+    gpio_set_level(gpio_num, 0);
+    for (int i = 1; i < SOC_MCPWM_TIMERS_PER_GROUP; i++) {
+        sync_phase_config.sync_src = sync_srcs[i - 1];
+        TEST_ESP_OK(mcpwm_timer_set_phase_on_sync(timers[i], &sync_phase_config));
+    }
+    sync_phase_config.sync_src = gpio_sync_src;
+    TEST_ESP_OK(mcpwm_timer_set_phase_on_sync(timers[0], &sync_phase_config));
+
+    // simulate an GPIO sync singal
+    gpio_set_level(gpio_num, 1);
+    gpio_set_level(gpio_num, 0);
+    check_mcpwm_timer_phase(timers, SOC_MCPWM_CAPTURE_TIMERS_PER_GROUP, 100, MCPWM_TIMER_DIRECTION_UP);
+
+    TEST_ESP_OK(mcpwm_del_sync_src(gpio_sync_src));
+    for (int i = 0; i < SOC_MCPWM_TIMERS_PER_GROUP; i++) {
+        TEST_ESP_OK(mcpwm_del_sync_src(sync_srcs[i]));
+        TEST_ESP_OK(mcpwm_del_timer(timers[i]));
+    }
+}
+
+TEST_CASE("mcpwm_timer_sync_timer_phase_lock", "[mcpwm]")
+{
+    //          +->timer1
+    //          |
+    // timer0---+
+    //          |
+    //          +->timer2
+    mcpwm_timer_config_t timer_config = {
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .group_id = 0,
+        .resolution_hz = 1000000, // 1MHz, 1us per tick
+        .period_ticks = 500,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP_DOWN,
+    };
+    mcpwm_timer_handle_t timers[SOC_MCPWM_TIMERS_PER_GROUP];
+    for (int i = 0; i < SOC_MCPWM_TIMERS_PER_GROUP; i++) {
+        TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timers[i]));
+    }
+
+    mcpwm_timer_sync_src_config_t sync_config = {
+        .timer_event = MCPWM_TIMER_EVENT_FULL,
+    };
+    mcpwm_sync_handle_t sync_src;
+    TEST_ESP_OK(mcpwm_new_timer_sync_src(timers[0], &sync_config, &sync_src));
+
+    mcpwm_timer_sync_phase_config_t sync_phase_config = {
+        .count_value = 50,
+        .direction = MCPWM_TIMER_DIRECTION_DOWN,
+        .sync_src = sync_src,
+    };
+    for (int i = 1; i < SOC_MCPWM_TIMERS_PER_GROUP; i++) {
+        TEST_ESP_OK(mcpwm_timer_set_phase_on_sync(timers[i], &sync_phase_config));
+    }
+
+    TEST_ESP_OK(mcpwm_timer_enable(timers[0]));
+    TEST_ESP_OK(mcpwm_timer_start_stop(timers[0], MCPWM_TIMER_START_STOP_FULL));
+    vTaskDelay(pdMS_TO_TICKS(10));
+
+    check_mcpwm_timer_phase(&timers[1], 2, 50, MCPWM_TIMER_DIRECTION_DOWN);
+
+    TEST_ESP_OK(mcpwm_timer_disable(timers[0]));
+    TEST_ESP_OK(mcpwm_del_sync_src(sync_src));
+    for (int i = 0; i < SOC_MCPWM_TIMERS_PER_GROUP; i++) {
+        TEST_ESP_OK(mcpwm_del_timer(timers[i]));
+    }
+}
diff --git a/components/driver/test_apps/mcpwm/main/test_mcpwm_timer.c b/components/driver/test_apps/mcpwm/main/test_mcpwm_timer.c
new file mode 100644
index 0000000000..2c69fd7dbe
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/main/test_mcpwm_timer.c
@@ -0,0 +1,186 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/event_groups.h"
+#include "unity.h"
+#include "soc/soc_caps.h"
+#include "driver/mcpwm_timer.h"
+#include "esp_private/mcpwm.h"
+#include "test_mcpwm_utils.h"
+
+TEST_CASE("mcpwm_timer_start_stop", "[mcpwm]")
+{
+    mcpwm_timer_config_t config = {
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .resolution_hz = 1000000, // 1MHz
+        .period_ticks = 400,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP_DOWN,
+    };
+    const int num_timers = SOC_MCPWM_TIMERS_PER_GROUP * SOC_MCPWM_GROUPS;
+
+    printf("create mcpwm timer instances\r\n");
+    mcpwm_timer_handle_t timers[num_timers];
+    for (int i = 0; i < SOC_MCPWM_GROUPS; i++) {
+        for (int j = 0; j < SOC_MCPWM_TIMERS_PER_GROUP; j++) {
+            config.group_id = i;
+            TEST_ESP_OK(mcpwm_new_timer(&config, &timers[i * SOC_MCPWM_TIMERS_PER_GROUP + j]));
+        }
+        TEST_ESP_ERR(ESP_ERR_NOT_FOUND, mcpwm_new_timer(&config, &timers[0]));
+    }
+
+    // can't do start/stop control before enable
+    TEST_ESP_ERR(ESP_ERR_INVALID_STATE, mcpwm_timer_start_stop(timers[0], MCPWM_TIMER_START_NO_STOP));
+
+    printf("enable timers\r\n");
+    for (int i = 0; i < num_timers; i++) {
+        TEST_ESP_OK(mcpwm_timer_enable(timers[i]));
+    }
+
+    printf("start timer and then stop when empty\r\n");
+    for (int i = 0; i < num_timers; i++) {
+        TEST_ESP_OK(mcpwm_timer_start_stop(timers[i], MCPWM_TIMER_START_STOP_EMPTY));
+    }
+    vTaskDelay(pdMS_TO_TICKS(10));
+    check_mcpwm_timer_phase(timers, num_timers, 0, MCPWM_TIMER_DIRECTION_UP);
+
+    printf("start timer and then stop when full\r\n");
+    for (int i = 0; i < num_timers; i++) {
+        TEST_ESP_OK(mcpwm_timer_start_stop(timers[i], MCPWM_TIMER_START_STOP_FULL));
+    }
+    vTaskDelay(pdMS_TO_TICKS(10));
+    check_mcpwm_timer_phase(timers, num_timers, config.period_ticks / 2, MCPWM_TIMER_DIRECTION_DOWN);
+
+    printf("start freely and stop manually when full\r\n");
+    for (int i = 0; i < num_timers; i++) {
+        TEST_ESP_OK(mcpwm_timer_start_stop(timers[i], MCPWM_TIMER_START_NO_STOP));
+        vTaskDelay(pdMS_TO_TICKS(10));
+        // stop at next counter full
+        TEST_ESP_OK(mcpwm_timer_start_stop(timers[i], MCPWM_TIMER_STOP_FULL));
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+    check_mcpwm_timer_phase(timers, num_timers, config.period_ticks / 2, MCPWM_TIMER_DIRECTION_DOWN);
+
+    printf("start freely and stop manually when empty\r\n");
+    for (int i = 0; i < num_timers; i++) {
+        TEST_ESP_OK(mcpwm_timer_start_stop(timers[i], MCPWM_TIMER_START_NO_STOP));
+        vTaskDelay(pdMS_TO_TICKS(10));
+        // stop at next counter empty
+        TEST_ESP_OK(mcpwm_timer_start_stop(timers[i], MCPWM_TIMER_STOP_EMPTY));
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+    check_mcpwm_timer_phase(timers, num_timers, 0, MCPWM_TIMER_DIRECTION_UP);
+
+    // can't delete timer before disable
+    TEST_ESP_ERR(ESP_ERR_INVALID_STATE, mcpwm_del_timer(timers[0]));
+
+    printf("disable timers\r\n");
+    for (int i = 0; i < num_timers; i++) {
+        TEST_ESP_OK(mcpwm_timer_disable(timers[i]));
+    }
+
+    printf("delete timers\r\n");
+    for (int i = 0; i < num_timers; i++) {
+        TEST_ESP_OK(mcpwm_del_timer(timers[i]));
+    }
+}
+
+#define TEST_MCPWM_TIMER_EVENT_BIT_FULL  (1 << 0)
+#define TEST_MCPWM_TIMER_EVENT_BIT_EMPTY (1 << 1)
+#define TEST_MCPWM_TIMER_EVENT_BIT_STOP  (1 << 2)
+
+typedef struct {
+    EventGroupHandle_t event_group;
+    uint32_t expected_full_counts;
+    uint32_t expected_empty_counts;
+    uint32_t accumulate_full_counts;
+    uint32_t accumulate_empty_counts;
+} test_mcpwm_timer_user_data_t;
+
+static bool test_on_stop(mcpwm_timer_handle_t timer, const mcpwm_timer_event_data_t *edata, void *user_data)
+{
+    test_mcpwm_timer_user_data_t *udata = (test_mcpwm_timer_user_data_t *)user_data;
+    BaseType_t high_task_wakeup = pdFALSE;
+    esp_rom_printf("timer stopped at %u\r\n", edata->count_value);
+    TEST_ASSERT_EQUAL(0, edata->count_value);
+    xEventGroupSetBitsFromISR(udata->event_group, TEST_MCPWM_TIMER_EVENT_BIT_STOP, &high_task_wakeup);
+    return high_task_wakeup == pdTRUE;
+}
+
+static bool test_on_full(mcpwm_timer_handle_t timer, const mcpwm_timer_event_data_t *edata, void *user_data)
+{
+    test_mcpwm_timer_user_data_t *udata = (test_mcpwm_timer_user_data_t *)user_data;
+    BaseType_t high_task_wakeup = pdFALSE;
+    udata->accumulate_full_counts++;
+    if (udata->accumulate_full_counts >= udata->expected_full_counts) {
+        udata->accumulate_full_counts = 0;
+        xEventGroupSetBitsFromISR(udata->event_group, TEST_MCPWM_TIMER_EVENT_BIT_FULL, &high_task_wakeup);
+    }
+    return high_task_wakeup == pdTRUE;
+}
+
+static bool test_on_empty(mcpwm_timer_handle_t timer, const mcpwm_timer_event_data_t *edata, void *user_data)
+{
+    test_mcpwm_timer_user_data_t *udata = (test_mcpwm_timer_user_data_t *)user_data;
+    BaseType_t high_task_wakeup = pdFALSE;
+    udata->accumulate_empty_counts++;
+    if (udata->accumulate_empty_counts >= udata->expected_empty_counts) {
+        udata->accumulate_empty_counts = 0;
+        xEventGroupSetBitsFromISR(udata->event_group, TEST_MCPWM_TIMER_EVENT_BIT_EMPTY, &high_task_wakeup);
+    }
+    return high_task_wakeup == pdTRUE;
+}
+
+TEST_CASE("mcpwm_timer_event_callbacks", "[mcpwm]")
+{
+    EventGroupHandle_t event_group = xEventGroupCreate();
+    EventBits_t bits = 0;
+    mcpwm_timer_config_t timer_config = {
+        .group_id = 0,
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .resolution_hz = 1 * 1000 * 1000, // 1MHz, 1us per tick
+        .period_ticks = 20 * 1000,        // 20ms, 50Hz
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+    };
+    mcpwm_timer_handle_t timer = NULL;
+    printf("create mcpwm timer\r\n");
+    TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timer));
+
+    printf("register event callbacks\r\n");
+    mcpwm_timer_event_callbacks_t cbs = {
+        .on_stop = test_on_stop,
+        .on_full = test_on_full,
+        .on_empty = test_on_empty,
+    };
+    test_mcpwm_timer_user_data_t udata = {
+        .event_group = event_group,
+        .expected_empty_counts = 50,
+        .expected_full_counts = 50,
+    };
+    TEST_ESP_OK(mcpwm_timer_register_event_callbacks(timer, &cbs, &udata));
+
+    printf("enable timer\r\n");
+    TEST_ESP_OK(mcpwm_timer_enable(timer));
+
+    printf("start timer\r\n");
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+
+    printf("wait for full and empty events\r\n");
+    bits = xEventGroupWaitBits(event_group, TEST_MCPWM_TIMER_EVENT_BIT_FULL | TEST_MCPWM_TIMER_EVENT_BIT_EMPTY, pdTRUE, pdTRUE, pdMS_TO_TICKS(1050));
+    TEST_ASSERT_EQUAL(TEST_MCPWM_TIMER_EVENT_BIT_FULL | TEST_MCPWM_TIMER_EVENT_BIT_EMPTY, bits);
+
+    printf("stop timer and wait for event\r\n");
+    TEST_ESP_OK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_STOP_EMPTY));
+    bits = xEventGroupWaitBits(event_group, TEST_MCPWM_TIMER_EVENT_BIT_STOP, pdTRUE, pdTRUE, pdMS_TO_TICKS(50));
+    TEST_ASSERT_EQUAL(TEST_MCPWM_TIMER_EVENT_BIT_STOP, bits);
+
+    printf("disable timer\r\n");
+    TEST_ESP_OK(mcpwm_timer_disable(timer));
+
+    printf("delete timer\r\n");
+    TEST_ESP_OK(mcpwm_del_timer(timer));
+    vEventGroupDelete(event_group);
+}
diff --git a/components/driver/test_apps/mcpwm/main/test_mcpwm_utils.c b/components/driver/test_apps/mcpwm/main/test_mcpwm_utils.c
new file mode 100644
index 0000000000..d1c933b62a
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/main/test_mcpwm_utils.c
@@ -0,0 +1,20 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "unity.h"
+#include "esp_private/mcpwm.h"
+#include "test_mcpwm_utils.h"
+
+void check_mcpwm_timer_phase(mcpwm_timer_handle_t *timers, size_t num_timers,
+                             uint32_t expected_count, mcpwm_timer_direction_t expected_direction)
+{
+    uint32_t count_value;
+    mcpwm_timer_direction_t direction;
+    for (size_t i = 0; i < num_timers; i++) {
+        TEST_ESP_OK(mcpwm_timer_get_phase(timers[i], &count_value, &direction));
+        TEST_ASSERT_INT_WITHIN(1, expected_count, count_value);
+        TEST_ASSERT_EQUAL(expected_direction, direction);
+    }
+}
diff --git a/components/driver/test_apps/mcpwm/main/test_mcpwm_utils.h b/components/driver/test_apps/mcpwm/main/test_mcpwm_utils.h
new file mode 100644
index 0000000000..feb98a415f
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/main/test_mcpwm_utils.h
@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "sdkconfig.h"
+#include "esp_attr.h"
+#include "driver/mcpwm_types.h"
+
+#if CONFIG_MCPWM_ISR_IRAM_SAFE
+#define TEST_MCPWM_CALLBACK_ATTR IRAM_ATTR
+#else
+#define TEST_MCPWM_CALLBACK_ATTR
+#endif // CONFIG_MCPWM_ISR_IRAM_SAFE
+
+void check_mcpwm_timer_phase(mcpwm_timer_handle_t *timers, size_t num_timers,
+                             uint32_t expected_count, mcpwm_timer_direction_t expected_direction);
diff --git a/components/driver/test_apps/mcpwm/pytest_mcpwm.py b/components/driver/test_apps/mcpwm/pytest_mcpwm.py
new file mode 100644
index 0000000000..6def6d2cf4
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/pytest_mcpwm.py
@@ -0,0 +1,22 @@
+# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: CC0-1.0
+
+import pytest
+from pytest_embedded import Dut
+
+
+@pytest.mark.esp32
+@pytest.mark.esp32s3
+@pytest.mark.generic
+@pytest.mark.parametrize(
+    'config',
+    [
+        'release',
+        'iram_safe',
+    ],
+    indirect=True,
+)
+def test_mcpwm(dut: Dut) -> None:
+    dut.expect('Press ENTER to see the list of tests')
+    dut.write('*')
+    dut.expect_unity_test_output()
diff --git a/components/driver/test_apps/mcpwm/sdkconfig.ci.iram_safe b/components/driver/test_apps/mcpwm/sdkconfig.ci.iram_safe
new file mode 100644
index 0000000000..f5e68a8539
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/sdkconfig.ci.iram_safe
@@ -0,0 +1,5 @@
+CONFIG_COMPILER_DUMP_RTL_FILES=y
+CONFIG_MCPWM_ISR_IRAM_SAFE=y
+
+# silent the error check, as the error string are stored in rodata, causing RTL check failure
+CONFIG_COMPILER_OPTIMIZATION_CHECKS_SILENT=y
diff --git a/components/driver/test_apps/mcpwm/sdkconfig.ci.release b/components/driver/test_apps/mcpwm/sdkconfig.ci.release
new file mode 100644
index 0000000000..91d93f163e
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/sdkconfig.ci.release
@@ -0,0 +1,5 @@
+CONFIG_PM_ENABLE=y
+CONFIG_FREERTOS_USE_TICKLESS_IDLE=y
+CONFIG_COMPILER_OPTIMIZATION_SIZE=y
+CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y
+CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT=y
diff --git a/components/driver/test_apps/mcpwm/sdkconfig.defaults b/components/driver/test_apps/mcpwm/sdkconfig.defaults
new file mode 100644
index 0000000000..b308cb2ddd
--- /dev/null
+++ b/components/driver/test_apps/mcpwm/sdkconfig.defaults
@@ -0,0 +1,2 @@
+CONFIG_FREERTOS_HZ=1000
+CONFIG_ESP_TASK_WDT=n

From 938b3d717fb4716ad87bdb6a90891b146f9e8fae Mon Sep 17 00:00:00 2001
From: morris <maoshengrong@espressif.com>
Date: Sat, 28 May 2022 17:03:57 +0800
Subject: [PATCH 3/8] example: update bdc speed control example with new driver
 API

---
 examples/peripherals/.build-test-rules.yml    |  16 +
 .../mcpwm/mcpwm_bdc_speed_control/README.md   | 107 +++----
 .../bdc_speed_dashboard.png                   | Bin 0 -> 124458 bytes
 .../components/bdc_motor/CMakeLists.txt       |   9 +
 .../components/bdc_motor/README.md            |   7 +
 .../components/bdc_motor/include/bdc_motor.h  | 145 +++++++++
 .../bdc_motor/interface/bdc_motor_interface.h | 116 +++++++
 .../components/bdc_motor/src/bdc_motor.c      |  62 ++++
 .../bdc_motor/src/bdc_motor_mcpwm_impl.c      | 185 ++++++++++++
 .../main/Kconfig.projbuild                    |  12 +
 .../main/mcpwm_bdc_control_example_main.c     | 282 ++++++------------
 .../pytest_bdc_speed_control.py               |  17 ++
 .../serial-studio-dashboard.json              |  28 ++
 .../serial-studio-proto-map.json              |  22 --
 tools/ci/check_copyright_ignore.txt           |   3 -
 15 files changed, 736 insertions(+), 275 deletions(-)
 create mode 100644 examples/peripherals/mcpwm/mcpwm_bdc_speed_control/bdc_speed_dashboard.png
 create mode 100644 examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/CMakeLists.txt
 create mode 100644 examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/README.md
 create mode 100644 examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/include/bdc_motor.h
 create mode 100644 examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/interface/bdc_motor_interface.h
 create mode 100644 examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/src/bdc_motor.c
 create mode 100644 examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/src/bdc_motor_mcpwm_impl.c
 create mode 100644 examples/peripherals/mcpwm/mcpwm_bdc_speed_control/main/Kconfig.projbuild
 create mode 100644 examples/peripherals/mcpwm/mcpwm_bdc_speed_control/pytest_bdc_speed_control.py
 create mode 100644 examples/peripherals/mcpwm/mcpwm_bdc_speed_control/serial-studio-dashboard.json
 delete mode 100644 examples/peripherals/mcpwm/mcpwm_bdc_speed_control/serial-studio-proto-map.json

diff --git a/examples/peripherals/.build-test-rules.yml b/examples/peripherals/.build-test-rules.yml
index 9845fe85fb..391a727b4f 100644
--- a/examples/peripherals/.build-test-rules.yml
+++ b/examples/peripherals/.build-test-rules.yml
@@ -70,6 +70,22 @@ examples/peripherals/mcpwm:
   disable:
     - if: SOC_MCPWM_SUPPORTED != 1
 
+examples/peripherals/mcpwm/mcpwm_bdc_speed_control:
+  disable:
+    - if: SOC_MCPWM_SUPPORTED != 1
+  disable_test:
+    - if: IDF_TARGET != "esp32s3"
+      temporary: true
+      reason: lack of runners
+
+examples/peripherals/mcpwm/mcpwm_bldc_hall_control:
+  disable:
+    - if: SOC_MCPWM_SUPPORTED != 1
+  disable_test:
+    - if: IDF_TARGET != "esp32s3"
+      temporary: true
+      reason: lack of runners
+
 examples/peripherals/pcnt:
   disable:
     - if: SOC_PCNT_SUPPORTED != 1
diff --git a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/README.md b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/README.md
index e2e90b2fb3..09ab448a55 100644
--- a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/README.md
+++ b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/README.md
@@ -4,7 +4,11 @@
 
 (See the README.md file in the upper level 'examples' directory for more information about examples.)
 
-This example mainly illustrates how to drive a brushed DC motor by generating two specific PWM signals. However the PWM signals from ESP32 can't drive motors directly as the motor usually consumes high current. So an H-bridge like [DRV8848](https://www.ti.com/product/DRV8848) should be used to provide the needed voltage and current for brushed DC motor. To measure the speed of motor, a photoelectric encoder is used to generate the "speed feedback" signals (e.g. a pair of quadrature signal). The example uses a simple PID control approach to keep the motor speed in a constant speed. The example provides a console command line interface for user to update the PID parameters according to actual situation.
+This example mainly illustrates how to drive a brushed DC motor by generating two specific PWM signals. However the PWM signals from ESP chip can't drive motors directly as the motor usually consumes high current. So an H-bridge like [DRV8848](https://www.ti.com/product/DRV8848) should be used to provide the needed voltage and current for brushed DC motor. To simplify the DC motor control of MCPWM peripheral driver, there's a component called [bdc_motor](components/bdc_motor/README.md) which abstracts the common operations into a generic interface. The most useful operations are: `forward`, `reverse`, `coast` and `brake`.
+
+To measure the speed of motor, a photoelectric encoder is used to generate the "speed feedback" signals (e.g. a pair of quadrature signal). In the example, we use the PCNT peripheral to decode that quadrature signals. For more information, please refer to [rotary encoder example](../../pcnt/rotary_encoder/README.md) as well.
+
+The example uses a simple PID algorithm to keep the motor spin in a stable speed. The PID component is fetched from the [IDF Component Registry](https://components.espressif.com/component/espressif/pid_ctrl).
 
 ## How to Use Example
 
@@ -12,7 +16,7 @@ Before project configuration and build, be sure to set the correct chip target u
 
 ### Hardware Required
 
-* A development board with any Espressif SoC which features MCPWM and PCNT peripheral (e.g., ESP32-DevKitC, ESP-WROVER-KIT, etc.)
+* A development board with any Espressif SoC which features MCPWM and PCNT peripheral (e.g., ESP32-DevKitC, ESP32-S3-Motor-Devkit, etc.)
 * A USB cable for Power supply and programming
 * A separate 12V power supply for brushed DC motor and H-bridge (the voltage depends on the motor model used in the example)
 * A motor driving board to transfer pwm signal into driving signal
@@ -23,28 +27,28 @@ Connection :
 ```
                                      Power(12V)
                                          |
-                                         v
-+----------------+             +--------------------+
-|                |             |      H-Bridge      |
-|            GND +<----------->| GND                |      +--------------+
-|                |             |                    |      |              |
-|  GENA_GPIO_NUM +----PWM0A--->| IN_A         OUT_A +----->|   Brushed    |
-|                |             |                    |      |     DC       |
-|  GENB_GPIO_NUM +----PWM0B--->| IN_B         OUT_B +----->|    Motor     |
-|                |             |                    |      |              |
-| ESP            |             +--------------------+      |              |
-|                |                                         +------+-------+
-|                |                                                |
-|                |             +--------------------+             |
-|         VCC3.3 +------------>| VCC    Encoder     |             |
-|                |             |                    |             |
-|            GND +<----------->|                    |<------------+
-|                |             |                    |
-|PHASEA_GPIO_NUM |<---PhaseA---+ C1                 |
-|                |             |                    |
-|PHASEB_GPIO_NUM |<---PhaseB---+ C2                 |
-|                |             |                    |
-+----------------+             +--------------------+
+      ESP                                v
++-------------------+             +--------------------+
+|                   |             |      H-Bridge      |
+|               GND +<----------->| GND                |      +--------------+
+|                   |             |                    |      |              |
+|  BDC_MCPWM_GPIO_A +----PWM0A--->| IN_A         OUT_A +----->|   Brushed    |
+|                   |             |                    |      |     DC       |
+|  BDC_MCPWM_GPIO_B +----PWM0B--->| IN_B         OUT_B +----->|    Motor     |
+|                   |             |                    |      |              |
+|                   |             +--------------------+      |              |
+|                   |                                         +------+-------+
+|                   |                                                |
+|                   |             +--------------------+             |
+|            VCC3.3 +------------>| VCC    Encoder     |             |
+|                   |             |                    |             |
+|               GND +<----------->|                    |<------------+
+|                   |             |                    |
+|BDC_ENCODER_GPIO_A |<---PhaseA---+ C1                 |
+|                   |             |                    |
+|BDC_ENCODER_GPIO_B |<---PhaseB---+ C2                 |
+|                   |             |                    |
++-------------------+             +--------------------+
 ```
 
 ### Build and Flash
@@ -62,51 +66,30 @@ Run the example, you will see the following output log:
 
 ```
 I (0) cpu_start: Starting scheduler on APP CPU.
-configure mcpwm gpio
-init mcpwm driver
-init and start rotary encoder
-init PID control block
-init motor control timer
-D (561) gptimer: new group (0) @0x3fce0a24
-D (561) gptimer: new gptimer (0,0) at 0x3fce0964, resolution=1000000Hz
-create motor control task
-start motor control timer
-D (571) gptimer: install interrupt service for timer (0,0)
-install console command line
-
-Type 'help' to get the list of commands.
-Use UP/DOWN arrows to navigate through command history.
-Press TAB when typing command name to auto-complete.
-dc-motor>
-dc-motor> help
-help
-  Print the list of registered commands
-
-pid  [-p <kp>] [-i <ki>] [-d <kd>]
-  Set PID parameters
-       -p <kp>  Set Kp value of PID
-       -i <ki>  Set Ki value of PID
-       -d <kd>  Set Kd value of PID
+I (308) example: Create DC motor
+I (308) gpio: GPIO[7]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (318) gpio: GPIO[15]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (328) example: Init pcnt driver to decode rotary signal
+I (328) gpio: GPIO[36]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (338) gpio: GPIO[35]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (348) gpio: GPIO[35]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (358) gpio: GPIO[36]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (368) example: Create PID control block
+I (378) example: Create a timer to do PID calculation periodically
+I (378) example: Enable motor
+I (388) example: Forward motor
+I (388) example: Start motor speed loop
 ```
 
-### Set PID parameters
+### View velocity curve in [Serial Studio](https://github.com/Serial-Studio/Serial-Studio)
 
-* Command: `pid -p <double> -i <double> -d <double> -t <loc/inc>`
-* 'p' - proportion value
-* 'i' - integral value
-* 'd' - differential value
-* 't' - PID calculation type (locational or incremental).
+To help tune the PID parameters (i.e. `Kp`, `Ki` and `Kd` in the example), this example supports to log a short string frame of runtime motor speed. The string frame can be parsed by [Serial Studio](https://github.com/Serial-Studio/Serial-Studio). This example also provides the [communication description file](serial-studio-dashboard.json) out of the box, which can be loaded by Serial Studio and then plot the curves as follows:
 
-```bash
-mcpwm-motor> pid -p 0.8 -i 0.02 -d 0.1 -t inc
-pid: kp = 0.800
-pid: ki = 0.020
-pid: kd = 0.100
-pid: type = increment
-```
+![bdc_speed_dashboard](bdc_speed_dashboard.png)
 
 ## Troubleshooting
 
 * Make sure your ESP board and H-bridge module have been connected to the same GND panel.
+* The PID parameter set in ths example might not work well in all kinds of motors, because it's not adaptive. You need to fine tune the parameters again by yourself.
 
 For any technical queries, please open an [issue](https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you soon.
diff --git a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/bdc_speed_dashboard.png b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/bdc_speed_dashboard.png
new file mode 100644
index 0000000000000000000000000000000000000000..24318617d322456b051adcf97e150276966b97ff
GIT binary patch
literal 124458
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
MPgg&ebxsLQ0Ft9sX#fBK

literal 0
HcmV?d00001

diff --git a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/CMakeLists.txt b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/CMakeLists.txt
new file mode 100644
index 0000000000..e8f680b259
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/CMakeLists.txt
@@ -0,0 +1,9 @@
+set(srcs "src/bdc_motor.c")
+
+if(CONFIG_SOC_MCPWM_SUPPORTED)
+    list(APPEND srcs "src/bdc_motor_mcpwm_impl.c")
+endif()
+
+idf_component_register(SRCS ${srcs}
+                       INCLUDE_DIRS "include" "interface"
+                       PRIV_REQUIRES "driver")
diff --git a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/README.md b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/README.md
new file mode 100644
index 0000000000..8918067552
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/README.md
@@ -0,0 +1,7 @@
+# Brushed DC Motor Component
+
+This directory contains an implementation for Brushed DC Motor by different peripherals. Currently only MCPWM is supported as the BDC motor backend.
+
+To learn more about how to use this component, please check API Documentation from header file [bdc_motor.h](./include/bdc_motor.h).
+
+Please note that this component is not considered to be a part of ESP-IDF stable API. It may change and it may be removed in the future releases.
diff --git a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/include/bdc_motor.h b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/include/bdc_motor.h
new file mode 100644
index 0000000000..1b102d91f6
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/include/bdc_motor.h
@@ -0,0 +1,145 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include <stdint.h>
+#include "esp_err.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Brushed DC Motor handle
+ */
+typedef struct bdc_motor_t *bdc_motor_handle_t;
+
+/**
+ * @brief Enable BDC motor
+ *
+ * @param motor: BDC Motor handle
+ *
+ * @return
+ *      - ESP_OK: Enable motor successfully
+ *      - ESP_ERR_INVALID_ARG: Enable motor failed because of invalid parameters
+ *      - ESP_FAIL: Enable motor failed because other error occurred
+ */
+esp_err_t bdc_motor_enable(bdc_motor_handle_t motor);
+
+/**
+ * @brief Disable BDC motor
+ *
+ * @param motor: BDC Motor handle
+ *
+ * @return
+ *      - ESP_OK: Disable motor successfully
+ *      - ESP_ERR_INVALID_ARG: Disable motor failed because of invalid parameters
+ *      - ESP_FAIL: Disable motor failed because other error occurred
+ */
+esp_err_t bdc_motor_disable(bdc_motor_handle_t motor);
+
+/**
+ * @brief Set speed for bdc motor
+ *
+ * @param motor: BDC Motor handle
+ * @param speed: BDC speed
+ *
+ * @return
+ *      - ESP_OK: Set motor speed successfully
+ *      - ESP_ERR_INVALID_ARG: Set motor speed failed because of invalid parameters
+ *      - ESP_FAIL: Set motor speed failed because other error occurred
+ */
+esp_err_t bdc_motor_set_speed(bdc_motor_handle_t motor, uint32_t speed);
+
+/**
+ * @brief Forward BDC motor
+ *
+ * @param motor: BDC Motor handle
+ *
+ * @return
+ *      - ESP_OK: Forward motor successfully
+ *      - ESP_FAIL: Forward motor failed because some other error occurred
+ */
+esp_err_t bdc_motor_forward(bdc_motor_handle_t motor);
+
+/**
+ * @brief Reverse BDC Motor
+ *
+ * @param strip: BDC Motor handle
+ *
+ * @return
+ *      - ESP_OK: Reverse motor successfully
+ *      - ESP_FAIL: Reverse motor failed because some other error occurred
+ */
+esp_err_t bdc_motor_reverse(bdc_motor_handle_t motor);
+
+/**
+ * @brief Stop motor in a coast way (a.k.a Fast Decay)
+ *
+ * @param motor: BDC Motor handle
+ *
+ * @return
+ *      - ESP_OK: Stop motor successfully
+ *      - ESP_FAIL: Stop motor failed because some other error occurred
+ */
+esp_err_t bdc_motor_coast(bdc_motor_handle_t motor);
+
+/**
+ * @brief Stop motor in a brake way (a.k.a Slow Decay)
+ *
+ * @param motor: BDC Motor handle
+ *
+ * @return
+ *      - ESP_OK: Stop motor successfully
+ *      - ESP_FAIL: Stop motor failed because some other error occurred
+ */
+esp_err_t bdc_motor_brake(bdc_motor_handle_t motor);
+
+/**
+ * @brief Free BDC Motor resources
+ *
+ * @param strip: BDC Motor handle
+ *
+ * @return
+ *      - ESP_OK: Free resources successfully
+ *      - ESP_FAIL: Free resources failed because error occurred
+ */
+esp_err_t bdc_motor_del(bdc_motor_handle_t motor);
+
+/**
+ * @brief BDC Motor Configuration
+ */
+typedef struct {
+    uint32_t pwma_gpio_num; /*!< BDC Motor PWM A gpio number */
+    uint32_t pwmb_gpio_num; /*!< BDC Motor PWM B gpio number */
+    uint32_t pwm_freq_hz;   /*!< PWM frequency, in Hz */
+} bdc_motor_config_t;
+
+/**
+ * @brief BDC Motor MCPWM specific configuration
+ */
+typedef struct {
+    int group_id;           /*!< MCPWM group number */
+    uint32_t resolution_hz; /*!< MCPWM timer resolution */
+} bdc_motor_mcpwm_config_t;
+
+/**
+ * @brief Create BDC Motor based on MCPWM peripheral
+ *
+ * @param motor_config: BDC Motor configuration
+ * @param mcpwm_config: MCPWM specific configuration
+ * @param ret_motor Returned BDC Motor handle
+ * @return
+ *      - ESP_OK: Create BDC Motor handle successfully
+ *      - ESP_ERR_INVALID_ARG: Create BDC Motor handle failed because of invalid argument
+ *      - ESP_ERR_NO_MEM: Create BDC Motor handle failed because of out of memory
+ *      - ESP_FAIL: Create BDC Motor handle failed because some other error
+ */
+esp_err_t bdc_motor_new_mcpwm_device(const bdc_motor_config_t *motor_config, const bdc_motor_mcpwm_config_t *mcpwm_config, bdc_motor_handle_t *ret_motor);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/interface/bdc_motor_interface.h b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/interface/bdc_motor_interface.h
new file mode 100644
index 0000000000..35e9697ac2
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/interface/bdc_motor_interface.h
@@ -0,0 +1,116 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include <stdint.h>
+#include "esp_err.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct bdc_motor_t bdc_motor_t; /*!< Type of BDC motor */
+
+/**
+ * @brief BDC motor interface definition
+ */
+struct bdc_motor_t {
+    /**
+     * @brief Enable BDC motor
+     *
+     * @param motor: BDC Motor handle
+     *
+     * @return
+     *      - ESP_OK: Enable motor successfully
+     *      - ESP_ERR_INVALID_ARG: Enable motor failed because of invalid parameters
+     *      - ESP_FAIL: Enable motor failed because other error occurred
+     */
+    esp_err_t (*enable)(bdc_motor_t *motor);
+
+    /**
+     * @brief Disable BDC motor
+     *
+     * @param motor: BDC Motor handle
+     *
+     * @return
+     *      - ESP_OK: Disable motor successfully
+     *      - ESP_ERR_INVALID_ARG: Disable motor failed because of invalid parameters
+     *      - ESP_FAIL: Disable motor failed because other error occurred
+     */
+    esp_err_t (*disable)(bdc_motor_t *motor);
+
+    /**
+     * @brief Set speed for bdc motor
+     *
+     * @param motor: BDC Motor handle
+     * @param speed: BDC speed
+     *
+     * @return
+     *      - ESP_OK: Set motor speed successfully
+     *      - ESP_ERR_INVALID_ARG: Set motor speed failed because of invalid parameters
+     *      - ESP_FAIL: Set motor speed failed because other error occurred
+     */
+    esp_err_t (*set_speed)(bdc_motor_t *motor, uint32_t speed);
+
+    /**
+     * @brief Forward BDC motor
+     *
+     * @param motor: BDC Motor handle
+     *
+     * @return
+     *      - ESP_OK: Forward motor successfully
+     *      - ESP_FAIL: Forward motor failed because some other error occurred
+     */
+    esp_err_t (*forward)(bdc_motor_t *motor);
+
+    /**
+     * @brief Reverse BDC Motor
+     *
+     * @param motor: BDC Motor handle
+     *
+     * @return
+     *      - ESP_OK: Reverse motor successfully
+     *      - ESP_FAIL: Reverse motor failed because some other error occurred
+     */
+    esp_err_t (*reverse)(bdc_motor_t *motor);
+
+    /**
+     * @brief Stop motor in a coast way (a.k.a Fast Decay)
+     *
+     * @param motor: BDC Motor handle
+     *
+     * @return
+     *      - ESP_OK: Stop motor successfully
+     *      - ESP_FAIL: Stop motor failed because some other error occurred
+     */
+    esp_err_t (*coast)(bdc_motor_t *motor);
+
+    /**
+     * @brief Stop motor in a brake way (a.k.a Slow Decay)
+     *
+     * @param motor: BDC Motor handle
+     *
+     * @return
+     *      - ESP_OK: Stop motor successfully
+     *      - ESP_FAIL: Stop motor failed because some other error occurred
+     */
+    esp_err_t (*brake)(bdc_motor_t *motor);
+
+    /**
+     * @brief Free BDC Motor handle resources
+     *
+     * @param motor: BDC Motor handle
+     *
+     * @return
+     *      - ESP_OK: Free resources successfully
+     *      - ESP_FAIL: Free resources failed because error occurred
+     */
+    esp_err_t (*del)(bdc_motor_t *motor);
+};
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/src/bdc_motor.c b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/src/bdc_motor.c
new file mode 100644
index 0000000000..fbbc440312
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/src/bdc_motor.c
@@ -0,0 +1,62 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <sys/cdefs.h>
+#include "esp_log.h"
+#include "esp_check.h"
+#include "bdc_motor.h"
+#include "bdc_motor_interface.h"
+
+static const char *TAG = "bdc_motor";
+
+esp_err_t bdc_motor_enable(bdc_motor_handle_t motor)
+{
+    ESP_RETURN_ON_FALSE(motor, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    return motor->enable(motor);
+}
+
+esp_err_t bdc_motor_disable(bdc_motor_handle_t motor)
+{
+    ESP_RETURN_ON_FALSE(motor, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    return motor->disable(motor);
+}
+
+esp_err_t bdc_motor_set_speed(bdc_motor_handle_t motor, uint32_t speed)
+{
+    ESP_RETURN_ON_FALSE(motor, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    return motor->set_speed(motor, speed);
+}
+
+esp_err_t bdc_motor_forward(bdc_motor_handle_t motor)
+{
+    ESP_RETURN_ON_FALSE(motor, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    return motor->forward(motor);
+}
+
+esp_err_t bdc_motor_reverse(bdc_motor_handle_t motor)
+{
+    ESP_RETURN_ON_FALSE(motor, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    return motor->reverse(motor);
+}
+
+esp_err_t bdc_motor_coast(bdc_motor_handle_t motor)
+{
+    ESP_RETURN_ON_FALSE(motor, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    return motor->coast(motor);
+}
+
+esp_err_t bdc_motor_brake(bdc_motor_handle_t motor)
+{
+    ESP_RETURN_ON_FALSE(motor, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    return motor->brake(motor);
+}
+
+esp_err_t bdc_motor_del(bdc_motor_handle_t motor)
+{
+    ESP_RETURN_ON_FALSE(motor, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
+    return motor->del(motor);
+}
diff --git a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/src/bdc_motor_mcpwm_impl.c b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/src/bdc_motor_mcpwm_impl.c
new file mode 100644
index 0000000000..2b502a6a44
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/components/bdc_motor/src/bdc_motor_mcpwm_impl.c
@@ -0,0 +1,185 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <sys/cdefs.h>
+#include "esp_log.h"
+#include "esp_check.h"
+#include "driver/mcpwm_prelude.h"
+#include "bdc_motor.h"
+#include "bdc_motor_interface.h"
+
+static const char *TAG = "bdc_motor_mcpwm";
+
+typedef struct {
+    bdc_motor_t base;
+    mcpwm_timer_handle_t timer;
+    mcpwm_oper_handle_t operator;
+    mcpwm_cmpr_handle_t cmpa;
+    mcpwm_cmpr_handle_t cmpb;
+    mcpwm_gen_handle_t gena;
+    mcpwm_gen_handle_t genb;
+} bdc_motor_mcpwm_obj;
+
+static esp_err_t bdc_motor_mcpwm_set_speed(bdc_motor_t *motor, uint32_t speed)
+{
+    bdc_motor_mcpwm_obj *mcpwm_motor = __containerof(motor, bdc_motor_mcpwm_obj, base);
+    ESP_RETURN_ON_ERROR(mcpwm_comparator_set_compare_value(mcpwm_motor->cmpa, speed), TAG, "set compare value failed");
+    ESP_RETURN_ON_ERROR(mcpwm_comparator_set_compare_value(mcpwm_motor->cmpb, speed), TAG, "set compare value failed");
+    return ESP_OK;
+}
+
+static esp_err_t bdc_motor_mcpwm_enable(bdc_motor_t *motor)
+{
+    bdc_motor_mcpwm_obj *mcpwm_motor = __containerof(motor, bdc_motor_mcpwm_obj, base);
+    ESP_RETURN_ON_ERROR(mcpwm_timer_enable(mcpwm_motor->timer), TAG, "enable timer failed");
+    ESP_RETURN_ON_ERROR(mcpwm_timer_start_stop(mcpwm_motor->timer, MCPWM_TIMER_START_NO_STOP), TAG, "start timer failed");
+    return ESP_OK;
+}
+
+static esp_err_t bdc_motor_mcpwm_disable(bdc_motor_t *motor)
+{
+    bdc_motor_mcpwm_obj *mcpwm_motor = __containerof(motor, bdc_motor_mcpwm_obj, base);
+    ESP_RETURN_ON_ERROR(mcpwm_timer_start_stop(mcpwm_motor->timer, MCPWM_TIMER_STOP_EMPTY), TAG, "stop timer failed");
+    ESP_RETURN_ON_ERROR(mcpwm_timer_disable(mcpwm_motor->timer), TAG, "disable timer failed");
+    return ESP_OK;
+}
+
+static esp_err_t bdc_motor_mcpwm_forward(bdc_motor_t *motor)
+{
+    bdc_motor_mcpwm_obj *mcpwm_motor = __containerof(motor, bdc_motor_mcpwm_obj, base);
+    ESP_RETURN_ON_ERROR(mcpwm_generator_set_force_level(mcpwm_motor->gena, -1, true), TAG, "disable force level for gena failed");
+    ESP_RETURN_ON_ERROR(mcpwm_generator_set_force_level(mcpwm_motor->genb, 0, true), TAG, "set force level for genb failed");
+    return ESP_OK;
+}
+
+static esp_err_t bdc_motor_mcpwm_reverse(bdc_motor_t *motor)
+{
+    bdc_motor_mcpwm_obj *mcpwm_motor = __containerof(motor, bdc_motor_mcpwm_obj, base);
+    ESP_RETURN_ON_ERROR(mcpwm_generator_set_force_level(mcpwm_motor->genb, -1, true), TAG, "disable force level for genb failed");
+    ESP_RETURN_ON_ERROR(mcpwm_generator_set_force_level(mcpwm_motor->gena, 0, true), TAG, "set force level for gena failed");
+    return ESP_OK;
+}
+
+static esp_err_t bdc_motor_mcpwm_coast(bdc_motor_t *motor)
+{
+    bdc_motor_mcpwm_obj *mcpwm_motor = __containerof(motor, bdc_motor_mcpwm_obj, base);
+    ESP_RETURN_ON_ERROR(mcpwm_generator_set_force_level(mcpwm_motor->gena, 0, true), TAG, "set force level for gena failed");
+    ESP_RETURN_ON_ERROR(mcpwm_generator_set_force_level(mcpwm_motor->genb, 0, true), TAG, "set force level for genb failed");
+    return ESP_OK;
+}
+
+static esp_err_t bdc_motor_mcpwm_brake(bdc_motor_t *motor)
+{
+    bdc_motor_mcpwm_obj *mcpwm_motor = __containerof(motor, bdc_motor_mcpwm_obj, base);
+    ESP_RETURN_ON_ERROR(mcpwm_generator_set_force_level(mcpwm_motor->gena, 1, true), TAG, "set force level for gena failed");
+    ESP_RETURN_ON_ERROR(mcpwm_generator_set_force_level(mcpwm_motor->genb, 1, true), TAG, "set force level for genb failed");
+    return ESP_OK;
+}
+
+static esp_err_t bdc_motor_mcpwm_del(bdc_motor_t *motor)
+{
+    bdc_motor_mcpwm_obj *mcpwm_motor = __containerof(motor, bdc_motor_mcpwm_obj, base);
+    mcpwm_del_generator(mcpwm_motor->gena);
+    mcpwm_del_generator(mcpwm_motor->genb);
+    mcpwm_del_comparator(mcpwm_motor->cmpa);
+    mcpwm_del_comparator(mcpwm_motor->cmpb);
+    mcpwm_del_operator(mcpwm_motor->operator);
+    mcpwm_del_timer(mcpwm_motor->timer);
+    free(mcpwm_motor);
+    return ESP_OK;
+}
+
+esp_err_t bdc_motor_new_mcpwm_device(const bdc_motor_config_t *motor_config, const bdc_motor_mcpwm_config_t *mcpwm_config, bdc_motor_handle_t *ret_motor)
+{
+    bdc_motor_mcpwm_obj *mcpwm_motor = NULL;
+    esp_err_t ret = ESP_OK;
+    ESP_GOTO_ON_FALSE(motor_config && mcpwm_config && ret_motor, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    mcpwm_motor = calloc(1, sizeof(bdc_motor_mcpwm_obj));
+    ESP_GOTO_ON_FALSE(mcpwm_motor, ESP_ERR_NO_MEM, err, TAG, "no mem for rmt motor");
+
+    // mcpwm timer
+    mcpwm_timer_config_t timer_config = {
+        .group_id = mcpwm_config->group_id,
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .resolution_hz = mcpwm_config->resolution_hz,
+        .period_ticks = mcpwm_config->resolution_hz / motor_config->pwm_freq_hz,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+    };
+    ESP_GOTO_ON_ERROR(mcpwm_new_timer(&timer_config, &mcpwm_motor->timer), err, TAG, "create MCPWM timer failed");
+
+    mcpwm_operator_config_t operator_config = {
+        .group_id = mcpwm_config->group_id,
+    };
+    ESP_GOTO_ON_ERROR(mcpwm_new_operator(&operator_config, &mcpwm_motor->operator), err, TAG, "create MCPWM operator failed");
+
+    ESP_GOTO_ON_ERROR(mcpwm_operator_connect_timer(mcpwm_motor->operator, mcpwm_motor->timer), err, TAG, "connect timer and operator failed");
+
+    mcpwm_comparator_config_t comparator_config = {
+        .flags.update_cmp_on_tez = true,
+    };
+    ESP_GOTO_ON_ERROR(mcpwm_new_comparator(mcpwm_motor->operator, &comparator_config, &mcpwm_motor->cmpa), err, TAG, "create comparator failed");
+    ESP_GOTO_ON_ERROR(mcpwm_new_comparator(mcpwm_motor->operator, &comparator_config, &mcpwm_motor->cmpb), err, TAG, "create comparator failed");
+
+    // set the initial compare value for both comparators
+    mcpwm_comparator_set_compare_value(mcpwm_motor->cmpa, 0);
+    mcpwm_comparator_set_compare_value(mcpwm_motor->cmpb, 0);
+
+    mcpwm_generator_config_t generator_config = {
+        .gen_gpio_num = motor_config->pwma_gpio_num,
+    };
+    ESP_GOTO_ON_ERROR(mcpwm_new_generator(mcpwm_motor->operator, &generator_config, &mcpwm_motor->gena), err, TAG, "create generator failed");
+    generator_config.gen_gpio_num = motor_config->pwmb_gpio_num;
+    ESP_GOTO_ON_ERROR(mcpwm_new_generator(mcpwm_motor->operator, &generator_config, &mcpwm_motor->genb), err, TAG, "create generator failed");
+
+    mcpwm_generator_set_actions_on_timer_event(mcpwm_motor->gena,
+            MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+            MCPWM_GEN_TIMER_EVENT_ACTION_END());
+    mcpwm_generator_set_actions_on_compare_event(mcpwm_motor->gena,
+            MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, mcpwm_motor->cmpa, MCPWM_GEN_ACTION_LOW),
+            MCPWM_GEN_COMPARE_EVENT_ACTION_END());
+    mcpwm_generator_set_actions_on_timer_event(mcpwm_motor->genb,
+            MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+            MCPWM_GEN_TIMER_EVENT_ACTION_END());
+    mcpwm_generator_set_actions_on_compare_event(mcpwm_motor->genb,
+            MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, mcpwm_motor->cmpb, MCPWM_GEN_ACTION_LOW),
+            MCPWM_GEN_COMPARE_EVENT_ACTION_END());
+
+    mcpwm_motor->base.enable = bdc_motor_mcpwm_enable;
+    mcpwm_motor->base.disable = bdc_motor_mcpwm_disable;
+    mcpwm_motor->base.forward = bdc_motor_mcpwm_forward;
+    mcpwm_motor->base.reverse = bdc_motor_mcpwm_reverse;
+    mcpwm_motor->base.coast = bdc_motor_mcpwm_coast;
+    mcpwm_motor->base.brake = bdc_motor_mcpwm_brake;
+    mcpwm_motor->base.set_speed = bdc_motor_mcpwm_set_speed;
+    mcpwm_motor->base.del = bdc_motor_mcpwm_del;
+    *ret_motor = &mcpwm_motor->base;
+    return ESP_OK;
+
+err:
+    if (mcpwm_motor) {
+        if (mcpwm_motor->gena) {
+            mcpwm_del_generator(mcpwm_motor->gena);
+        }
+        if (mcpwm_motor->genb) {
+            mcpwm_del_generator(mcpwm_motor->genb);
+        }
+        if (mcpwm_motor->cmpa) {
+            mcpwm_del_comparator(mcpwm_motor->cmpa);
+        }
+        if (mcpwm_motor->cmpb) {
+            mcpwm_del_comparator(mcpwm_motor->cmpb);
+        }
+        if (mcpwm_motor->operator) {
+            mcpwm_del_operator(mcpwm_motor->operator);
+        }
+        if (mcpwm_motor->timer) {
+            mcpwm_del_timer(mcpwm_motor->timer);
+        }
+        free(mcpwm_motor);
+    }
+    return ret;
+}
diff --git a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/main/Kconfig.projbuild b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/main/Kconfig.projbuild
new file mode 100644
index 0000000000..67e1060d3d
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/main/Kconfig.projbuild
@@ -0,0 +1,12 @@
+menu "Example Configuration"
+
+    config SERIAL_STUDIO_DEBUG
+        bool "Enable log that can be parsed by Serial Studio"
+        default "n"
+        help
+            Enable this option, the example will print a string at runtime with a specific format,
+            which can be parsed by the Serial Studio tool.
+            With the "serial-studio-dashboard.json" template file provided in this example,
+            user can observe the speed in a curve window in the Serial Studio.
+
+endmenu
diff --git a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/main/mcpwm_bdc_control_example_main.c b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/main/mcpwm_bdc_control_example_main.c
index e0ae9205d5..f718225eca 100644
--- a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/main/mcpwm_bdc_control_example_main.c
+++ b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/main/mcpwm_bdc_control_example_main.c
@@ -5,176 +5,97 @@
  */
 
 #include <stdio.h>
+#include "sdkconfig.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/queue.h"
-#include "driver/gptimer.h"
+#include "esp_log.h"
+#include "esp_timer.h"
 #include "driver/pulse_cnt.h"
-#include "driver/mcpwm.h"
+#include "bdc_motor.h"
 #include "pid_ctrl.h"
-#include "esp_console.h"
-#include "argtable3/argtable3.h"
+
+static const char *TAG = "example";
 
 // Enable this config,  we will print debug formated string, which in return can be captured and parsed by Serial-Studio
-#define SERIAL_STUDIO_DEBUG           0
+#define SERIAL_STUDIO_DEBUG           CONFIG_SERIAL_STUDIO_DEBUG
 
-#define BDC_MCPWM_UNIT                0
-#define BDC_MCPWM_TIMER               0
-#define BDC_MCPWM_GENA_GPIO_NUM       7
-#define BDC_MCPWM_GENB_GPIO_NUM       15
-#define BDC_MCPWM_FREQ_HZ             1500
+#define BDC_MCPWM_TIMER_RESOLUTION_HZ 10000000 // 10MHz, 1 tick = 0.1us
+#define BDC_MCPWM_FREQ_HZ             25000    // 25KHz PWM
+#define BDC_MCPWM_DUTY_TICK_MAX       (BDC_MCPWM_TIMER_RESOLUTION_HZ / BDC_MCPWM_FREQ_HZ) // maximum value we can set for the duty cycle, in ticks
+#define BDC_MCPWM_GPIO_A              7
+#define BDC_MCPWM_GPIO_B              15
 
-#define BDC_ENCODER_PCNT_HIGH_LIMIT   100
-#define BDC_ENCODER_PCNT_LOW_LIMIT    -100
-#define BDC_ENCODER_PHASEA_GPIO_NUM   36
-#define BDC_ENCODER_PHASEB_GPIO_NUM   35
+#define BDC_ENCODER_GPIO_A            36
+#define BDC_ENCODER_GPIO_B            35
+#define BDC_ENCODER_PCNT_HIGH_LIMIT   1000
+#define BDC_ENCODER_PCNT_LOW_LIMIT    -1000
 
-#define BDC_PID_CALCULATION_PERIOD_US 10000
-#define BDC_PID_FEEDBACK_QUEUE_LEN    10
-
-static pid_ctrl_parameter_t pid_runtime_param = {
-    .kp = 0.6,
-    .ki = 0.3,
-    .kd = 0.12,
-    .cal_type = PID_CAL_TYPE_INCREMENTAL,
-    .max_output   = 100,
-    .min_output   = -100,
-    .max_integral = 1000,
-    .min_integral = -1000,
-};
-static bool pid_need_update = false;
-static int expect_pulses = 300;
-static int real_pulses;
+#define BDC_PID_LOOP_PERIOD_MS        10   // calculate the motor speed every 10ms
+#define BDC_PID_EXPECT_SPEED          400  // expected motor speed, in the pulses counted by the rotary encoder
 
 typedef struct {
-    pcnt_unit_handle_t hall_pcnt_encoder;
-    int accumu_count;
-    QueueHandle_t pid_feedback_queue;
-} motor_control_timer_context_t;
-
-typedef struct {
-    QueueHandle_t pid_feedback_queue;
+    bdc_motor_handle_t motor;
+    pcnt_unit_handle_t pcnt_encoder;
     pid_ctrl_block_handle_t pid_ctrl;
-} motor_control_task_context_t;
+    int accumu_count;
+    int report_pulses;
+} motor_control_context_t;
 
 static bool example_pcnt_on_reach(pcnt_unit_handle_t unit, const pcnt_watch_event_data_t *edata, void *user_ctx)
 {
-    motor_control_timer_context_t *ctx = (motor_control_timer_context_t *)user_ctx;
-    ctx->accumu_count += edata->watch_point_value;
+    int *accumu_count = (int *)user_ctx;
+    *accumu_count += edata->watch_point_value;
     return false;
 }
 
-static void brushed_motor_set_duty(float duty_cycle)
-{
-    /* motor moves in forward direction, with duty cycle = duty % */
-    if (duty_cycle > 0) {
-        mcpwm_set_signal_low(BDC_MCPWM_UNIT, BDC_MCPWM_TIMER, MCPWM_OPR_A);
-        mcpwm_set_duty(BDC_MCPWM_UNIT, BDC_MCPWM_TIMER, MCPWM_OPR_B, duty_cycle);
-        mcpwm_set_duty_type(BDC_MCPWM_UNIT, BDC_MCPWM_TIMER, MCPWM_OPR_B, MCPWM_DUTY_MODE_0);
-    }
-    /* motor moves in backward direction, with duty cycle = -duty % */
-    else {
-        mcpwm_set_signal_low(BDC_MCPWM_UNIT, BDC_MCPWM_TIMER, MCPWM_OPR_B);
-        mcpwm_set_duty(BDC_MCPWM_UNIT, BDC_MCPWM_TIMER, MCPWM_OPR_A, -duty_cycle);
-        mcpwm_set_duty_type(BDC_MCPWM_UNIT, BDC_MCPWM_TIMER, MCPWM_OPR_A, MCPWM_DUTY_MODE_0);
-    }
-}
-
-static bool motor_ctrl_timer_cb(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *arg)
+static void pid_loop_cb(void *args)
 {
     static int last_pulse_count = 0;
-    BaseType_t high_task_awoken = pdFALSE;
-    motor_control_timer_context_t *user_ctx = (motor_control_timer_context_t *)arg;
-    pcnt_unit_handle_t pcnt_unit = user_ctx->hall_pcnt_encoder;
+    motor_control_context_t *ctx = (motor_control_context_t *)args;
+    pcnt_unit_handle_t pcnt_unit = ctx->pcnt_encoder;
+    pid_ctrl_block_handle_t pid_ctrl = ctx->pid_ctrl;
+    bdc_motor_handle_t motor = ctx->motor;
 
+    // get the result from rotary encoder
     int cur_pulse_count = 0;
     pcnt_unit_get_count(pcnt_unit, &cur_pulse_count);
-    cur_pulse_count += user_ctx->accumu_count;
-
-    int delta = cur_pulse_count - last_pulse_count;
+    cur_pulse_count += ctx->accumu_count;
+    int real_pulses = cur_pulse_count - last_pulse_count;
     last_pulse_count = cur_pulse_count;
-    xQueueSendFromISR(user_ctx->pid_feedback_queue, &delta, &high_task_awoken);
+    ctx->report_pulses = real_pulses;
 
-    return high_task_awoken == pdTRUE;
-}
+    // calculate the speed error
+    float error = BDC_PID_EXPECT_SPEED - real_pulses;
+    float new_speed = 0;
 
-static void bdc_ctrl_task(void *arg)
-{
-    float duty_cycle = 0;
-    motor_control_task_context_t *user_ctx = (motor_control_task_context_t *)arg;
-    while (1) {
-        xQueueReceive(user_ctx->pid_feedback_queue, &real_pulses, portMAX_DELAY);
-        float error = expect_pulses - real_pulses;
-        pid_compute(user_ctx->pid_ctrl, error, &duty_cycle);
-        brushed_motor_set_duty(duty_cycle);
-    }
-}
-
-static struct {
-    struct arg_dbl *kp;
-    struct arg_dbl *ki;
-    struct arg_dbl *kd;
-    struct arg_end *end;
-} pid_ctrl_args;
-
-static int do_pid_ctrl_cmd(int argc, char **argv)
-{
-    int nerrors = arg_parse(argc, argv, (void **)&pid_ctrl_args);
-    if (nerrors != 0) {
-        arg_print_errors(stderr, pid_ctrl_args.end, argv[0]);
-        return 0;
-    }
-    if (pid_ctrl_args.kp->count) {
-        pid_runtime_param.kp = pid_ctrl_args.kp->dval[0];
-    }
-    if (pid_ctrl_args.ki->count) {
-        pid_runtime_param.ki = pid_ctrl_args.ki->dval[0];
-    }
-    if (pid_ctrl_args.kd->count) {
-        pid_runtime_param.kd = pid_ctrl_args.kd->dval[0];
-    }
-
-    pid_need_update = true;
-    return 0;
-}
-
-static void register_pid_console_command(void)
-{
-    pid_ctrl_args.kp   = arg_dbl0("p", NULL, "<kp>", "Set Kp value of PID");
-    pid_ctrl_args.ki   = arg_dbl0("i", NULL, "<ki>", "Set Ki value of PID");
-    pid_ctrl_args.kd   = arg_dbl0("d", NULL, "<kd>", "Set Kd value of PID");
-    pid_ctrl_args.end  = arg_end(2);
-    const esp_console_cmd_t pid_ctrl_cmd = {
-        .command = "pid",
-        .help = "Set PID parameters",
-        .hint = NULL,
-        .func = &do_pid_ctrl_cmd,
-        .argtable = &pid_ctrl_args
-    };
-    ESP_ERROR_CHECK(esp_console_cmd_register(&pid_ctrl_cmd));
+    // set the new speed
+    pid_compute(pid_ctrl, error, &new_speed);
+    bdc_motor_set_speed(motor, (uint32_t)new_speed);
 }
 
 void app_main(void)
 {
-    static motor_control_timer_context_t my_timer_ctx = {};
-
-    QueueHandle_t pid_fb_queue = xQueueCreate(BDC_PID_FEEDBACK_QUEUE_LEN, sizeof(int));
-    assert(pid_fb_queue);
-
-    printf("configure mcpwm gpio\r\n");
-    ESP_ERROR_CHECK(mcpwm_gpio_init(BDC_MCPWM_UNIT, MCPWM0A, BDC_MCPWM_GENA_GPIO_NUM));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(BDC_MCPWM_UNIT, MCPWM0B, BDC_MCPWM_GENB_GPIO_NUM));
-    printf("init mcpwm driver\n");
-    mcpwm_config_t pwm_config = {
-        .frequency = BDC_MCPWM_FREQ_HZ,
-        .cmpr_a = 0,
-        .cmpr_b = 0,
-        .counter_mode = MCPWM_UP_COUNTER,
-        .duty_mode = MCPWM_DUTY_MODE_0,
+    static motor_control_context_t motor_ctrl_ctx = {
+        .accumu_count = 0,
+        .pcnt_encoder = NULL,
     };
-    ESP_ERROR_CHECK(mcpwm_init(BDC_MCPWM_UNIT, BDC_MCPWM_TIMER, &pwm_config));
 
-    printf("init and start rotary encoder\r\n");
+    ESP_LOGI(TAG, "Create DC motor");
+    bdc_motor_config_t motor_config = {
+        .pwm_freq_hz = BDC_MCPWM_FREQ_HZ,
+        .pwma_gpio_num = BDC_MCPWM_GPIO_A,
+        .pwmb_gpio_num = BDC_MCPWM_GPIO_B,
+    };
+    bdc_motor_mcpwm_config_t mcpwm_config = {
+        .group_id = 0,
+        .resolution_hz = BDC_MCPWM_TIMER_RESOLUTION_HZ,
+    };
+    bdc_motor_handle_t motor = NULL;
+    ESP_ERROR_CHECK(bdc_motor_new_mcpwm_device(&motor_config, &mcpwm_config, &motor));
+    motor_ctrl_ctx.motor = motor;
+
+    ESP_LOGI(TAG, "Init pcnt driver to decode rotary signal");
     pcnt_unit_config_t unit_config = {
         .high_limit = BDC_ENCODER_PCNT_HIGH_LIMIT,
         .low_limit = BDC_ENCODER_PCNT_LOW_LIMIT,
@@ -186,14 +107,14 @@ void app_main(void)
     };
     ESP_ERROR_CHECK(pcnt_unit_set_glitch_filter(pcnt_unit, &filter_config));
     pcnt_chan_config_t chan_a_config = {
-        .edge_gpio_num = BDC_ENCODER_PHASEA_GPIO_NUM,
-        .level_gpio_num = BDC_ENCODER_PHASEB_GPIO_NUM,
+        .edge_gpio_num = BDC_ENCODER_GPIO_A,
+        .level_gpio_num = BDC_ENCODER_GPIO_B,
     };
     pcnt_channel_handle_t pcnt_chan_a = NULL;
     ESP_ERROR_CHECK(pcnt_new_channel(pcnt_unit, &chan_a_config, &pcnt_chan_a));
     pcnt_chan_config_t chan_b_config = {
-        .edge_gpio_num = BDC_ENCODER_PHASEB_GPIO_NUM,
-        .level_gpio_num = BDC_ENCODER_PHASEA_GPIO_NUM,
+        .edge_gpio_num = BDC_ENCODER_GPIO_B,
+        .level_gpio_num = BDC_ENCODER_GPIO_A,
     };
     pcnt_channel_handle_t pcnt_chan_b = NULL;
     ESP_ERROR_CHECK(pcnt_new_channel(pcnt_unit, &chan_b_config, &pcnt_chan_b));
@@ -204,70 +125,55 @@ void app_main(void)
     ESP_ERROR_CHECK(pcnt_unit_add_watch_point(pcnt_unit, BDC_ENCODER_PCNT_HIGH_LIMIT));
     ESP_ERROR_CHECK(pcnt_unit_add_watch_point(pcnt_unit, BDC_ENCODER_PCNT_LOW_LIMIT));
     pcnt_event_callbacks_t pcnt_cbs = {
-        .on_reach = example_pcnt_on_reach,
+        .on_reach = example_pcnt_on_reach, // accumulate the overflow in the callback
     };
-    ESP_ERROR_CHECK(pcnt_unit_register_event_callbacks(pcnt_unit, &pcnt_cbs, &my_timer_ctx));
+    ESP_ERROR_CHECK(pcnt_unit_register_event_callbacks(pcnt_unit, &pcnt_cbs, &motor_ctrl_ctx.accumu_count));
     ESP_ERROR_CHECK(pcnt_unit_enable(pcnt_unit));
     ESP_ERROR_CHECK(pcnt_unit_clear_count(pcnt_unit));
     ESP_ERROR_CHECK(pcnt_unit_start(pcnt_unit));
+    motor_ctrl_ctx.pcnt_encoder = pcnt_unit;
 
-    printf("init PID control block\r\n");
-    pid_ctrl_block_handle_t pid_ctrl;
+    ESP_LOGI(TAG, "Create PID control block");
+    pid_ctrl_parameter_t pid_runtime_param = {
+        .kp = 0.6,
+        .ki = 0.4,
+        .kd = 0.2,
+        .cal_type = PID_CAL_TYPE_INCREMENTAL,
+        .max_output   = BDC_MCPWM_DUTY_TICK_MAX - 1,
+        .min_output   = 0,
+        .max_integral = 1000,
+        .min_integral = -1000,
+    };
+    pid_ctrl_block_handle_t pid_ctrl = NULL;
     pid_ctrl_config_t pid_config = {
         .init_param = pid_runtime_param,
     };
     ESP_ERROR_CHECK(pid_new_control_block(&pid_config, &pid_ctrl));
+    motor_ctrl_ctx.pid_ctrl = pid_ctrl;
 
-    printf("init motor control timer\r\n");
-    gptimer_handle_t gptimer;
-    gptimer_config_t timer_config = {
-        .clk_src = GPTIMER_CLK_SRC_DEFAULT,
-        .direction = GPTIMER_COUNT_UP,
-        .resolution_hz = 1000000, // 1MHz, 1 tick = 1us
+    ESP_LOGI(TAG, "Create a timer to do PID calculation periodically");
+    const esp_timer_create_args_t periodic_timer_args = {
+        .callback = pid_loop_cb,
+        .arg = &motor_ctrl_ctx,
+        .name = "pid_loop"
     };
-    ESP_ERROR_CHECK(gptimer_new_timer(&timer_config, &gptimer));
+    esp_timer_handle_t pid_loop_timer = NULL;
+    ESP_ERROR_CHECK(esp_timer_create(&periodic_timer_args, &pid_loop_timer));
 
-    printf("create motor control task\r\n");
-    static motor_control_task_context_t my_ctrl_task_ctx = {};
-    my_ctrl_task_ctx.pid_feedback_queue = pid_fb_queue;
-    my_ctrl_task_ctx.pid_ctrl = pid_ctrl;
-    xTaskCreate(bdc_ctrl_task, "bdc_ctrl_task", 4096, &my_ctrl_task_ctx, 5, NULL);
+    ESP_LOGI(TAG, "Enable motor");
+    ESP_ERROR_CHECK(bdc_motor_enable(motor));
+    ESP_LOGI(TAG, "Forward motor");
+    ESP_ERROR_CHECK(bdc_motor_forward(motor));
 
-    printf("start motor control timer\r\n");
-    my_timer_ctx.pid_feedback_queue = pid_fb_queue;
-    my_timer_ctx.hall_pcnt_encoder = pcnt_unit;
-    gptimer_event_callbacks_t gptimer_cbs = {
-        .on_alarm = motor_ctrl_timer_cb,
-    };
-    ESP_ERROR_CHECK(gptimer_register_event_callbacks(gptimer, &gptimer_cbs, &my_timer_ctx));
-    gptimer_alarm_config_t alarm_config = {
-        .reload_count = 0,
-        .alarm_count = BDC_PID_CALCULATION_PERIOD_US,
-        .flags.auto_reload_on_alarm = true,
-    };
-    ESP_ERROR_CHECK(gptimer_set_alarm_action(gptimer, &alarm_config));
-    ESP_ERROR_CHECK(gptimer_enable(gptimer));
-    ESP_ERROR_CHECK(gptimer_start(gptimer));
-
-    printf("install console command line\r\n");
-    esp_console_repl_t *repl = NULL;
-    esp_console_repl_config_t repl_config = ESP_CONSOLE_REPL_CONFIG_DEFAULT();
-    repl_config.prompt = "dc-motor>";
-    esp_console_dev_uart_config_t uart_config = ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT();
-    ESP_ERROR_CHECK(esp_console_new_repl_uart(&uart_config, &repl_config, &repl));
-    register_pid_console_command();
-    ESP_ERROR_CHECK(esp_console_start_repl(repl));
+    ESP_LOGI(TAG, "Start motor speed loop");
+    ESP_ERROR_CHECK(esp_timer_start_periodic(pid_loop_timer, BDC_PID_LOOP_PERIOD_MS * 1000));
 
     while (1) {
         vTaskDelay(pdMS_TO_TICKS(100));
-        // the following logging format is according to the requirement of serial-studio
-        // also see the parser mapping file `serial-studio-proto-map.json` in the project folder
+        // the following logging format is according to the requirement of serial-studio frame format
+        // also see the dashboard config file `serial-studio-dashboard.json` for more information
 #if SERIAL_STUDIO_DEBUG
-        printf("/*%d*/\r\n", real_pulses);
+        printf("/*%d*/\r\n", motor_ctrl_ctx.report_pulses);
 #endif
-        if (pid_need_update) {
-            pid_update_parameters(pid_ctrl, &pid_runtime_param);
-            pid_need_update = false;
-        }
     }
 }
diff --git a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/pytest_bdc_speed_control.py b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/pytest_bdc_speed_control.py
new file mode 100644
index 0000000000..95579418bd
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/pytest_bdc_speed_control.py
@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: CC0-1.0
+
+import pytest
+from pytest_embedded import Dut
+
+
+@pytest.mark.esp32s3
+@pytest.mark.generic
+def test_bdc_speed_control_example(dut: Dut) -> None:
+    dut.expect_exact('example: Create DC motor')
+    dut.expect_exact('example: Init pcnt driver to decode rotary signal')
+    dut.expect_exact('example: Create PID control block')
+    dut.expect_exact('example: Create a timer to do PID calculation periodically')
+    dut.expect_exact('example: Enable motor')
+    dut.expect_exact('example: Forward motor')
+    dut.expect_exact('example: Start motor speed loop')
diff --git a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/serial-studio-dashboard.json b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/serial-studio-dashboard.json
new file mode 100644
index 0000000000..efa33c1430
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/serial-studio-dashboard.json
@@ -0,0 +1,28 @@
+{
+    "frameEnd": "*/",
+    "frameStart": "/*",
+    "groups": [
+        {
+            "datasets": [
+                {
+                    "alarm": 1000,
+                    "fft": false,
+                    "fftSamples": 1024,
+                    "graph": true,
+                    "led": false,
+                    "log": false,
+                    "max": 500,
+                    "min": 0,
+                    "title": "current speed",
+                    "units": "",
+                    "value": "%1",
+                    "widget": "gauge"
+                }
+            ],
+            "title": "speed",
+            "widget": ""
+        }
+    ],
+    "separator": ",",
+    "title": "Brushed DC Motor Speed"
+}
diff --git a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/serial-studio-proto-map.json b/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/serial-studio-proto-map.json
deleted file mode 100644
index 29ac2d6695..0000000000
--- a/examples/peripherals/mcpwm/mcpwm_bdc_speed_control/serial-studio-proto-map.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
-    "fe": "*/",
-    "fs": "/*",
-    "g": [
-        {
-            "d": [
-                {
-                    "g": true,
-                    "max": 100,
-                    "min": 0,
-                    "t": "pulses within 10ms",
-                    "u": "",
-                    "v": "%1",
-                    "w": ""
-                }
-            ],
-            "t": "Encoder Feedback",
-        }
-    ],
-    "s": ",",
-    "t": "Brushed DC Motor Speed"
-}
diff --git a/tools/ci/check_copyright_ignore.txt b/tools/ci/check_copyright_ignore.txt
index 11589d787c..e13723ab90 100644
--- a/tools/ci/check_copyright_ignore.txt
+++ b/tools/ci/check_copyright_ignore.txt
@@ -1773,9 +1773,6 @@ examples/peripherals/i2c/i2c_tools/main/cmd_i2ctools.h
 examples/peripherals/i2c/i2c_tools/main/i2ctools_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_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_servo_control/main/mcpwm_servo_control_example_main.c
 examples/peripherals/sdio/host/main/app_main.c
 examples/peripherals/sdio/sdio_test.py

From b77446b5c834a2447a3a5012aa900a50d3a15685 Mon Sep 17 00:00:00 2001
From: morris <maoshengrong@espressif.com>
Date: Sat, 28 May 2022 17:04:38 +0800
Subject: [PATCH 4/8] example: update bldc example with new driver API

---
 .../mcpwm/mcpwm_bldc_hall_control/README.md   | 111 +++--
 .../mcpwm_bldc_hall_control_example_main.c    | 436 +++++++++++-------
 .../pytest_bldc_hall_control.py               |  25 +
 3 files changed, 360 insertions(+), 212 deletions(-)
 create mode 100644 examples/peripherals/mcpwm/mcpwm_bldc_hall_control/pytest_bldc_hall_control.py

diff --git a/examples/peripherals/mcpwm/mcpwm_bldc_hall_control/README.md b/examples/peripherals/mcpwm/mcpwm_bldc_hall_control/README.md
index 5fa70fe40d..9e53e1c2ea 100644
--- a/examples/peripherals/mcpwm/mcpwm_bldc_hall_control/README.md
+++ b/examples/peripherals/mcpwm/mcpwm_bldc_hall_control/README.md
@@ -1,51 +1,54 @@
 | Supported Targets | ESP32 | ESP32-S3 |
 | ----------------- | ----- | -------- |
 
-# MCPWM BLDC Hall motor control Example
+# MCPWM BLDC Motor Control with HALL Sensor Example
 
 (See the README.md file in the upper level 'examples' directory for more information about examples.)
 
-This example will illustrate how to use MCPWM driver to control BLDC motor with hall sensor feedback. In the example, a timer is running at the background to update the motor speed periodically.
-
-With the hardware fault detection feature of MCPWM, the example will shut down the MOSFETs when over current happens.
+The MCPWM peripheral can generate three pairs of complementary PWMs by the internal dead time submodule, which is suitable for a BLDC motor application. This example demonstrates how to use the MCPWM peripheral to control a BLDC motor in a six-step commutation scheme.
+We will change the on/off state of the six MOSFETs in a predefined order when the Hall sensor detects a change of the motor phase, so that the motor can spin in a predefined direction.
 
 ## How to Use Example
 
 ### Hardware Required
 
-1. The BLDC motor used in this example has a hall sensor capture sequence of `6-->4-->5-->1-->3-->2-->6-->4-->` and so on.
-2. A three-phase gate driver, this example uses [IR2136](https://www.infineon.com/cms/en/product/power/gate-driver-ics/ir2136s/).
-3. Six N-MOSFETs, this example uses [IRF540NS](https://www.infineon.com/cms/en/product/power/mosfet/12v-300v-n-channel-power-mosfet/irf540ns/).
-4. A development board with any Espressif SoC which features MCPWM peripheral (e.g., ESP32-DevKitC, ESP-WROVER-KIT, etc.)
-5. A USB cable for Power supply and programming.
+1. A ESP board with MCPWM peripheral supported (e.g. ESP32-S3-Motor-DevKit)
+2. A BLDC motor whose commutation table is `6-->4-->5-->1-->3-->2-->6`
+3. A three-phase gate driver, for example, the [DRV8302](https://www.ti.com.cn/product/zh-cn/DRV8302)
+4. Six N-MOSFETs, for example, the [IRF540NS](https://www.infineon.com/cms/en/product/power/mosfet/12v-300v-n-channel-power-mosfet/irf540ns/)
+5. A USB cable for Power supply and programming
 
 Connection :
 
 ```
-          ┌─────────────────────────────────────────────┐
-          │                                             │
-          │         ┌───────────────────────────┐       │
-          │         │                           │       │
-┌─────────┴─────────┴───────────┐      ┌────────┴───────┴──────────┐
-│      GPIO19      GPIO18       │      │        EN    FAULT        │
-│                         GPIO21├──────┤PWM_UH                     │        ┌────────────┐
-│                         GPIO22├──────┤PWM_UL                    U├────────┤            │
-│                               │      │                           │        │            │
-│                         GPIO23├──────┤PWM_VH                    V├────────┤    BLDC    │
-│         ESP Board       GPIO25├──────┤PWM_VL   3-Phase Bridge    │        │            │
-│                               │      │               +          W├────────┤            │
-│                         GPIO26├──────┤PWM_WH      MOSFET         │        └─┬───┬───┬──┘
-│                         GPIO27├──────┤PWM_WL                     │          │   │   │
-│    GPIO5  GPIO4  GPIO2        │      │                           │          │   │   │
-└─────┬──────┬──────┬───────────┘      └───────────────────────────┘          │   │   │
-      │      │      │   Hall U                                                │   │   │
-      │      │      └─────────────────────────────────────────────────────────┘   │   │
-      │      │          Hall V                                                    │   │
-      │      └────────────────────────────────────────────────────────────────────┘   │
-      │                 Hall W                                                        │
-      └───────────────────────────────────────────────────────────────────────────────┘
+              +---------------------------------------------------------------------------------+
+              |                                                                                 |
+              |                             +---------------------------------------------+     |  VM
+              |                             |                                             |     |   ^
+              |                             |         +---------------------------+       |     |   |
+              |                             |         |                           |       |     |   |
++-------------+-----------------------------+---------+-----------+      +--------+-------+-----+---++
+|            GND           BLDC_DRV_FAULT_GPIO   BLDC_DRV_EN_GPIO |      |        EN    FAULT  GND   |
+|                                                BLDC_PWM_UH_GPIO +------+PWM_UH                     |        +------------+
+|                                                BLDC_PWM_UL_GPIO +------+PWM_UL                    U+--------+            |
+|                                                                 |      |                           |        |            |
+|                     ESP Board                  BLDC_PWM_VH_GPIO +------+PWM_VH                    V+--------+    BLDC    |
+|                                                BLDC_PWM_VL_GPIO +------+PWM_VL   3-Phase Bridge    |        |            |
+|                                                                 |      |               +          W+--------+            |
+|                                                BLDC_PWM_WH_GPIO +------+PWM_WH      MOSFET         |        +-+---+---+--+
+|                                                BLDC_PWM_WL_GPIO +------+PWM_WL                     |          |   |   |
+|   HALL_CAP_W_GPIO    HALL_CAP_V_GPIO    HALL_CAP_U_GPIO         |      |                           |          |   |   |
++-----------+------------------+------------------+---------------+      +---------------------------+          |   |   |
+            |                  |                  |       Hall U                                                |   |   |
+            |                  |                  +-------------------------------------------------------------+   |   |
+            |                  |                          Hall V                                                    |   |
+            |                  +------------------------------------------------------------------------------------+   |
+            |                                             Hall W                                                        |
+            +-----------------------------------------------------------------------------------------------------------+
 ```
 
+You can change the GPIO number in the [example code](main/mcpwm_bldc_hall_control_example_main.c) according to your board. You can define the spin direction in the code as well by the `BLDC_SPIN_DIRECTION_CCW` macro.
+
 ### Build and Flash
 
 Run `idf.py -p PORT flash monitor` to build, flash and monitor the project.
@@ -62,20 +65,42 @@ Run the example, you will see the following output log:
 ```
 ...
 I (0) cpu_start: Starting scheduler on APP CPU.
-I (327) example: Disable gate driver
-I (327) gpio: GPIO[18]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0
-I (337) example: Setup PWM and Hall GPIO (pull up internally)
-I (347) example: Initialize PWM (default to turn off all MOSFET)
-I (357) example: Initialize over current fault action
-I (357) example: Initialize Hall sensor capture
-I (367) example: Please turn on the motor power
-I (5367) example: Enable gate driver
-I (5367) example: Changing speed at background
+I (307) example: Disable MOSFET gate
+I (307) gpio: GPIO[46]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0
+I (317) example: Create MCPWM timer
+I (317) example: Create MCPWM operator
+I (327) example: Connect operators to the same timer
+I (327) example: Create comparators
+I (337) example: Create over current fault detector
+I (337) gpio: GPIO[10]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (347) example: Set brake mode on the fault event
+I (357) example: Create PWM generators
+I (357) gpio: GPIO[47]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (367) gpio: GPIO[21]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (377) gpio: GPIO[14]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (387) gpio: GPIO[13]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (397) gpio: GPIO[12]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (407) gpio: GPIO[11]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (417) example: Set generator actions
+I (417) example: Setup deadtime
+I (427) example: Turn off all the gates by default
+I (427) example: Create Hall sensor capture channels
+I (437) gpio: GPIO[4]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (447) gpio: GPIO[5]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (457) gpio: GPIO[6]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (457) example: Register event callback for capture channels
+I (467) example: Start a timer to adjust motor speed periodically
+I (477) example: Enable MOSFET gate
+I (477) example: Start the MCPWM timer
 ...
 ```
 
-## Dive into the example
+The BLDC motor will update the speed periodically.
 
-1. How to change the rotation direction?
+## Troubleshooting
 
-      The rotation direction is controlled by how the hall sensor value is parsed. If you pass `false` to `bldc_get_hall_sensor_value`, the BLDC should rotate in clock wise. Likewise, passing `true` to that function will make tha BLDC rotate in counter clock wise.
+* Make sure your ESP board and H-bridge module have been connected to the same GND panel.
+* Check the fault signal polarity, otherwise the motor will not spin if the MCPWM detector treats the normal level as a fault one.
+* Don't use the PC USB as the power source of the BLDC motor (see the `VM` in the above connection diagram), it might damage your UAB port.
+
+For any technical queries, please open an [issue](https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you soon.
diff --git a/examples/peripherals/mcpwm/mcpwm_bldc_hall_control/main/mcpwm_bldc_hall_control_example_main.c b/examples/peripherals/mcpwm/mcpwm_bldc_hall_control/main/mcpwm_bldc_hall_control_example_main.c
index f4a0f62bbb..3fcb12d21e 100644
--- a/examples/peripherals/mcpwm/mcpwm_bldc_hall_control/main/mcpwm_bldc_hall_control_example_main.c
+++ b/examples/peripherals/mcpwm/mcpwm_bldc_hall_control/main/mcpwm_bldc_hall_control_example_main.c
@@ -8,47 +8,46 @@
 #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"
+#include "esp_timer.h"
+#include "driver/mcpwm_prelude.h"
+#include "driver/gpio.h"
 
-#define PWM_DEFAULT_FREQ   14400
-#define PWM_MIN_DUTY       40.0
-#define PWM_MAX_DUTY       80.0
-#define PWM_DUTY_STEP      5.0
-#define BLDC_MCPWM_GROUP   0
-#define BLDC_MCPWM_TIMER_U 0
-#define BLDC_MCPWM_TIMER_V 1
-#define BLDC_MCPWM_TIMER_W 2
-#define BLDC_MCPWM_GEN_HIGH MCPWM_GEN_A
-#define BLDC_MCPWM_GEN_LOW  MCPWM_GEN_B
+#define BLDC_MCPWM_TIMER_RESOLUTION_HZ 10000000 // 10MHz, 1 tick = 0.1us
+#define BLDC_MCPWM_PERIOD              500      // 50us, 20KHz
+#define BLDC_SPIN_DIRECTION_CCW        false    // define the spin direction
+#define BLDC_SPEED_UPDATE_PERIOD_US    200000   // 200ms
 
+#define BLDC_DRV_EN_GPIO          46
+#define BLDC_DRV_FAULT_GPIO       10
+#define BLDC_PWM_UH_GPIO          47
+#define BLDC_PWM_UL_GPIO          21
+#define BLDC_PWM_VH_GPIO          14
+#define BLDC_PWM_VL_GPIO          13
+#define BLDC_PWM_WH_GPIO          12
+#define BLDC_PWM_WL_GPIO          11
+#define HALL_CAP_U_GPIO           4
+#define HALL_CAP_V_GPIO           5
+#define HALL_CAP_W_GPIO           6
 
-#define BLDC_DRV_EN_GPIO    18
-#define BLDC_DRV_FAULT_GPIO 19
-#define BLDC_DRV_OVER_CURRENT_FAULT MCPWM_SELECT_F0
-
-#define BLDC_PWM_UH_GPIO 21
-#define BLDC_PWM_UL_GPIO 22
-#define BLDC_PWM_VH_GPIO 23
-#define BLDC_PWM_VL_GPIO 25
-#define BLDC_PWM_WH_GPIO 26
-#define BLDC_PWM_WL_GPIO 27
-#define HALL_CAP_U_GPIO  2
-#define HALL_CAP_V_GPIO  4
-#define HALL_CAP_W_GPIO  5
+#define BLDC_MCPWM_OP_INDEX_U     0
+#define BLDC_MCPWM_OP_INDEX_V     1
+#define BLDC_MCPWM_OP_INDEX_W     2
+#define BLDC_MCPWM_GEN_INDEX_HIGH 0
+#define BLDC_MCPWM_GEN_INDEX_LOW  1
 
 static const char *TAG = "example";
 
+typedef void (*bldc_hall_phase_action_t)(mcpwm_gen_handle_t (*gens)[2]);
+
 static inline uint32_t bldc_get_hall_sensor_value(bool ccw)
 {
     uint32_t hall_val = gpio_get_level(HALL_CAP_U_GPIO) * 4 + gpio_get_level(HALL_CAP_V_GPIO) * 2 + gpio_get_level(HALL_CAP_W_GPIO) * 1;
     return ccw ? hall_val ^ (0x07) : hall_val;
 }
 
-static bool IRAM_ATTR bldc_hall_updated(mcpwm_unit_t mcpwm, mcpwm_capture_channel_id_t cap_channel, const cap_event_data_t *edata, void *user_data)
+static bool IRAM_ATTR bldc_hall_updated(mcpwm_cap_channel_handle_t cap_channel, const mcpwm_capture_event_data_t *edata, void *user_data)
 {
     TaskHandle_t task_to_notify = (TaskHandle_t)user_data;
     BaseType_t high_task_wakeup = pdFALSE;
@@ -56,101 +55,99 @@ static bool IRAM_ATTR bldc_hall_updated(mcpwm_unit_t mcpwm, mcpwm_capture_channe
     return high_task_wakeup == pdTRUE;
 }
 
-static void update_bldc_speed(void *arg)
+// U+V-
+static void bldc_set_phase_up_vm(mcpwm_gen_handle_t (*gens)[2])
 {
-    static float duty = PWM_MIN_DUTY;
-    static float duty_step = PWM_DUTY_STEP;
-    duty += duty_step;
-    if (duty > PWM_MAX_DUTY || duty < PWM_MIN_DUTY) {
-        duty_step *= -1;
-    }
-    mcpwm_set_duty(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, BLDC_MCPWM_GEN_HIGH, duty);
-    mcpwm_set_duty(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, BLDC_MCPWM_GEN_LOW, duty);
-    mcpwm_set_duty(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, BLDC_MCPWM_GEN_HIGH, duty);
-    mcpwm_set_duty(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, BLDC_MCPWM_GEN_LOW, duty);
-    mcpwm_set_duty(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, BLDC_MCPWM_GEN_HIGH, duty);
-    mcpwm_set_duty(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, BLDC_MCPWM_GEN_LOW, duty);
+    // U+ = PWM, U- = _PWM_
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_U][BLDC_MCPWM_GEN_INDEX_HIGH], -1, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_U][BLDC_MCPWM_GEN_INDEX_LOW], -1, true);
+    // V+ = 0, V- = 1
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_V][BLDC_MCPWM_GEN_INDEX_HIGH], 0, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_V][BLDC_MCPWM_GEN_INDEX_LOW], 1, true);
+    // W+ = 0, W- = 0
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_W][BLDC_MCPWM_GEN_INDEX_HIGH], 0, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_W][BLDC_MCPWM_GEN_INDEX_LOW], 0, true);
 }
 
-// U+V- / A+B-
-static void bldc_set_phase_up_vm(void)
+// W+U-
+static void bldc_set_phase_wp_um(mcpwm_gen_handle_t (*gens)[2])
 {
-    mcpwm_set_duty_type(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, BLDC_MCPWM_GEN_HIGH, MCPWM_DUTY_MODE_0); // U+ = PWM
-    mcpwm_deadtime_enable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, MCPWM_ACTIVE_HIGH_COMPLIMENT_MODE, 3, 3); // U- = _PWM_
-    mcpwm_deadtime_disable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V);
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, BLDC_MCPWM_GEN_HIGH); // V+ = 0
-    mcpwm_set_signal_high(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, BLDC_MCPWM_GEN_LOW); // V- = 1
-    mcpwm_deadtime_disable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W);
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, BLDC_MCPWM_GEN_HIGH); // W+ = 0
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, BLDC_MCPWM_GEN_LOW);  // W- = 0
+    // U+ = 0, U- = 1
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_U][BLDC_MCPWM_GEN_INDEX_HIGH], 0, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_U][BLDC_MCPWM_GEN_INDEX_LOW], 1, true);
+
+    // V+ = 0, V- = 0
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_V][BLDC_MCPWM_GEN_INDEX_HIGH], 0, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_V][BLDC_MCPWM_GEN_INDEX_LOW], 0, true);
+
+    // W+ = PWM, W- = _PWM_
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_W][BLDC_MCPWM_GEN_INDEX_HIGH], -1, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_W][BLDC_MCPWM_GEN_INDEX_LOW], -1, true);
 }
 
-// W+U- / C+A-
-static void bldc_set_phase_wp_um(void)
+// W+V-
+static void bldc_set_phase_wp_vm(mcpwm_gen_handle_t (*gens)[2])
 {
-    mcpwm_deadtime_disable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U);
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, BLDC_MCPWM_GEN_HIGH); // U+ = 0
-    mcpwm_set_signal_high(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, BLDC_MCPWM_GEN_LOW); // U- = 1
-    mcpwm_deadtime_disable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V);
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, BLDC_MCPWM_GEN_HIGH); // V+ = 0
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, BLDC_MCPWM_GEN_LOW);  // V- = 0
-    mcpwm_set_duty_type(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, BLDC_MCPWM_GEN_HIGH, MCPWM_DUTY_MODE_0); // W+ = PWM
-    mcpwm_deadtime_enable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, MCPWM_ACTIVE_HIGH_COMPLIMENT_MODE, 3, 3); // W- = _PWM_
+    // U+ = 0, U- = 0
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_U][BLDC_MCPWM_GEN_INDEX_HIGH], 0, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_U][BLDC_MCPWM_GEN_INDEX_LOW], 0, true);
+
+    // V+ = 0, V- = 1
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_V][BLDC_MCPWM_GEN_INDEX_HIGH], 0, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_V][BLDC_MCPWM_GEN_INDEX_LOW], 1, true);
+
+    // W+ = PWM, W- = _PWM_
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_W][BLDC_MCPWM_GEN_INDEX_HIGH], -1, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_W][BLDC_MCPWM_GEN_INDEX_LOW], -1, true);
 }
 
-// W+V- / C+B-
-static void bldc_set_phase_wp_vm(void)
+// V+U-
+static void bldc_set_phase_vp_um(mcpwm_gen_handle_t (*gens)[2])
 {
-    mcpwm_deadtime_disable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U);
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, BLDC_MCPWM_GEN_HIGH); // U+ = 0
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, BLDC_MCPWM_GEN_LOW);  // U- = 0
-    mcpwm_deadtime_disable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V);
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, BLDC_MCPWM_GEN_HIGH); // V+ = 0
-    mcpwm_set_signal_high(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, BLDC_MCPWM_GEN_LOW); // V- = 1
-    mcpwm_set_duty_type(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, BLDC_MCPWM_GEN_HIGH, MCPWM_DUTY_MODE_0); // W+ = PWM
-    mcpwm_deadtime_enable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, MCPWM_ACTIVE_HIGH_COMPLIMENT_MODE, 3, 3); // W- = _PWM_
+    // U+ = 0, U- = 1
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_U][BLDC_MCPWM_GEN_INDEX_HIGH], 0, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_U][BLDC_MCPWM_GEN_INDEX_LOW], 1, true);
+
+    // V+ = PWM, V- = _PWM_
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_V][BLDC_MCPWM_GEN_INDEX_HIGH], -1, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_V][BLDC_MCPWM_GEN_INDEX_LOW], -1, true);
+
+    // W+ = 0, W- = 0
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_W][BLDC_MCPWM_GEN_INDEX_HIGH], 0, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_W][BLDC_MCPWM_GEN_INDEX_LOW], 0, true);
 }
 
-// V+U- / B+A-
-static void bldc_set_phase_vp_um(void)
+// V+W-
+static void bldc_set_phase_vp_wm(mcpwm_gen_handle_t (*gens)[2])
 {
-    mcpwm_deadtime_disable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U);
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, BLDC_MCPWM_GEN_HIGH); // U+ = 0
-    mcpwm_set_signal_high(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, BLDC_MCPWM_GEN_LOW); // U- = 1
-    mcpwm_set_duty_type(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, BLDC_MCPWM_GEN_HIGH, MCPWM_DUTY_MODE_0); // V+ = PWM
-    mcpwm_deadtime_enable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, MCPWM_ACTIVE_HIGH_COMPLIMENT_MODE, 3, 3); // V- = _PWM_
-    mcpwm_deadtime_disable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W);
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, BLDC_MCPWM_GEN_HIGH); // W+ = 0
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, BLDC_MCPWM_GEN_LOW);  // W- = 0
-}
+    // U+ = 0, U- = 0
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_U][BLDC_MCPWM_GEN_INDEX_HIGH], 0, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_U][BLDC_MCPWM_GEN_INDEX_LOW], 0, true);
 
-// V+W- / B+C-
-static void bldc_set_phase_vp_wm(void)
-{
-    mcpwm_deadtime_disable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U);
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, BLDC_MCPWM_GEN_HIGH); // U+ = 0
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, BLDC_MCPWM_GEN_LOW);  // U- = 0
-    mcpwm_set_duty_type(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, BLDC_MCPWM_GEN_HIGH, MCPWM_DUTY_MODE_0); // V+ = PWM
-    mcpwm_deadtime_enable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, MCPWM_ACTIVE_HIGH_COMPLIMENT_MODE, 3, 3); // V- = _PWM_
-    mcpwm_deadtime_disable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W);
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, BLDC_MCPWM_GEN_HIGH); // W+ = 0
-    mcpwm_set_signal_high(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, BLDC_MCPWM_GEN_LOW); // W- = 1
+    // V+ = PWM, V- = _PWM_
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_V][BLDC_MCPWM_GEN_INDEX_HIGH], -1, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_V][BLDC_MCPWM_GEN_INDEX_LOW], -1, true);
+
+    // W+ = 0, W- = 1
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_W][BLDC_MCPWM_GEN_INDEX_HIGH], 0, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_W][BLDC_MCPWM_GEN_INDEX_LOW], 1, true);
 }
 
 // U+W- / A+C-
-static void bldc_set_phase_up_wm(void)
+static void bldc_set_phase_up_wm(mcpwm_gen_handle_t (*gens)[2])
 {
-    mcpwm_set_duty_type(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, BLDC_MCPWM_GEN_HIGH, MCPWM_DUTY_MODE_0); // U+ = PWM
-    mcpwm_deadtime_enable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, MCPWM_ACTIVE_HIGH_COMPLIMENT_MODE, 3, 3); // U- = _PWM_
-    mcpwm_deadtime_disable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V);
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, BLDC_MCPWM_GEN_HIGH); // V+ = 0
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, BLDC_MCPWM_GEN_LOW); // V- = 0
-    mcpwm_deadtime_disable(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W);
-    mcpwm_set_signal_low(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, BLDC_MCPWM_GEN_HIGH); // W+ = 0
-    mcpwm_set_signal_high(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, BLDC_MCPWM_GEN_LOW); // W- = 1
-}
+    // U+ = PWM, U- = _PWM_
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_U][BLDC_MCPWM_GEN_INDEX_HIGH], -1, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_U][BLDC_MCPWM_GEN_INDEX_LOW], -1, true);
 
-typedef void (*bldc_hall_phase_action_t)(void);
+    // V+ = 0, V- = 0
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_V][BLDC_MCPWM_GEN_INDEX_HIGH], 0, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_V][BLDC_MCPWM_GEN_INDEX_LOW], 0, true);
+
+    // W+ = 0, W- = 1
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_W][BLDC_MCPWM_GEN_INDEX_HIGH], 0, true);
+    mcpwm_generator_set_force_level(gens[BLDC_MCPWM_OP_INDEX_W][BLDC_MCPWM_GEN_INDEX_LOW], 1, true);
+}
 
 static const bldc_hall_phase_action_t s_hall_actions[] = {
     [2] = bldc_set_phase_up_vm,
@@ -161,90 +158,191 @@ static const bldc_hall_phase_action_t s_hall_actions[] = {
     [3] = bldc_set_phase_up_wm,
 };
 
+static void update_motor_speed_callback(void *arg)
+{
+    static int step = 20;
+    static int cur_speed = 0;
+    if ((cur_speed + step) > 300 || (cur_speed + step) < 0) {
+        step *= -1;
+    }
+    cur_speed += step;
+
+    mcpwm_cmpr_handle_t *cmprs = (mcpwm_cmpr_handle_t *)arg;
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_comparator_set_compare_value(cmprs[i], cur_speed));
+    }
+}
+
 void app_main(void)
 {
-    uint32_t hall_sensor_value = 0;
-    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
-
-    ESP_LOGI(TAG, "Disable gate driver");
+    ESP_LOGI(TAG, "Disable MOSFET gate");
     gpio_config_t drv_en_config = {
         .mode = GPIO_MODE_OUTPUT,
-        .pin_bit_mask = 1 << BLDC_DRV_EN_GPIO,
+        .pin_bit_mask = 1ULL << BLDC_DRV_EN_GPIO,
     };
     ESP_ERROR_CHECK(gpio_config(&drv_en_config));
     gpio_set_level(BLDC_DRV_EN_GPIO, 0);
 
-    ESP_LOGI(TAG, "Setup PWM and Hall GPIO (pull up internally)");
-    mcpwm_pin_config_t mcpwm_gpio_config = {
-        .mcpwm0a_out_num = BLDC_PWM_UH_GPIO,
-        .mcpwm0b_out_num = BLDC_PWM_UL_GPIO,
-        .mcpwm1a_out_num = BLDC_PWM_VH_GPIO,
-        .mcpwm1b_out_num = BLDC_PWM_VL_GPIO,
-        .mcpwm2a_out_num = BLDC_PWM_WH_GPIO,
-        .mcpwm2b_out_num = BLDC_PWM_WL_GPIO,
-        .mcpwm_cap0_in_num   = HALL_CAP_U_GPIO,
-        .mcpwm_cap1_in_num   = HALL_CAP_V_GPIO,
-        .mcpwm_cap2_in_num   = HALL_CAP_W_GPIO,
-        .mcpwm_sync0_in_num  = -1,  //Not used
-        .mcpwm_sync1_in_num  = -1,  //Not used
-        .mcpwm_sync2_in_num  = -1,  //Not used
-        .mcpwm_fault0_in_num = BLDC_DRV_FAULT_GPIO,
-        .mcpwm_fault1_in_num = -1,  //Not used
-        .mcpwm_fault2_in_num = -1   //Not used
+    ESP_LOGI(TAG, "Create MCPWM timer");
+    mcpwm_timer_handle_t timer = NULL;
+    mcpwm_timer_config_t timer_config = {
+        .group_id = 0,
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .resolution_hz = BLDC_MCPWM_TIMER_RESOLUTION_HZ,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+        .period_ticks = BLDC_MCPWM_PERIOD,
     };
-    ESP_ERROR_CHECK(mcpwm_set_pin(BLDC_MCPWM_GROUP, &mcpwm_gpio_config));
-    // In case there's no pull-up resister for hall sensor on board
-    gpio_pullup_en(HALL_CAP_U_GPIO);
-    gpio_pullup_en(HALL_CAP_V_GPIO);
-    gpio_pullup_en(HALL_CAP_W_GPIO);
-    gpio_pullup_en(BLDC_DRV_FAULT_GPIO);
+    ESP_ERROR_CHECK(mcpwm_new_timer(&timer_config, &timer));
 
-    ESP_LOGI(TAG, "Initialize PWM (default to turn off all MOSFET)");
-    mcpwm_config_t pwm_config = {
-        .frequency = PWM_DEFAULT_FREQ,
-        .cmpr_a = PWM_MIN_DUTY,
-        .cmpr_b = PWM_MIN_DUTY,
-        .counter_mode = MCPWM_UP_COUNTER,
-        .duty_mode = MCPWM_HAL_GENERATOR_MODE_FORCE_LOW,
+    ESP_LOGI(TAG, "Create MCPWM operator");
+    mcpwm_oper_handle_t operators[3];
+    mcpwm_operator_config_t operator_config = {
+        .group_id = 0,
     };
-    ESP_ERROR_CHECK(mcpwm_init(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, &pwm_config));
-    ESP_ERROR_CHECK(mcpwm_init(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, &pwm_config));
-    ESP_ERROR_CHECK(mcpwm_init(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, &pwm_config));
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_new_operator(&operator_config, &operators[i]));
+    }
 
-    ESP_LOGI(TAG, "Initialize over current fault action");
-    ESP_ERROR_CHECK(mcpwm_fault_init(BLDC_MCPWM_GROUP, MCPWM_LOW_LEVEL_TGR, BLDC_DRV_OVER_CURRENT_FAULT));
-    ESP_ERROR_CHECK(mcpwm_fault_set_cyc_mode(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_U, BLDC_DRV_OVER_CURRENT_FAULT, MCPWM_ACTION_FORCE_LOW, MCPWM_ACTION_FORCE_LOW));
-    ESP_ERROR_CHECK(mcpwm_fault_set_cyc_mode(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_V, BLDC_DRV_OVER_CURRENT_FAULT, MCPWM_ACTION_FORCE_LOW, MCPWM_ACTION_FORCE_LOW));
-    ESP_ERROR_CHECK(mcpwm_fault_set_cyc_mode(BLDC_MCPWM_GROUP, BLDC_MCPWM_TIMER_W, BLDC_DRV_OVER_CURRENT_FAULT, MCPWM_ACTION_FORCE_LOW, MCPWM_ACTION_FORCE_LOW));
+    ESP_LOGI(TAG, "Connect operators to the same timer");
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_operator_connect_timer(operators[i], timer));
+    }
 
-    ESP_LOGI(TAG, "Initialize Hall sensor capture");
-    mcpwm_capture_config_t cap_config = {
-        .cap_edge = MCPWM_BOTH_EDGE,
-        .cap_prescale = 1,
-        .capture_cb = bldc_hall_updated,
-        .user_data = cur_task,
+    ESP_LOGI(TAG, "Create comparators");
+    mcpwm_cmpr_handle_t comparators[3];
+    mcpwm_comparator_config_t compare_config = {
+        .flags.update_cmp_on_tez = true,
     };
-    ESP_ERROR_CHECK(mcpwm_capture_enable_channel(BLDC_MCPWM_GROUP, 0, &cap_config));
-    ESP_ERROR_CHECK(mcpwm_capture_enable_channel(BLDC_MCPWM_GROUP, 1, &cap_config));
-    ESP_ERROR_CHECK(mcpwm_capture_enable_channel(BLDC_MCPWM_GROUP, 2, &cap_config));
-    ESP_LOGI(TAG, "Please turn on the motor power");
-    vTaskDelay(pdMS_TO_TICKS(5000));
-    ESP_LOGI(TAG, "Enable gate driver");
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_new_comparator(operators[i], &compare_config, &comparators[i]));
+        // set compare value to 0, we will adjust the speed in a period timer callback
+        ESP_ERROR_CHECK(mcpwm_comparator_set_compare_value(comparators[i], 0));
+    }
+
+    ESP_LOGI(TAG, "Create over current fault detector");
+    mcpwm_fault_handle_t over_cur_fault = NULL;
+    mcpwm_gpio_fault_config_t gpio_fault_config = {
+        .gpio_num = BLDC_DRV_FAULT_GPIO,
+        .group_id = 0,
+        .flags.active_level = 0, // low level means fault, refer to DRV8302 datasheet
+        .flags.pull_up = true,   // internally pull up
+    };
+    ESP_ERROR_CHECK(mcpwm_new_gpio_fault(&gpio_fault_config, &over_cur_fault));
+
+    ESP_LOGI(TAG, "Set brake mode on the fault event");
+    mcpwm_brake_config_t brake_config = {
+        .brake_mode = MCPWM_OPER_BRAKE_MODE_CBC,
+        .fault = over_cur_fault,
+        .flags.cbc_recover_on_tez = true,
+    };
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_operator_set_brake_on_fault(operators[i], &brake_config));
+    }
+
+    ESP_LOGI(TAG, "Create PWM generators");
+    mcpwm_gen_handle_t generators[3][2] = {};
+    mcpwm_generator_config_t gen_config = {};
+    const int gen_gpios[3][2] = {
+        {BLDC_PWM_UH_GPIO, BLDC_PWM_UL_GPIO},
+        {BLDC_PWM_VH_GPIO, BLDC_PWM_VL_GPIO},
+        {BLDC_PWM_WH_GPIO, BLDC_PWM_WL_GPIO},
+    };
+    for (int i = 0; i < 3; i++) {
+        for (int j = 0; j < 2; j++) {
+            gen_config.gen_gpio_num = gen_gpios[i][j];
+            ESP_ERROR_CHECK(mcpwm_new_generator(operators[i], &gen_config, &generators[i][j]));
+        }
+    }
+
+    ESP_LOGI(TAG, "Set generator actions");
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(generators[i][BLDC_MCPWM_GEN_INDEX_HIGH],
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(generators[i][BLDC_MCPWM_GEN_INDEX_HIGH],
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, comparators[i], MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_brake_event(generators[i][BLDC_MCPWM_GEN_INDEX_HIGH],
+                        MCPWM_GEN_BRAKE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_OPER_BRAKE_MODE_CBC, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_BRAKE_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_brake_event(generators[i][BLDC_MCPWM_GEN_INDEX_HIGH],
+                        MCPWM_GEN_BRAKE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_OPER_BRAKE_MODE_CBC, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_BRAKE_EVENT_ACTION_END()));
+    }
+
+    ESP_LOGI(TAG, "Setup deadtime");
+    mcpwm_dead_time_config_t dt_config = {
+        .posedge_delay_ticks = 5,
+    };
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(generators[i][BLDC_MCPWM_GEN_INDEX_HIGH], generators[i][BLDC_MCPWM_GEN_INDEX_HIGH], &dt_config));
+    }
+    dt_config = (mcpwm_dead_time_config_t) {
+        .negedge_delay_ticks = 5,
+        .flags.invert_output = true,
+    };
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(generators[i][BLDC_MCPWM_GEN_INDEX_HIGH], generators[i][BLDC_MCPWM_GEN_INDEX_LOW], &dt_config));
+    }
+
+    ESP_LOGI(TAG, "Turn off all the gates");
+    for (int i = 0; i < 3; i++) {
+        for (int j = 0; j < 2; j++) {
+            ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generators[i][j], 0, true));
+        }
+    }
+
+    ESP_LOGI(TAG, "Create Hall sensor capture channels");
+    mcpwm_cap_timer_handle_t cap_timer = NULL;
+    mcpwm_capture_timer_config_t cap_timer_config = {
+        .group_id = 0,
+        .clk_src = MCPWM_CAPTURE_CLK_SRC_DEFAULT,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_capture_timer(&cap_timer_config, &cap_timer));
+    mcpwm_cap_channel_handle_t cap_channels[3];
+    mcpwm_capture_channel_config_t cap_channel_config = {
+        .prescale = 1,
+        .flags.pull_up = true,
+        .flags.neg_edge = true,
+        .flags.pos_edge = true,
+    };
+    const int cap_chan_gpios[3] = {HALL_CAP_U_GPIO, HALL_CAP_V_GPIO, HALL_CAP_W_GPIO};
+    for (int i = 0; i < 3; i++) {
+        cap_channel_config.gpio_num = cap_chan_gpios[i];
+        ESP_ERROR_CHECK(mcpwm_new_capture_channel(cap_timer, &cap_channel_config, &cap_channels[i]));
+    }
+
+    ESP_LOGI(TAG, "Register event callback for capture channels");
+    TaskHandle_t task_to_notify = xTaskGetCurrentTaskHandle();
+    for (int i = 0; i < 3; i++) {
+        mcpwm_capture_event_callbacks_t cbs = {
+            .on_cap = bldc_hall_updated,
+        };
+        ESP_ERROR_CHECK(mcpwm_capture_channel_register_event_callbacks(cap_channels[i], &cbs, task_to_notify));
+    }
+
+    ESP_LOGI(TAG, "Start a timer to adjust motor speed periodically");
+    esp_timer_handle_t periodic_timer = NULL;
+    const esp_timer_create_args_t periodic_timer_args = {
+        .callback = update_motor_speed_callback,
+        .arg = comparators,
+    };
+    ESP_ERROR_CHECK(esp_timer_create(&periodic_timer_args, &periodic_timer));
+    ESP_ERROR_CHECK(esp_timer_start_periodic(periodic_timer, BLDC_SPEED_UPDATE_PERIOD_US));
+
+    ESP_LOGI(TAG, "Enable MOSFET gate");
     gpio_set_level(BLDC_DRV_EN_GPIO, 1);
-    ESP_LOGI(TAG, "Changing speed at background");
-    const esp_timer_create_args_t bldc_timer_args = {
-        .callback = update_bldc_speed,
-        .name = "bldc_speed"
-    };
-    esp_timer_handle_t bldc_speed_timer;
-    ESP_ERROR_CHECK(esp_timer_create(&bldc_timer_args, &bldc_speed_timer));
-    ESP_ERROR_CHECK(esp_timer_start_periodic(bldc_speed_timer, 2000000));
 
+    ESP_LOGI(TAG, "Start the MCPWM timer");
+    ESP_ERROR_CHECK(mcpwm_timer_enable(timer));
+    ESP_ERROR_CHECK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+
+    uint32_t hall_sensor_value = 0;
     while (1) {
         // The rotation direction is controlled by inverting the hall sensor value
-        hall_sensor_value = bldc_get_hall_sensor_value(false);
-        if (hall_sensor_value >= 1 && hall_sensor_value < sizeof(s_hall_actions) / sizeof(s_hall_actions[0])) {
-            s_hall_actions[hall_sensor_value]();
+        hall_sensor_value = bldc_get_hall_sensor_value(BLDC_SPIN_DIRECTION_CCW);
+        if (hall_sensor_value >= 1 && hall_sensor_value <= 6) {
+            s_hall_actions[hall_sensor_value](generators);
         } else {
             ESP_LOGE(TAG, "invalid bldc phase, wrong hall sensor value:%d", hall_sensor_value);
         }
diff --git a/examples/peripherals/mcpwm/mcpwm_bldc_hall_control/pytest_bldc_hall_control.py b/examples/peripherals/mcpwm/mcpwm_bldc_hall_control/pytest_bldc_hall_control.py
new file mode 100644
index 0000000000..ccc6a4e34e
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_bldc_hall_control/pytest_bldc_hall_control.py
@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: CC0-1.0
+
+import pytest
+from pytest_embedded import Dut
+
+
+@pytest.mark.esp32s3
+@pytest.mark.generic
+def test_bldc_hall_control_example(dut: Dut) -> None:
+    dut.expect_exact('example: Disable MOSFET gate')
+    dut.expect_exact('example: Create MCPWM timer')
+    dut.expect_exact('example: Create MCPWM operator')
+    dut.expect_exact('example: Connect operators to the same timer')
+    dut.expect_exact('example: Create comparators')
+    dut.expect_exact('example: Create over current fault detector')
+    dut.expect_exact('example: Set brake mode on the fault event')
+    dut.expect_exact('example: Create PWM generators')
+    dut.expect_exact('example: Set generator actions')
+    dut.expect_exact('example: Setup deadtime')
+    dut.expect_exact('example: Turn off all the gates')
+    dut.expect_exact('example: Create Hall sensor capture channels')
+    dut.expect_exact('example: Start a timer to adjust motor speed periodically')
+    dut.expect_exact('example: Enable MOSFET gate')
+    dut.expect_exact('example: Start the MCPWM timer')

From 6751b229f11da471bc531951d7b6670f1949f420 Mon Sep 17 00:00:00 2001
From: morris <maoshengrong@espressif.com>
Date: Sat, 28 May 2022 17:05:09 +0800
Subject: [PATCH 5/8] example: update capture example with new driver API

---
 .../mcpwm/mcpwm_capture_hc_sr04/README.md     |  42 +++--
 .../main/mcpwm_capture_hc_sr04.c              | 170 +++++++++---------
 .../mcpwm_capture_hc_sr04/pytest_hc_sr04.py   |  16 ++
 3 files changed, 120 insertions(+), 108 deletions(-)
 create mode 100644 examples/peripherals/mcpwm/mcpwm_capture_hc_sr04/pytest_hc_sr04.py

diff --git a/examples/peripherals/mcpwm/mcpwm_capture_hc_sr04/README.md b/examples/peripherals/mcpwm/mcpwm_capture_hc_sr04/README.md
index 4df1e96735..941d25a886 100644
--- a/examples/peripherals/mcpwm/mcpwm_capture_hc_sr04/README.md
+++ b/examples/peripherals/mcpwm/mcpwm_capture_hc_sr04/README.md
@@ -1,14 +1,15 @@
 | Supported Targets | ESP32 | ESP32-S3 |
 | ----------------- | ----- | -------- |
 
-# HC-SR04 Example
+# HC-SR04 Example based on MCPWM Capture
 
 (See the README.md file in the upper level 'examples' directory for more information about examples.)
 
-The capture module in MCPWM peripheral is designed to accurately log the time stamp on the hardware side when an event happens (compared to GPIO ISR which requires a software-based logging method). Each capture unit has three channels, which can be used together to capture IO events parallelly.
-This example shows how to make use of the HW features to decode the pulse width signals generated from a common HC-SR04 sonar range finder -- [HC-SR04](https://www.sparkfun.com/products/15569).
+The capture module in MCPWM peripheral is designed to accurately log the time stamp on the hardware side when an event happens (compared to GPIO ISR which requires a software-based logging method). Each capture unit has three channels, which can be used together to capture IO events in parallel.
 
-The signal that HC-SR04 produces (and what can be handled by this example) is a simple pulse whose width indicates the measured distance. A pulse is required to send to HC-SR04 on `Trig` pin to begin a new measurement. Then the pulse described above will be sent back on `Echo` pin for decoding.
+This example shows how to make use of the hardware features to decode the pulse width signals generated from a common HC-SR04 sonar sensor -- [HC-SR04](https://www.sparkfun.com/products/15569).
+
+The signal that HC-SR04 produces (and what can be handled by this example) is a simple pulse whose width indicates the measured distance. An excitation pulse is required to send to HC-SR04 on `Trig` pin to begin a new measurement. Then the pulse described above will appear on the `Echo` pin after a while.
 
 Typical signals:
 
@@ -30,8 +31,8 @@ Echo                   +-----+
 
 ### Hardware Required
 
-* An ESP development board
-* HC-SR04 module
+* An ESP development board that features the MCPWM peripheral
+* An HC-SR04 sensor module
 
 Connection :
 
@@ -60,21 +61,24 @@ See the [Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/l
 ## Example Output
 
 ```
-I (314) hc-sr04: HC-SR04 example based on capture function from MCPWM
-I (324) hc-sr04: Echo pin configured
-I (324) gpio: GPIO[19]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
-I (334) hc-sr04: Trig pin configured
-I (344) hc-sr04: trig task started
-I (444) hc-sr04: Pulse width: 419us, Measured distance: 7.22cm
-I (544) hc-sr04: Pulse width: 419us, Measured distance: 7.22cm
-I (644) hc-sr04: Pulse width: 416us, Measured distance: 7.17cm
-I (744) hc-sr04: Pulse width: 415us, Measured distance: 7.16cm
-I (844) hc-sr04: Pulse width: 415us, Measured distance: 7.16cm
-I (944) hc-sr04: Pulse width: 416us, Measured distance: 7.17cm
-I (1044) hc-sr04: Pulse width: 391us, Measured distance: 6.74cm
+I (0) cpu_start: Starting scheduler on APP CPU.
+I (304) example: Create capture queue
+I (304) example: Install capture timer
+I (304) example: Install capture channel
+I (314) gpio: GPIO[2]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (324) example: Register capture callback
+I (324) example: Create a timer to trig HC_SR04 periodically
+I (334) example: Configure Trig pin
+I (334) gpio: GPIO[0]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0
+I (344) example: Enable and start capture timer
+I (434) example: Pulse width: 189.02us, Measured distance: 3.26cm
+I (534) example: Pulse width: 189.02us, Measured distance: 3.26cm
+I (634) example: Pulse width: 189.01us, Measured distance: 3.26cm
+I (734) example: Pulse width: 188.98us, Measured distance: 3.26cm
+I (834) example: Pulse width: 188.99us, Measured distance: 3.26cm
 ```
 
-This example runs at 10Hz sampling rate. out of range data is dropped and only valid measurement is printed.
+This example runs at 10Hz sampling rate. Measure data that out of the range is dropped and only valid measurement is printed out.
 
 ## Troubleshooting
 
diff --git a/examples/peripherals/mcpwm/mcpwm_capture_hc_sr04/main/mcpwm_capture_hc_sr04.c b/examples/peripherals/mcpwm/mcpwm_capture_hc_sr04/main/mcpwm_capture_hc_sr04.c
index e7fefeb6d2..b18fbfe81e 100644
--- a/examples/peripherals/mcpwm/mcpwm_capture_hc_sr04/main/mcpwm_capture_hc_sr04.c
+++ b/examples/peripherals/mcpwm/mcpwm_capture_hc_sr04/main/mcpwm_capture_hc_sr04.c
@@ -6,119 +6,111 @@
 
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
-#include "freertos/queue.h"
 #include "esp_log.h"
 #include "esp_private/esp_clk.h"
-#include "driver/mcpwm.h"
+#include "driver/mcpwm_cap.h"
 #include "driver/gpio.h"
 
-const static char *TAG = "hc-sr04";
+const static char *TAG = "example";
 
-#define HC_SR04_SAMPLE_PERIOD_MS    100
-_Static_assert(HC_SR04_SAMPLE_PERIOD_MS > 50, "Sample period too short!");
-#define HC_SR04_PIN_ECHO    GPIO_NUM_18
-#define HC_SR04_PIN_TRIG    GPIO_NUM_19
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////// Please update the following configuration according to your board spec ////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#define HC_SR04_TRIG_GPIO  0
+#define HC_SR04_ECHO_GPIO  2
 
-#define TRIGGER_THREAD_STACK_SIZE 512
-#define TRIGGER_THREAD_PRIORITY 5
-
-typedef struct {
-    uint32_t capture_signal;
-    mcpwm_capture_signal_t sel_cap_signal;
-} capture;
-
-static uint32_t cap_val_begin_of_sample = 0;
-static uint32_t cap_val_end_of_sample = 0;
-
-static QueueHandle_t cap_queue;
-
-/**
- * @brief generate single pulse on Trig pin to activate a new sample
- */
-static void gen_trig_output(void *arg) {
-    TickType_t xLastWakeTime = xTaskGetTickCount();
-    while (true) {
-        vTaskDelayUntil(&xLastWakeTime, HC_SR04_SAMPLE_PERIOD_MS / portTICK_PERIOD_MS);
-        ESP_ERROR_CHECK(gpio_set_level(HC_SR04_PIN_TRIG, 1)); // set high
-        esp_rom_delay_us(10);
-        ESP_ERROR_CHECK(gpio_set_level(HC_SR04_PIN_TRIG, 0)); // set low
-    }
-}
-
-/**
- * @brief this is an ISR callback, we take action according to the captured edge
- */
-static bool sr04_echo_isr_handler(mcpwm_unit_t mcpwm, mcpwm_capture_channel_id_t cap_sig, const cap_event_data_t *edata,
-                                  void *arg) {
-    //calculate the interval in the ISR,
-    //so that the interval will be always correct even when cap_queue is not handled in time and overflow.
+static bool hc_sr04_echo_callback(mcpwm_cap_channel_handle_t cap_chan, const mcpwm_capture_event_data_t *edata, void *user_data)
+{
+    static uint32_t cap_val_begin_of_sample = 0;
+    static uint32_t cap_val_end_of_sample = 0;
+    TaskHandle_t task_to_notify = (TaskHandle_t)user_data;
     BaseType_t high_task_wakeup = pdFALSE;
-    if (edata->cap_edge == MCPWM_POS_EDGE) {
+
+    //calculate the interval in the ISR,
+    //so that the interval will be always correct even when capture_queue is not handled in time and overflow.
+    if (edata->cap_edge == MCPWM_CAP_EDGE_POS) {
         // store the timestamp when pos edge is detected
         cap_val_begin_of_sample = edata->cap_value;
         cap_val_end_of_sample = cap_val_begin_of_sample;
     } else {
         cap_val_end_of_sample = edata->cap_value;
-        // following formula refers to: https://www.elecrow.com/download/HC_SR04%20Datasheet.pdf
-        uint32_t pulse_count = cap_val_end_of_sample - cap_val_begin_of_sample;
-        // send measurement back though queue
-        xQueueSendFromISR(cap_queue, &pulse_count, &high_task_wakeup);
+        uint32_t tof_ticks = cap_val_end_of_sample - cap_val_begin_of_sample;
+
+        // notify the task to calculate the distance
+        xTaskNotifyFromISR(task_to_notify, tof_ticks, eSetValueWithOverwrite, &high_task_wakeup);
     }
+
     return high_task_wakeup == pdTRUE;
 }
 
-void app_main(void) {
-    ESP_LOGI(TAG, "HC-SR04 example based on capture function from MCPWM");
+/**
+ * @brief generate single pulse on Trig pin to start a new sample
+ */
+static void gen_trig_output(void)
+{
+    gpio_set_level(HC_SR04_TRIG_GPIO, 1); // set high
+    esp_rom_delay_us(10);
+    gpio_set_level(HC_SR04_TRIG_GPIO, 0); // set low
+}
 
-    // the queue where we read data
-    cap_queue = xQueueCreate(1, sizeof(uint32_t));
-    if (cap_queue == NULL) {
-        ESP_LOGE(TAG, "failed to alloc cap_queue");
-        return;
-    }
-
-    /* configure Echo pin */
-    // set CAP_0 on GPIO
-    ESP_ERROR_CHECK(mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM_CAP_0, HC_SR04_PIN_ECHO));
-    // enable pull down CAP0, to reduce noise
-    ESP_ERROR_CHECK(gpio_pulldown_en(HC_SR04_PIN_ECHO));
-    // enable both edge capture on CAP0
-    mcpwm_capture_config_t conf = {
-        .cap_edge = MCPWM_BOTH_EDGE,
-        .cap_prescale = 1,
-        .capture_cb = sr04_echo_isr_handler,
-        .user_data = NULL
+void app_main(void)
+{
+    ESP_LOGI(TAG, "Install capture timer");
+    mcpwm_cap_timer_handle_t cap_timer = NULL;
+    mcpwm_capture_timer_config_t cap_conf = {
+        .clk_src = MCPWM_CAPTURE_CLK_SRC_DEFAULT,
+        .group_id = 0,
     };
-    ESP_ERROR_CHECK(mcpwm_capture_enable_channel(MCPWM_UNIT_0, MCPWM_SELECT_CAP0, &conf));
-    ESP_LOGI(TAG, "Echo pin configured");
+    ESP_ERROR_CHECK(mcpwm_new_capture_timer(&cap_conf, &cap_timer));
 
-    /* configure Trig pin */
+    ESP_LOGI(TAG, "Install capture channel");
+    mcpwm_cap_channel_handle_t cap_chan = NULL;
+    mcpwm_capture_channel_config_t cap_ch_conf = {
+        .gpio_num = HC_SR04_ECHO_GPIO,
+        .prescale = 1,
+        // capture on both edge
+        .flags.neg_edge = true,
+        .flags.pos_edge = true,
+        // pull up internally
+        .flags.pull_up = true,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_capture_channel(cap_timer, &cap_ch_conf, &cap_chan));
+
+    ESP_LOGI(TAG, "Register capture callback");
+    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
+    mcpwm_capture_event_callbacks_t cbs = {
+        .on_cap = hc_sr04_echo_callback,
+    };
+    ESP_ERROR_CHECK(mcpwm_capture_channel_register_event_callbacks(cap_chan, &cbs, cur_task));
+
+    ESP_LOGI(TAG, "Configure Trig pin");
     gpio_config_t io_conf = {
-        .intr_type = GPIO_INTR_DISABLE,
         .mode = GPIO_MODE_OUTPUT,
-        .pull_down_en = GPIO_PULLDOWN_DISABLE,
-        .pull_up_en = GPIO_PULLUP_DISABLE,
-        .pin_bit_mask = BIT64(HC_SR04_PIN_TRIG),
+        .pin_bit_mask = 1ULL << HC_SR04_TRIG_GPIO,
     };
     ESP_ERROR_CHECK(gpio_config(&io_conf));
-    ESP_ERROR_CHECK(gpio_set_level(HC_SR04_PIN_TRIG, 0)); // drive low by default
-    ESP_LOGI(TAG, "Trig pin configured");
+    // drive low by default
+    ESP_ERROR_CHECK(gpio_set_level(HC_SR04_TRIG_GPIO, 0));
 
-    // start generating trig signal
-    xTaskCreate(gen_trig_output, "gen_trig_output", TRIGGER_THREAD_STACK_SIZE, NULL, TRIGGER_THREAD_PRIORITY, NULL);
-    ESP_LOGI(TAG, "trig task started");
-    // forever loop
-    while (true) {
-        uint32_t pulse_count;
-        // block and wait for new measurement
-        xQueueReceive(cap_queue, &pulse_count, portMAX_DELAY);
-        uint32_t pulse_width_us = pulse_count * (1000000.0 / esp_clk_apb_freq());
-        // following formula is based on: https://www.elecrow.com/download/HC_SR04%20Datasheet.pdf
-        if (pulse_width_us > 35000) {
-            // out of range
-            continue;
+    ESP_LOGI(TAG, "Enable and start capture timer");
+    ESP_ERROR_CHECK(mcpwm_capture_timer_enable(cap_timer));
+    ESP_ERROR_CHECK(mcpwm_capture_timer_start(cap_timer));
+
+    uint32_t tof_ticks;
+    while (1) {
+        // trigger the sensor to start a new sample
+        gen_trig_output();
+        // wait for echo done signal
+        if (xTaskNotifyWait(0x00, ULONG_MAX, &tof_ticks, pdMS_TO_TICKS(1000)) == pdTRUE) {
+            float pulse_width_us = tof_ticks * (1000000.0 / esp_clk_apb_freq());
+            if (pulse_width_us > 35000) {
+                // out of range
+                continue;
+            }
+            // convert the pulse width into measure distance
+            float distance = (float) pulse_width_us / 58;
+            ESP_LOGI(TAG, "Measured distance: %.2fcm", distance);
         }
-        float distance = (float) pulse_width_us / 58;
-        ESP_LOGI(TAG, "Pulse width: %uus, Measured distance: %.2fcm", pulse_width_us, distance);
+        vTaskDelay(pdMS_TO_TICKS(500));
     }
 }
diff --git a/examples/peripherals/mcpwm/mcpwm_capture_hc_sr04/pytest_hc_sr04.py b/examples/peripherals/mcpwm/mcpwm_capture_hc_sr04/pytest_hc_sr04.py
new file mode 100644
index 0000000000..6e519dff82
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_capture_hc_sr04/pytest_hc_sr04.py
@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: CC0-1.0
+
+import pytest
+from pytest_embedded import Dut
+
+
+@pytest.mark.esp32
+@pytest.mark.esp32s3
+@pytest.mark.generic
+def test_hc_sr04_example(dut: Dut) -> None:
+    dut.expect_exact('example: Install capture timer')
+    dut.expect_exact('example: Install capture channel')
+    dut.expect_exact('example: Register capture callback')
+    dut.expect_exact('example: Configure Trig pin')
+    dut.expect_exact('example: Enable and start capture timer')

From 1557a533fe881d1766ac1cd7c18c548e06a4e7d0 Mon Sep 17 00:00:00 2001
From: morris <maoshengrong@espressif.com>
Date: Sat, 28 May 2022 17:05:36 +0800
Subject: [PATCH 6/8] example: update servo example with new driver API

---
 .../mcpwm/mcpwm_servo_control/README.md       |  40 ++++---
 .../main/mcpwm_servo_control_example_main.c   | 100 +++++++++++++-----
 .../pytest_servo_mg996r.py                    |  17 +++
 tools/ci/check_copyright_ignore.txt           |   1 -
 4 files changed, 115 insertions(+), 43 deletions(-)
 create mode 100644 examples/peripherals/mcpwm/mcpwm_servo_control/pytest_servo_mg996r.py

diff --git a/examples/peripherals/mcpwm/mcpwm_servo_control/README.md b/examples/peripherals/mcpwm/mcpwm_servo_control/README.md
index cc174b1b1f..c25d811e51 100644
--- a/examples/peripherals/mcpwm/mcpwm_servo_control/README.md
+++ b/examples/peripherals/mcpwm/mcpwm_servo_control/README.md
@@ -4,7 +4,7 @@
 
 (See the README.md file in the upper level 'examples' directory for more information about examples.)
 
-This example illustrates how to drive a typical [RC Servo](https://en.wikipedia.org/wiki/Servo_%28radio_control%29) by sending a PWM signal using the MCPWM driver. The PWM pulse has a frequency of 50Hz (period of 20ms), and the active-high time (which controls the rotation) ranges from 1ms to 2ms with 1.5ms always being center of range.
+This example illustrates how to drive a typical [RC Servo](https://en.wikipedia.org/wiki/Servo_%28radio_control%29) by sending a PWM signal using the MCPWM driver. The PWM pulse has a frequency of 50Hz (period of 20ms), and the active-high time (which controls the rotation) ranges from 0.5s to 2.5ms with 1.5ms always being center of range.
 
 ## How to Use Example
 
@@ -17,15 +17,16 @@ This example illustrates how to drive a typical [RC Servo](https://en.wikipedia.
 Connection :
 
 ```
-+-------+                                     +-----------------+
-|       |                                     |                 |
-|       +-+ GPIO18++  PWM(Orange)  +----------+                 |
-|  ESP  |---5V------+ Vcc(Red) +--------------|   Servo Motor   |
-|       +---------+   GND(Brown)   +----------+                 |
-|       |                                     |                 |
-+-------+                                     +-----------------+
+      ESP Board              Servo Motor      5V
++-------------------+     +---------------+    ^
+|  SERVO_PULSE_GPIO +-----+PWM        VCC +----+
+|                   |     |               |
+|               GND +-----+GND            |
++-------------------+     +---------------+
 ```
 
+Note that, some kind of servo might need a higher current supply than the development board usually can provide. It's recommended to power the servo separately.
+
 ### Build and Flash
 
 Run `idf.py -p PORT flash monitor` to build, flash and monitor the project.
@@ -42,11 +43,22 @@ Run the example, you will see the following output log:
 ```
 ...
 I (0) cpu_start: Starting scheduler on APP CPU.
-I (349) example: Angle of rotation: -90
-I (449) example: Angle of rotation: -89
-I (549) example: Angle of rotation: -88
-I (649) example: Angle of rotation: -87
-I (749) example: Angle of rotation: -86
+I (305) example: Create timer and operator
+I (305) example: Connect timer and operator
+I (305) example: Create comparator and generator from the operator
+I (315) gpio: GPIO[44]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (325) example: Set generator action on timer and compare event
+I (335) example: Enable and start timer
+I (335) example: Angle of rotation: 0
+I (1345) example: Angle of rotation: 2
+I (2345) example: Angle of rotation: 4
+I (3345) example: Angle of rotation: 6
+I (4345) example: Angle of rotation: 8
+I (5345) example: Angle of rotation: 10
+I (6345) example: Angle of rotation: 12
+I (7345) example: Angle of rotation: 14
+I (8345) example: Angle of rotation: 16
+I (9345) example: Angle of rotation: 18
 ...
 ```
 
@@ -54,6 +66,4 @@ The servo will rotate from -90 degree to 90 degree, and then turn back again.
 
 ## Troubleshooting
 
-Note that, some kind of servo might need a higher current supply than the development board usually can provide. It's recommended to power the servo separately.
-
 For any technical queries, please open an [issue] (https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you soon.
diff --git a/examples/peripherals/mcpwm/mcpwm_servo_control/main/mcpwm_servo_control_example_main.c b/examples/peripherals/mcpwm/mcpwm_servo_control/main/mcpwm_servo_control_example_main.c
index 0c11a6db84..c905eeafc8 100644
--- a/examples/peripherals/mcpwm/mcpwm_servo_control/main/mcpwm_servo_control_example_main.c
+++ b/examples/peripherals/mcpwm/mcpwm_servo_control/main/mcpwm_servo_control_example_main.c
@@ -1,47 +1,93 @@
-/* Servo Motor control example
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 
-   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.
-*/
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_log.h"
-#include "driver/mcpwm.h"
+#include "driver/mcpwm_prelude.h"
 
 static const char *TAG = "example";
 
-// You can get these value from the datasheet of servo you use, in general pulse width varies between 1000 to 2000 mocrosecond
-#define SERVO_MIN_PULSEWIDTH_US (1000) // Minimum pulse width in microsecond
-#define SERVO_MAX_PULSEWIDTH_US (2000) // Maximum pulse width in microsecond
-#define SERVO_MAX_DEGREE        (90)   // Maximum angle in degree upto which servo can rotate
+// Please consult the datasheet of your servo before changing the following parameters
+#define SERVO_MIN_PULSEWIDTH_US 500  // Minimum pulse width in microsecond
+#define SERVO_MAX_PULSEWIDTH_US 2500  // Maximum pulse width in microsecond
+#define SERVO_MIN_DEGREE        -90   // Minimum angle
+#define SERVO_MAX_DEGREE        90    // Maximum angle
 
-#define SERVO_PULSE_GPIO        (18)   // GPIO connects to the PWM signal line
+#define SERVO_PULSE_GPIO             0        // GPIO connects to the PWM signal line
+#define SERVO_TIMEBASE_RESOLUTION_HZ 1000000  // 1MHz, 1us per tick
+#define SERVO_TIMEBASE_PERIOD        20000    // 20000 ticks, 20ms
 
-static inline uint32_t example_convert_servo_angle_to_duty_us(int angle)
+static inline uint32_t example_angle_to_compare(int angle)
 {
-    return (angle + SERVO_MAX_DEGREE) * (SERVO_MAX_PULSEWIDTH_US - SERVO_MIN_PULSEWIDTH_US) / (2 * SERVO_MAX_DEGREE) + SERVO_MIN_PULSEWIDTH_US;
+    return (angle - SERVO_MIN_DEGREE) * (SERVO_MAX_PULSEWIDTH_US - SERVO_MIN_PULSEWIDTH_US) / (SERVO_MAX_DEGREE - SERVO_MIN_DEGREE) + SERVO_MIN_PULSEWIDTH_US;
 }
 
 void app_main(void)
 {
-    mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM0A, SERVO_PULSE_GPIO); // To drive a RC servo, one MCPWM generator is enough
-
-    mcpwm_config_t pwm_config = {
-        .frequency = 50, // frequency = 50Hz, i.e. for every servo motor time period should be 20ms
-        .cmpr_a = 0,     // duty cycle of PWMxA = 0
-        .counter_mode = MCPWM_UP_COUNTER,
-        .duty_mode = MCPWM_DUTY_MODE_0,
+    ESP_LOGI(TAG, "Create timer and operator");
+    mcpwm_timer_handle_t timer = NULL;
+    mcpwm_timer_config_t timer_config = {
+        .group_id = 0,
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .resolution_hz = SERVO_TIMEBASE_RESOLUTION_HZ,
+        .period_ticks = SERVO_TIMEBASE_PERIOD,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
     };
-    mcpwm_init(MCPWM_UNIT_0, MCPWM_TIMER_0, &pwm_config);
+    ESP_ERROR_CHECK(mcpwm_new_timer(&timer_config, &timer));
 
+    mcpwm_oper_handle_t operator = NULL;
+    mcpwm_operator_config_t operator_config = {
+        .group_id = 0, // operator must be in the same group to the timer
+    };
+    ESP_ERROR_CHECK(mcpwm_new_operator(&operator_config, &operator));
+
+    ESP_LOGI(TAG, "Connect timer and operator");
+    ESP_ERROR_CHECK(mcpwm_operator_connect_timer(operator, timer));
+
+    ESP_LOGI(TAG, "Create comparator and generator from the operator");
+    mcpwm_cmpr_handle_t comparator = NULL;
+    mcpwm_comparator_config_t comparator_config = {
+        .flags.update_cmp_on_tez = true,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_comparator(operator, &comparator_config, &comparator));
+
+    mcpwm_gen_handle_t generator = NULL;
+    mcpwm_generator_config_t generator_config = {
+        .gen_gpio_num = SERVO_PULSE_GPIO,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_generator(operator, &generator_config, &generator));
+
+    // set the initial compare value, so that the servo will spin to the center position
+    ESP_ERROR_CHECK(mcpwm_comparator_set_compare_value(comparator, example_angle_to_compare(0)));
+
+    ESP_LOGI(TAG, "Set generator action on timer and compare event");
+    // go high on counter empty
+    ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(generator,
+                    MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                    MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    // go low on compare threshold
+    ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(generator,
+                    MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, comparator, MCPWM_GEN_ACTION_LOW),
+                    MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+
+    ESP_LOGI(TAG, "Enable and start timer");
+    ESP_ERROR_CHECK(mcpwm_timer_enable(timer));
+    ESP_ERROR_CHECK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));
+
+    int angle = 0;
+    int step = 2;
     while (1) {
-        for (int angle = -SERVO_MAX_DEGREE; angle < SERVO_MAX_DEGREE; angle++) {
-            ESP_LOGI(TAG, "Angle of rotation: %d", angle);
-            ESP_ERROR_CHECK(mcpwm_set_duty_in_us(MCPWM_UNIT_0, MCPWM_TIMER_0, MCPWM_OPR_A, example_convert_servo_angle_to_duty_us(angle)));
-            vTaskDelay(pdMS_TO_TICKS(100)); //Add delay, since it takes time for servo to rotate, generally 100ms/60degree rotation under 5V power supply
+        ESP_LOGI(TAG, "Angle of rotation: %d", angle);
+        ESP_ERROR_CHECK(mcpwm_comparator_set_compare_value(comparator, example_angle_to_compare(angle)));
+        //Add delay, since it takes time for servo to rotate, usually 200ms/60degree rotation under 5V power supply
+        vTaskDelay(pdMS_TO_TICKS(500));
+        if ((angle + step) > 60 || (angle + step) < -60) {
+            step *= -1;
         }
+        angle += step;
     }
 }
diff --git a/examples/peripherals/mcpwm/mcpwm_servo_control/pytest_servo_mg996r.py b/examples/peripherals/mcpwm/mcpwm_servo_control/pytest_servo_mg996r.py
new file mode 100644
index 0000000000..d22aa363d5
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_servo_control/pytest_servo_mg996r.py
@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: CC0-1.0
+
+import pytest
+from pytest_embedded import Dut
+
+
+@pytest.mark.esp32
+@pytest.mark.esp32s3
+@pytest.mark.generic
+def test_servo_mg996r_example(dut: Dut) -> None:
+    dut.expect_exact('example: Create timer and operator')
+    dut.expect_exact('example: Connect timer and operator')
+    dut.expect_exact('example: Create comparator and generator from the operator')
+    dut.expect_exact('example: Set generator action on timer and compare event')
+    dut.expect_exact('example: Enable and start timer')
+    dut.expect_exact('example: Angle of rotation: 0')
diff --git a/tools/ci/check_copyright_ignore.txt b/tools/ci/check_copyright_ignore.txt
index e13723ab90..40f6d52873 100644
--- a/tools/ci/check_copyright_ignore.txt
+++ b/tools/ci/check_copyright_ignore.txt
@@ -1773,7 +1773,6 @@ examples/peripherals/i2c/i2c_tools/main/cmd_i2ctools.h
 examples/peripherals/i2c/i2c_tools/main/i2ctools_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_servo_control/main/mcpwm_servo_control_example_main.c
 examples/peripherals/sdio/host/main/app_main.c
 examples/peripherals/sdio/sdio_test.py
 examples/peripherals/sdio/slave/main/app_main.c

From 169a43b8ebc3ee0d7f15036d2d8e46db360308fd Mon Sep 17 00:00:00 2001
From: morris <maoshengrong@espressif.com>
Date: Sat, 28 May 2022 17:06:06 +0800
Subject: [PATCH 7/8] example: update MCPWM sync example with new driver API

---
 .../CMakeLists.txt                            |   2 +-
 .../peripherals/mcpwm/mcpwm_sync/README.md    |  88 ++++++++
 .../mcpwm/mcpwm_sync/main/CMakeLists.txt      |   2 +
 .../mcpwm/mcpwm_sync/main/Kconfig.projbuild   |  20 ++
 .../mcpwm_sync/main/mcpwm_sync_example_main.c | 211 ++++++++++++++++++
 .../mcpwm/mcpwm_sync/pytest_mcpwm_sync.py     |  24 ++
 .../mcpwm/mcpwm_sync/sdkconfig.ci.gpio        |   1 +
 .../mcpwm/mcpwm_sync/sdkconfig.ci.soft        |   1 +
 .../mcpwm/mcpwm_sync/sdkconfig.ci.tez         |   1 +
 .../mcpwm/mcpwm_sync_example/README.md        |  74 ------
 .../mcpwm_sync_example/main/CMakeLists.txt    |   2 -
 .../main/mcpwm_sync_example.c                 | 146 ------------
 .../mcpwm_sync_example/readme_res/overall.png | Bin 35797 -> 0 bytes
 .../readme_res/sync_phase.png                 | Bin 10151 -> 0 bytes
 .../mcpwm_sync_example/readme_res/synced.png  | Bin 16120 -> 0 bytes
 15 files changed, 349 insertions(+), 223 deletions(-)
 rename examples/peripherals/mcpwm/{mcpwm_sync_example => mcpwm_sync}/CMakeLists.txt (88%)
 create mode 100644 examples/peripherals/mcpwm/mcpwm_sync/README.md
 create mode 100644 examples/peripherals/mcpwm/mcpwm_sync/main/CMakeLists.txt
 create mode 100644 examples/peripherals/mcpwm/mcpwm_sync/main/Kconfig.projbuild
 create mode 100644 examples/peripherals/mcpwm/mcpwm_sync/main/mcpwm_sync_example_main.c
 create mode 100644 examples/peripherals/mcpwm/mcpwm_sync/pytest_mcpwm_sync.py
 create mode 100644 examples/peripherals/mcpwm/mcpwm_sync/sdkconfig.ci.gpio
 create mode 100644 examples/peripherals/mcpwm/mcpwm_sync/sdkconfig.ci.soft
 create mode 100644 examples/peripherals/mcpwm/mcpwm_sync/sdkconfig.ci.tez
 delete mode 100644 examples/peripherals/mcpwm/mcpwm_sync_example/README.md
 delete mode 100644 examples/peripherals/mcpwm/mcpwm_sync_example/main/CMakeLists.txt
 delete mode 100644 examples/peripherals/mcpwm/mcpwm_sync_example/main/mcpwm_sync_example.c
 delete mode 100644 examples/peripherals/mcpwm/mcpwm_sync_example/readme_res/overall.png
 delete mode 100644 examples/peripherals/mcpwm/mcpwm_sync_example/readme_res/sync_phase.png
 delete mode 100644 examples/peripherals/mcpwm/mcpwm_sync_example/readme_res/synced.png

diff --git a/examples/peripherals/mcpwm/mcpwm_sync_example/CMakeLists.txt b/examples/peripherals/mcpwm/mcpwm_sync/CMakeLists.txt
similarity index 88%
rename from examples/peripherals/mcpwm/mcpwm_sync_example/CMakeLists.txt
rename to examples/peripherals/mcpwm/mcpwm_sync/CMakeLists.txt
index ba6c087f5d..7bfcd825e0 100644
--- a/examples/peripherals/mcpwm/mcpwm_sync_example/CMakeLists.txt
+++ b/examples/peripherals/mcpwm/mcpwm_sync/CMakeLists.txt
@@ -3,4 +3,4 @@
 cmake_minimum_required(VERSION 3.16)
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(mcpwm_sync_example)
+project(mcpwm_sync)
diff --git a/examples/peripherals/mcpwm/mcpwm_sync/README.md b/examples/peripherals/mcpwm/mcpwm_sync/README.md
new file mode 100644
index 0000000000..983731e2d0
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_sync/README.md
@@ -0,0 +1,88 @@
+| Supported Targets | ESP32 | ESP32-S3 |
+| ----------------- | ----- | -------- |
+
+# MCPWM Sync Example
+
+(See the README.md file in the upper level 'examples' directory for more information about examples.)
+
+MCPWM timers can't be started together because you have to call **mcpwm_timer_start_stop** function timer by timer, so the generators driven by them are not in sync with each other. But there're several ways to force these timers jump to the same point by setting sync phase for timers and then wait for a proper sync event to happen.
+
+This example illustrates how to generate three PWMs that are in perfect synchronization.
+
+## How to Use Example
+
+### Hardware Required
+
+* A development board with any Espressif SoC which features MCPWM peripheral (e.g., ESP32-DevKitC, ESP-WROVER-KIT, etc.)
+* A USB cable for Power supply and programming
+
+It is recommended to have an oscilloscope or logic analyzer to view the generated PWM waveforms.
+
+Connection :
+
+```
+          ESP Board                           oscilloscope / logic analyzer
++--------------------------+                 +----------------------------+
+|                          |                 |                            |
+|        EXAMPLE_GEN_GPIO0 +-----------------+ channelA                   |
+|                          |                 |                            |
+|        EXAMPLE_GEN_GPIO1 +-----------------+ channelB                   |
+|                          |                 |                            |
+|        EXAMPLE_GEN_GPIO2 +-----------------+ channelC                   |
+|                          |                 |                            |
+|                     GND  +-----------------+ GND                        |
+|                          |                 |                            |
++--------------------------+                 +----------------------------+
+```
+
+Above used GPIO numbers (e.g. `EXAMPLE_GEN_GPIO0`) can be changed in [the source file](main/mcpwm_sync_example_main.c).
+
+### Configure the project
+
+```
+idf.py menuconfig
+```
+
+You can select the way to synchronize the MCPWM timers in the menu: `Example Configuration` -> `Where the sync event is generated from`.
+
+* GPIO
+    * This approach will consume a GPIO, where a configurable pulse on the GPIO is treated as the sync event. And the sync event is routed to each MCPWM timers.
+* Timer TEZ
+    * This approach won't consume any GPIO, the sync even is generated by a main timer, and then routed to other MCPWM timers. The drawback of this approach is, the main timer will have a tiny phase shift to other two timers.
+* Software (optional)
+    * This approach won't consume any GPIO as well and also doesn't have the drawback in the `Timer TEZ` approach. The main timer is sync by software, and it will propagate the sync event to other timers.
+
+### Build and Flash
+
+Run `idf.py -p PORT flash monitor` to build, flash and monitor the project.
+
+(To exit the serial monitor, type ``Ctrl-]``.)
+
+See the [Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html) for full steps to configure and use ESP-IDF to build projects.
+
+## Example Output
+
+```
+I (0) cpu_start: Starting scheduler on APP CPU.
+I (305) example: Create timers
+I (305) example: Create operators
+I (305) example: Connect timers and operators with each other
+I (315) example: Create comparators
+I (315) example: Create generators
+I (325) gpio: GPIO[0]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (335) gpio: GPIO[2]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (345) gpio: GPIO[4]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (355) example: Set generator actions on timer and compare event
+I (355) example: Start timers one by one, so they are not synced
+I (495) example: Force the output level to low, timer still running
+I (495) example: Setup sync strategy
+I (495) example: Create GPIO sync source
+I (495) gpio: GPIO[5]| InputEn: 1| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 1| Intr:0
+I (505) example: Set timers to sync on the GPIO
+I (505) example: Trigger a pulse on the GPIO as a sync event
+I (515) example: Now the output PWMs should in sync
+```
+
+## Troubleshooting
+
+For any technical queries, please open an [issue] (https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you soon.
diff --git a/examples/peripherals/mcpwm/mcpwm_sync/main/CMakeLists.txt b/examples/peripherals/mcpwm/mcpwm_sync/main/CMakeLists.txt
new file mode 100644
index 0000000000..cdf25dbaf1
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_sync/main/CMakeLists.txt
@@ -0,0 +1,2 @@
+idf_component_register(SRCS "mcpwm_sync_example_main.c"
+                       INCLUDE_DIRS ".")
diff --git a/examples/peripherals/mcpwm/mcpwm_sync/main/Kconfig.projbuild b/examples/peripherals/mcpwm/mcpwm_sync/main/Kconfig.projbuild
new file mode 100644
index 0000000000..3bb0fe9fee
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_sync/main/Kconfig.projbuild
@@ -0,0 +1,20 @@
+menu "Example Configuration"
+
+    choice EXAMPLE_SYNC_FROM
+        prompt "Where the sync event is generated from"
+        default EXAMPLE_SYNC_FROM_GPIO
+        help
+            Select MCPWM sync source.
+
+        config EXAMPLE_SYNC_FROM_GPIO
+            bool "GPIO"
+
+        config EXAMPLE_SYNC_FROM_TEZ
+            bool "Timer TEZ"
+
+        config EXAMPLE_SYNC_FROM_SOFT
+            bool "Software"
+            depends on SOC_MCPWM_SWSYNC_CAN_PROPAGATE
+    endchoice
+
+endmenu
diff --git a/examples/peripherals/mcpwm/mcpwm_sync/main/mcpwm_sync_example_main.c b/examples/peripherals/mcpwm/mcpwm_sync/main/mcpwm_sync_example_main.c
new file mode 100644
index 0000000000..e68bb3c96b
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_sync/main/mcpwm_sync_example_main.c
@@ -0,0 +1,211 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#include "sdkconfig.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_log.h"
+#include "driver/mcpwm_prelude.h"
+#include "driver/gpio.h"
+
+const static char *TAG = "example";
+
+#define EXAMPLE_TIMER_RESOLUTION_HZ 1000000  // 1MHz, 1us per tick
+#define EXAMPLE_TIMER_PERIOD        1000     // 1000 ticks, 1ms
+#define EXAMPLE_GEN_GPIO0           0
+#define EXAMPLE_GEN_GPIO1           2
+#define EXAMPLE_GEN_GPIO2           4
+#define EXAMPLE_SYNC_GPIO           5
+
+#if CONFIG_EXAMPLE_SYNC_FROM_GPIO
+static void example_setup_sync_strategy(mcpwm_timer_handle_t timers[])
+{
+    //    +----GPIO----+
+    //    |     |      |
+    //    |     |      |
+    //    v     v      v
+    // timer0 timer1 timer2
+    ESP_LOGI(TAG, "Create GPIO sync source");
+    mcpwm_sync_handle_t gpio_sync_source = NULL;
+    mcpwm_gpio_sync_src_config_t gpio_sync_config = {
+        .group_id = 0,  // GPIO fault should be in the same group of the above timers
+        .gpio_num = EXAMPLE_SYNC_GPIO,
+        .flags.pull_down = true,
+        .flags.active_neg = false,  // by default, a posedge pulse can trigger a sync event
+        .flags.io_loop_back = true, // then we can trigger a sync event using `gpio_set_level` on the same GPIO
+    };
+    ESP_ERROR_CHECK(mcpwm_new_gpio_sync_src(&gpio_sync_config, &gpio_sync_source));
+
+    ESP_LOGI(TAG, "Set timers to sync on the GPIO");
+    mcpwm_timer_sync_phase_config_t sync_phase_config = {
+        .count_value = 0,
+        .direction = MCPWM_TIMER_DIRECTION_UP,
+        .sync_src = gpio_sync_source,
+    };
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_timer_set_phase_on_sync(timers[i], &sync_phase_config));
+    }
+
+    ESP_LOGI(TAG, "Trigger a pulse on the GPIO as a sync event");
+    gpio_set_level(EXAMPLE_SYNC_GPIO, 0);
+    gpio_set_level(EXAMPLE_SYNC_GPIO, 1);
+}
+#endif // CONFIG_EXAMPLE_SYNC_FROM_GPIO
+
+#if CONFIG_EXAMPLE_SYNC_FROM_TEZ
+static void example_setup_sync_strategy(mcpwm_timer_handle_t timers[])
+{
+    //          +->timer1
+    // (TEZ)    |
+    // timer0---+
+    //          |
+    //          +->timer2
+    ESP_LOGI(TAG, "Create TEZ sync source from timer0");
+    mcpwm_sync_handle_t timer_sync_source = NULL;
+    mcpwm_timer_sync_src_config_t timer_sync_config = {
+        .timer_event = MCPWM_TIMER_EVENT_EMPTY, // generate sync event on timer empty
+    };
+    ESP_ERROR_CHECK(mcpwm_new_timer_sync_src(timers[0], &timer_sync_config, &timer_sync_source));
+
+    ESP_LOGI(TAG, "Set other timers sync to the first timer");
+    mcpwm_timer_sync_phase_config_t sync_phase_config = {
+        .count_value = 0,
+        .direction = MCPWM_TIMER_DIRECTION_UP,
+        .sync_src = timer_sync_source,
+    };
+    for (int i = 1; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_timer_set_phase_on_sync(timers[i], &sync_phase_config));
+    }
+
+    ESP_LOGI(TAG, "Wait some time for the timer TEZ event");
+    vTaskDelay(pdMS_TO_TICKS(10));
+}
+#endif // CONFIG_EXAMPLE_SYNC_FROM_TEZ
+
+#if CONFIG_EXAMPLE_SYNC_FROM_SOFT
+static void example_setup_sync_strategy(mcpwm_timer_handle_t timers[])
+{
+    //       soft
+    //        |
+    //        v
+    //    +-timer0--+
+    //    |         |
+    //    v         v
+    // timer1    timer2
+    ESP_LOGI(TAG, "Create software sync source");
+    mcpwm_sync_handle_t soft_sync_source = NULL;
+    mcpwm_soft_sync_config_t soft_sync_config = {};
+    ESP_ERROR_CHECK(mcpwm_new_soft_sync_src(&soft_sync_config, &soft_sync_source));
+
+    ESP_LOGI(TAG, "Create timer sync source to propagate the sync event");
+    mcpwm_sync_handle_t timer_sync_source;
+    mcpwm_timer_sync_src_config_t timer_sync_config = {
+        .flags.propagate_input_sync = true,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_timer_sync_src(timers[0], &timer_sync_config, &timer_sync_source));
+
+    ESP_LOGI(TAG, "Set sync phase for timers");
+    mcpwm_timer_sync_phase_config_t sync_phase_config = {
+        .count_value = 0,
+        .direction = MCPWM_TIMER_DIRECTION_UP,
+        .sync_src = soft_sync_source,
+    };
+    ESP_ERROR_CHECK(mcpwm_timer_set_phase_on_sync(timers[0], &sync_phase_config));
+    sync_phase_config.sync_src = timer_sync_source;
+    for (int i = 1; i < 3; ++i) {
+        ESP_ERROR_CHECK(mcpwm_timer_set_phase_on_sync(timers[i], &sync_phase_config));
+    }
+
+    ESP_LOGI(TAG, "Trigger the software sync event");
+    ESP_ERROR_CHECK(mcpwm_soft_sync_activate(soft_sync_source));
+}
+#endif // CONFIG_EXAMPLE_SYNC_FROM_SOFT
+
+void app_main(void)
+{
+    ESP_LOGI(TAG, "Create timers");
+    mcpwm_timer_handle_t timers[3];
+    mcpwm_timer_config_t timer_config = {
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .group_id = 0,
+        .resolution_hz = EXAMPLE_TIMER_RESOLUTION_HZ,
+        .period_ticks = EXAMPLE_TIMER_PERIOD,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+    };
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_new_timer(&timer_config, &timers[i]));
+    }
+
+    ESP_LOGI(TAG, "Create operators");
+    mcpwm_oper_handle_t operators[3];
+    mcpwm_operator_config_t operator_config = {
+        .group_id = 0, // operator should be in the same group of the above timers
+    };
+    for (int i = 0; i < 3; ++i) {
+        ESP_ERROR_CHECK(mcpwm_new_operator(&operator_config, &operators[i]));
+    }
+
+    ESP_LOGI(TAG, "Connect timers and operators with each other");
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_operator_connect_timer(operators[i], timers[i]));
+    }
+
+    ESP_LOGI(TAG, "Create comparators");
+    mcpwm_cmpr_handle_t comparators[3];
+    mcpwm_comparator_config_t compare_config = {
+        .flags.update_cmp_on_tez = true,
+    };
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_new_comparator(operators[i], &compare_config, &comparators[i]));
+        // init compare for each comparator
+        ESP_ERROR_CHECK(mcpwm_comparator_set_compare_value(comparators[i], 200));
+    }
+
+    ESP_LOGI(TAG, "Create generators");
+    mcpwm_gen_handle_t generators[3];
+    const int gen_gpios[3] = {EXAMPLE_GEN_GPIO0, EXAMPLE_GEN_GPIO1, EXAMPLE_GEN_GPIO2};
+    mcpwm_generator_config_t gen_config = {};
+    for (int i = 0; i < 3; i++) {
+        gen_config.gen_gpio_num = gen_gpios[i];
+        ESP_ERROR_CHECK(mcpwm_new_generator(operators[i], &gen_config, &generators[i]));
+    }
+
+    ESP_LOGI(TAG, "Set generator actions on timer and compare event");
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(generators[i],
+                        // when the timer value is zero, and is counting up, set output to high
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(generators[i],
+                        // when compare event happens, and timer is counting up, set output to low
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, comparators[i], MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    }
+
+    ESP_LOGI(TAG, "Start timers one by one, so they are not synced");
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_timer_enable(timers[i]));
+        ESP_ERROR_CHECK(mcpwm_timer_start_stop(timers[i], MCPWM_TIMER_START_NO_STOP));
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+    vTaskDelay(pdMS_TO_TICKS(100));
+
+    // Manually added this "IDLE" phase, which can help us distinguish the wave forms before and after sync
+    ESP_LOGI(TAG, "Force the output level to low, timer still running");
+    for (int i = 0; i < 3; i++) {
+        ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generators[i], 0, true));
+    }
+
+    ESP_LOGI(TAG, "Setup sync strategy");
+    example_setup_sync_strategy(timers);
+
+    ESP_LOGI(TAG, "Now the output PWMs should in sync");
+    for (int i = 0; i < 3; ++i) {
+        // remove the force level on the generator, so that we can see the PWM again
+        ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generators[i], -1, true));
+    }
+    vTaskDelay(pdMS_TO_TICKS(100));
+}
diff --git a/examples/peripherals/mcpwm/mcpwm_sync/pytest_mcpwm_sync.py b/examples/peripherals/mcpwm/mcpwm_sync/pytest_mcpwm_sync.py
new file mode 100644
index 0000000000..3e130c6646
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_sync/pytest_mcpwm_sync.py
@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: CC0-1.0
+
+import pytest
+from pytest_embedded import Dut
+
+
+@pytest.mark.esp32
+@pytest.mark.esp32s3
+@pytest.mark.generic
+@pytest.mark.parametrize('config', [
+    pytest.param('gpio', marks=[pytest.mark.esp32, pytest.mark.esp32s3]),
+    pytest.param('tez', marks=[pytest.mark.esp32, pytest.mark.esp32s3]),
+    pytest.param('soft', marks=[pytest.mark.esp32s3]),
+], indirect=True)
+def test_mcpwm_sync_example(dut: Dut) -> None:
+    dut.expect_exact('example: Create timers')
+    dut.expect_exact('example: Create operators')
+    dut.expect_exact('example: Create comparators')
+    dut.expect_exact('example: Create generators')
+    dut.expect_exact('example: Set generator actions on timer and compare event')
+    dut.expect_exact('example: Start timers one by one, so they are not synced')
+    dut.expect_exact('example: Setup sync strategy')
+    dut.expect_exact('example: Now the output PWMs should in sync')
diff --git a/examples/peripherals/mcpwm/mcpwm_sync/sdkconfig.ci.gpio b/examples/peripherals/mcpwm/mcpwm_sync/sdkconfig.ci.gpio
new file mode 100644
index 0000000000..3e98959154
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_sync/sdkconfig.ci.gpio
@@ -0,0 +1 @@
+CONFIG_EXAMPLE_SYNC_FROM_GPIO=y
diff --git a/examples/peripherals/mcpwm/mcpwm_sync/sdkconfig.ci.soft b/examples/peripherals/mcpwm/mcpwm_sync/sdkconfig.ci.soft
new file mode 100644
index 0000000000..6e2b3b5e1a
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_sync/sdkconfig.ci.soft
@@ -0,0 +1 @@
+CONFIG_EXAMPLE_SYNC_FROM_SOFT=y
diff --git a/examples/peripherals/mcpwm/mcpwm_sync/sdkconfig.ci.tez b/examples/peripherals/mcpwm/mcpwm_sync/sdkconfig.ci.tez
new file mode 100644
index 0000000000..4e6ee21440
--- /dev/null
+++ b/examples/peripherals/mcpwm/mcpwm_sync/sdkconfig.ci.tez
@@ -0,0 +1 @@
+CONFIG_EXAMPLE_SYNC_FROM_TEZ=y
diff --git a/examples/peripherals/mcpwm/mcpwm_sync_example/README.md b/examples/peripherals/mcpwm/mcpwm_sync_example/README.md
deleted file mode 100644
index 761aaf9927..0000000000
--- a/examples/peripherals/mcpwm/mcpwm_sync_example/README.md
+++ /dev/null
@@ -1,74 +0,0 @@
-| Supported Targets | ESP32 | ESP32-S3 |
-| ----------------- | ----- | -------- |
-
-# MCPWM sync Example
-
-(See the README.md file in the upper level 'examples' directory for more information about examples.)
-
-This example aims to show howto sync those timers within the same MCPWM unit to produce fully synchronized output.
-
-The example will:
-
-- init MCPWM
-- sync all three timers with the help of one extra GPIO
-- mess the synchronized timers by stopping and restarting
-- sync all three timers with software sync event, no GPIO required. (Only targets with `SOC_MCPWM_SWSYNC_CAN_PROPAGATE` ability can support).
-- sync all three timers, but adding 10% delay between pulses from different channels
-
-## How to Use Example
-
-### Hardware Required
-
-* An ESP32/ESP32S3 development board
-
-It is recommended to have an oscilloscope or logic analyzer to verify the output pulse
-
-Connection :
-
-|     Pin     |        Func        |  Mode  |
-| :---------: | :----------------: | :----: |
-| GPIO_NUM_16 | MCPWM0.Timer0.GenA | Output |
-| GPIO_NUM_17 | MCPWM0.Timer1.GenA | Output |
-| GPIO_NUM_18 | MCPWM0.Timer2.GenA | Output |
-| GPIO_NUM_21 |     GPIO_SYNC0     | INPUT  |
-| GPIO_NUM_19 |   simulate input   | OUTPUT |
-
-GPIO_NUM_21 and GPIO_NUM_19 **SHOULD** be wired together to provide simulated input.
-
-Above pin selection can be changed within file `mcpwm_sync_example.c`.
-
-### Build and Flash
-
-Run `idf.py -p PORT flash monitor` to build, flash and monitor the project.
-
-(To exit the serial monitor, type ``Ctrl-]``.)
-
-See the [Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html) for full steps to configure and use ESP-IDF to build projects.
-
-## Example Output
-
-```
-I (306) sync_example: MCPWM sync example
-I (306) sync_example: PWM started, not synchronized
-I (3316) sync_example: Sync timers with GPIO approach
-I (3326) sync_example: Output should already be synchronized
-I (6326) sync_example: force synchronous lost
-I (9326) sync_example: Output should already be synchronized on esp32s3
-I (12336) sync_example: Each output pulse should be placed with 10 percents of period
-```
-
-Overall pulse graph:
-
-![](readme_res/overall.png)
-
-Sync:
-
-![](readme_res/synced.png)
-
-Sync with phase:
-
-![](readme_res/sync_phase.png)
-
-## Troubleshooting
-
-For any technical queries, please open an [issue] (https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you soon.
diff --git a/examples/peripherals/mcpwm/mcpwm_sync_example/main/CMakeLists.txt b/examples/peripherals/mcpwm/mcpwm_sync_example/main/CMakeLists.txt
deleted file mode 100644
index d4f23669d5..0000000000
--- a/examples/peripherals/mcpwm/mcpwm_sync_example/main/CMakeLists.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-idf_component_register(SRCS "mcpwm_sync_example.c"
-                    INCLUDE_DIRS ".")
diff --git a/examples/peripherals/mcpwm/mcpwm_sync_example/main/mcpwm_sync_example.c b/examples/peripherals/mcpwm/mcpwm_sync_example/main/mcpwm_sync_example.c
deleted file mode 100644
index bc7b6c30a1..0000000000
--- a/examples/peripherals/mcpwm/mcpwm_sync_example/main/mcpwm_sync_example.c
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * 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 "esp_log.h"
-#include "driver/mcpwm.h"
-#include "driver/gpio.h"
-
-const static char *TAG = "example";
-
-#define TARGET_MCPWM_UNIT MCPWM_UNIT_0
-#define TIMER0_OUTPUT_GPIO GPIO_NUM_16
-#define TIMER1_OUTPUT_GPIO GPIO_NUM_17
-#define TIMER2_OUTPUT_GPIO GPIO_NUM_18
-#define SIMU_GPIO_SYNC_SOURCE_GPIO GPIO_NUM_21
-#define SIMU_GPIO_SYNC_SIMULATE_GPIO GPIO_NUM_19
-
-void app_main(void) {
-    ESP_LOGI(TAG, "MCPWM sync example");
-
-    // init MCPWM: 10% duty cycle on all three timers in MCPWM unit 0 (currently not synchronous)
-    mcpwm_config_t pwm_config = {
-        .frequency = 1000,
-        .cmpr_a = 10,
-        .cmpr_b = 0,
-        .counter_mode = MCPWM_UP_COUNTER,
-        .duty_mode = MCPWM_DUTY_MODE_0,
-    };
-    ESP_ERROR_CHECK(mcpwm_init(TARGET_MCPWM_UNIT, MCPWM_TIMER_0, &pwm_config));
-    ESP_ERROR_CHECK(mcpwm_init(TARGET_MCPWM_UNIT, MCPWM_TIMER_1, &pwm_config));
-    ESP_ERROR_CHECK(mcpwm_init(TARGET_MCPWM_UNIT, MCPWM_TIMER_2, &pwm_config));
-
-    // bind output to GPIO
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM0A, TIMER0_OUTPUT_GPIO));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM1A, TIMER1_OUTPUT_GPIO));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM2A, TIMER2_OUTPUT_GPIO));
-    ESP_LOGI(TAG, "PWM started, not synchronized");
-
-    vTaskDelay(pdMS_TO_TICKS(1000));
-    // temporarily disable GPIO output, by binding to GenBs which have 0 output
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM0B, TIMER0_OUTPUT_GPIO));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM1B, TIMER1_OUTPUT_GPIO));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM2B, TIMER2_OUTPUT_GPIO));
-    vTaskDelay(pdMS_TO_TICKS(2000));
-
-    ESP_LOGI(TAG, "Sync timers with GPIO approach");
-    // first configure sync source
-    mcpwm_sync_config_t sync_conf = {
-        .sync_sig = MCPWM_SELECT_GPIO_SYNC0,
-        .timer_val = 0,
-        .count_direction = MCPWM_TIMER_DIRECTION_UP,
-    };
-    ESP_ERROR_CHECK(mcpwm_sync_configure(TARGET_MCPWM_UNIT, MCPWM_TIMER_0, &sync_conf));
-    ESP_ERROR_CHECK(mcpwm_sync_configure(TARGET_MCPWM_UNIT, MCPWM_TIMER_1, &sync_conf));
-    ESP_ERROR_CHECK(mcpwm_sync_configure(TARGET_MCPWM_UNIT, MCPWM_TIMER_2, &sync_conf));
-    // then configure GPIO
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM_SYNC_0, SIMU_GPIO_SYNC_SOURCE_GPIO));
-    gpio_config_t io_conf = {};
-    io_conf.intr_type = GPIO_INTR_DISABLE;
-    io_conf.mode = GPIO_MODE_OUTPUT;
-    io_conf.pin_bit_mask = BIT64(SIMU_GPIO_SYNC_SIMULATE_GPIO);
-    io_conf.pull_down_en = 0;
-    io_conf.pull_up_en = 0;
-    ESP_ERROR_CHECK(gpio_config(&io_conf));
-    ESP_ERROR_CHECK(gpio_set_level(SIMU_GPIO_SYNC_SIMULATE_GPIO, 0));
-    ESP_ERROR_CHECK(gpio_set_level(SIMU_GPIO_SYNC_SIMULATE_GPIO, 1));
-    // wait for at least one TEP
-    vTaskDelay(pdMS_TO_TICKS(10));
-    // re-enable GPIO output, to see the result
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM0A, TIMER0_OUTPUT_GPIO));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM1A, TIMER1_OUTPUT_GPIO));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM2A, TIMER2_OUTPUT_GPIO));
-    ESP_LOGI(TAG, "Output should already be synchronized");
-
-    vTaskDelay(pdMS_TO_TICKS(1000));
-
-    // stop and restart timers to mess them
-    ESP_ERROR_CHECK(mcpwm_stop(TARGET_MCPWM_UNIT, MCPWM_TIMER_2));
-    ESP_ERROR_CHECK(mcpwm_stop(TARGET_MCPWM_UNIT, MCPWM_TIMER_1));
-    ESP_ERROR_CHECK(mcpwm_stop(TARGET_MCPWM_UNIT, MCPWM_TIMER_0));
-    vTaskDelay(pdMS_TO_TICKS(2000));
-    ESP_ERROR_CHECK(mcpwm_start(TARGET_MCPWM_UNIT, MCPWM_TIMER_0));
-    ESP_ERROR_CHECK(mcpwm_start(TARGET_MCPWM_UNIT, MCPWM_TIMER_1));
-    ESP_ERROR_CHECK(mcpwm_start(TARGET_MCPWM_UNIT, MCPWM_TIMER_2));
-    ESP_LOGI(TAG, "force synchronous lost");
-
-    vTaskDelay(pdMS_TO_TICKS(1000));
-    // temporarily disable GPIO output, by binding to GenBs which have 0 output
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM0B, TIMER0_OUTPUT_GPIO));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM1B, TIMER1_OUTPUT_GPIO));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM2B, TIMER2_OUTPUT_GPIO));
-    vTaskDelay(pdMS_TO_TICKS(2000));
-
-#ifdef SOC_MCPWM_SWSYNC_CAN_PROPAGATE
-    // use the trick that only available on esp32s3
-    mcpwm_set_timer_sync_output(MCPWM_UNIT_0, MCPWM_TIMER_0, MCPWM_SWSYNC_SOURCE_SYNCIN);
-    sync_conf.sync_sig = MCPWM_SELECT_TIMER0_SYNC;
-    mcpwm_sync_configure(MCPWM_UNIT_0, MCPWM_TIMER_0, &sync_conf);
-    mcpwm_sync_configure(MCPWM_UNIT_0, MCPWM_TIMER_1, &sync_conf);
-    mcpwm_sync_configure(MCPWM_UNIT_0, MCPWM_TIMER_2, &sync_conf);
-    // then send soft sync event to timer0
-    mcpwm_timer_trigger_soft_sync(MCPWM_UNIT_0, MCPWM_TIMER_0);
-    // re-enable GPIO output
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM0A, TIMER0_OUTPUT_GPIO));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM1A, TIMER1_OUTPUT_GPIO));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM2A, TIMER2_OUTPUT_GPIO));
-    ESP_LOGI(TAG, "Output should already be synchronized on esp32s3");
-
-    vTaskDelay(pdMS_TO_TICKS(1000));
-#endif
-
-    // temporarily disable GPIO output, by binding to GenBs which have 0 output
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM0B, TIMER0_OUTPUT_GPIO));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM1B, TIMER1_OUTPUT_GPIO));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM2B, TIMER2_OUTPUT_GPIO));
-    vTaskDelay(pdMS_TO_TICKS(2000));
-    // create phase between each timer.
-    // for this case all timers has 10% of period phase between each other
-    sync_conf.sync_sig = MCPWM_SELECT_GPIO_SYNC0;
-    sync_conf.timer_val = 0;  // no phase applied
-    mcpwm_sync_configure(MCPWM_UNIT_0, MCPWM_TIMER_0, &sync_conf);
-    sync_conf.timer_val = 900;  // fill the counter with 90.0% of period will cause next pulse being delayed 10% period
-    mcpwm_sync_configure(MCPWM_UNIT_0, MCPWM_TIMER_1, &sync_conf);
-    sync_conf.timer_val = 800;  // fill the counter with 80.0% of period will cause next pulse being delayed 20% period
-    mcpwm_sync_configure(MCPWM_UNIT_0, MCPWM_TIMER_2, &sync_conf);
-    // trigger positive edge
-    ESP_ERROR_CHECK(gpio_set_level(SIMU_GPIO_SYNC_SIMULATE_GPIO, 0));
-    ESP_ERROR_CHECK(gpio_set_level(SIMU_GPIO_SYNC_SIMULATE_GPIO, 1));
-    // wait for at least one TEP
-    vTaskDelay(pdMS_TO_TICKS(10));
-    // re-enable GPIO output, to see the result
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM0A, TIMER0_OUTPUT_GPIO));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM1A, TIMER1_OUTPUT_GPIO));
-    ESP_ERROR_CHECK(mcpwm_gpio_init(TARGET_MCPWM_UNIT, MCPWM2A, TIMER2_OUTPUT_GPIO));
-    ESP_LOGI(TAG, "Each output pulse should be placed with 10 percents of period");
-
-    vTaskDelay(pdMS_TO_TICKS(1000));
-
-    ESP_ERROR_CHECK(mcpwm_stop(TARGET_MCPWM_UNIT, MCPWM_TIMER_2));
-    ESP_ERROR_CHECK(mcpwm_stop(TARGET_MCPWM_UNIT, MCPWM_TIMER_1));
-    ESP_ERROR_CHECK(mcpwm_stop(TARGET_MCPWM_UNIT, MCPWM_TIMER_0));
-}
diff --git a/examples/peripherals/mcpwm/mcpwm_sync_example/readme_res/overall.png b/examples/peripherals/mcpwm/mcpwm_sync_example/readme_res/overall.png
deleted file mode 100644
index 092cebd55edeb34b73c437927c3a6b226744059c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 35797
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%0D)XKzzUcaBs&cCoR*}bB&^5I$Y
z`%ij5y}G_WzO_*C`uh0uyX*Y?_>T3<pP%~ltoi*Tlhyrq{9PNp{TOJw*3?zPP8^C$
z8Vz$8HgDbfblT%bj|$%3v(*sUHS<LqGv^u4gh=6^pI5#5_4PHV<l3Hh_rhX#{y$$X
z``@v1cX!WY$??5<_s(y|U2Ud&r^i)wa<4wPN$1+y=<ugj(x*<GcrcAOT}{C0)HP5_
z+Lm=y>)x-wzrR;5{?pDY9rkvU&paE@eCLl>tJfRk-Ld%c@-q9~-R0)9RM+!s$IT4L
zZj<Hz_U)V7!?Lf&91L|kl!EqmYS}GG^H>_R<^2QZ1BajdJ95OO<c-nO`G1c+EL9QW
zWJ+)QzxmmR^Xv>pJ$<Yt$}jDIn#jy&V9;UQVz_$F{=eU(e<-e#meg6kP-o%7g$btp
z3nv|K6f`?#9v$o}7k>BogsD?oQ%~<dWR&N<y8d4{_kxsb&Y|yvFIHAft(3pIa<g8e
zPjsHGxw-gT>o03J)L5yWoV_$i^IFYL*6bYt6WUIu82$hG;pp+>$wy}YvUvIHNB>TS
zy2D)`?*G$t-gU9E<%%gcH+Rg=BG$05FbxfjhW>tj^Pt+3lT>GzW{WZ0?P!p*ttwbN
z<JtN7{Szh#FdXO-)!vYPUQQ=+6N}Tr39}c;N=S4(Jw5&NJN1cE&UkovdmrwRG_Lr)
z+<$)G&CTh>%1cDJSnK|N4PO(r_0$^qtqh<fac}y}KYwbzyuN-u<5pQ%nAoAihd<W;
z|6c#$+qY+}Z#B=qy}f;7=4G|K6z0PQ8JCuD{`>bkfAaD2S64XaT9-e&wlqkSjYr~u
zHb|Xe)t3xVJIOGUnVETG;bXVB<IJF?fpIpTo}K}#ue#k2t^4!Qo#DXU-Q~SSqA%U2
zPg`D+4(iNp+O%m^<gHJ>GmTjL`ucu6ogTmAy&o$pYe!$-u`4TscRpUTW=%jyNXXk=
z;os^S-ffQ!3!8Rv%{A-tcOQg!!jB(pX8-u{_%6ved3kvp+}wwEmA>Bb{uXG^_w}{4
zAAfvIzO%P_yW2a@6Z_}dl|;-o+ht}Qyzuas&i(&+6EAz6K53YDU0X}5skwO_@7XIp
zzfVnBTK@jtk2jmopV8|6x6{qV1+tPVsBPgj&`9ge&FPOH9qktAKAILg`_Jxx?Y^cJ
zm6f21ys)rP!aPr=%Q&2IjnsCz9}6M^%ax5d6pviGB*b(0z`=tL=lhw?HB3HMa5^k3
zY)@uq^6|c>)7W{XSPodEHzaOS3y#{7aWFbvf-NyIv7oq^`LIDu%zx;Jl4#$)>)NvK
z)HO6tyx^X+aL*o_IrjDY&iq)vY{{}u)`h&nC#R=b#0oJyJ3BjllTFY{5$&)w53aE?
zF|zT?<&@0?t);kRkhwK#@q4+bwPK#0o(u_}tk0aAYkhXtw!|BAZrq62{P}rksD}rK
zm`(&}EyUtI)m1vDmCVh>9lpMfyZQSicz5Ei)#2;cIraK>_w+nDdVZc^GTXY?-N#OU
z-d_4TjD?Nu+6`OIOb)4_8(S{<JY_Ms6L!}z>HWUndij4(OjMp>RjReC{5_w)zkl41
zsJ|!vo@$9Q=BZbketP1>iGk0a_uKzl5f*#mv-4cWs}CMOZg%{8Ct)#{^TFnW8s|D0
zlyiEXKJ0(BE2CwC_zbV5PE}PW*GzqRc{%e1-`Co<pAv3u$z&*zWp3mBySx0oS>@Xo
zFEaGX7RFUoSzWq(x$ytL+Br6rmtM&H6*pTOcKWpKhf~_?58S_he~p!-AA6{V$d1a-
z%OanLy8Zw6xAOJVRz_o;{-Bj6UP<X1YHDrfUip81e7vfm3QEvYU6(rb=iBLWMpym$
zQFza8TI%V)`w~wWY}*o{<92$Q?!|qz)r)V=Hg#PaR(!gwtgN8C+`Mb%|Ig>`KVMrN
z{C(9O{tHik8s|t%KK<16){KY{@amtBQrC_o8O}1vJj7j^Dbds{aLM5CvX@iku6+A+
zTEBQR6GQBd&95q+P7UAj^z-xc$tNeN?x^``#Kq11@b&BHyccrCPHQFG>?faoDq)nu
z0gCcZi}TABzRH)fg&bb&-oGHw_QF#ojjnbf+YL#@?tlKegnc~OA`sNgQ-9+{^0Z&S
zeo6V}Upb!q<>SYPy_+=tGW+Tq8VW94xNuJ{YNL`<0N$vaFRpB;p>bl(uNTWrm>%@*
zxb*wQ;{JkncPv#@R0`&Ei|frWP2E)Z_!tK#=fNqO!8>wwPCt5hxII*_U$NKi@b67o
zT8u`Z@Qkx@@0WYJR{B{+)rSX+>l^PBENG8=`6sI?`}(@0|Nj22RJLNg+jIWalVa`D
zr>1HvPW0$`xBP0>#F;ZY`R#r%%&+^UnIB*JDsJj;P<y%Uek;F>MZzY#t7ku(=iD%m
zu`21vK47xv+TQB#8)|=-P5!R>#C0jZY}l;C7aK0Ek}`W+8NDS#P`v#9ty@yr*Va6I
zYyO5~CD&mqv#cu}vn%f}a^+rJ{Ss6*9Xxn&&&&_M0<zoItXU%<DS2}3?wvb9YZv$I
zspL7lz<<8o4C`_|Ha?k%wYw%ff4=i6PezB|T&vdb>N!rHf2v;E%R6zb1f8gR@X5)^
zj4!0twK^%f^~s!kn;tohTR9~)we{j+_u}85K7Y>MqBGk(|5=)FN?MwdmR48y^Q;*Y
zR@k%|ruzCW{qp_0`{iZ6mABu#eQQ|u=7y0q3#dx?`T6<mJK-14FdzOjWnNfjS0aa^
zxA$qTe)SdsCy&GB&(FzLR8>vedH?$L?RP%&Iy*{fX=xq$^z?M^C!3d3%g-M<a-`_{
z>_w+{e~&)OF15n%?&>0Yhw0DH7koGkTeGtIYtN=ln*_wf+BR(1;5B{X1o4S>B{SOF
z+4E<Eg0j*@OW4fU{x)bB&wsuhsC~J!__@zHg;kl;rcDD4V@;enlQTU%{a*e->+*LJ
zt;Va@oSv><ynp51J$nkCo)SHgVzguD&Z(B#3Mwir>(;G{*pR@;#m%ia)hjVG^W^Nr
zrTkmV9vomiGt;<z_C=G-ODa9`_HsXe{!EZy`}XZyjML-n>+7aku9$E|-^92<z)5Ps
zZ1eo0#VitSj??vGcSJHY=v`bNx4-UhMPmNCxV=$}Q*Um|mCnCgU^4Yzx3epcd)ExF
zq%RK+GEaUUs`@antZZB0o1>?uEjKx=U;8z2mli0gp6FgsGS7Z*_VslOckI}~=k3N}
zcqQP_vYARETo<=w2H(qfS{l?Dxj8NL_pRt{IS>EpZr-}p_3^RZoqY|LjE^^*YK;ok
z5Sd|FthWBLlZw#6t5-$!^z`=J|J;^1$K$WtT*elGOAMJNQgJh8M{Z6lT$md%?P#a4
z`i|Pm%Y2<DtNHHu3h6&aOf&UblWnnSf60wSo1Q#*QgHg*xpQv6)6dLc1T_Pzsvhlr
zzt8yftf;kOSzD#Frg9xUdep<;|9Bg(^o8aA@*-klvts2APjFnu(duMjWmWV#GBPr4
zYCm}4S4e+<KmVUUe=e*DRL+w=y(wZ-il^+fE`gvZXU^Ga9jTEu-|v?1nUJV+8Z>8h
zxQ+Mm)s?GKJ-xjTOXu%tY-wSM^AqWHYd$?)U)j)b;_YSUJHu}VWP?`PZAd)4A^AAp
z;>eFWrx)$mAtA08b6`{IX{|bqC2<Q399sk~ImGTLV9dR>g>k`e#U<0{&h1S;-j@g(
zoNG8Y*ZT7^pX(_~TW1wLJtewM@7uR;8Q0cG%GuY&tj(_beAc|9qhrOTot&JUF_mxL
zyt%NavN*0t)!Dh7?`e`b)3L>IpbF5*<88&47lQe*def7CetMc(m#^G%rMFGUZ0(k>
zudjm!-$doY=YB}xm$!TJbpL9PP^Yz?;FVWWpjz)r<&wHZGeL3WAgQK&>9{9L!;T#m
zcXpTeOD{~Yn0wyfVs7Lsr88$iMb_*1+OMMP8~;{n$Ik1OHlNjV^2LJ(4gPjNTejzZ
ze|L9llo@E@hrpuZS64LizO7ikTzyyB+pgr}eOF62g1T*1&fvu0psK3+@e$*zzds)L
zGc@cje=qfRcg@eD*6X@=B_BL{7Isu<7O0#Ct+BthyX0k)b35O`+qY+z$4pl9y|6ZV
zdzAk9`1-%C`~Uswj(&e<r}4hu@2vGU3NdWSzc0tmC-dNF{GZR~?KOP_K#3b1La$g_
zIh9%_uz9V%s$^;^DkmqmCl}OMXfRGcw;*`A-=5;KcXu+cZA~?jG)K$oJ5roYb1yD(
zwJ3WdQ668LygO=bo72LE*4EZQqxj&til$Hhe!qWwqO$vrnWBGxe?R{7^K-??Cly4v
z5_5CUTJKvn$wd$xC{7$J>$ST6`g_zm7&CJyE@9M`oqx~3^Ww+H$18tFOmlT|YKpwx
z+tu}G+R-G#sBJl&-`?H^tzr(<%XS5|PeB8%6`!7P=I{1UX<EB>ZJ;~D=}mhAJWby|
zJlqbN9SG5Sy3LS>+1lEAabLrtMM^!A#%w=-{@fZS2en_Z)Ls7f{mYkyWv$EBynZB*
zBvi^K;N-zv_T@$3y{eKDlkI;V9Au7r?od^=>*CK}7kP9}f7-S_cDLB?@9*2amOjcA
z=V}%0YxD5*d^nA_-_$)TON)(Pu4lsr1DmQZCtm#0IlXAZ27!wgFMjy?_2{P5(-psq
zi;8wUy~O$SRM0)k?Rj^b*00w$%e~d|=TFVO;!D$0-{0E{>VyXc2cKQ14v#Aj-((vb
zn;TvH&>?aGr+<I{{Qdj!>-BhM1~L7(9FvMil^$MRO#vD%adC1rH8t~o|ILnaUhQA|
z`C4>-;-MDKjN99Eb8>SP1zsF0)tc(1qN<ws`Ptcy?(WBPAHRClWt@KQz@bA->i+YN
zEOPCBwde(CtB>R?(9RC<sQi;w1+ngrFPG0RdVP0S>FUWv9IZ|a4U;Da&%LvMS?G2<
zr-cGSoh(9~EaLicYfdgQ<w#6Sd~s<h_nWtGclI$je7|2jT`v|?E9*pTIPk(|q6f>u
zfR2gE?u)#q>z&_x0%V)!D;@=~T`dBioIowen3xy_hODhp@iiY^Wv8!5ywL8YBO7%o
z=GQqEhJxba)f0_ORhG_Qz4Ez?j7-nBx3`O5-@JMA#_n?c?fa^}zPhEYpx82@o)=;2
zr3Z#Q%?lPN<o&&{&^ciB)zXMXZOM=+ygh$HmOQKZbW+`-=7&KVq;v&k9a-x#7tl78
z9W#y7KV4H+Qd)2|i;+Qp{~x1UTeH94IpyO~`}FD4R?x)zi;IhQ6h3A%*Y;GJ81m!4
z;KG281q&2n_EZR-JbBW?&(AF>NvZ7Zt=91P+O5aVD=#q%IL81>g}ib9|NY&Vd)q8;
zZ}|GS6X(xAmwk-7)OJDl>3I_-G?c!+1{v+<<Kx>=^puN1L06Y|ciG!RZ*FdW`05oG
zLjcN(-H-2-CwlBi_4oJRl6ko;+XFN+1v(VRt^WI~tK9Z~zX&rtIMypY!z6Q3<kzyo
zLPrk|4!2$@R(E%I10LpHx8^NdOlm%#H3w((H`C+mI?eA@FgL8*tfHgSb2~jbxp~D3
zjV)PMxflebq`HLF{TMW?(;e_nUV)0gr>Cb+kNme~iwTdc)s;2blKbX=vRVH<X5Oq-
z=a+g<-?7O<Md;n%m$DWG4EOHcV`$i%em?2k9Lu!n6DPD~{Qma##r5^`Pu9lQd}IX`
zQAP6uG>%+b8+~zme*EO$TcdQFnwtfsrK6Rf3kF4Jq%lBq(F8Wo=GQw#VPVq(-485q
zYzAFZ0~+tmR$wbBy!rdf%jOd&JbwKCU3~lP+qXNPhOLcK)Y0L|%galUVB<M_;M6Iu
z<YPSt-`(9^nOLB8X;Z5AWZuw&2M^xaG=2K?$m?0x*U2tgyjV~|f<s+h-GGPL;kw0F
z#6*u~`5q6IN7F!yrY0)87roXFU-!g{iD5zZ^>uePt(?O+*Q(ShBt+!TpFaud>BsLz
zqpTumPCGkmYIM7pZq$rg-Qp|l-(!Nmf;Kbn+z`(2;mJwi#mV2^+&rv1{i=lLiEfws
zm0^*_>E}#-{h#2r_~A5GCdPgLeq~!&SX?<#*>Xh;IX{%Xzc)8}U(HXW{P~+V8-qp!
zvw5y(m;|g0xwFeb;lQu2uP^Q>OrCuGy7`N&tx@+@{0on(Y`wlC$15vK>)oB5hu7AB
zILPky)L5o)z5K*@xs4G$xwp4{lzI_4tu<)nlc}JU4KdFTAD6H1IdjG*@BS>)Y*2OG
zBWEkM*sb@`w&hEghR(=Oe0ZpJ!-fqHu9-^lc6D`CoZk|-*bOuy0Gii-zHIq&Wm{X>
z@9*y)KRH?b?7lG9SHEmuhi<j|{QUg!mzS4=mXRMh;*xV~OQ$wJ!=Dd_`Q4t+u`F(j
z-nL;w!|vU?BU4qDEbQv)I@HY0KVj0Orr6zOGpD|GQ4mPDx2N*XF0ZABK0G{paiKH2
zPSlo;+j*IpkXD_IQ<gBODgalN9GMqdoD|mw{+S+M_wX%02S>x!t)|=S-rO(*%?Zr4
zDt**?O0d&qkKnJiEm68oPEHS=K5hN?_qVgw)S}-!#iCQ5-p=3ubegS=O+{zPa-W%?
z<wMV_Uq*af2HJ+;JKOB(wa1ShJ$U=JH$1*p)VYnvv8>E&yT84)gW6<83yT@u#`%ef
zjqmsWpLhMk`moh!xdKyWoG~*q6O*+nahR?bdtqg;`j@x2#Xmngd-&Sg=!r9CbX>R)
zaBnBPLuc>g><kXN!_{nO>dlt+N*FTfMr~=>yVrKTG2?|+&^Z63i<Uos{+w|7>78AP
z%lQ=b7lB4{zg~|&-XW;Gq3EgC=5rsveQTRLS9bfptgBi}mMvpq=##halQz#Q_|22P
zF!Za9zP`R*f8$EOeb?jb=idH*Qhol1Z=l8hf`WoOs=jJXnmk!?qDR5+Z@Dpht3?0*
zzW*OIF17iUkCYx#np`lIkGt^WBiDPsIs}z>Jbm;i33NiponH%`+d*0<AD6ndr_$K`
zkgc(?aA08I9ngVtVG+k>%#aWf6DxZC>*5mde$5HD=gpdxCGzORlulvwqSLIbtQFty
zmM;v^Vq}n%l>G5xasLj`Iu4`lf1b~;PkMZ;_s%bG{k=!HmkW!Dwau9`hwFVjbTawS
z_3P8K51c!7>d;K%^n!<nTDjH-2hEiF%D})K<LTlUGWq%{{`WhrzFss}nssSMVe(==
zCfmdR<Ep;CN)40bR8(!_kvyckS?4tOe%6NX<p&NPY@EF@`08h#|7zdg+`PQPCU#fJ
z!)d&ScV12LFuha|n2so~)>eLgwx@J!)Y<6#OG`Mn*L-~yy7)8i;ZG9BCYYzpm?Oau
z6cn`M=_aX6-b@pzH~06?kDhOk$i%|LSoQrKZ+d!q-tX!0b&(IZGSnU3vUjhoc~{7P
zLz&7vi`NVc+w$&aeX=}q?AW6d6P45M+N-IxMVFPAAHTLX`s4HY^-7TCU3$hm{<(3h
z?e?TEc=eT&kFO2XdM$n3wqSvRike!{Z#Eu@fHdX#K5CDrt(MZCJ3)Nr!yLK8=WO=w
z*kN&Rm)&&t(DSQT&Ei_=CS`_*;ZIJ+J&ONdTvT5C_xwED$J2O|x4eFt{88G7=WNm|
znc#i@|5fYNZC$!l_1E|J=efg!V`9#9GlI&NoNI;4Ht1xV7{#u>`YBB~L<QT7+M1i3
zx!JFxzCN`L-)?6#ljr&Q`Nw~Jd|deYnr`0jGc%2~_iTS?tk5#!_=bu5R;)OYQSau)
zmVfu~;l)wULqmOALzH=?k+Z#*`5&%Ur+d2|`Y^h?yD$FC>ptcBvNLCV;*>vLTIzjq
zu{(d>-wzKDr^TNxP+1Y9=kDg_HgmrHzaP!z>)PAd?^VCIy=T_wknn8{i^KH<+tgDc
zd;WgAZBhTvCcngLLG~0g9``Rc>q6u275myrAD(!0*((-?ZQHipDay;s6ZP^r(S3G<
z@Y*kDj2z6F?oY6D_XUS1&v`c~y;nk@8Awp+bZNoVzQX(KVy#uw)r(*I&$oMe=#Yfj
zzSlp0|1Lhw)w*b!*UHV%?Y9kjar@;?Z;IHSH}~fClP69zG&eId#HJsZpy<3KlKtt%
zO`8sFzh9SqC6S3?-@bjI{mA-r0$ta|??0z{ZR_^!$D3HW4N6~yFzh;(ot>S%_~N&#
zJEyI@xV`G@OIzlv>-ib>d^)8qdhhs##*g>*R$tXHRMb~H-1g^E;#G#nd})90_ph24
z9%^W42+E0!Q(6=*XKe+w-a)0vT<h{rX$}*`h0ns<fR`44`p4}Detdjf`I|TSC};@g
z)02~Te$6mU25q9qv(?mGDdx>}<oI!AZSB(;zvo()S8%pz3rXVLYr4Jm=BCs=HO%gP
zGLBJEQrq_>9p&1Rd3o8P-~Ka=SPvdNSWsU6e4D6<h=P^XtnxWir%t{2BEsB!yH@;a
z8&IlRX18zOJ`R3<P+(N-RL;rG-I#EYiAT<6MtSe0IdkSD<mR4TJA3x$MuDJ1AMW!9
z*Qa|uUt0O$f#cS5t34tWPi7g}NN4UqZkFgPDl#5!<7H;xkuu?kuldNjJ^%bX+Zndi
zX4fM=-%OvcXksD)+SHjFv9l<3?ex;)eX<doQaJN(zq-0wyR?^?oiE|s9LpG^Tb`5E
z694@8c;ftd_QM7nwr_ua$Q`x|bAqC?0caLZ>ij(0!;@6KFRY8Tc5!ue)DUq}5O}cr
z{l3E;g3704FUkuEF@=YR>qKl|Xl-qs;I(wamMu?IH>5^R<BnFId~!#D*~X0<D}H^^
zOfix?H`ls-`@O2wLD#jsYb(!BtuzD8N9`zl%<w{pLwl;%1|9B=5jj^Bc4S}ITU;$!
zCYG@^>dubB#nZA}Jr1i*^my?4H8;Z^ztFvxc;EbT`@3phy2auHA&2WDI}dzSJOOGZ
zK6sE&^8VgjaWx<LrZwT~<J8Wp>$4&HBuft7-ki?A{mvp+?t2+8@7#&eiP<s1-0AMc
zix*ckRvhn>-D+pdzyO*hT^n|K?dhjQF}q4u23-$;4$L&hzz1ex+!+=~Z@jgmFgZ>_
zX>Hi)-Z}fLzw50p+>?5GTEwoB%$?uObIxqqyt#Sz?%jdR*UsDjKcnmJ>RNa@X`_U0
z^fs5@-`*M~AM5doU#$a4BmMIB&vM1Pk8aqq#Ux8%Pt{i~v)o%LCF>g+81jBTJluX&
z&stG`QSfrV!qZHR40m^zKYv^Q`K<ZQ)TKcu|NdR~suGls=Z0H-EWf@k_O$MLJC;b4
zIk#F4qfd_(A$1_`$=Clm*qW0d!Ir=Gt5|-0PL9s8KH2W<>+3#BJ&K$LniQU<6M0B_
zZob5%r6n_@89Y2a4J+3?{Fr+5!}g6EADVuXvnW__=-135#Fj?`ub|V&8y?TBkXs$L
z_K|Abz1`*de)H|lt}TCeXXl+?Yhrc^33awiKOu3U)Cjsc^8jd(OK$w`GTm?Q@8_57
z3D8*cW$UTWHusAowSworc#-ku-d^d-%E~>TUiH`i`l4y~??-an;{EeBZ#K3ndvjuK
zxEiC0;*ult>;IknE&c23_4va_kFqit6g}}Md3mYzcKOp&Q?urm|NmE;H#1QJv^lV0
zUGjsy-|szcEiw)XR=nzQ_*g|nMaUe-4)9o)fD^~h>9Y-!*$y2##J~`=QpC>A&W(4?
zSI3G93vsEo)X0*TmsmktoMN;-<%13&VPRuqx^Px+Wrm5NqJC4|-(QJ0H>GCW+M>x&
z_d{-J5a-sY-amh8-rU;CeS2H(<8Q32tcjpm@m+3<8)NjIPnyKMYyb7Sy1G4mS60m{
ze|APP&W~|t4Btc#mW>f-R{KNx=nM?g^<p2TNlq1ST2uS`+cP`8OAHs!z&nNdEq8a9
zD_dJjGdy_kpyA?T_v?k7UWf@OP@3(2?k~%@WK&FR?8k4n^NU}v4qLnG@Fjtu`aR!n
zWrLO<<>ch_Jo?dnH0j2T8=zwYW87!m`+mQ^|9<`dxzXZWt$WyN8E$M!<zDZ&-|Bho
z$D`tVZibnenYqa_F1;G!VR~r;QhP+a$!qDME>Z0rrH2K0OV1uZ&R$nn2ih{Sy*D*-
zvCE;B8Q${OUcBG`e_hcEO(!X-PM4%>g-e}RXPQWXCjM{iC|rDT-<~}-Ev>B&SFhh^
zw97B_ymjp_6DKF92{UJAmYn<c_V&)N>F4Jao;H;X>NSZGQG-X`%4F2N5`CZnw8WL*
z`fox2yv+oO>q`d$XDGnB*5DC^C5?*_d4)KUPygTEYy_S8eL$i9b#={BL55-@1~7P*
z0;U+woP^LbCPR+TH&AB=3nchKE}S?p2c(^Wp}`V*<I|`C48#Yb9^cLDjR)hLH9=wO
M>FVdQ&MBb@07G>+9{>OV

diff --git a/examples/peripherals/mcpwm/mcpwm_sync_example/readme_res/sync_phase.png b/examples/peripherals/mcpwm/mcpwm_sync_example/readme_res/sync_phase.png
deleted file mode 100644
index 47e8aedf7599dded297468acbb170776a1468dd6..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10151
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
b^Wr~ql<!BqQ;Rj`f_fsJu6{1-oD!M<U8@*i

diff --git a/examples/peripherals/mcpwm/mcpwm_sync_example/readme_res/synced.png b/examples/peripherals/mcpwm/mcpwm_sync_example/readme_res/synced.png
deleted file mode 100644
index 26a6cd68c22a48f731ae63d7b397ba29b5398166..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 16120
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%0A>sQlo@wTg3rNzbEe4Kv%{@&i+*7?ih6?LPx
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


From e4868548c7ffae5a349fd8c4bafafe4dfda2c450 Mon Sep 17 00:00:00 2001
From: morris <maoshengrong@espressif.com>
Date: Sat, 28 May 2022 17:07:17 +0800
Subject: [PATCH 8/8] doc: update MCPWM api reference with new driver API

---
 .../diagrams/mcpwm/deadtime_active_high.json  |  26 +
 .../deadtime_active_high_complementary.json   |  26 +
 .../diagrams/mcpwm/deadtime_active_low.json   |  26 +
 .../deadtime_active_low_complementary.json    |  26 +
 .../diagrams/mcpwm/deadtime_fedb_bypassa.json |  28 +
 .../diagrams/mcpwm/deadtime_reda_bypassb.json |  28 +
 .../mcpwm/deadtime_redb_fedb_bypassa.json     |  29 +
 .../mcpwm/dual_edge_asym_active_low.json      |  15 +
 .../mcpwm/dual_edge_sym_active_low.json       |  15 +
 .../mcpwm/dual_edge_sym_complementary.json    |  15 +
 .../diagrams/mcpwm/mcpwm_overview.diag        |  59 ++
 .../diagrams/mcpwm/pulse_placement_asym.json  |  15 +
 .../mcpwm/single_edge_asym_active_high.json   |  15 +
 .../mcpwm/single_edge_asym_active_low.json    |  15 +
 docs/_static/mcpwm-block-diagram.png          | Bin 56162 -> 0 bytes
 docs/_static/mcpwm-brushed-dc-control.png     | Bin 20746 -> 0 bytes
 docs/_static/mcpwm-overview.png               | Bin 18209 -> 0 bytes
 docs/doxygen/Doxyfile_esp32                   |   9 +-
 docs/doxygen/Doxyfile_esp32s3                 |   9 +-
 docs/en/api-reference/peripherals/mcpwm.rst   | 976 +++++++++++++++---
 .../release-5.x/peripherals.rst               |  63 +-
 .../zh_CN/api-reference/peripherals/mcpwm.rst |   2 +-
 22 files changed, 1233 insertions(+), 164 deletions(-)
 create mode 100644 docs/_static/diagrams/mcpwm/deadtime_active_high.json
 create mode 100644 docs/_static/diagrams/mcpwm/deadtime_active_high_complementary.json
 create mode 100644 docs/_static/diagrams/mcpwm/deadtime_active_low.json
 create mode 100644 docs/_static/diagrams/mcpwm/deadtime_active_low_complementary.json
 create mode 100644 docs/_static/diagrams/mcpwm/deadtime_fedb_bypassa.json
 create mode 100644 docs/_static/diagrams/mcpwm/deadtime_reda_bypassb.json
 create mode 100644 docs/_static/diagrams/mcpwm/deadtime_redb_fedb_bypassa.json
 create mode 100644 docs/_static/diagrams/mcpwm/dual_edge_asym_active_low.json
 create mode 100644 docs/_static/diagrams/mcpwm/dual_edge_sym_active_low.json
 create mode 100644 docs/_static/diagrams/mcpwm/dual_edge_sym_complementary.json
 create mode 100644 docs/_static/diagrams/mcpwm/mcpwm_overview.diag
 create mode 100644 docs/_static/diagrams/mcpwm/pulse_placement_asym.json
 create mode 100644 docs/_static/diagrams/mcpwm/single_edge_asym_active_high.json
 create mode 100644 docs/_static/diagrams/mcpwm/single_edge_asym_active_low.json
 delete mode 100644 docs/_static/mcpwm-block-diagram.png
 delete mode 100644 docs/_static/mcpwm-brushed-dc-control.png
 delete mode 100644 docs/_static/mcpwm-overview.png

diff --git a/docs/_static/diagrams/mcpwm/deadtime_active_high.json b/docs/_static/diagrams/mcpwm/deadtime_active_high.json
new file mode 100644
index 0000000000..8a396f18f5
--- /dev/null
+++ b/docs/_static/diagrams/mcpwm/deadtime_active_high.json
@@ -0,0 +1,26 @@
+{
+  "signal": [
+    {
+      "name": "origin",
+      "wave": "0...1.....0...",
+      "node": "....a.....b..."
+    },
+    {
+      "name": "pwm_A",
+      "wave": "0....1....0...",
+      "node": ".....c....."
+    },
+    {
+      "name": "pwm_B",
+      "wave": "0...1......0..",
+      "node": "...........d.."
+    }
+  ],
+  "edge": [
+    "a|->c RED",
+    "b|->d FED"
+  ],
+  "head": {
+    "text": "Active High"
+  }
+}
diff --git a/docs/_static/diagrams/mcpwm/deadtime_active_high_complementary.json b/docs/_static/diagrams/mcpwm/deadtime_active_high_complementary.json
new file mode 100644
index 0000000000..fa11d72590
--- /dev/null
+++ b/docs/_static/diagrams/mcpwm/deadtime_active_high_complementary.json
@@ -0,0 +1,26 @@
+{
+  "signal": [
+    {
+      "name": "origin",
+      "wave": "0...1.....0...",
+      "node": "....a.....b..."
+    },
+    {
+      "name": "pwm_A",
+      "wave": "0....1....0...",
+      "node": ".....c....."
+    },
+    {
+      "name": "pwm_B",
+      "wave": "1...0......1..",
+      "node": "...........d.."
+    }
+  ],
+  "edge": [
+    "a|->c RED",
+    "b|->d FED"
+  ],
+  "head": {
+    "text": "Active High, Complementary"
+  }
+}
diff --git a/docs/_static/diagrams/mcpwm/deadtime_active_low.json b/docs/_static/diagrams/mcpwm/deadtime_active_low.json
new file mode 100644
index 0000000000..b225dff2e0
--- /dev/null
+++ b/docs/_static/diagrams/mcpwm/deadtime_active_low.json
@@ -0,0 +1,26 @@
+{
+  "signal": [
+    {
+      "name": "origin",
+      "wave": "0...1.....0...",
+      "node": "....a.....b..."
+    },
+    {
+      "name": "pwm_A",
+      "wave": "1....0....1...",
+      "node": ".....c....."
+    },
+    {
+      "name": "pwm_B",
+      "wave": "1...0......1..",
+      "node": "...........d.."
+    }
+  ],
+  "edge": [
+    "a|->c RED",
+    "b|->d FED"
+  ],
+  "head": {
+    "text": "Active Low"
+  }
+}
diff --git a/docs/_static/diagrams/mcpwm/deadtime_active_low_complementary.json b/docs/_static/diagrams/mcpwm/deadtime_active_low_complementary.json
new file mode 100644
index 0000000000..eefd2b88ff
--- /dev/null
+++ b/docs/_static/diagrams/mcpwm/deadtime_active_low_complementary.json
@@ -0,0 +1,26 @@
+{
+  "signal": [
+    {
+      "name": "origin",
+      "wave": "0...1.....0...",
+      "node": "....a.....b..."
+    },
+    {
+      "name": "pwm_A",
+      "wave": "1....0....1...",
+      "node": ".....c....."
+    },
+    {
+      "name": "pwm_B",
+      "wave": "0...1......0..",
+      "node": "...........d.."
+    }
+  ],
+  "edge": [
+    "a|->c RED",
+    "b|->d FED"
+  ],
+  "head": {
+    "text": "Active Low, Complementary"
+  }
+}
diff --git a/docs/_static/diagrams/mcpwm/deadtime_fedb_bypassa.json b/docs/_static/diagrams/mcpwm/deadtime_fedb_bypassa.json
new file mode 100644
index 0000000000..d4fcfc0d8b
--- /dev/null
+++ b/docs/_static/diagrams/mcpwm/deadtime_fedb_bypassa.json
@@ -0,0 +1,28 @@
+{
+  "signal": [
+    {
+      "name": "origin_A",
+      "wave": "0...1.....0..."
+    },
+    {
+      "name": "origin_B",
+      "wave": "0...1.....0...",
+      "node": "..........a..."
+    },
+    {
+      "name": "pwm_A",
+      "wave": "0...1.....0..."
+    },
+    {
+      "name": "pwm_B",
+      "wave": "0...1......0..",
+      "node": "...........b..."
+    }
+  ],
+  "edge": [
+    "a|->b FED"
+  ],
+  "head": {
+    "text": "FED on B, Bypass A"
+  }
+}
diff --git a/docs/_static/diagrams/mcpwm/deadtime_reda_bypassb.json b/docs/_static/diagrams/mcpwm/deadtime_reda_bypassb.json
new file mode 100644
index 0000000000..f65f031223
--- /dev/null
+++ b/docs/_static/diagrams/mcpwm/deadtime_reda_bypassb.json
@@ -0,0 +1,28 @@
+{
+  "signal": [
+    {
+      "name": "origin_A",
+      "wave": "0...1.....0...",
+      "node": "....a........."
+    },
+    {
+      "name": "origin_B",
+      "wave": "0...1.....0..."
+    },
+    {
+      "name": "pwm_A",
+      "wave": "0....1....0...",
+      "node": ".....b....."
+    },
+    {
+      "name": "pwm_B",
+      "wave": "0...1.....0..."
+    }
+  ],
+  "edge": [
+    "a|->b RED"
+  ],
+  "head": {
+    "text": "RED on A, Bypass B"
+  }
+}
diff --git a/docs/_static/diagrams/mcpwm/deadtime_redb_fedb_bypassa.json b/docs/_static/diagrams/mcpwm/deadtime_redb_fedb_bypassa.json
new file mode 100644
index 0000000000..936978185a
--- /dev/null
+++ b/docs/_static/diagrams/mcpwm/deadtime_redb_fedb_bypassa.json
@@ -0,0 +1,29 @@
+{
+  "signal": [
+    {
+      "name": "origin_A",
+      "wave": "0...1.....0..."
+    },
+    {
+      "name": "origin_B",
+      "wave": "0...1.....0...",
+      "node": "....a.....b..."
+    },
+    {
+      "name": "pwm_A",
+      "wave": "0...1.....0..."
+    },
+    {
+      "name": "pwm_B",
+      "wave": "0....1.....0..",
+      "node": ".....c.....d..."
+    }
+  ],
+  "edge": [
+    "a|->c RED",
+    "b|->d FED"
+  ],
+  "head": {
+    "text": "Bypass A, RED + FED on B"
+  }
+}
diff --git a/docs/_static/diagrams/mcpwm/dual_edge_asym_active_low.json b/docs/_static/diagrams/mcpwm/dual_edge_asym_active_low.json
new file mode 100644
index 0000000000..b5981ef7b3
--- /dev/null
+++ b/docs/_static/diagrams/mcpwm/dual_edge_asym_active_low.json
@@ -0,0 +1,15 @@
+{
+  "signal": [
+    {
+      "name": "pwm_A",
+      "wave": "01..0..1..0."
+    },
+    {
+      "name": "pwm_B",
+      "wave": "0..1..0..1.."
+    }
+  ],
+  "head": {
+    "text": "Dual Edge Asymmetric Waveform, Active Low"
+  }
+}
diff --git a/docs/_static/diagrams/mcpwm/dual_edge_sym_active_low.json b/docs/_static/diagrams/mcpwm/dual_edge_sym_active_low.json
new file mode 100644
index 0000000000..680b3295bf
--- /dev/null
+++ b/docs/_static/diagrams/mcpwm/dual_edge_sym_active_low.json
@@ -0,0 +1,15 @@
+{
+  "signal": [
+    {
+      "name": "pwm_A",
+      "wave": "0.1..0...1..0.."
+    },
+    {
+      "name": "pwm_B",
+      "wave": "0..10.....10..."
+    }
+  ],
+  "head": {
+    "text": "Dual Edge Symmetric Waveform, Active Low"
+  }
+}
diff --git a/docs/_static/diagrams/mcpwm/dual_edge_sym_complementary.json b/docs/_static/diagrams/mcpwm/dual_edge_sym_complementary.json
new file mode 100644
index 0000000000..44b27470ab
--- /dev/null
+++ b/docs/_static/diagrams/mcpwm/dual_edge_sym_complementary.json
@@ -0,0 +1,15 @@
+{
+  "signal": [
+    {
+      "name": "pwm_A",
+      "wave": "01..0...1..0"
+    },
+    {
+      "name": "pwm_B",
+      "wave": "1.01.....01."
+    }
+  ],
+  "head": {
+    "text": "Dual Edge Symmetric Waveform, Complementary"
+  }
+}
diff --git a/docs/_static/diagrams/mcpwm/mcpwm_overview.diag b/docs/_static/diagrams/mcpwm/mcpwm_overview.diag
new file mode 100644
index 0000000000..ea3a6debb4
--- /dev/null
+++ b/docs/_static/diagrams/mcpwm/mcpwm_overview.diag
@@ -0,0 +1,59 @@
+blockdiag mcpwm_overview {
+    default_fontsize = 18;
+    node_width = 130;
+    node_height = 100;
+    default_group_color = lightgrey;
+
+    mcpwm_timers [label = "MCPWM\nTimer", stacked];
+    timer_sync [label = "Timer Sync", stacked];
+    timer_sync <-> mcpwm_timers;
+
+    mcpwm_capture_timer [label = "MCPWM\nCapture Timer"];
+    mcpwm_capture_channels [label = "MCPWM\nCapture Chan", stacked];
+    mcpwm_capture_gpio [label = "Cap\nGPIO", shape = minidiamond];
+    mcpwm_capture_timer -> mcpwm_capture_channels;
+    mcpwm_capture_channels <- mcpwm_capture_gpio;
+
+    timer_sync -> mcpwm_capture_timer;
+    gpio_sync [label = "Sync\nGPIO", shape = minidiamond];
+    gpio_sync -> mcpwm_timers;
+    gpio_sync -> mcpwm_capture_timer;
+
+    mcpwm_compares [label = "MCPWM\nComparators", stacked];
+    mcpwm_generators [label = "MCPWM\nGenerators", stacked];
+    mcpwm_dead_time [label = "Dead Time"];
+    mcpwm_carrier [label = "Carrier\nModulation"];
+    mcpwm_brake [label = "Brake"];
+    pwma [label = "PWM_A", shape = minidiamond];
+    pwmb [label = "PWM_B", shape = minidiamond];
+    stub [shape = none];
+    mcpwm_timers -> mcpwm_generators;
+    mcpwm_timers -> mcpwm_compares;
+    mcpwm_compares -> mcpwm_generators [folded];
+    mcpwm_generators -> mcpwm_dead_time;
+    mcpwm_dead_time -> mcpwm_carrier;
+    mcpwm_carrier -> mcpwm_brake;
+    mcpwm_brake -> stub;
+    stub -> pwma, pwmb;
+    mcpwm_generators -> mcpwm_carrier;
+    mcpwm_generators -> mcpwm_brake;
+    mcpwm_generators -> stub;
+
+    gpio_faults [label = "Fault\nGPIO", shape = minidiamond];
+    mcpwm_brake <- gpio_faults [folded];
+
+    group {
+        label = "MCPWM Operators";
+        mcpwm_compares, mcpwm_generators, mcpwm_dead_time, mcpwm_carrier, mcpwm_brake;
+    }
+
+    group {
+        label = "MCPWM Capture";
+        mcpwm_capture_timer, mcpwm_capture_channels, mcpwm_capture_gpio;
+    }
+
+    group {
+        label = "MCPWM Sync";
+        gpio_sync, timer_sync;
+    }
+}
diff --git a/docs/_static/diagrams/mcpwm/pulse_placement_asym.json b/docs/_static/diagrams/mcpwm/pulse_placement_asym.json
new file mode 100644
index 0000000000..ae0097d351
--- /dev/null
+++ b/docs/_static/diagrams/mcpwm/pulse_placement_asym.json
@@ -0,0 +1,15 @@
+{
+  "signal": [
+    {
+      "name": "pwm_A",
+      "wave": "0.1..0..1..0..1..0..1..0.."
+    },
+    {
+      "name": "pwm_B",
+      "wave": "01.....0.....1.....0.....1"
+    }
+  ],
+  "head": {
+    "text": "Pulse Placement Asymmetric Waveform"
+  }
+}
diff --git a/docs/_static/diagrams/mcpwm/single_edge_asym_active_high.json b/docs/_static/diagrams/mcpwm/single_edge_asym_active_high.json
new file mode 100644
index 0000000000..f7b4bd6446
--- /dev/null
+++ b/docs/_static/diagrams/mcpwm/single_edge_asym_active_high.json
@@ -0,0 +1,15 @@
+{
+  "signal": [
+    {
+      "name": "pwm_A",
+      "wave": "01....0..1....0..1"
+    },
+    {
+      "name": "pwm_B",
+      "wave": "01..0....1..0....1"
+    }
+  ],
+  "head": {
+    "text": "Single Edge Asymmetric Waveform, Active High"
+  }
+}
diff --git a/docs/_static/diagrams/mcpwm/single_edge_asym_active_low.json b/docs/_static/diagrams/mcpwm/single_edge_asym_active_low.json
new file mode 100644
index 0000000000..68386ffd9f
--- /dev/null
+++ b/docs/_static/diagrams/mcpwm/single_edge_asym_active_low.json
@@ -0,0 +1,15 @@
+{
+  "signal": [
+    {
+      "name": "pwm_A",
+      "wave": "10....1..0....1..0"
+    },
+    {
+      "name": "pwm_B",
+      "wave": "10..1....0..1....0"
+    }
+  ],
+  "head": {
+    "text": "Single Edge Asymmetric Waveform, Active Low"
+  }
+}
diff --git a/docs/_static/mcpwm-block-diagram.png b/docs/_static/mcpwm-block-diagram.png
deleted file mode 100644
index 97620c29da0b34496de769660834f53ae44ccd18..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 56162
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
K=d#Wzp$P!Y38}sS

diff --git a/docs/_static/mcpwm-brushed-dc-control.png b/docs/_static/mcpwm-brushed-dc-control.png
deleted file mode 100644
index f8cec6fff82c917e001d403539cb53d309f5cd58..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 20746
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

diff --git a/docs/_static/mcpwm-overview.png b/docs/_static/mcpwm-overview.png
deleted file mode 100644
index 6d3204466a5dedc1f5202756332e1998eaa237ac..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 18209
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

diff --git a/docs/doxygen/Doxyfile_esp32 b/docs/doxygen/Doxyfile_esp32
index 960010f85d..43644961e8 100644
--- a/docs/doxygen/Doxyfile_esp32
+++ b/docs/doxygen/Doxyfile_esp32
@@ -5,7 +5,14 @@ INPUT += \
          $(PROJECT_PATH)/components/driver/include/driver/i2s_pdm.h \
          $(PROJECT_PATH)/components/driver/include/driver/i2s_std.h \
          $(PROJECT_PATH)/components/driver/include/driver/i2s_types.h \
-         $(PROJECT_PATH)/components/driver/include/driver/mcpwm.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_cap.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_cmpr.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_fault.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_gen.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_oper.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_sync.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_timer.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_types.h \
          $(PROJECT_PATH)/components/driver/include/driver/pulse_cnt.h \
          $(PROJECT_PATH)/components/driver/include/driver/rmt_common.h \
          $(PROJECT_PATH)/components/driver/include/driver/rmt_encoder.h \
diff --git a/docs/doxygen/Doxyfile_esp32s3 b/docs/doxygen/Doxyfile_esp32s3
index 7b9a67d7aa..4c247aaffa 100644
--- a/docs/doxygen/Doxyfile_esp32s3
+++ b/docs/doxygen/Doxyfile_esp32s3
@@ -5,7 +5,14 @@ INPUT += \
          $(PROJECT_PATH)/components/driver/include/driver/i2s_std.h \
          $(PROJECT_PATH)/components/driver/include/driver/i2s_tdm.h \
          $(PROJECT_PATH)/components/driver/include/driver/i2s_types.h \
-         $(PROJECT_PATH)/components/driver/include/driver/mcpwm.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_cap.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_cmpr.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_fault.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_gen.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_oper.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_sync.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_timer.h \
+         $(PROJECT_PATH)/components/driver/include/driver/mcpwm_types.h \
          $(PROJECT_PATH)/components/driver/include/driver/pulse_cnt.h \
          $(PROJECT_PATH)/components/driver/include/driver/rmt_common.h \
          $(PROJECT_PATH)/components/driver/include/driver/rmt_encoder.h \
diff --git a/docs/en/api-reference/peripherals/mcpwm.rst b/docs/en/api-reference/peripherals/mcpwm.rst
index d07f3b32d9..6166899582 100644
--- a/docs/en/api-reference/peripherals/mcpwm.rst
+++ b/docs/en/api-reference/peripherals/mcpwm.rst
@@ -1,238 +1,902 @@
 Motor Control Pulse Width Modulator (MCPWM)
 ===========================================
 
-{IDF_TARGET_NAME} has two MCPWM units which can be used to control different types of motors. Each unit has three pairs of PWM outputs.
+The MCPWM peripheral is a versatile PWM generator, which contains various submodules to make it a key element in power electronic applications like motor control, digital power and so on. Typically, the MCPWM peripheral can be used in the following scenarios:
 
-.. figure:: ../../../_static/mcpwm-overview.png
+- Digital motor control, e.g. brushed/brushless DC motor, RC servo motor
+- Switch mode based digital power conversion
+- Power DAC, where the duty cycle is equivalent to a DAC analog value
+- Calculate external pulse width, and convert it into other analog value like speed, distance
+- Generate Space Vector PWM (SVPWM) signals for Field Oriented Control (FOC)
+
+The main submodules are listed in the following diagram:
+
+.. blockdiag:: /../_static/diagrams/mcpwm/mcpwm_overview.diag
+    :caption: MCPWM Overview
     :align: center
-    :alt: MCPWM Overview
-    :figclass: align-center
 
-    MCPWM Overview
+- **MCPWM Timer**: The time base of the final PWM signal, it also determines the event timing of other submodules.
+- **MCPWM Operator**: The key module that is responsible for generating the PWM waveforms. It consists of other submodules, like comparator, PWM generator, dead-time and carrier modulator.
+- **MCPWM Comparator**: The compare module takes the time-base count value as input, and continuously compare to the threshold value that configured by user. When the time-base counter is equal to any of the threshold value, an compare event will be generated and the MCPWM generator can update its level accordingly.
+- **MCPWM Generator**: One MCPWM generator can generate a pair of PWM waves, complementarily or independently, based on various events triggered from other submodules like MCPWM Timer, MCPWM Comparator.
+- **MCPWM Fault**: The fault module is used to detect the fault condition from outside, mainly via GPIO matrix. Once the fault signal is active, MCPWM Operator will force all the generators into a predefined state, to protect the system from damage.
+- **MCPWM Sync**: The sync module is used to synchronize the MCPWM timers, so that the final PWM signals generated by different MCPWM generators can have a fixed phase difference. The sync signal can be routed from GPIO matrix or from MCPWM Timer event.
+- **Dead Time**: This submodule is used to insert extra delay to the existing PWM edges that generated in the previous steps.
+- **Carrier Modulation**: The carrier submodule allows a high-frequency carrier signal to modulate the PWM waveforms generated by the generator and dead time submodules. This capability is mandatory if you need pulse transformer-based gate drivers to control the power switching elements.
+- **Brake**: MCPWM operator can set how to brake the generators when particular fault is detected. We can shut down the PWM output immediately or regulate the PWM output cycle by cycle, depends on how critical the fault is.
+- **MCPWM Capture**: This is a standalone submodule which can work even without the above MCPWM operators. The capture consists one dedicated timer and several independent channels. Each channel is connected to the GPIO, a pulse on the GPIO will trigger the capture timer to store the time-base count value and then notify the user by interrupt. Using this feature, we can measure a pulse width precisely. What's more, the capture timer can also be synchronized by the MCPWM Sync submodule.
 
-Further in documentation the outputs of a single unit are labeled ``PWMxA`` / ``PWMxB``.
+Functional Overview
+-------------------
 
-More detailed block diagram of the MCPWM unit is shown below. Each A/B pair may be clocked by any one of the three timers Timer 0, 1 and 2. The same timer may be used to clock more than one pair of PWM outputs. Each unit is also able to collect inputs such as ``SYNC SIGNALS``, detect ``FAULT SIGNALS`` like motor overcurrent or overvoltage, as well as obtain feedback with ``CAPTURE SIGNALS`` on e.g. a rotor position.
+Description of the MCPWM functionality is divided into the following sections:
 
-.. _mcpwm_block_diagram:
+-  `Resource Allocation and Initialization <#resource-allocation-and-initialization>`__ - covers how to allocate various MCPWM objects, like timers, operators, comparators, generators and so on. These objects are the basis of the following IO setting and control functions.
+-  `Timer Operations and Events <#timer-operations-and-events>`__ - describes control functions and event callbacks that supported by the MCPWM timer.
+-  `Comparator Operations and Events <comparator-operations-and-events>`__ - describes control functions and event callbacks that supported by the MCPWM comparator.
+-  `Generator Actions on Events <#generator-actions-on-events>`__ - describes how to set actions for MCPWM generators on particular events that generated by the MCPWM timer and comparators.
+-  `Classical PWM Waveforms and Generator Configurations <#classical-pwm-waveforms-and-generator-configurations>`__ - demonstrates some classical PWM waveforms that can be achieved by configuring generator actions.
+-  `Dead Time <#dead-time>`__ - describes how to set dead time for MCPWM generators.
+-  `Classical PWM Waveforms and Dead Time Configurations <#classical-pwm-waveforms-and-dead-time-configurations>`__ - demonstrates some classical PWM waveforms that can be achieved by configuring dead time.
+-  `Carrier Modulation <#carrier-modulation>`__ - describes how to set modulate a high frequency onto the final PWM waveforms.
+-  `Faults and Brake Actions <#faults-and-brake-actions>`__ - describes how to set brake actions for MCPWM operators on particular fault event.
+-  `Generator Force Actions <#generator-force-actions>`__ - describes how to control the generator output level asynchronously in a forceful way.
+-  `Synchronization <#synchronization>`__ - describes how to synchronize the MCPWM timers and get a fixed phase difference between the generated PWM signals.
+-  `Capture <#capture>`__ - describes how to use the MCPWM capture module to measure the pulse width of a signal.
+-  `Power Management <#power-management>`__ - describes how different source clock will affect power consumption.
+-  `IRAM Safe <#iram-safe>`__ - describes tips on how to make the RMT interrupt work better along with a disabled cache.
+-  `Thread Safety <#thread-safety>`__ - lists which APIs are guaranteed to be thread safe by the driver.
+-  `Kconfig Options <#kconfig-options>`__ - lists the supported Kconfig options that can bring different effects to the driver.
 
-.. figure:: ../../../_static/mcpwm-block-diagram.png
-    :align: center
-    :alt: MCPWM Block Diagram
-    :figclass: align-center
+Resource Allocation and Initialization
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-    MCPWM Block Diagram
+As displayed in the diagram above, the MCPWM peripheral consists of several submodules. Each submodule has its own resource allocation, which is described in the following sections.
 
-Description of this API starts with configuration of MCPWM's **Timer** and **Generator** submodules to provide the basic motor control functionality. Then it discusses more advanced submodules and functionalities of a **Fault Handler**, signal **Capture** and **Carrier**.
+MCPWM Timers
+~~~~~~~~~~~~
 
-Contents
---------
+You can allocate a MCPWM timer object by calling :cpp:func:`mcpwm_new_timer` function, with a configuration structure :cpp:type:`mcpwm_timer_config_t` as the parameter. The configuration structure is defined as:
 
-* `Configure`_ a basic functionality of the outputs
-* `Operate`_ the outputs to drive a motor
-* `Adjust`_ how the motor is driven
-* `Synchronize`_ sync timers to work together
-* `Capture`_ external signals to provide additional control over the outputs
-* Use `Fault Handler`_ to detect and manage faults
-* Add a higher frequency `Carrier`_, if output signals are passed through an isolation transformer
-* Extra configuration of `Resolution`_.
+- :cpp:member:`mcpwm_timer_config_t::group_id` specifies the MCPWM group ID. The ID should belong to [0, :c:macro:`SOC_MCPWM_GROUPS` - 1] range. Please note, timers located in different groups are totally independent.
+- :cpp:member:`mcpwm_timer_config_t::clk_src` sets the clock source of the timer.
+- :cpp:member:`mcpwm_timer_config_t::resolution_hz` set the expected resolution of the timer, the driver internally will set a proper divider based on the clock source and the resolution.
+- :cpp:member:`mcpwm_timer_config_t::count_mode` sets the count mode of the timer.
+- :cpp:member:`mcpwm_timer_config_t::period_ticks` sets the period of the timer, in ticks (the tick resolution is set in the :cpp:member:`mcpwm_timer_config_t::resolution_hz`).
+- :cpp:member:`mcpwm_timer_config_t::update_period_on_empty` sets whether to update the period value when the timer counts to zero.
+- :cpp:member:`mcpwm_timer_config_t::update_period_on_sync` sets whether to update the period value when the timer takes a sync signal.
+
+The :cpp:func:`mcpwm_new_timer` will return a pointer to the allocated timer object if the allocation succeeds. Otherwise, it will return error code. Specifically, when there are no more free timers in the MCPWM group, this function will return :c:macro:`ESP_ERR_NOT_FOUND` error. [1]_
+
+On the contrary, calling :cpp:func:`mcpwm_del_timer` function will free the allocated timer object.
+
+MCPWM Operators
+~~~~~~~~~~~~~~~
+
+You can allocate a MCPWM operator object by calling :cpp:func:`mcpwm_new_operator` function, with a configuration structure :cpp:type:`mcpwm_operator_config_t` as the parameter. The configuration structure is defined as:
+
+- :cpp:member:`mcpwm_operator_config_t::group_id` specifies the MCPWM group ID. The ID should belong to [0, :c:macro:`SOC_MCPWM_GROUPS` - 1] range. Please note, operators located in different groups are totally independent.
+- :cpp:member:`mcpwm_operator_config_t::update_gen_action_on_tez` sets whether to update the generator action when the timer counts to zero. Here and below, the timer refers to the one that is connected to the operator by :cpp:func:`mcpwm_operator_connect_timer`.
+- :cpp:member:`mcpwm_operator_config_t::update_gen_action_on_tep` sets whether to update the generator action when the timer counts to peak.
+- :cpp:member:`mcpwm_operator_config_t::update_gen_action_on_sync` sets whether to update the generator action when the timer takes a sync signal.
+- :cpp:member:`mcpwm_operator_config_t::update_dead_time_on_tez` sets whether to update the dead time when the timer counts to zero.
+- :cpp:member:`mcpwm_operator_config_t::update_dead_time_on_tep` sets whether to update the dead time when the timer counts to peak.
+- :cpp:member:`mcpwm_operator_config_t::update_dead_time_on_sync` sets whether to update the dead time when the timer takes a sync signal.
+
+The :cpp:func:`mcpwm_new_operator` will return a pointer to the allocated operator object if the allocation succeeds. Otherwise, it will return error code. Specifically, when there are no more free operators in the MCPWM group, this function will return :c:macro:`ESP_ERR_NOT_FOUND` error. [1]_
+
+On the contrary, calling :cpp:func:`mcpwm_del_operator` function will free the allocated operator object.
+
+MCPWM Comparators
+~~~~~~~~~~~~~~~~~
+
+You can allocate a MCPWM comparator object by calling :cpp:func:`mcpwm_new_comparator` function, with a MCPWM operator handle and configuration structure :cpp:type:`mcpwm_comparator_config_t` as the parameter. The operator handle is created by :cpp:func:`mcpwm_new_operator`. The configuration structure is defined as:
+
+- :cpp:member:`mcpwm_comparator_config_t::update_cmp_on_tez` sets whether to update the compare threshold when the timer counts to zero.
+- :cpp:member:`mcpwm_comparator_config_t::update_cmp_on_tep` sets whether to update the compare threshold when the timer counts to peak.
+- :cpp:member:`mcpwm_comparator_config_t::update_cmp_on_sync` sets whether to update the compare threshold when the timer takes a sync signal.
+
+The :cpp:func:`mcpwm_new_comparator` will return a pointer to the allocated comparator object if the allocation succeeds. Otherwise, it will return error code. Specifically, when there are no more free comparators in the MCPWM operator, this function will return :c:macro:`ESP_ERR_NOT_FOUND` error. [1]_
+
+On the contrary, calling :cpp:func:`mcpwm_del_comparator` function will free the allocated comparator object.
+
+MCPWM Generators
+~~~~~~~~~~~~~~~~
+
+You can allocate a MCPWM generator object by calling :cpp:func:`mcpwm_new_generator` function, with a MCPWM operator handle and configuration structure :cpp:type:`mcpwm_generator_config_t` as the parameter. The operator handle is created by :cpp:func:`mcpwm_new_operator`. The configuration structure is defined as:
+
+- :cpp:member:`mcpwm_generator_config_t::gen_gpio_num` sets the GPIO number used by the generator.
+- :cpp:member:`mcpwm_generator_config_t::invert_pwm` sets whether to invert the PWM signal.
+- :cpp:member:`mcpwm_generator_config_t::io_loop_back` sets whether to enable the loop back mode. It is for debugging purposes only. It enables both the GPIO's input and output ability through the GPIO matrix peripheral.
+
+The :cpp:func:`mcpwm_new_generator` will return a pointer to the allocated generator object if the allocation succeeds. Otherwise, it will return error code. Specifically, when there are no more free generators in the MCPWM operator, this function will return :c:macro:`ESP_ERR_NOT_FOUND` error. [1]_
+
+On the contrary, calling :cpp:func:`mcpwm_del_generator` function will free the allocated generator object.
+
+MCPWM Faults
+~~~~~~~~~~~~
+
+There are two types of faults: A fault signal reflected from the GPIO and a fault generated by software. To allocate a GPIO fault object, you can call :cpp:func:`mcpwm_new_gpio_fault` function, with configuration structure :cpp:type:`mcpwm_gpio_fault_config_t` as the parameter. The configuration structure is defined as:
+
+- :cpp:member:`mcpwm_gpio_fault_config_t::group_id` sets the MCPWM group ID. The ID should belong to [0, :c:macro:`SOC_MCPWM_GROUPS` - 1] range. Please note, GPIO fault located in different groups are totally independent, i.e. GPIO fault in group 0 can not be detected by the operator in group 1.
+- :cpp:member:`mcpwm_gpio_fault_config_t::gpio_num` sets the GPIO number used by the fault.
+- :cpp:member:`mcpwm_gpio_fault_config_t::active_level` sets the active level of the fault signal.
+- :cpp:member:`mcpwm_gpio_fault_config_t::pull_up` and :cpp:member:`mcpwm_gpio_fault_config_t::pull_down` set whether to pull up and/or pull down the GPIO internally.
+- :cpp:member:`mcpwm_gpio_fault_config_t::io_loop_back` sets whether to enable the loop back mode. It is for debugging purposes only. It enables both the GPIO's input and output ability through the GPIO matrix peripheral.
+
+The :cpp:func:`mcpwm_new_gpio_fault` will return a pointer to the allocated fault object if the allocation succeeds. Otherwise, it will return error code. Specifically, when there are no more free GPIO faults in the MCPWM group, this function will return :c:macro:`ESP_ERR_NOT_FOUND` error. [1]_
+
+Software fault object can be used to trigger a fault by calling a function :cpp:func:`mcpwm_soft_fault_activate` instead of waiting for a real fault signal on the GPIO. A software fault object can be allocated by calling :cpp:func:`mcpwm_new_soft_fault` function, with configuration structure :cpp:type:`mcpwm_soft_fault_config_t` as the parameter. Currently this configuration structure is left for future purpose. :cpp:func:`mcpwm_new_soft_fault` function will return a pointer to the allocated fault object if the allocation succeeds. Otherwise, it will return error code. Specifically, when there are no memory left for the fault object, this function will return :c:macro:`ESP_ERR_NO_MEM` error. Although the software fault and GPIO fault are of different types, but the returned fault handle is of the same type.
+
+On the contrary, calling :cpp:func:`mcpwm_del_fault` function will free the allocated fault object, this function works for both software and GPIO fault.
+
+MCPWM Sync Sources
+~~~~~~~~~~~~~~~~~~
+
+The sync source is what can be used to synchronize the MCPWM timer and MCPWM capture timer. There're three types of sync sources: A sync source reflected from the GPIO, a sync source generated by software and a sync source generated by MCPWM timer event.
+
+To allocate a GPIO sync source, you can call :cpp:func:`mcpwm_new_gpio_sync_src` function, with configuration structure :cpp:type:`mcpwm_gpio_sync_src_config_t` as the parameter. The configuration structure is defined as:
+
+- :cpp:member:`mcpwm_gpio_sync_src_config_t::group_id` sets the MCPWM group ID. The ID should belong to [0, :c:macro:`SOC_MCPWM_GROUPS` - 1] range. Please note, GPIO sync source located in different groups are totally independent, i.e. GPIO sync source in group 0 can not be detected by the timers in group 1.
+- :cpp:member:`mcpwm_gpio_sync_src_config_t::gpio_num` sets the GPIO number used by the sync source.
+- :cpp:member:`mcpwm_gpio_sync_src_config_t::active_neg` sets whether the sync signal is active on falling edge.
+- :cpp:member:`mcpwm_gpio_sync_src_config_t::pull_up` and :cpp:member:`mcpwm_gpio_sync_src_config_t::pull_down` set whether to pull up and/or pull down the GPIO internally.
+- :cpp:member:`mcpwm_gpio_sync_src_config_t::io_loop_back` sets whether to enable the loop back mode. It is for debugging purposes only. It enables both the GPIO's input and output ability through the GPIO matrix peripheral.
+
+The :cpp:func:`mcpwm_new_gpio_sync_src` will return a pointer to the allocated sync source object if the allocation succeeds. Otherwise, it will return error code. Specifically, when there are no more free GPIO sync sources in the MCPWM group, this function will return :c:macro:`ESP_ERR_NOT_FOUND` error. [1]_
+
+To allocate a Timer event sync source, you can call :cpp:func:`mcpwm_new_timer_sync_src` function, with configuration structure :cpp:type:`mcpwm_timer_sync_src_config_t` as the parameter. The configuration structure is defined as:
+
+- :cpp:member:`mcpwm_timer_sync_src_config_t::timer_event` specifies on what timer event to generate the sync signal.
+- :cpp:member:`mcpwm_timer_sync_src_config_t::propagate_input_sync` sets whether to propagate the input sync signal (i.e. the input sync signal will be routed to its sync output).
+
+The :cpp:func:`mcpwm_new_timer_sync_src` will return a pointer to the allocated sync source object if the allocation succeeds. Otherwise, it will return error code. Specifically, if a sync source has been allocated from the same timer before, this function will return :c:macro:`ESP_ERR_INVALID_STATE` error.
+
+Last but not least, to allocate a software sync source, you can call :cpp:func:`mcpwm_new_soft_sync_src` function, with configuration structure :cpp:type:`mcpwm_soft_sync_config_t` as the parameter. Currently this configuration structure is left for future purpose. :cpp:func:`mcpwm_new_soft_sync_src` will return a pointer to the allocated sync source object if the allocation succeeds. Otherwise, it will return error code. Specifically, when there are no memory left for the sync source object, this function will return :c:macro:`ESP_ERR_NO_MEM` error. Please note, to make a software sync source take effect, don't forget to call :cpp:func:`mcpwm_soft_sync_activate`.
+
+On the contrary, calling :cpp:func:`mcpwm_del_sync_src` function will free the allocated sync source object, this function works for all types of sync sources.
+
+MCPWM Capture Timer and Channels
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The MCPWM group has a dedicated timer which is used to capture the timestamp when specific event occurred. The capture timer is connected with several independent channels, each channel is assigned with a GPIO.
+
+To allocate a capture timer, you can call :cpp:func:`mcpwm_new_capture_timer` function, with configuration structure :cpp:type:`mcpwm_capture_timer_config_t` as the parameter. The configuration structure is defined as:
+
+- :cpp:member:`mcpwm_capture_timer_config_t::group_id` sets the MCPWM group ID. The ID should belong to [0, :c:macro:`SOC_MCPWM_GROUPS` - 1] range.
+- :cpp:member:`mcpwm_capture_timer_config_t::clk_src` sets the clock source of the capture timer.
+
+The :cpp:func:`mcpwm_new_capture_timer` will return a pointer to the allocated capture timer object if the allocation succeeds. Otherwise, it will return error code. Specifically, when there are no free capture timer left in the MCPWM group, this function will return :c:macro:`ESP_ERR_NOT_FOUND` error. [1]_
+
+Next, to allocate a capture channel, you can call :cpp:func:`mcpwm_new_capture_channel` function, with a capture timer handle and configuration structure :cpp:type:`mcpwm_capture_channel_config_t` as the parameter. The configuration structure is defined as:
+
+- :cpp:member:`mcpwm_capture_channel_config_t::gpio_num` sets the GPIO number used by the capture channel.
+- :cpp:member:`mcpwm_capture_channel_config_t::prescale` sets the prescaler of the input signal.
+- :cpp:member:`mcpwm_capture_channel_config_t::pos_edge` and :cpp:member:`mcpwm_capture_channel_config_t::neg_edge` set whether to capture on the positive and/or negative edge of the input signal.
+- :cpp:member:`mcpwm_capture_channel_config_t::pull_up` and :cpp:member:`mcpwm_capture_channel_config_t::pull_down` set whether to pull up and/or pull down the GPIO internally.
+- :cpp:member:`mcpwm_capture_channel_config_t::invert_cap_signal` sets whether to invert the capture signal.
+- :cpp:member:`mcpwm_capture_channel_config_t::io_loop_back` sets whether to enable the loop back mode. It is for debugging purposes only. It enables both the GPIO's input and output ability through the GPIO matrix peripheral.
+
+The :cpp:func:`mcpwm_new_capture_channel` will return a pointer to the allocated capture channel object if the allocation succeeds. Otherwise, it will return error code. Specifically, when there are no free capture channel left in the capture timer, this function will return :c:macro:`ESP_ERR_NOT_FOUND` error.
+
+On the contrary, calling :cpp:func:`mcpwm_del_capture_channel` and :cpp:func:`mcpwm_del_capture_timer` function will free the allocated capture channel and timer object accordingly.
+
+Timer Operations and Events
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Register Event Callbacks
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+The MCPWM timer can generate different events at runtime. If you have some function that should be called when particular event happens, you should hook your function to the interrupt service routine by calling :cpp:func:`mcpwm_timer_register_event_callbacks`. The callback function prototype is declared in :cpp:type:`mcpwm_timer_event_cb_t`. All supported event callbacks are listed in the :cpp:type:`mcpwm_timer_event_callbacks_t`:
+
+- :cpp:member:`mcpwm_timer_event_callbacks_t::on_full` sets callback function for timer when it counts to peak value.
+- :cpp:member:`mcpwm_timer_event_callbacks_t::on_empty` sets callback function for timer when it counts to zero.
+- :cpp:member:`mcpwm_timer_event_callbacks_t::on_stop` sets callback function for timer when it is stopped.
+
+The callback functions above are called within the ISR context, so they should **not** attempt to block (e.g., make sure that only FreeRTOS APIs with ``ISR`` suffix is called within the function).
+
+The parameter ``user_data`` of :cpp:func:`mcpwm_timer_register_event_callbacks` function is used to save user's own context, it will be passed to each callback function directly.
+
+This function will lazy install interrupt service for the MCPWM timer without enabling it. It is only allowed to be called before before :cpp:func:`mcpwm_timer_enable`, otherwise the :c:macro:`ESP_ERR_INVALID_STATE` error will be returned. See also `Enable and Disable timer <#enable-and-disable-timer>`__ for more information.
+
+Enable and Disable Timer
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+Before doing IO control to the timer, user needs to enable the timer first, by calling :cpp:func:`mcpwm_timer_enable`. Internally, this function will:
+
+* switch the timer state from **init** to **enable**.
+* enable the interrupt service if it has been lazy installed by :cpp:func:`mcpwm_timer_register_event_callbacks`.
+* acquire a proper power management lock if a specific clock source (e.g. PLL_160M clock) is selected. See also `Power management <#power-management>`__ for more information.
+
+On the contrary, calling :cpp:func:`mcpwm_timer_disable` will put the timer driver back to **init** state, disable the interrupts service and release the power management lock.
+
+Start and Stop Timer
+~~~~~~~~~~~~~~~~~~~~
+
+The basic IO operation of a timer is to start and stop. Calling :cpp:func:`mcpwm_timer_start_stop` with different :cpp:type:`mcpwm_timer_start_stop_cmd_t` commands can start the timer immediately or stop the timer at a specific event. What're more, you can even start the timer for only one round, that means, the timer will count to peak value or zero, and then stop itself.
+
+Connect Timer with Operator
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The allocated MCPWM Timer should be connected with a MCPWM operator by calling :cpp:func:`mcpwm_operator_connect_timer`, so that the operator can take that timer as its time base, and generate the required PWM waves. Make sure the MCPWM timer and operator are in the same group, otherwise, this function will return :c:macro:`ESP_ERR_INVALID_ARG` error.
+
+Comparator Operations and Events
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Register Event Callbacks
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+The MCPWM comparator can inform the user when the timer counter equals to the compare value. If you have some function that should be called when this event happens, you should hook your function to the interrupt service routine by calling :cpp:func:`mcpwm_comparator_register_event_callbacks`. The callback function prototype is declared in :cpp:type:`mcpwm_compare_event_cb_t`. All supported event callbacks are listed in the :cpp:type:`mcpwm_comparator_event_callbacks_t`:
+
+- :cpp:member:`mcpwm_comparator_event_callbacks_t::on_reach` sets callback function for comparator when the timer counter equals to the compare value.
+
+The callback function will provide event specific data of type :cpp:type:`mcpwm_compare_event_data_t` to the user. The callback function is called within the ISR context, so is should **not** attempt to block (e.g., make sure that only FreeRTOS APIs with ``ISR`` suffix is called within the function).
+
+The parameter ``user_data`` of :cpp:func:`mcpwm_comparator_register_event_callbacks` function is used to save user's own context, it will be passed to the callback function directly.
+
+This function will lazy install interrupt service for the MCPWM comparator, whereas the service can only be removed in :cpp:type:`mcpwm_del_comparator`.
+
+Set Compare Value
+~~~~~~~~~~~~~~~~~
+
+You can set the compare value for the MCPWM comparator at runtime by calling :cpp:func:`mcpwm_comparator_set_compare_value`. There're a few points to note:
+
+- New compare value might won't take effect immediately. The update time for the compare value is set by :cpp:member:`mcpwm_comparator_config_t::update_cmp_on_tez` or :cpp:member:`mcpwm_comparator_config_t::update_cmp_on_tep` or :cpp:member:`mcpwm_comparator_config_t::update_cmp_on_sync`.
+- Make sure the operator has connected to one MCPWM timer already by :cpp:func:`mcpwm_operator_connect_timer`. Otherwise, it will return error code :c:macro:`ESP_ERR_INVALID_STATE`.
+- The compare value shouldn't exceed timer's count peak, otherwise, the compare event will never got triggered.
+
+Generator Actions on Events
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Set Generator Action on Timer Event
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+One generator can set multiple actions on different timer events, by calling :cpp:func:`mcpwm_generator_set_actions_on_timer_event` with variable number of action configurations. The action configuration is defined in :cpp:type:`mcpwm_gen_timer_event_action_t`:
+
+- :cpp:member:`mcpwm_gen_timer_event_action_t::direction` specific the timer direction. The supported directions are listed in :cpp:type:`mcpwm_timer_direction_t`.
+- :cpp:member:`mcpwm_gen_timer_event_action_t::event` specifies the timer event. The supported timer events are listed in :cpp:type:`mcpwm_timer_event_t`.
+- :cpp:member:`mcpwm_gen_timer_event_action_t::action` specifies the generator action to be taken. The supported actions are listed in :cpp:type:`mcpwm_generator_action_t`.
+
+There's a helper macro :c:macro:`MCPWM_GEN_TIMER_EVENT_ACTION` to simplify the construction of a timer event action entry.
+
+Please note, the argument list of :cpp:func:`mcpwm_generator_set_actions_on_timer_event` **must** be terminated by :c:macro:`MCPWM_GEN_TIMER_EVENT_ACTION_END`.
+
+Set Generator Action on Compare Event
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+One generator can set multiple actions on different compare events, by calling :cpp:func:`mcpwm_generator_set_actions_on_compare_event` with variable number of action configurations. The action configuration is defined in :cpp:type:`mcpwm_gen_compare_event_action_t`:
+
+- :cpp:member:`mcpwm_gen_compare_event_action_t::direction` specific the timer direction. The supported directions are listed in :cpp:type:`mcpwm_timer_direction_t`.
+- :cpp:member:`mcpwm_gen_compare_event_action_t::comparator` specifies the comparator handle. See `MCPWM Comparators <#mcpwm-comparators>`__ for how to allocate a comparator.
+- :cpp:member:`mcpwm_gen_compare_event_action_t::action` specifies the generator action to be taken. The supported actions are listed in :cpp:type:`mcpwm_generator_action_t`.
+
+There's a helper macro :c:macro:`MCPWM_GEN_COMPARE_EVENT_ACTION` to simplify the construction of a compare event action entry.
+
+Please note, the argument list of :cpp:func:`mcpwm_generator_set_actions_on_compare_event` **must** be terminated by :c:macro:`MCPWM_GEN_COMPARE_EVENT_ACTION_END`.
+
+Classical PWM Waveforms and Generator Configurations
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This section will demonstrate the classical PWM waveforms that can be generated by the pair of the generators. The code snippet that is used to generate the waveforms is also provided below the diagram. Some general summary:
+
+- The **Symmetric** or **Asymmetric** of the waveforms are determined by the count mode of the MCPWM timer.
+- The **active level** of the waveform pair is determined by the level of the PWM with a smaller duty cycle.
+- The period of the PWM waveform is determined by the timer's period and count mode.
+- The duty cycle of the PWM waveform is determined by the generator's various action combinations.
+
+Asymmetric Single Edge Active High
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. wavedrom:: /../_static/diagrams/mcpwm/single_edge_asym_active_high.json
+
+.. code:: c
+
+    static void gen_action_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+    {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(gena,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(gena,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(genb,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(genb,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    }
+
+Asymmetric Single Edge Active Low
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. wavedrom:: /../_static/diagrams/mcpwm/single_edge_asym_active_low.json
+
+.. code:: c
+
+    static void gen_action_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+    {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(gena,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_FULL, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(gena,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(genb,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_FULL, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(genb,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    }
+
+Asymmetric Pulse Placement
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. wavedrom:: /../_static/diagrams/mcpwm/pulse_placement_asym.json
+
+.. code:: c
+
+    static void gen_action_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+    {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(gena,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(genb,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_TOGGLE),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    }
+
+Asymmetric Dual Edge Active Low
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. wavedrom:: /../_static/diagrams/mcpwm/dual_edge_asym_active_low.json
+
+.. code:: c
+
+    static void gen_action_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+    {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(gena,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, cmpb, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(genb,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_FULL, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+    }
+
+Symmetric Dual Edge Active Low
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. wavedrom:: /../_static/diagrams/mcpwm/dual_edge_sym_active_low.json
+
+.. code:: c
+
+    static void gen_action_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+    {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(gena,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, cmpa, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(genb,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, cmpb, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    }
+
+Symmetric Dual Edge Complementary
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. wavedrom:: /../_static/diagrams/mcpwm/dual_edge_sym_complementary.json
+
+.. code:: c
+
+    static void gen_action_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+    {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(gena,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, cmpa, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(genb,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, cmpb, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    }
 
 
-Configure
----------
+Dead Time
+^^^^^^^^^
 
-The scope of configuration depends on the motor type, in particular how many outputs and inputs are required, and what will be the sequence of signals to drive the motor.
+In power electronics, the rectifier and inverter are commonly used. This requires the use of rectifier bridge and inverter bridge. Each bridge arm has two power electronic devices, such as MOSFET, IGBT, etc. The two MOSFETs on the same arm can't conduct at the same time, otherwise there will be a short circuit. The fact is that, although the PWM wave shows it is turning off the switch, but the MOSFET still needs a small time window to make that happen. This requires an extra delay to be added to the existing PWM wave that generated by setting `Generator Actions on Events <#generator-actions-on-events>`__.
 
-In this case we will describe a simple configuration to control a brushed DC motor that is using only some of the available MCPWM's resources. An example circuit is shown below. It includes a `H-Bridge <https://en.wikipedia.org/wiki/H_bridge>`_ to switch polarization of a voltage applied to the motor (M) and to provide sufficient current to drive it.
+The dead-time driver works like a *decorator*, which is also reflected in the function parameters of :cpp:func:`mcpwm_generator_set_dead_time`, where it takes the primary generator handle (``in_generator``), and returns a generator (``out_generator``) after applying the dead-time. Please note, if the ``out_generator`` and ``in_generator`` are the same, it means we're adding the time delay to the PWM waveform in a "in-place" fashion. In turn, if the ``out_generator`` and ``in_generator`` are different, it means we're deriving a new PWM waveform from the existing ``in_generator``.
 
-.. figure:: ../../../_static/mcpwm-brushed-dc-control.png
-    :align: center
-    :alt: Example of Brushed DC Motor Control with MCPWM
-    :figclass: align-center
+Dead-time specific configuration is listed in the :cpp:type:`mcpwm_dead_time_config_t` structure:
 
-    Example of Brushed DC Motor Control with MCPWM
-
-Configuration covers the following steps:
-
-1. Selection of a MCPWM unit that will be used to drive the motor. There are two units available on-board of {IDF_TARGET_NAME} and enumerated in :cpp:type:`mcpwm_unit_t`.
-2. Initialization of two GPIOs as output signals within selected unit by calling :cpp:func:`mcpwm_gpio_init`. The two output signals are typically used to command the motor to rotate right or left. All available signal options are listed in :cpp:type:`mcpwm_io_signals_t`. To set more than a single pin at a time, use function :cpp:func:`mcpwm_set_pin` together with :cpp:type:`mcpwm_pin_config_t`.
-3. Selection of a timer. There are three timers available within the unit. The timers are listed in :cpp:type:`mcpwm_timer_t`.
-4. Setting of the timer frequency and initial duty within :cpp:type:`mcpwm_config_t` structure.
-5. Setting timer resolution if necessary, by calling :cpp:func:`mcpwm_group_set_resolution` and :cpp:func:`mcpwm_timer_set_resolution`
-6. Calling of :cpp:func:`mcpwm_init` with the above parameters to make the configuration effective.
-
-
-Operate
--------
-
-To operate a motor connected to the MCPWM unit, e.g. turn it left or right, or vary the speed, we should apply some control signals to the unit's outputs. The outputs are organized into three pairs. Within a pair they are labeled "A" and "B" and each driven by a submodule called an "Generator". To provide a PWM signal, the Operator itself, which contains two Generator, should be clocked by one of three available Timers. To make the API simpler, each Timer is automatically associated by the API to drive an Operator of the same index, e.g. Timer 0 is associated with Operator 0.
-
-There are the following basic ways to control the outputs:
-
-* We can drive particular signal steady high or steady low with function :cpp:func:`mcpwm_set_signal_high` or :cpp:func:`mcpwm_set_signal_low`. This will make the motor to turn with a maximum speed or stop. Depending on selected output A or B the motor will rotate either right or left.
-* Another option is to drive the outputs with the PWM signal by calling :cpp:func:`mcpwm_start` or :cpp:func:`mcpwm_stop`. The motor speed will be proportional to the PWM duty.
-* To vary PWM's duty call :cpp:func:`mcpwm_set_duty` and provide the duty value in %. Optionally, you may call :cpp:func:`mcpwm_set_duty_in_us`, if you prefer to set the duty in microseconds. Checking of currently set value is possible by calling :cpp:func:`mcpwm_get_duty`. Phase of the PWM signal may be altered by calling :cpp:func:`mcpwm_set_duty_type`. The duty is set individually for each A and B output using :cpp:type:`mcpwm_generator_t` in specific function calls. The duty value refers either to high or low output signal duration. This is configured when calling :cpp:func:`mcpwm_init`, as discussed in section `Configure`_, and selecting one of options from :cpp:type:`mcpwm_duty_type_t`.
+- :cpp:member:`mcpwm_dead_time_config_t::posedge_delay_ticks` and :cpp:member:`mcpwm_dead_time_config_t::negedge_delay_ticks` set the number of ticks to delay the PWM waveform on the rising and falling edge. Specifically, setting both of them to zero means to bypass the dead-time module. The resolution of the dead-time tick is the same to the timer that is connected with the operator by :cpp:func:`mcpwm_operator_connect_timer`.
+- :cpp:member:`mcpwm_dead_time_config_t::invert_output`: Whether to invert the signal after applying the dead-time, which can be used to control the delay edge polarity.
 
 .. note::
 
-    Call function :cpp:func:`mcpwm_set_duty_type` every time after :cpp:func:`mcpwm_set_signal_high` or :cpp:func:`mcpwm_set_signal_low` to resume with previously set duty cycle.
+    It is also possible to generate the required dead time by setting `Generator Actions on Events <#generator-actions-on-events>`__, especially by controlling edge placement using different comparators. However, if the more classical edge delay-based dead time with polarity control is required, then the dead-time submodule should be used.
 
+Classical PWM Waveforms and Dead Time Configurations
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Adjust
-------
+This section will demonstrate the classical PWM waveforms that can be generated by the dead-time submodule. The code snippet that is used to generate the waveforms is also provided below the diagram.
 
-There are couple of ways to adjust a signal on the outputs and changing how the motor operates.
+Active High Complementary
+~~~~~~~~~~~~~~~~~~~~~~~~~
 
-* Set specific PWM frequency by calling :cpp:func:`mcpwm_set_frequency`. This may be required to adjust to electrical or mechanical characteristics of particular motor and driver. To check what frequency is set, use function :cpp:func:`mcpwm_get_frequency`.
-* Introduce a dead time between outputs A and B when they are changing the state to reverse direction of the motor rotation. This is to make up for on/off switching delay of the motor driver FETs. The dead time options are defined in :cpp:type:`mcpwm_deadtime_type_t` and enabled by calling :cpp:func:`mcpwm_deadtime_enable`. To disable this functionality call :cpp:func:`mcpwm_deadtime_disable`.
-* Synchronize outputs of operator submodules, e.g. to get raising edge of PWM0A/B and PWM1A/B to start exactly at the same time, or shift them between each other by a given phase. Synchronization is triggered by ``SYNC SIGNALS`` shown on the :ref:`block diagram <mcpwm_block_diagram>` of the MCPWM above, and defined in :cpp:type:`mcpwm_sync_signal_t`. To attach the signal to a GPIO call :cpp:func:`mcpwm_gpio_init`. You can then enable synchronization with function :cpp:func:`mcpwm_sync_configure`. As input parameters provide MCPWM unit, timer to synchronize, the synchronization signal and a phase to delay the timer.
+.. wavedrom:: /../_static/diagrams/mcpwm/deadtime_active_high_complementary.json
 
-.. note::
+.. code:: c
 
-    Synchronization signals are referred to using two different enumerations. First one :cpp:type:`mcpwm_io_signals_t` is used together with function :cpp:func:`mcpwm_gpio_init` when selecting a GPIO as the signal input source. The second one :cpp:type:`mcpwm_sync_signal_t` is used when enabling or disabling synchronization with :cpp:func:`mcpwm_sync_configure` or :cpp:func:`mcpwm_sync_disable`.
+    static void gen_action_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+    {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(gena,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(gena,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    }
 
-
-* Vary the pattern of the A/B output signals by getting MCPWM counters to count up, down and up/down (automatically changing the count direction). Respective configuration is done when calling :cpp:func:`mcpwm_init`, as discussed in section `Configure`_, and selecting one of counter types from :cpp:type:`mcpwm_counter_type_t`. For explanation of how A/B PWM output signals are generated, see *{IDF_TARGET_NAME} Technical Reference Manual* > *Motor Control PWM (MCPWM)* [`PDF <{IDF_TARGET_TRM_EN_URL}#mcpwm>`__].
-
-
-Synchronize
------------
-
-Each PWM timer has a synchronization input and a synchronization output. The synchronization input can be selected from other timers' synchronization outputs or GPIO signals via the GPIO matrix. Timer's synchronization signal can be generated from either the input sync signal or when the count value reaches peak/zero. Thus, the PWM timers can be chained together with their phase-locked. During synchronization, the PWM timer clock prescaler will reset its counter in order to synchronize the PWM timer clock.
-
-The functionality is enabled in following steps:
-
-1. Make sure the PWM timer and operator are already configured so that sync will inherit its config (count mode, freq and duty).
-2. Enabling sync input of the timer by invoking :cpp:func:`mcpwm_sync_configure`, selecting desired signal input from :cpp:type:`mcpwm_sync_signal_t`, and setting the desired phase range from 0 to 999 which is mapped to 0%~99.9%. 0 means zero phase is applied and output is fired at the same time. And selecting desired counting direction.
-3. Enabling one of sync event source from another timer or from external GPIO input.
-
-To sync with another timer:
-
-Enabling sync output of another timer by invoking :cpp:func:`mcpwm_set_timer_sync_output` and selecting desired event to generate sync output from :cpp:type:`mcpwm_timer_sync_trigger_t`.
-
-To sync with GPIO positive edge input (negative edge requires :cpp:func:`mcpwm_sync_invert_gpio_synchro`):
-
-Configuring GPIOs to act as the sync signal inputs by calling functions :cpp:func:`mcpwm_gpio_init` or :cpp:func:`mcpwm_set_pin`, which were described in section `Configure`_.
-
-It's normal condition that chained sync signal may have tens or even hundreds of nanoseconds of delay between each timer output due to hardware limitation. To sync two timers accurately it is required to have the third timer occupied to produce sync event that can be consumed parallel by other two timer, so that those two timer will have no delay between each other but have the same delay between the timer which provides events. Another solution is introducing an external GPIO event source so that all three timers can be synced together with no delay.
-
-.. only:: SOC_MCPWM_SWSYNC_CAN_PROPAGATE
-
-    Software sync event which triggered on one timer can be propagated to other timers on {IDF_TARGET_NAME}, which can be used as a tricky way to get all three timers synced without any extra requirement.
-
-    .. code-block:: c
-
-        // configure timer0 as trigger source
-        mcpwm_set_timer_sync_output(MCPWM_UNIT_0, MCPWM_TIMER_0, MCPWM_SWSYNC_SOURCE_SYNCIN);
-        mcpwm_sync_config_t sync_conf = {
-            .sync_sig = MCPWM_SELECT_TIMER0_SYNC,
-            .timer_val = 0,
-            .count_direction = MCPWM_TIMER_DIRECTION_UP,
+    static void dead_time_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb)
+    {
+        mcpwm_dead_time_config_t dead_time_config = {
+            .posedge_delay_ticks = 50,
+            .negedge_delay_ticks = 0
         };
-        mcpwm_sync_configure(TARGET_MCPWM_UNIT, MCPWM_TIMER_0, &sync_conf);
-        mcpwm_sync_configure(TARGET_MCPWM_UNIT, MCPWM_TIMER_1, &sync_conf);
-        mcpwm_sync_configure(TARGET_MCPWM_UNIT, MCPWM_TIMER_2, &sync_conf);
-        // then send soft sync event to timer0
-        mcpwm_timer_trigger_soft_sync(MCPWM_UNIT_0, MCPWM_TIMER_0);
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(gena, gena, &dead_time_config));
+        dead_time_config.posedge_delay_ticks = 0;
+        dead_time_config.negedge_delay_ticks = 100;
+        dead_time_config.flags.invert_output = true;
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(gena, genb, &dead_time_config));
+    }
 
-If not required anymore, the capture functionality may be disabled with :cpp:func:`mcpwm_sync_disable`.
+Active Low Complementary
+~~~~~~~~~~~~~~~~~~~~~~~~
 
+.. wavedrom:: /../_static/diagrams/mcpwm/deadtime_active_low_complementary.json
+
+.. code:: c
+
+    static void gen_action_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+    {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(gena,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(gena,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    }
+
+    static void dead_time_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb)
+    {
+        mcpwm_dead_time_config_t dead_time_config = {
+            .posedge_delay_ticks = 50,
+            .negedge_delay_ticks = 0,
+            .flags.invert_output = true
+        };
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(gena, gena, &dead_time_config));
+        dead_time_config.posedge_delay_ticks = 0;
+        dead_time_config.negedge_delay_ticks = 100;
+        dead_time_config.flags.invert_output = false;
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(gena, genb, &dead_time_config));
+    }
+
+Active High
+~~~~~~~~~~~
+
+.. wavedrom:: /../_static/diagrams/mcpwm/deadtime_active_high.json
+
+.. code:: c
+
+    static void gen_action_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+    {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(gena,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(gena,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    }
+
+    static void dead_time_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb)
+    {
+        mcpwm_dead_time_config_t dead_time_config = {
+            .posedge_delay_ticks = 50,
+            .negedge_delay_ticks = 0,
+        };
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(gena, gena, &dead_time_config));
+        dead_time_config.posedge_delay_ticks = 0;
+        dead_time_config.negedge_delay_ticks = 100;
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(gena, genb, &dead_time_config));
+    }
+
+Active Low
+~~~~~~~~~~
+
+.. wavedrom:: /../_static/diagrams/mcpwm/deadtime_active_low.json
+
+.. code:: c
+
+    static void gen_action_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+    {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(gena,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(gena,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    }
+
+    static void dead_time_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb)
+    {
+        mcpwm_dead_time_config_t dead_time_config = {
+            .posedge_delay_ticks = 50,
+            .negedge_delay_ticks = 0,
+            .flags.invert_output = true
+        };
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(gena, gena, &dead_time_config));
+        dead_time_config.posedge_delay_ticks = 0;
+        dead_time_config.negedge_delay_ticks = 100;
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(gena, genb, &dead_time_config));
+    }
+
+Rising Delay on PWMA, Bypass deadtime for PWMB
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. wavedrom:: /../_static/diagrams/mcpwm/deadtime_reda_bypassb.json
+
+.. code:: c
+
+    static void gen_action_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+    {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(gena,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(gena,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(genb,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(genb,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    }
+
+    static void dead_time_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb)
+    {
+        mcpwm_dead_time_config_t dead_time_config = {
+            .posedge_delay_ticks = 50,
+            .negedge_delay_ticks = 0,
+        };
+        // apply deadtime to generator_a
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(gena, gena, &dead_time_config));
+        // bypass deadtime module for generator_b
+        dead_time_config.posedge_delay_ticks = 0;
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(genb, genb, &dead_time_config));
+    }
+
+Falling Delay on PWMB, Bypass deadtime for PWMA
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. wavedrom:: /../_static/diagrams/mcpwm/deadtime_fedb_bypassa.json
+
+.. code:: c
+
+    static void gen_action_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+    {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(gena,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(gena,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(genb,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(genb,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    }
+
+    static void dead_time_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb)
+    {
+        mcpwm_dead_time_config_t dead_time_config = {
+            .posedge_delay_ticks = 0,
+            .negedge_delay_ticks = 0,
+        };
+        // generator_a bypass the deadtime module (no delay)
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(gena, gena, &dead_time_config));
+        // apply dead time to generator_b
+        dead_time_config.negedge_delay_ticks = 50;
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(genb, genb, &dead_time_config));
+
+    }
+
+Rising and Falling Delay on PWMB, Bypass deadtime for PWMA
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. wavedrom:: /../_static/diagrams/mcpwm/deadtime_redb_fedb_bypassa.json
+
+.. code:: c
+
+    static void gen_action_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb, mcpwm_cmpr_handle_t cmpa, mcpwm_cmpr_handle_t cmpb)
+    {
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(gena,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(gena,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpa, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_timer_event(genb,
+                        MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH),
+                        MCPWM_GEN_TIMER_EVENT_ACTION_END()));
+        ESP_ERROR_CHECK(mcpwm_generator_set_actions_on_compare_event(genb,
+                        MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, cmpb, MCPWM_GEN_ACTION_LOW),
+                        MCPWM_GEN_COMPARE_EVENT_ACTION_END()));
+    }
+
+    static void dead_time_config(mcpwm_gen_handle_t gena, mcpwm_gen_handle_t genb)
+    {
+        mcpwm_dead_time_config_t dead_time_config = {
+            .posedge_delay_ticks = 0,
+            .negedge_delay_ticks = 0,
+        };
+        // generator_a bypass the deadtime module (no delay)
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(gena, gena, &dead_time_config));
+        // apply dead time on both edge for generator_b
+        dead_time_config.negedge_delay_ticks = 50;
+        dead_time_config.posedge_delay_ticks = 50;
+        ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(genb, genb, &dead_time_config));
+    }
+
+Carrier Modulation
+^^^^^^^^^^^^^^^^^^
+
+The MCPWM operator has a carrier submodule that can be used if galvanic isolation from the motor driver is required (e.g. isolated digital power application) by passing the PWM output signals through transformers. Any of PWM output signals may be at 100% duty and not changing whenever motor is required to run steady at the full load. Coupling of non alternating signals with a transformer is problematic, so the signals are modulated by the carrier submodule to create an AC waveform, to make the coupling possible.
+
+To configure the carrier submodule, you can call :cpp:func:`mcpwm_operator_apply_carrier`, and provide configuration structure :cpp:type:`mcpwm_carrier_config_t`:
+
+- :cpp:member:`mcpwm_carrier_config_t::frequency_hz`: The carrier frequency in Hz.
+- :cpp:member:`mcpwm_carrier_config_t::duty_cycle`: The duty cycle of the carrier. Note that, the supported choices of duty cycle are discrete, the driver will search the nearest one based the user configuration.
+- :cpp:member:`mcpwm_carrier_config_t::first_pulse_duration_us`: The duration of the first pulse in microseconds. The resolution of the first pulse duration is determined by the carrier frequency you set in the :cpp:member:`mcpwm_carrier_config_t::frequency_hz`. The first pulse duration can't be zero, and it has to be at least one period of the carrier. A longer pulse width can help conduct the inductance quicker.
+- :cpp:member:`mcpwm_carrier_config_t::invert_before_modulate` and :cpp:member:`mcpwm_carrier_config_t::invert_after_modulate`: Set whether to invert the carrier output before and after modulation.
+
+Specifically, the carrier submodule can be disabled by calling :cpp:func:`mcpwm_operator_apply_carrier` with a ``NULL`` configuration.
+
+Faults and Brake Actions
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+The MCPWM operator is able to sense external signals with information about failure of the motor, the power driver or any other device connected. These failure signals are encapsulated into `MCPWM fault objects <#mcpwm-faults>`__.
+
+The user should determine possible failure modes of the motor and what action should be performed on detection of particular fault, e.g. drive all outputs low for a brushed motor, or lock current state for a stepper motor, etc. As result of this action the motor should be put into a safe state to reduce likelihood of a damage caused by the fault.
+
+Set Operator Brake Mode on Fault
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The way that MCPWM operator reacts to the fault is called **Brake**. The MCPWM operator can be configured to perform different brake modes for each fault object by calling :cpp:func:`mcpwm_operator_set_brake_on_fault`. Brake specific configuration is passed as a structure :cpp:type:`mcpwm_brake_config_t`:
+
+- :cpp:member:`mcpwm_brake_config_t::fault` set which fault that the operator should react to.
+- :cpp:member:`mcpwm_brake_config_t::brake_mode` set the brake mode that should be used for the fault. The supported brake modes are listed in the :cpp:type:`mcpwm_operator_brake_mode_t`. For :cpp:enumerator:`MCPWM_OPER_BRAKE_MODE_CBC` mode, the operator will recover itself automatically as long as the fault disappears. You can specify the recovery time in :cpp:member:`mcpwm_brake_config_t::cbc_recover_on_tez` and :cpp:member:`mcpwm_brake_config_t::cbc_recover_on_tep`. For :cpp:enumerator:`MCPWM_OPER_BRAKE_MODE_OST` mode, the operator can't recover even though the fault disappears. User has to call :cpp:func:`mcpwm_operator_recover_from_fault` to manually recover it.
+
+Set Generator Action on Brake Event
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+One generator can set multiple actions on different brake events, by calling :cpp:func:`mcpwm_generator_set_actions_on_brake_event` with variable number of action configurations. The action configuration is defined in :cpp:type:`mcpwm_gen_brake_event_action_t`:
+
+- :cpp:member:`mcpwm_gen_brake_event_action_t::direction` specific the timer direction. The supported directions are listed in :cpp:type:`mcpwm_timer_direction_t`.
+- :cpp:member:`mcpwm_gen_brake_event_action_t::brake_mode` specifies the brake mode. The supported brake modes are listed in the :cpp:type:`mcpwm_operator_brake_mode_t`.
+- :cpp:member:`mcpwm_gen_brake_event_action_t::action` specifies the generator action to be taken. The supported actions are listed in :cpp:type:`mcpwm_generator_action_t`.
+
+There's a helper macro :c:macro:`MCPWM_GEN_BRAKE_EVENT_ACTION` to simplify the construction of a brake event action entry.
+
+Please note, the argument list of :cpp:func:`mcpwm_generator_set_actions_on_brake_event` **must** be terminated by :c:macro:`MCPWM_GEN_BRAKE_EVENT_ACTION_END`.
+
+Register Fault Event Callbacks
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The MCPWM fault detector can inform the user when it detects a valid fault or a fault signal disappears. If you have some function that should be called when such event happens, you should hook your function to the interrupt service routine by calling :cpp:func:`mcpwm_fault_register_event_callbacks`. The callback function prototype is declared in :cpp:type:`mcpwm_fault_event_cb_t`. All supported event callbacks are listed in the :cpp:type:`mcpwm_fault_event_callbacks_t`:
+
+- :cpp:member:`mcpwm_fault_event_callbacks_t::on_fault_enter` sets callback function that will be called when a fault is detected.
+- :cpp:member:`mcpwm_fault_event_callbacks_t::on_fault_exit` sets callback function that will be called when a fault is cleared.
+
+The callback function is called within the ISR context, so is should **not** attempt to block (e.g., make sure that only FreeRTOS APIs with ``ISR`` suffix is called within the function).
+
+The parameter ``user_data`` of :cpp:func:`mcpwm_fault_register_event_callbacks` function is used to save user's own context, it will be passed to the callback function directly.
+
+This function will lazy install interrupt service for the MCPWM fault, whereas the service can only be removed in :cpp:type:`mcpwm_del_fault`.
+
+Register Brake Event Callbacks
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The MCPWM operator can inform the user when it going to take a brake action. If you have some function that should be called when this event happens, you should hook your function to the interrupt service routine by calling :cpp:func:`mcpwm_operator_register_event_callbacks`. The callback function prototype is declared in :cpp:type:`mcpwm_brake_event_cb_t`. All supported event callbacks are listed in the :cpp:type:`mcpwm_operator_event_callbacks_t`:
+
+- :cpp:member:`mcpwm_operator_event_callbacks_t::on_brake_cbc` sets callback function that will be called when the operator is going to take a *CBC* action.
+- :cpp:member:`mcpwm_operator_event_callbacks_t::on_brake_ost` sets callback function that will be called when the operator is going to take an *OST* action.
+
+The callback function is called within the ISR context, so is should **not** attempt to block (e.g., make sure that only FreeRTOS APIs with ``ISR`` suffix is called within the function).
+
+The parameter ``user_data`` of :cpp:func:`mcpwm_operator_register_event_callbacks` function is used to save user's own context, it will be passed to the callback function directly.
+
+This function will lazy install interrupt service for the MCPWM operator, whereas the service can only be removed in :cpp:type:`mcpwm_del_operator`.
+
+Generator Force Actions
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Software can override generator output level at runtime, by calling :cpp:func:`mcpwm_generator_set_force_level`. The software force level always has a higher priority than other event actions set in e.g. :cpp:func:`mcpwm_generator_set_actions_on_timer_event`.
+
+- Set the ``level`` to -1 means to disable the force action, and the generator's output level will be controlled by the event actions again.
+- Set the ``hold_on`` to true, the force output level will keep alive, until it's removed by assigning ``level`` to -1.
+- Set the ``hole_on`` to false, the force output level will only be active for a short time, any upcoming event can override it.
+
+Synchronization
+^^^^^^^^^^^^^^^
+
+When a sync signal is taken by the MCPWM timer, the timer will be forced into a predefined **phase**, where the phase is determined by count value and count direction. You can set the sync phase by calling :cpp:func:`mcpwm_timer_set_phase_on_sync`. The sync phase configuration is defined in :cpp:type:`mcpwm_timer_sync_phase_config_t` structure:
+
+- :cpp:member:`mcpwm_timer_sync_phase_config_t::sync_src` sets the sync signal source. See `MCPWM Sync Sources <#mcpwm-sync-sources>`__ for how to create a sync source object. Specifically, if this is set to ``NULL``, the driver will disable the sync feature for the MCPWM timer.
+- :cpp:member:`mcpwm_timer_sync_phase_config_t::count_value` sets the count value to load when the sync signal is taken.
+- :cpp:member:`mcpwm_timer_sync_phase_config_t::direction` sets the count direction when the sync signal is taken.
+
+Likewise, the MCPWM capture timer `MCPWM Capture Timer <#mcpwm-capture-timer-and-channels>`__ can be synced as well. You can set the sync phase for the capture timer by calling :cpp:func:`mcpwm_capture_timer_set_phase_on_sync`. The sync phase configuration is defined in :cpp:type:`mcpwm_capture_timer_sync_phase_config_t` structure:
+
+- :cpp:member:`mcpwm_capture_timer_sync_phase_config_t::sync_src` sets the sync signal source. See `MCPWM Sync Sources <#mcpwm-sync-sources>`__ for how to create a sync source object. Specifically, if this is set to ``NULL``, the driver will disable the sync feature for the MCPWM capture timer.
+- :cpp:member:`mcpwm_capture_timer_sync_phase_config_t::count_value` sets the count value to load when the sync signal is taken.
+- :cpp:member:`mcpwm_capture_timer_sync_phase_config_t::direction` sets the count direction when the sync signal is taken. Note that, different from MCPWM Timer, the capture timer can only support one count direction: :cpp:enumerator:`MCPWM_TIMER_DIRECTION_UP`.
+
+Sync Timers by GPIO
+~~~~~~~~~~~~~~~~~~~
+
+.. blockdiag::
+    :caption: GPIO Sync All MCPWM Timers
+    :align: center
+
+    blockdiag {
+        GPIO -> Timer0, Timer1, Timer2;
+    }
+
+.. code-block:: c
+
+    static void example_setup_sync_strategy(mcpwm_timer_handle_t timers[])
+    {
+        mcpwm_sync_handle_t gpio_sync_source = NULL;
+        mcpwm_gpio_sync_src_config_t gpio_sync_config = {
+            .group_id = 0,              // GPIO fault should be in the same group of the above timers
+            .gpio_num = EXAMPLE_SYNC_GPIO,
+            .flags.pull_down = true,
+            .flags.active_neg = false,  // by default, a posedge pulse can trigger a sync event
+        };
+        ESP_ERROR_CHECK(mcpwm_new_gpio_sync_src(&gpio_sync_config, &gpio_sync_source));
+
+        mcpwm_timer_sync_phase_config_t sync_phase_config = {
+            .count_value = 0,                      // sync phase: target count value
+            .direction = MCPWM_TIMER_DIRECTION_UP, // sync phase: count direction
+            .sync_src = gpio_sync_source,          // sync source
+        };
+        for (int i = 0; i < 3; i++) {
+            ESP_ERROR_CHECK(mcpwm_timer_set_phase_on_sync(timers[i], &sync_phase_config));
+        }
+    }
 
 Capture
--------
+^^^^^^^
 
-One of requirements of BLDC (Brushless DC, see figure below) motor control is sensing of the rotor position. To facilitate this task each MCPWM unit provides three sensing inputs together with dedicated hardware. The hardware is able to detect the input signal's edge and measure time between signals. As result the control software is simpler and the CPU power may be used for other tasks.
+The basic functionality of MCPWM capture is to record the time when any pulse edge of the capture signal turns active. Then you can get the pulse width and convert it into other physical quantity like distance or speed in the capture callback function. For example, in the BLDC (Brushless DC, see figure below) scenario, we can use the capture submodule to sense the rotor position from Hall sensor.
 
 .. figure:: ../../../_static/mcpwm-bldc-control.png
     :align: center
     :alt: Example of Brushless DC Motor Control with MCPWM
     :figclass: align-center
 
-    Example of Brushless DC Motor Control with MCPWM
+    MCPWM BLDC with Hall Sensor
 
-The capture functionality may be used for other types of motors or tasks. The functionality is enabled in two steps:
+The capture timer is usually connected with several capture channels, please refer to `<how to allocate capture timer and channels #mcpwm-capture-timer-and-channels>`__ for resource allocation.
 
-1. Configuration of GPIOs to act as the capture signal inputs by calling functions :cpp:func:`mcpwm_gpio_init` or :cpp:func:`mcpwm_set_pin`, that were described in section `Configure`_.
-2. Enabling of the functionality itself by invoking :cpp:func:`mcpwm_capture_enable_channel`, selecting desired signal input from :cpp:type:`mcpwm_capture_channel_id_t`, setting the signal edge, signal count prescaler and user callback within :cpp:type:`mcpwm_capture_config_t`
+Register Event Callbacks
+~~~~~~~~~~~~~~~~~~~~~~~~
 
-Within the second step above a 32-bit capture timer is enabled. The timer runs continuously driven by the APB clock. The clock frequency is typically 80 MHz. On each capture event the capture timer’s value is stored in time-stamp register that may be then checked by calling :cpp:func:`mcpwm_capture_signal_get_value`. The edge of the last signal may be checked with :cpp:func:`mcpwm_capture_signal_get_edge`. Those data are also provided inside callback function as event data :cpp:type:`cap_event_data_t`
+The MCPWM capture channel can inform the user when there's a valid edge detected on the signal. You have to register a callback function to get the timer count value of the capture moment, by calling :cpp:func:`mcpwm_capture_channel_register_event_callbacks`. The callback function prototype is declared in :cpp:type:`mcpwm_capture_event_cb_t`. All supported capture callbacks are listed in the :cpp:type:`mcpwm_capture_event_callbacks_t`:
 
-If not required anymore, the capture functionality may be disabled with :cpp:func:`mcpwm_capture_disable_channel`.
+- :cpp:member:`mcpwm_capture_event_callbacks_t::on_cap` sets callback function for the capture channel when a valid edge is detected.
 
-Capture prescale is different from other modules as it is applied to the input signal, not the timer source. Prescaler has maintained its own level state with the initial value set to low and is detecting the positive edge of the input signal to change its internal state. That means if two pairs of positive and negative edges are passed to input, the prescaler's internal state will change twice. ISR will report on this internal state change, not the input signal. For example, setting prescale to 2 will generate ISR callback on each positive edge of input if both edge is selected via :cpp:type:`mcpwm_capture_config_t`. Or each 2 positive edges of input if only one edge is selected though :cpp:type:`mcpwm_capture_config_t`.
+The callback function will provide event specific data of type :cpp:type:`mcpwm_capture_event_data_t`, so that you can get the the edge of the capture signal in :cpp:member:`mcpwm_capture_event_data_t::cap_edge` and the count value of that moment in :cpp:member:`mcpwm_capture_event_data_t::cap_value`.
 
+The callback function is called within the ISR context, so is should **not** attempt to block (e.g., make sure that only FreeRTOS APIs with ``ISR`` suffix is called within the function).
 
-Fault Handler
--------------
+The parameter ``user_data`` of :cpp:func:`mcpwm_capture_channel_register_event_callbacks` function is used to save user's own context, it will be passed to the callback function directly.
 
-Each unit of the MCPWM is able to sense external signals with information about failure of the motor, the motor driver or any other device connected to the MCPWM. There are three fault inputs per unit that may be routed to user selectable GPIOs. The MCPWM may be configured to perform one of four predefined actions on A/B outputs when a fault signal is received:
+This function will lazy install interrupt service for the MCPWM capture channel, whereas the service can only be removed in :cpp:type:`mcpwm_del_capture_channel`.
 
-* lock current state of the output
-* set the output low
-* set the output high
-* toggle the output
+Enable and Disable Capture Timer
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The user should determine possible failure modes of the motor and what action should be performed on detection of particular fault, e.g. drive all outputs low for a brushed motor, or lock current state for a stepper motor, etc. As result of this action the motor should be put into a safe state to reduce likelihood of a damage caused by the fault.
+Before doing IO control to the capture timer, user needs to enable the timer first, by calling :cpp:func:`mcpwm_capture_timer_enable`. Internally, this function will:
 
-The fault handler functionality is enabled in two steps:
+* switch the capture timer state from **init** to **enable**.
+* acquire a proper power management lock if a specific clock source (e.g. APB clock) is selected. See also `Power management <#power-management>`__ for more information.
 
-1. Configuration of GPIOs to act as fault signal inputs. This is done in analogous way as described for capture signals in section above. It includes setting the signal level to trigger the fault as defined in :cpp:type:`mcpwm_fault_input_level_t`.
-2. Initialization of the fault handler by calling either :cpp:func:`mcpwm_fault_set_oneshot_mode` or :cpp:func:`mcpwm_fault_set_cyc_mode`. These functions set the mode that MCPWM should operate once fault signal becomes inactive. There are two modes possible:
+On the contrary, calling :cpp:func:`mcpwm_capture_timer_disable` will put the timer driver back to **init** state, and release the power management lock.
 
-  * State of MCPWM unit will be locked until reset - :cpp:func:`mcpwm_fault_set_oneshot_mode`.
-  * The MCPWM will resume operation once fault signal becoming inactive - :cpp:func:`mcpwm_fault_set_cyc_mode`.
+Start and Stop Capture Timer
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-  The function call parameters include selection of one of three fault inputs defined in :cpp:type:`mcpwm_fault_signal_t` and specific action on outputs A and B defined in :cpp:type:`mcpwm_action_on_pwmxa_t` and :cpp:type:`mcpwm_action_on_pwmxb_t`.
+The basic IO operation of a capture timer is to start and stop. Calling :cpp:func:`mcpwm_capture_timer_start` can start the timer and calling :cpp:func:`mcpwm_capture_timer_stop` can stop the timer immediately.
 
-Particular fault signal may be disabled at the runtime by calling :cpp:func:`mcpwm_fault_deinit`.
+Trigger a Software Capture Event
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+Sometime, the software also wants to trigger a "fake" capture event. The :cpp:func:`mcpwm_capture_channel_trigger_soft_catch` is provided for that purpose. Please note that, even though it's a "fake" capture event, it can still cause an interrupt, thus your capture event callback function will get invoked as well.
 
-Carrier
--------
+Power Management
+^^^^^^^^^^^^^^^^
 
-The MCPWM has a carrier submodule used if galvanic isolation from the motor driver is required by passing the A/B output signals through transformers. Any of A and B output signals may be at 100% duty and not changing whenever motor is required to run steady at the full load. Coupling of non alternating signals with a transformer is problematic, so the signals are modulated by the carrier submodule to create an AC waveform, to make the coupling possible.
+When power management is enabled (i.e. :ref:`CONFIG_PM_ENABLE` is on), the system will adjust the PLL, APB frequency before going into light sleep, thus potentially changing the period of a MCPWM timers' counting step and leading to inaccurate time keeping.
 
-To use the carrier submodule, it should be first initialized by calling :cpp:func:`mcpwm_carrier_init`. The carrier parameters are defined in :cpp:type:`mcpwm_carrier_config_t` structure invoked within the function call. Then the carrier functionality may be enabled by calling :cpp:func:`mcpwm_carrier_enable`.
+However, the driver can prevent the system from changing APB frequency by acquiring a power management lock of type :cpp:enumerator:`ESP_PM_APB_FREQ_MAX`. Whenever the driver creates a MCPWM timer instance that has selected :cpp:enumerator:`MCPWM_TIMER_CLK_SRC_PLL160M` as its clock source, the driver will guarantee that the power management lock is acquired when enable the timer by :cpp:func:`mcpwm_timer_enable`. Likewise, the driver releases the lock when :cpp:func:`mcpwm_timer_disable` is called for that timer.
 
-The carrier parameters may be then altered at a runtime by calling dedicated functions to change individual fields of the :cpp:type:`mcpwm_carrier_config_t` structure, like :cpp:func:`mcpwm_carrier_set_period`, :cpp:func:`mcpwm_carrier_set_duty_cycle`, :cpp:func:`mcpwm_carrier_output_invert`, etc.
+Likewise, Whenever the driver creates a MCPWM capture timer instance that has selected :cpp:enumerator:`MCPWM_CAPTURE_CLK_SRC_APB` as its clock source, the driver will guarantee that the power management lock is acquired when enable the timer by :cpp:func:`mcpwm_capture_timer_enable`. And will release the lock in  :cpp:func:`mcpwm_capture_timer_disable`.
 
-This includes enabling and setting duration of the first pulse of the career with :cpp:func:`mcpwm_carrier_oneshot_mode_enable`. For more details, see *{IDF_TARGET_NAME} Technical Reference Manual* > *Motor Control PWM (MCPWM)* > *PWM Carrier Submodule* [`PDF <{IDF_TARGET_TRM_EN_URL}#mcpwm>`__].
+IRAM Safe
+^^^^^^^^^
 
-To disable carrier functionality call :cpp:func:`mcpwm_carrier_disable`.
+By default, the MCPWM interrupt will be deferred when the Cache is disabled for reasons like writing/erasing Flash. Thus the event callback functions will not get executed in time, which is not expected in a real-time application.
 
+There's a Kconfig option :ref:`CONFIG_MCPWM_ISR_IRAM_SAFE` that will:
 
-Interrupts
-----------
+1. Enable the interrupt being serviced even when cache is disabled
+2. Place all functions that used by the ISR into IRAM [2]_
+3. Place driver object into DRAM (in case it's mapped to PSRAM by accident)
 
-Registering of the MCPWM interrupt handler is possible by calling :cpp:func:`mcpwm_isr_register`. Note if :cpp:func:`mcpwm_capture_enable_channel` is used then a default ISR routine will be installed hence please do not call this function to register any more.
+This will allow the interrupt to run while the cache is disabled but will come at the cost of increased IRAM consumption.
 
+Thread Safety
+^^^^^^^^^^^^^
 
-Resolution
-----------
+The factory functions like :cpp:func:`mcpwm_new_timer` are guaranteed to be thread safe by the driver, which means, you can call it from different RTOS tasks without protection by extra locks.
 
-The default resolution for MCPWM group and MCPWM timer are configured to **10MHz** and **1MHz** in :cpp:func:`mcpwm_init`, which might be not enough for some applications.
-The driver also provides two APIs that can be used to override the default resolution: :cpp:func:`mcpwm_group_set_resolution` and :cpp:func:`mcpwm_timer_set_resolution`.
+No functions are allowed to run within ISR environment.
 
-Note that, these two APIs won't update the frequency and duty automatically, to achieve that, one has to call :cpp:func:`mcpwm_set_frequency` and :cpp:func:`mcpwm_set_duty` accordingly.
+Functions that are not related to `Resource Allocation <#resource-allocation-and-initialization>`__, are not thread safe. Thus, you should avoid calling them in different tasks without mutex protection.
 
-To get PWM pulse that is below 15Hz, please set the resolution to a lower value. For high frequency PWM with limited step range, please set them with higher value.
+Kconfig Options
+^^^^^^^^^^^^^^^
 
+- :ref:`CONFIG_MCPWM_ISR_IRAM_SAFE` controls whether the default ISR handler can work when cache is disabled, see `IRAM Safe <#iram-safe>`__ for more information.
+- :ref:`CONFIG_MCPWM_ENABLE_DEBUG_LOG` is used to enabled the debug log output. Enable this option will increase the firmware binary size.
 
-Application Example
--------------------
+Application Examples
+--------------------
 
-MCPWM example are located under: :example:`peripherals/mcpwm`:
-
-* Control of BLDC (brushless DC) motor with hall sensor feedback - :example:`peripherals/mcpwm/mcpwm_bldc_hall_control`
-* Brushed DC motor control - :example:`peripherals/mcpwm/mcpwm_bdc_speed_control`
-* Servo motor control - :example:`peripherals/mcpwm/mcpwm_servo_control`
-* HC-SR04 sensor with capture - :example:`peripherals/mcpwm/mcpwm_capture_hc_sr04`
+* Brushed DC motor speed control by PID algorithm: :example:`peripherals/mcpwm/mcpwm_bdc_speed_control`
+* BLDC motor control with hall sensor feedback: :example:`peripherals/mcpwm/mcpwm_bldc_hall_control`
+* Ultrasonic sensor (HC-SR04) distance measurement: :example:`peripherals/mcpwm/mcpwm_capture_hc_sr04`
+* Servo motor angle control: :example:`peripherals/mcpwm/mcpwm_servo_control`
+* MCPWM synchronization between timers: :example:`peripherals/mcpwm/mcpwm_sync`
 
 
 API Reference
 -------------
 
-.. include-build-file:: inc/mcpwm_types.inc
-.. include-build-file:: inc/mcpwm.inc
+.. include-build-file:: inc/mcpwm_timer.inc
+.. include-build-file:: inc/mcpwm_oper.inc
+.. include-build-file:: inc/mcpwm_cmpr.inc
+.. include-build-file:: inc/mcpwm_gen.inc
+.. include-build-file:: inc/mcpwm_fault.inc
+.. include-build-file:: inc/mcpwm_sync.inc
+.. include-build-file:: inc/mcpwm_cap.inc
+.. include-build-file:: inc/components/driver/include/driver/mcpwm_types.inc
+.. include-build-file:: inc/components/hal/include/hal/mcpwm_types.inc
 
 
+.. [1]
+   Different ESP chip series might have different number of MCPWM resources (e.g. groups, timers, comparators, operators, generators and so on). Please refer to the [`TRM <{IDF_TARGET_TRM_EN_URL}#mcpwm>`__] for details. The driver won't forbid you from applying for more MCPWM resources, but it will return error when there's no hardware resources available. Please always check the return value when doing `Resource Allocation <#resource-allocation-and-initialization>`__.
+
+.. [2]
+   Callback function and the sub-functions invoked by itself should also be placed in IRAM, users need to take care of this by themselves.
diff --git a/docs/en/migration-guides/release-5.x/peripherals.rst b/docs/en/migration-guides/release-5.x/peripherals.rst
index fd980f58f3..c2584d4466 100644
--- a/docs/en/migration-guides/release-5.x/peripherals.rst
+++ b/docs/en/migration-guides/release-5.x/peripherals.rst
@@ -213,6 +213,7 @@ LEDC
 
     Breaking Changes in Usage
     ~~~~~~~~~~~~~~~~~~~~~~~~~
+
     - Channel installation has been separated for TX and RX channels into :cpp:func:`rmt_new_tx_channel` and :cpp:func:`rmt_new_rx_channel`.
     - ``rmt_set_clk_div`` and ``rmt_get_clk_div`` are removed. Channel clock configuration can only be done during channel installation.
     - ``rmt_set_rx_idle_thresh`` and ``rmt_get_rx_idle_thresh`` are removed. In the new driver, the RX channel IDLE threshold is redesigned into a new concept :cpp:member:`rmt_receive_config_t::signal_range_max_ns`.
@@ -259,11 +260,63 @@ LCD
     MCPWM
     -----
 
-    - ``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.
+    MCPWM driver was redesigned (see :doc:`MCPWM <../../api-reference/peripherals/mcpwm>`), meanwhile, the legacy driver is deprecated. The new driver's aim is to make each MCPWM submodule independent to each other, and give the freedom of resource connection back to users. Although it's recommended to use the new driver APIs, the legacy driver is still available in the previous include path ``driver/mcpwm.h``. However, by default, using legacy driver will bring compile warnings like ``legacy MCPWM driver is deprecated, please migrate to the new driver (include driver/mcpwm_prelude.h)``. This warning can be suppressed by the Kconfig option :ref:`CONFIG_MCPWM_SUPPRESS_DEPRECATE_WARN`.
+
+    The major breaking changes in concept and usage are listed as follows:
+
+    Breaking Changes in Concepts
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    The new MCPWM driver is object-oriented, where most of the MCPWM submodule has a driver object associated with it. The driver object is created by factory function like :cpp:func:`mcpwm_new_timer`. IO control function always needs an object handle, in the first place.
+
+    The legacy driver has an inappropriate assumption, that is the MCPWM operator should be connected to different MCPWM timer. In fact, the hardware doesn't have such limitation. In the new driver, a MCPWM timer can be connected to multiple operators, so that the operators can achieve the best synchronization performance.
+
+    The legacy driver preset the way to generate a PWM waveform into a so called ``mcpwm_duty_type_t``, however, the duty cycle modes listed there are far from sufficient. Likewise, legacy driver has several preset ``mcpwm_deadtime_type_t``, which also doesn't cover all the use cases. What's more, user usually gets confused by the name of the duty cycle mode and dead-time mode. In the new driver, there're no such limitation, but user has to construct the generator behavior from scratch.
+
+    In the legacy driver, the ways to synchronize the MCPWM timer by GPIO, software and other timer module are not unified. It increased learning costs for users. In the new driver, the synchronization APIs are unified.
+
+    The legacy driver has mixed the concepts of "Fault detector" and "Fault handler". Which make the APIs very confusing to users. In the new driver, the fault object just represents a failure source, and we introduced a new concept -- **brake** to express the concept of "Fault handler". What's more, the new driver supports software fault.
+
+    The legacy drive only provides callback functions for the capture submodule. The new driver provides more useful callbacks for various MCPWM submodules, like timer stop, compare match, fault enter, brake, etc.
+
+    - ``mcpwm_io_signals_t`` and ``mcpwm_pin_config_t`` are not used. GPIO configuration has been moved into submodule's configuration structure.
+    - ``mcpwm_timer_t``, ``mcpwm_generator_t`` are not used. Timer and generator are represented by :cpp:type:`mcpwm_timer_handle_t` and :cpp:type:`mcpwm_gen_handle_t`.
+    - ``mcpwm_fault_signal_t`` and ``mcpwm_sync_signal_t`` are not used. Fault and sync source are represented by :cpp:type:`mcpwm_fault_handle_t` and :cpp:type:`mcpwm_sync_handle_t`.
+    - ``mcpwm_capture_signal_t`` is not used. A capture channel is represented by :cpp:type:`mcpwm_cap_channel_handle_t`.
+
+    Breaking Changes in Usage
+    ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    - ``mcpwm_gpio_init`` and ``mcpwm_set_pin``: GPIO configurations are moved to submodule's own configuration. e.g. set the PWM GPIO in :cpp:member:`mcpwm_generator_config_t::gen_gpio_num`.
+    - ``mcpwm_init``: To get an expected PWM waveform, you need to allocated at least one MCPWM timer and MCPWM operator, then connect them by calling :cpp:func:`mcpwm_operator_connect_timer`. After that, you should set the generator's actions on various events by calling e.g. :cpp:func:`mcpwm_generator_set_actions_on_timer_event`, :cpp:func:`mcpwm_generator_set_actions_on_compare_event`.
+    - ``mcpwm_group_set_resolution``: in the new driver, the group resolution is fixed to the maximum, usually it's 80MHz.
+    - ``mcpwm_timer_set_resolution``: MCPWM Timer resolution is set in :cpp:member:`mcpwm_timer_config_t::resolution_hz`.
+    - ``mcpwm_set_frequency``: PWM frequency is determined by :cpp:member:`mcpwm_timer_config_t::resolution_hz`, :cpp:member:`mcpwm_timer_config_t::count_mode` and :cpp:member:`mcpwm_timer_config_t::period_ticks`.
+    - ``mcpwm_set_duty``: To set the PWM duty cycle, you should call :cpp:func:`mcpwm_comparator_set_compare_value` to change comparator's threshold.
+    - ``mcpwm_set_duty_type``: There won't be any preset duty types, the duty type is configured by setting different generator actions. e.g. :cpp:func:`mcpwm_generator_set_actions_on_timer_event`.
+    - ``mcpwm_set_signal_high`` and ``mcpwm_set_signal_low`` are replaced by :cpp:func:`mcpwm_generator_set_force_level`. In the new driver, it's implemented by setting force action for the generator, instead of changing the duty cycle to 0% or 100% at the background.
+    - ``mcpwm_start`` and ``mcpwm_stop`` are replaced by :cpp:func:`mcpwm_timer_start_stop`. You have more modes to start and stop the MCPWM timer, see :cpp:type:`mcpwm_timer_start_stop_cmd_t`.
+    - ``mcpwm_carrier_init``: It's replaced by :cpp:func:`mcpwm_operator_apply_carrier`.
+    - ``mcpwm_carrier_enable`` and ``mcpwm_carrier_disable``: Enabling and disabling carrier submodule is done automatically by checking whether the carrier configuration structure :cpp:type:`mcpwm_carrier_config_t` is NULL.
+    - ``mcpwm_carrier_set_period`` is replaced by :cpp:member:`mcpwm_carrier_config_t::frequency_hz`.
+    - ``mcpwm_carrier_set_duty_cycle`` is replaced by :cpp:member:`mcpwm_carrier_config_t::duty_cycle`.
+    - ``mcpwm_carrier_oneshot_mode_enable`` is replaced by :cpp:member:`mcpwm_carrier_config_t::first_pulse_duration_us`.
+    - ``mcpwm_carrier_oneshot_mode_disable`` is removed. Disabling the first pulse (a.k.a the one-shot pulse) in the carrier is never supported by the hardware.
+    - ``mcpwm_carrier_output_invert`` is replaced by :cpp:member:`mcpwm_carrier_config_t::invert_before_modulate` and :cpp:member:`mcpwm_carrier_config_t::invert_after_modulate`.
+    - ``mcpwm_deadtime_enable`` and ``mcpwm_deadtime_disable`` are replaced by :cpp:func:`mcpwm_generator_set_dead_time`.
+    - ``mcpwm_fault_init`` is replaced by :cpp:func:`mcpwm_new_gpio_fault`.
+    - ``mcpwm_fault_set_oneshot_mode``, ``mcpwm_fault_set_cyc_mode`` are replaced by :cpp:func:`mcpwm_operator_set_brake_on_fault` and :cpp:func:`mcpwm_generator_set_actions_on_brake_event`.
+    - ``mcpwm_capture_enable`` is removed. It's duplicated to :cpp:func:`mcpwm_capture_enable_channel`.
+    - ``mcpwm_capture_disable`` is removed. It's duplicated to :cpp:func:`mcpwm_capture_capture_disable_channel`.
+    - ``mcpwm_capture_enable_channel`` and ``mcpwm_capture_disable_channel`` are replaced by :cpp:func:`mcpwm_new_capture_channel` and :cpp:func:`mcpwm_del_capture_channel`.
+    - ``mcpwm_capture_signal_get_value`` and ``mcpwm_capture_signal_get_edge``: Capture timer count value and capture edge are provided in the capture event callback, via :cpp:type:`mcpwm_capture_event_data_t`. Capture data are only valuable when capture event happens. Providing single API to fetch capture data is meaningless.
+    - ``mcpwm_sync_enable`` is removed. It's duplicated to :cpp:func:`mcpwm_sync_configure`.
+    - ``mcpwm_sync_configure`` is replaced by :cpp:func:`mcpwm_timer_set_phase_on_sync`.
+    - ``mcpwm_sync_disable`` is equivalent to setting :cpp:member:`mcpwm_timer_sync_phase_config_t::sync_src` to ``NULL``.
+    - ``mcpwm_set_timer_sync_output`` is replaced by :cpp:func:`mcpwm_new_timer_sync_src`.
+    - ``mcpwm_timer_trigger_soft_sync`` is replaced by :cpp:func:`mcpwm_soft_sync_activate`.
+    - ``mcpwm_sync_invert_gpio_synchro`` is equivalent to setting :cpp:member:`mcpwm_gpio_sync_src_config_t::active_neg`.
+    - ``mcpwm_isr_register`` is removed. You can register various event callbacks instead. For example, to register capture event callback, you can use :cpp:func:`mcpwm_capture_channel_register_event_callbacks`.
 
 .. only:: SOC_DEDICATED_GPIO_SUPPORTED
 
diff --git a/docs/zh_CN/api-reference/peripherals/mcpwm.rst b/docs/zh_CN/api-reference/peripherals/mcpwm.rst
index a918a58c90..368f3c7f86 100644
--- a/docs/zh_CN/api-reference/peripherals/mcpwm.rst
+++ b/docs/zh_CN/api-reference/peripherals/mcpwm.rst
@@ -1 +1 @@
-.. include:: ../../../en/api-reference/peripherals/mcpwm.rst
\ No newline at end of file
+.. include:: ../../../en/api-reference/peripherals/mcpwm.rst