refactor(pcnt): clean up the soc_caps.h file for PCNT

Author: Kainarx

components/esp_driver_dac/test_apps/dac/main/test_dac.c

@@ -257,7 +257,7 @@ TEST_CASE("DAC_dma_convert_frequency_test", "[dac]")
     gpio_set_direction(GPIO_NUM_4, GPIO_MODE_INPUT_OUTPUT);
     // The DAC conversion frequency is equal to I2S bclk.
     esp_rom_gpio_connect_out_signal(GPIO_NUM_4, i2s_periph_signal[0].m_tx_ws_sig, 0, 0);
-    esp_rom_gpio_connect_in_signal(GPIO_NUM_4, pcnt_periph_signals.groups[0].units[0].channels[0].pulse_sig, 0);
+    esp_rom_gpio_connect_in_signal(GPIO_NUM_4, soc_pcnt_signals[0].units[0].channels[0].pulse_sig_id_matrix, 0);
 
     size_t len = 800;
     uint8_t data[len];

components/esp_driver_i2s/test_apps/i2s/main/test_i2s.c

@@ -847,7 +847,7 @@ static void i2s_test_common_sample_rate(i2s_chan_handle_t rx_chan, i2s_std_clk_c
     gpio_func_sel(MASTER_WS_IO, PIN_FUNC_GPIO);
     gpio_set_direction(MASTER_WS_IO, GPIO_MODE_INPUT_OUTPUT);
     esp_rom_gpio_connect_out_signal(MASTER_WS_IO, i2s_periph_signal[0].m_rx_ws_sig, 0, 0);
-    esp_rom_gpio_connect_in_signal(MASTER_WS_IO, pcnt_periph_signals.groups[0].units[0].channels[0].pulse_sig, 0);
+    esp_rom_gpio_connect_in_signal(MASTER_WS_IO, soc_pcnt_signals[0].units[0].channels[0].pulse_sig_id_matrix, 0);
 
     const uint32_t test_freq[] = {
         8000,  10000, 11025, 12000, 16000, 22050,

components/esp_driver_pcnt/src/pulse_cnt.c

@@ -68,16 +68,16 @@ typedef struct pcnt_chan_t pcnt_chan_t;
 
 struct pcnt_platform_t {
     _lock_t mutex;                         // platform level mutex lock
-    pcnt_group_t *groups[SOC_PCNT_GROUPS]; // pcnt group pool
-    int group_ref_counts[SOC_PCNT_GROUPS]; // reference count used to protect group install/uninstall
+    pcnt_group_t *groups[SOC_PCNT_ATTR(INST_NUM)]; // pcnt group pool
+    int group_ref_counts[SOC_PCNT_ATTR(INST_NUM)]; // reference count used to protect group install/uninstall
 };
 
 struct pcnt_group_t {
     int group_id;          // Group ID, index from 0
     int intr_priority;     // PCNT interrupt priority
     portMUX_TYPE spinlock; // to protect per-group register level concurrent access
     pcnt_hal_context_t hal;
-    pcnt_unit_t *units[SOC_PCNT_UNITS_PER_GROUP]; // array of PCNT units
+    pcnt_unit_t *units[SOC_PCNT_ATTR(UNITS_PER_INST)]; // array of PCNT units
 #if CONFIG_PM_ENABLE
     esp_pm_lock_handle_t pm_lock;  // power management lock
 #endif
@@ -112,7 +112,7 @@ struct pcnt_unit_t {
     int clear_signal_gpio_num;                            // which gpio clear signal input
     int accum_value;                                      // accumulated count value
     pcnt_step_interval_t step_info;                       // step interval info
-    pcnt_chan_t *channels[SOC_PCNT_CHANNELS_PER_UNIT];    // array of PCNT channels
+    pcnt_chan_t *channels[SOC_PCNT_ATTR(CHANS_PER_UNIT)];    // array of PCNT channels
     pcnt_watch_point_t watchers[PCNT_LL_WATCH_EVENT_MAX]; // array of PCNT watchers
     intr_handle_t intr;                                   // interrupt handle
     pcnt_unit_fsm_t fsm;      // record PCNT unit's driver state
@@ -145,12 +145,12 @@ static esp_err_t pcnt_register_to_group(pcnt_unit_t *unit)
 {
     pcnt_group_t *group = NULL;
     int unit_id = -1;
-    for (int i = 0; i < SOC_PCNT_GROUPS; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(INST_NUM); i++) {
         group = pcnt_acquire_group_handle(i);
         ESP_RETURN_ON_FALSE(group, ESP_ERR_NO_MEM, TAG, "no mem for group (%d)", i);
         // loop to search free unit in the group
         portENTER_CRITICAL(&group->spinlock);
-        for (int j = 0; j < SOC_PCNT_UNITS_PER_GROUP; j++) {
+        for (int j = 0; j < SOC_PCNT_ATTR(UNITS_PER_INST); j++) {
             if (!group->units[j]) {
                 unit_id = j;
                 group->units[j] = unit;
@@ -243,7 +243,7 @@ esp_err_t pcnt_new_unit(const pcnt_unit_config_t *config, pcnt_unit_handle_t *re
         } else {
             isr_flags |= PCNT_ALLOW_INTR_PRIORITY_MASK;
         }
-        ESP_GOTO_ON_ERROR(esp_intr_alloc_intrstatus(pcnt_periph_signals.groups[group_id].irq, isr_flags,
+        ESP_GOTO_ON_ERROR(esp_intr_alloc_intrstatus(soc_pcnt_signals[group_id].irq_id, isr_flags,
                                                     (uint32_t)pcnt_ll_get_intr_status_reg(group->hal.dev), PCNT_LL_UNIT_WATCH_EVENT(unit_id),
                                                     pcnt_default_isr, unit, &unit->intr), err,
                           TAG, "install interrupt service failed");
@@ -311,13 +311,13 @@ esp_err_t pcnt_del_unit(pcnt_unit_handle_t unit)
     int group_id = group->group_id;
     int unit_id = unit->unit_id;
 
-    for (int i = 0; i < SOC_PCNT_CHANNELS_PER_UNIT; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(CHANS_PER_UNIT); i++) {
         ESP_RETURN_ON_FALSE(!unit->channels[i], ESP_ERR_INVALID_STATE, TAG, "channel %d still in working", i);
     }
 
 #if SOC_PCNT_SUPPORT_CLEAR_SIGNAL
     if (unit->clear_signal_gpio_num >= 0) {
-        uint32_t clear_signal_idx = pcnt_periph_signals.groups[group_id].units[unit_id].clear_sig;
+        uint32_t clear_signal_idx = soc_pcnt_signals[group_id].units[unit_id].clear_sig_id_matrix;
         esp_rom_gpio_connect_in_signal(GPIO_MATRIX_CONST_ZERO_INPUT, clear_signal_idx, 0);
     }
 #endif // SOC_PCNT_SUPPORT_CLEAR_SIGNAL
@@ -335,7 +335,7 @@ esp_err_t pcnt_unit_set_clear_signal(pcnt_unit_handle_t unit, const pcnt_clear_s
     pcnt_group_t *group = unit->group;
     int group_id = group->group_id;
     int unit_id = unit->unit_id;
-    uint32_t clear_signal_idx = pcnt_periph_signals.groups[group_id].units[unit_id].clear_sig;
+    uint32_t clear_signal_idx = soc_pcnt_signals[group_id].units[unit_id].clear_sig_id_matrix;
 
     if (config) {
         int io_num = config->clear_signal_gpio_num;
@@ -534,7 +534,7 @@ esp_err_t pcnt_unit_register_event_callbacks(pcnt_unit_handle_t unit, const pcnt
         } else {
             isr_flags |= PCNT_ALLOW_INTR_PRIORITY_MASK;
         }
-        ESP_RETURN_ON_ERROR(esp_intr_alloc_intrstatus(pcnt_periph_signals.groups[group_id].irq, isr_flags,
+        ESP_RETURN_ON_ERROR(esp_intr_alloc_intrstatus(soc_pcnt_signals[group_id].irq_id, isr_flags,
                                                       (uint32_t)pcnt_ll_get_intr_status_reg(group->hal.dev), PCNT_LL_UNIT_WATCH_EVENT(unit_id),
                                                       pcnt_default_isr, unit, &unit->intr),
                             TAG, "install interrupt service failed");
@@ -592,7 +592,7 @@ esp_err_t pcnt_unit_add_watch_point(pcnt_unit_handle_t unit, int watch_point)
     }
     // other threshold watch point
     else {
-        int thres_num = SOC_PCNT_THRES_POINT_PER_UNIT - 1;
+        int thres_num = SOC_PCNT_ATTR(THRES_POINT_PER_UNIT) - 1;
         switch (thres_num) {
         case 1:
             if (unit->watchers[PCNT_LL_WATCH_EVENT_THRES1].event_id == PCNT_LL_WATCH_EVENT_INVALID) {
@@ -779,7 +779,7 @@ esp_err_t pcnt_new_channel(pcnt_unit_handle_t unit, const pcnt_chan_config_t *co
     // search for a free channel
     int channel_id = -1;
     portENTER_CRITICAL(&unit->spinlock);
-    for (int i = 0; i < SOC_PCNT_CHANNELS_PER_UNIT; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(CHANS_PER_UNIT); i++) {
         if (!unit->channels[i]) {
             channel_id = i;
             unit->channels[channel_id] = channel;
@@ -794,25 +794,25 @@ esp_err_t pcnt_new_channel(pcnt_unit_handle_t unit, const pcnt_chan_config_t *co
         gpio_func_sel(config->edge_gpio_num, PIN_FUNC_GPIO);
         gpio_input_enable(config->edge_gpio_num);
         esp_rom_gpio_connect_in_signal(config->edge_gpio_num,
-                                       pcnt_periph_signals.groups[group_id].units[unit_id].channels[channel_id].pulse_sig,
+                                       soc_pcnt_signals[group_id].units[unit_id].channels[channel_id].pulse_sig_id_matrix,
                                        config->flags.invert_edge_input);
     } else {
         // using virtual IO
         esp_rom_gpio_connect_in_signal(config->flags.virt_edge_io_level ? GPIO_MATRIX_CONST_ONE_INPUT : GPIO_MATRIX_CONST_ZERO_INPUT,
-                                       pcnt_periph_signals.groups[group_id].units[unit_id].channels[channel_id].pulse_sig,
+                                       soc_pcnt_signals[group_id].units[unit_id].channels[channel_id].pulse_sig_id_matrix,
                                        config->flags.invert_edge_input);
     }
 
     if (config->level_gpio_num >= 0) {
         gpio_func_sel(config->level_gpio_num, PIN_FUNC_GPIO);
         gpio_input_enable(config->level_gpio_num);
         esp_rom_gpio_connect_in_signal(config->level_gpio_num,
-                                       pcnt_periph_signals.groups[group_id].units[unit_id].channels[channel_id].control_sig,
+                                       soc_pcnt_signals[group_id].units[unit_id].channels[channel_id].ctl_sig_id_matrix,
                                        config->flags.invert_level_input);
     } else {
         // using virtual IO
         esp_rom_gpio_connect_in_signal(config->flags.virt_level_io_level ? GPIO_MATRIX_CONST_ONE_INPUT : GPIO_MATRIX_CONST_ZERO_INPUT,
-                                       pcnt_periph_signals.groups[group_id].units[unit_id].channels[channel_id].control_sig,
+                                       soc_pcnt_signals[group_id].units[unit_id].channels[channel_id].ctl_sig_id_matrix,
                                        config->flags.invert_level_input);
     }
 
@@ -846,12 +846,12 @@ esp_err_t pcnt_del_channel(pcnt_channel_handle_t chan)
 
     if (chan->level_gpio_num >= 0) {
         esp_rom_gpio_connect_in_signal(GPIO_MATRIX_CONST_ONE_INPUT,
-                                       pcnt_periph_signals.groups[group_id].units[unit_id].channels[channel_id].control_sig,
+                                       soc_pcnt_signals[group_id].units[unit_id].channels[channel_id].ctl_sig_id_matrix,
                                        0);
     }
     if (chan->edge_gpio_num >= 0) {
         esp_rom_gpio_connect_in_signal(GPIO_MATRIX_CONST_ONE_INPUT,
-                                       pcnt_periph_signals.groups[group_id].units[unit_id].channels[channel_id].pulse_sig,
+                                       soc_pcnt_signals[group_id].units[unit_id].channels[channel_id].pulse_sig_id_matrix,
                                        0);
     }
 

components/esp_driver_pcnt/test_apps/pulse_cnt/main/test_pulse_cnt.c

@@ -9,12 +9,13 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "unity.h"
+#include "soc/soc_caps.h"
+#include "soc/pcnt_periph.h"
+#include "hal/pcnt_ll.h"
 #include "driver/pulse_cnt.h"
 #include "driver/gpio.h"
-#include "soc/soc_caps.h"
 #include "esp_attr.h"
 #include "test_pulse_cnt_board.h"
-#include "hal/pcnt_ll.h"
 
 TEST_CASE("pcnt_unit_install_uninstall", "[pcnt]")
 {
@@ -23,21 +24,21 @@ TEST_CASE("pcnt_unit_install_uninstall", "[pcnt]")
         .high_limit = 100,
         .intr_priority = 0,
     };
-    pcnt_unit_handle_t units[SOC_PCNT_UNITS_PER_GROUP];
+    pcnt_unit_handle_t units[SOC_PCNT_ATTR(UNITS_PER_INST)];
     int count_value = 0;
 
     printf("install pcnt units and check initial count\r\n");
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP - 1; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST) - 1; i++) {
         TEST_ESP_OK(pcnt_new_unit(&unit_config, &units[i]));
         TEST_ESP_OK(pcnt_unit_get_count(units[i], &count_value));
         TEST_ASSERT_EQUAL(0, count_value);
     }
 
     // unit with a different interrupt priority
     unit_config.intr_priority = 3;
-    TEST_ESP_ERR(ESP_ERR_INVALID_STATE, pcnt_new_unit(&unit_config, &units[SOC_PCNT_UNITS_PER_GROUP - 1]));
+    TEST_ESP_ERR(ESP_ERR_INVALID_STATE, pcnt_new_unit(&unit_config, &units[SOC_PCNT_ATTR(UNITS_PER_INST) - 1]));
     unit_config.intr_priority = 0;
-    TEST_ESP_OK(pcnt_new_unit(&unit_config, &units[SOC_PCNT_UNITS_PER_GROUP - 1]));
+    TEST_ESP_OK(pcnt_new_unit(&unit_config, &units[SOC_PCNT_ATTR(UNITS_PER_INST) - 1]));
 
     // no more free pcnt units
     TEST_ASSERT_EQUAL(ESP_ERR_NOT_FOUND, pcnt_new_unit(&unit_config, &units[0]));
@@ -46,7 +47,7 @@ TEST_CASE("pcnt_unit_install_uninstall", "[pcnt]")
     pcnt_glitch_filter_config_t filter_config = {
         .max_glitch_ns = 1000,
     };
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST); i++) {
         TEST_ESP_OK(pcnt_unit_set_glitch_filter(units[i], &filter_config));
     }
     // invalid glitch configuration
@@ -56,30 +57,30 @@ TEST_CASE("pcnt_unit_install_uninstall", "[pcnt]")
         .on_reach = NULL,
     };
     printf("enable pcnt units\r\n");
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST); i++) {
         TEST_ESP_OK(pcnt_unit_register_event_callbacks(units[i], &cbs, NULL));
         TEST_ESP_OK(pcnt_unit_enable(units[i]));
     }
 
     printf("start pcnt units\r\n");
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST); i++) {
         TEST_ESP_OK(pcnt_unit_start(units[i]));
     }
 
     printf("stop pcnt units\r\n");
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST); i++) {
         TEST_ESP_OK(pcnt_unit_stop(units[i]));
     }
 
     // can't uninstall unit before disable it
     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_STATE, pcnt_del_unit(units[0]));
     printf("disable pcnt units\r\n");
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST); i++) {
         TEST_ESP_OK(pcnt_unit_disable(units[i]));
     }
 
     printf("uninstall pcnt units\r\n");
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST); i++) {
         TEST_ESP_OK(pcnt_del_unit(units[i]));
     }
 }
@@ -96,17 +97,17 @@ TEST_CASE("pcnt_channel_install_uninstall", "[pcnt]")
         .edge_gpio_num = TEST_PCNT_GPIO_A, // only detect edge signal in this case
         .level_gpio_num = -1,
     };
-    pcnt_unit_handle_t units[SOC_PCNT_UNITS_PER_GROUP];
-    pcnt_channel_handle_t chans[SOC_PCNT_UNITS_PER_GROUP][SOC_PCNT_CHANNELS_PER_UNIT];
+    pcnt_unit_handle_t units[SOC_PCNT_ATTR(UNITS_PER_INST)];
+    pcnt_channel_handle_t chans[SOC_PCNT_ATTR(UNITS_PER_INST)][SOC_PCNT_ATTR(CHANS_PER_UNIT)];
 
     printf("install pcnt units\r\n");
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST); i++) {
         TEST_ESP_OK(pcnt_new_unit(&unit_config, &units[i]));
     }
 
     printf("install pcnt channels\r\n");
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP; i++) {
-        for (int j = 0; j < SOC_PCNT_CHANNELS_PER_UNIT; j++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST); i++) {
+        for (int j = 0; j < SOC_PCNT_ATTR(CHANS_PER_UNIT); j++) {
             TEST_ESP_OK(pcnt_new_channel(units[i], &chan_config, &chans[i][j]));
             TEST_ESP_OK(pcnt_channel_set_edge_action(chans[i][j], PCNT_CHANNEL_EDGE_ACTION_INCREASE, PCNT_CHANNEL_EDGE_ACTION_HOLD));
             TEST_ESP_OK(pcnt_channel_set_level_action(chans[i][j], PCNT_CHANNEL_LEVEL_ACTION_KEEP, PCNT_CHANNEL_LEVEL_ACTION_KEEP));
@@ -117,55 +118,55 @@ TEST_CASE("pcnt_channel_install_uninstall", "[pcnt]")
 
     printf("start units\r\n");
     int count_value = 0;
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST); i++) {
         // start unit
         TEST_ESP_OK(pcnt_unit_start(units[i]));
         // trigger 10 rising edge on GPIO0
         test_gpio_simulate_rising_edge(TEST_PCNT_GPIO_A, 10);
         TEST_ESP_OK(pcnt_unit_get_count(units[i], &count_value));
         // each channel increases to the same unit counter
-        TEST_ASSERT_EQUAL(10 * SOC_PCNT_CHANNELS_PER_UNIT, count_value);
+        TEST_ASSERT_EQUAL(10 * SOC_PCNT_ATTR(CHANS_PER_UNIT), count_value);
     }
 
     printf("clear counts\r\n");
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST); i++) {
         TEST_ESP_OK(pcnt_unit_clear_count(units[i]));
         TEST_ESP_OK(pcnt_unit_get_count(units[i], &count_value));
         TEST_ASSERT_EQUAL(0, count_value);
     }
 
     printf("stop unit\r\n");
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST); i++) {
         // stop unit
         TEST_ESP_OK(pcnt_unit_stop(units[i]));
     }
 
     // trigger 10 rising edge on GPIO0 shouldn't increase the counter
     test_gpio_simulate_rising_edge(TEST_PCNT_GPIO_A, 10);
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST); i++) {
         TEST_ESP_OK(pcnt_unit_get_count(units[i], &count_value));
         TEST_ASSERT_EQUAL(0, count_value);
     }
 
     printf("restart units\r\n");
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST); i++) {
         // start unit
         TEST_ESP_OK(pcnt_unit_start(units[i]));
         // trigger 10 rising edge on GPIO
         test_gpio_simulate_rising_edge(TEST_PCNT_GPIO_A, 10);
         TEST_ESP_OK(pcnt_unit_get_count(units[i], &count_value));
         // each channel increases to the same unit counter
-        TEST_ASSERT_EQUAL(10 * SOC_PCNT_CHANNELS_PER_UNIT, count_value);
+        TEST_ASSERT_EQUAL(10 * SOC_PCNT_ATTR(CHANS_PER_UNIT), count_value);
     }
 
     printf("uninstall channels and units\r\n");
