Fix compatibility issues for ESP-IDF v5.3.2 and add es3c28p target support

Platforms/platform-esp32/CMakeLists.txt

@@ -6,7 +6,7 @@ idf_component_register(
     SRCS ${SOURCES}
     INCLUDE_DIRS "include/"
     PRIV_INCLUDE_DIRS "private/"
-    REQUIRES TactilityKernel driver esp_driver_i2c vfs fatfs
+    REQUIRES TactilityKernel driver vfs fatfs
 )
 
 idf_component_optional_requires(PRIVATE bt usb espressif__usb_host_hid espressif__usb_host_msc)

Platforms/platform-esp32/private/bluetooth/esp32_ble_internal.h

@@ -167,4 +167,11 @@ bool ble_hci_gate_wait_idle(int max_ms);
 #endif
 #endif // CONFIG_ESP_HOSTED_ENABLED
 
+#ifdef min
+#undef min
+#endif
+#ifdef max
+#undef max
+#endif
+
 #endif // CONFIG_BT_NIMBLE_ENABLED

Platforms/platform-esp32/source/drivers/esp32_gpio.cpp

@@ -1,5 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 #include <driver/gpio.h>
+#include <soc/soc.h>
+#include <soc/gpio_periph.h>
+#include <soc/gpio_struct.h>
+#include <soc/io_mux_reg.h>
 
 #include <tactility/driver.h>
 #include <tactility/drivers/esp32_gpio.h>