-    for (int i = 0; i < SOC_PCNT_UNITS_PER_GROUP; i++) {
+    for (int i = 0; i < SOC_PCNT_ATTR(UNITS_PER_INST); i++) {
         // stop unit
         TEST_ESP_OK(pcnt_unit_stop(units[i]));
         TEST_ESP_OK(pcnt_unit_disable(units[i]));
         // can't uninstall unit when channel is still alive
         TEST_ASSERT_EQUAL(ESP_ERR_INVALID_STATE, pcnt_del_unit(units[i]));
-        for (int j = 0; j < SOC_PCNT_CHANNELS_PER_UNIT; j++) {
+        for (int j = 0; j < SOC_PCNT_ATTR(CHANS_PER_UNIT); j++) {
             TEST_ESP_OK(pcnt_del_channel(chans[i][j]));
         }
         TEST_ESP_OK(pcnt_del_unit(units[i]));

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

@@ -559,22 +559,6 @@ config SOC_MPU_REGION_WO_SUPPORTED
     bool
     default n
 
-config SOC_PCNT_GROUPS
-    int
-    default 1
-
-config SOC_PCNT_UNITS_PER_GROUP
-    int
-    default 8
-
-config SOC_PCNT_CHANNELS_PER_UNIT
-    int
-    default 2
-
-config SOC_PCNT_THRES_POINT_PER_UNIT
-    int
-    default 2
-
 config SOC_RMT_GROUPS
     int
     default 1

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

@@ -275,12 +275,6 @@
 #define SOC_MPU_REGION_RO_SUPPORTED               0
 #define SOC_MPU_REGION_WO_SUPPORTED               0
 
-/*-------------------------- PCNT CAPS ---------------------------------------*/
-#define SOC_PCNT_GROUPS                  (1U)
-#define SOC_PCNT_UNITS_PER_GROUP         (8)
-#define SOC_PCNT_CHANNELS_PER_UNIT       (2)
-#define SOC_PCNT_THRES_POINT_PER_UNIT    (2)
-
 /*-------------------------- RMT CAPS ----------------------------------------*/
 #define SOC_RMT_GROUPS                  1U /*!< One RMT group */
 #define SOC_RMT_TX_CANDIDATES_PER_GROUP 8  /*!< Number of channels that capable of Transmit in each group */

components/soc/esp32/include/soc/soc_caps_full.h

@@ -23,3 +23,9 @@
 /*--------------------------- SDM (Sigma-Delta Modulator) ------------------------*/
 #define _SOC_CAPS_SDM_INST_NUM                    1  // Number of SDM instances
 #define _SOC_CAPS_SDM_CHANS_PER_INST              8  // Number of channels in each SDM instance
+
+/*--------------------------- PCNT (Pulse Counter) ------------------------*/
+#define _SOC_CAPS_PCNT_INST_NUM                   1  // Number of PCNT instances
+#define _SOC_CAPS_PCNT_UNITS_PER_INST             8  // Number of units in each PCNT instance
+#define _SOC_CAPS_PCNT_CHANS_PER_UNIT             2  // Number of channels in each PCNT unit
+#define _SOC_CAPS_PCNT_THRES_POINT_PER_UNIT       2  // Number of threshold points in each PCNT unit