@@ -65,30 +69,34 @@ static error_t set_flags(GpioDescriptor* descriptor, gpio_flags_t flags) {
 }
 
 static error_t get_flags(GpioDescriptor* descriptor, gpio_flags_t* flags) {
-    gpio_io_config_t esp_config;
-    if (gpio_get_io_config(static_cast<gpio_num_t>(descriptor->pin), &esp_config) != ESP_OK) {
-        return ERROR_RESOURCE;
-    }
-
+    auto pin = static_cast<gpio_num_t>(descriptor->pin);
     gpio_flags_t output = 0;
 
-    if (esp_config.pu) {
+    // Read pull-up, pull-down, input-enable from IO MUX register
+    uint32_t pin_mux = REG_READ(GPIO_PIN_MUX_REG[pin]);
+    if (pin_mux & FUN_PU) {
         output |= GPIO_FLAG_PULL_UP;
     }
-
-    if (esp_config.pd) {
+    if (pin_mux & FUN_PD) {
         output |= GPIO_FLAG_PULL_DOWN;
     }
-
-    if (esp_config.ie) {
+    if (pin_mux & FUN_IE) {
         output |= GPIO_FLAG_DIRECTION_INPUT;
     }
 
-    if (esp_config.oe) {
+    // Read output-enable from GPIO matrix
+    bool oe = false;
+    if (pin < 32) {
+        oe = (GPIO.enable & (1UL << pin)) != 0;
+    } else {
+        oe = (GPIO.enable1.data & (1UL << (pin - 32))) != 0;
+    }
+    if (oe) {
         output |= GPIO_FLAG_DIRECTION_OUTPUT;
     }
 
-    if (esp_config.oe_inv) {
+    // Read output-inversion from GPIO matrix
+    if (GPIO.func_out_sel_cfg[pin].inv_sel) {
         output |= GPIO_FLAG_ACTIVE_LOW;
     }
 

Platforms/platform-esp32/source/drivers/esp32_i2c_master.cpp

@@ -2,6 +2,8 @@
 #include <driver/i2c_master.h>
 
 #include <new>
+#include <cstring>
+#include <cstdlib>
 
 #include <tactility/error_esp32.h>
 #include <tactility/driver.h>
@@ -39,12 +41,48 @@ struct Esp32I2cMasterInternal {
 #define lock(data) mutex_lock(&data->mutex);
 #define unlock(data) mutex_unlock(&data->mutex);
 
+struct MyI2cMasterDev {
+    void* master_bus;
+    uint16_t device_address;
+};
+
+static esp_err_t my_i2c_master_device_change_address(i2c_master_dev_handle_t i2c_dev, uint16_t new_device_address, int timeout_ms) {
+    if (i2c_dev == nullptr) return ESP_ERR_INVALID_ARG;
+    auto* dev = reinterpret_cast<MyI2cMasterDev*>(i2c_dev);
+    dev->device_address = new_device_address;
+    return ESP_OK;
+}
+
+static esp_err_t my_i2c_master_transmit_multi_buffer(i2c_master_dev_handle_t dev_handle, uint8_t reg, const uint8_t* data, uint16_t data_size, int timeout_ms) {
+    uint32_t total_size = data_size + 1;
+    if (total_size <= 128) {
+        uint8_t temp_buf[128];
+        temp_buf[0] = reg;
+        if (data_size > 0 && data != nullptr) {
+            std::memcpy(temp_buf + 1, data, data_size);
+        }
+        return i2c_master_transmit(dev_handle, temp_buf, total_size, timeout_ms);
+    } else {
+        uint8_t* temp_buf = (uint8_t*)std::malloc(total_size);
+        if (temp_buf == nullptr) {
+            return ESP_ERR_NO_MEM;
+        }
+        temp_buf[0] = reg;
+        if (data_size > 0 && data != nullptr) {
+            std::memcpy(temp_buf + 1, data, data_size);
+        }
+        esp_err_t ret = i2c_master_transmit(dev_handle, temp_buf, total_size, timeout_ms);
+        std::free(temp_buf);
+        return ret;
+    }
+}
+
 // Switches the device's target address only when it differs from the currently configured one.
 static esp_err_t ensure_address(Esp32I2cMasterInternal* driver_data, uint8_t address, int timeout_ms) {
     if (driver_data->current_address == address) {
         return ESP_OK;
     }
-    esp_err_t esp_error = i2c_master_device_change_address(driver_data->dev_handle, address, timeout_ms);
+    esp_err_t esp_error = my_i2c_master_device_change_address(driver_data->dev_handle, address, timeout_ms);
     if (esp_error == ESP_OK) {
         driver_data->current_address = address;
     }
@@ -149,11 +187,7 @@ static error_t write_register(Device* device, uint8_t address, uint8_t reg, cons
     if (esp_error != ESP_OK) {
         LOG_E(TAG, "change_address(0x%02X) failed: %s", address, esp_err_to_name(esp_error));
     } else {
-        i2c_master_transmit_multi_buffer_info_t buffers[2] = {
-            {.write_buffer = &reg, .buffer_size = 1},
-            {.write_buffer = data, .buffer_size = data_size}
-        };
-        esp_error = i2c_master_multi_buffer_transmit(driver_data->dev_handle, buffers, 2, timeout_ms);
+        esp_error = my_i2c_master_transmit_multi_buffer(driver_data->dev_handle, reg, data, data_size, timeout_ms);
         if (esp_error != ESP_OK) {
             LOG_E(TAG, "write_register(0x%02X, reg=0x%02X) failed: %s", address, reg, esp_err_to_name(esp_error));
         }
@@ -212,7 +246,6 @@ static error_t start(Device* device) {
         .trans_queue_depth = 0,
         .flags = {
             .enable_internal_pullup = ((sda_spec.flags & GPIO_FLAG_PULL_UP) != 0) || ((scl_spec.flags & GPIO_FLAG_PULL_UP) != 0),
-            .allow_pd = 0,
         }
     };
 
@@ -307,7 +340,7 @@ extern Module platform_esp32_module;
 
 Driver esp32_i2c_master_driver = {
     .name = "esp32_i2c_master",
-    .compatible = (const char*[]) { "espressif,esp32-i2c-master", nullptr },
+    .compatible = (const char*[]) { "espressif,esp32-i2c", "espressif,esp32-i2c-master", nullptr },
     .start_device = start,
     .stop_device = stop,
     .api = &ESP32_I2C_MASTER_API,

Platforms/platform-esp32/source/drivers/esp32_i2s.cpp

@@ -18,6 +18,7 @@
 #include <tactility/drivers/esp32_i2s.h>
 
 #include <new>
+#include <cstring>
 
 #define TAG "esp32_i2s"
 

Platforms/platform-esp32/source/drivers/esp32_sdmmc_fs.cpp

@@ -14,6 +14,11 @@
 #include <freertos/task.h>
 #include <sdmmc_cmd.h>
 #include <string>
+#include <cstring>
+
+#ifndef SDMMC_SLOT_FLAG_UHS1
+#define SDMMC_SLOT_FLAG_UHS1 0
+#endif
 
 #if SOC_SD_PWR_CTRL_SUPPORTED
 #include <sd_pwr_ctrl_by_on_chip_ldo.h>

Platforms/platform-esp32/source/drivers/esp32_spi.cpp

@@ -101,7 +101,6 @@ static error_t start(Device* device) {
         .data5_io_num = GPIO_NUM_NC,
         .data6_io_num = GPIO_NUM_NC,
         .data7_io_num = GPIO_NUM_NC,
-        .data_io_default_level = false,
         .max_transfer_sz = dts_config->max_transfer_size,
         .flags = 0,
         .isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,

Platforms/platform-esp32/source/drivers/esp32_uart.cpp

@@ -13,6 +13,7 @@
 #include <tactility/drivers/esp32_gpio_helpers.h>
 
 #include <new>
+#include <cstring>
 
 #define TAG "esp32_uart"
 
@@ -264,10 +265,6 @@ static error_t open(Device* device) {
         .flow_ctrl = UART_HW_FLOWCTRL_DISABLE, // Flow control is not yet exposed via UartConfig
         .rx_flow_ctrl_thresh = 0,
         .source_clk = UART_SCLK_DEFAULT,
-        .flags = {
-            .allow_pd = 0,
-            .backup_before_sleep = 0
-        }
     };
 
     if (dts_config->pin_cts.gpio_controller != nullptr || dts_config->pin_rts.gpio_controller != nullptr) {

Platforms/platform-esp32/source/drivers/usb/esp32_usbhost.cpp

@@ -70,8 +70,6 @@ static error_t start_device(struct Device* device) {
         .root_port_unpowered = false,
         .intr_flags          = ESP_INTR_FLAG_LEVEL1,
         .enum_filter_cb      = nullptr,
-        .fifo_settings_custom = {},
-        .peripheral_map      = cfg->peripheral_map,
     };
 
     esp_err_t ret = usb_host_install(&host_cfg);