Merge branch 'feature/i2s_support_merge_simplex_to_duplex_v5.1' into 'release/v5.1'

feat(i2s): support to lazy constitute full-duplex mode (v5.1)

See merge request espressif/esp-idf!41846

Author: suda-morris

components/driver/i2s/i2s_common.c

@@ -211,12 +211,6 @@ static inline bool i2s_take_available_channel(i2s_controller_t *i2s_obj, uint8_t
 {
     bool is_available = false;
 
-#if SOC_I2S_HW_VERSION_1
-    /* In ESP32 and ESP32-S2, tx channel and rx channel are not totally separated
-     * Take both two channels in case one channel can affect another
-     */
-    chan_search_mask = I2S_DIR_RX | I2S_DIR_TX;
-#endif
     portENTER_CRITICAL(&g_i2s.spinlock);
     if (!(chan_search_mask & i2s_obj->chan_occupancy)) {
         i2s_obj->chan_occupancy |= chan_search_mask;
@@ -731,11 +725,11 @@ void i2s_gpio_check_and_set(gpio_num_t gpio, uint32_t signal_idx, bool is_input,
     if (gpio != I2S_GPIO_UNUSED) {
         gpio_hal_iomux_func_sel(GPIO_PIN_MUX_REG[gpio], PIN_FUNC_GPIO);
         if (is_input) {
-            /* Set direction, for some GPIOs, the input function are not enabled as default */
-            gpio_set_direction(gpio, GPIO_MODE_INPUT);
+            /* Enable the input, for some GPIOs, the input function are not enabled as default */
+            gpio_ll_input_enable(GPIO_HAL_GET_HW(GPIO_PORT_0), (uint32_t)gpio);
             esp_rom_gpio_connect_in_signal(gpio, signal_idx, is_invert);
         } else {
-            gpio_set_direction(gpio, GPIO_MODE_OUTPUT);
+            /* output will be enabled in esp_rom_gpio_connect_out_signal */
             esp_rom_gpio_connect_out_signal(gpio, signal_idx, is_invert, 0);
         }
     }
@@ -745,7 +739,7 @@ void i2s_gpio_loopback_set(gpio_num_t gpio, uint32_t out_sig_idx, uint32_t in_si
 {
     if (gpio != I2S_GPIO_UNUSED) {
         gpio_hal_iomux_func_sel(GPIO_PIN_MUX_REG[gpio], PIN_FUNC_GPIO);
-        gpio_set_direction(gpio, GPIO_MODE_INPUT_OUTPUT);
+        gpio_ll_input_enable(GPIO_HAL_GET_HW(GPIO_PORT_0), (uint32_t)gpio);
         esp_rom_gpio_connect_out_signal(gpio, out_sig_idx, 0, 0);
         esp_rom_gpio_connect_in_signal(gpio, in_sig_idx, 0);
     }

components/driver/i2s/i2s_private.h

@@ -90,6 +90,7 @@ struct i2s_channel_obj_t {
     i2s_state_t             state;          /*!< i2s driver state. Ensuring the driver working in a correct sequence */
     /* Stored configurations */
     void                    *mode_info;     /*!< Slot, clock and gpio information of each mode */
+    bool                    full_duplex_slave; /*!< whether the channel is forced to switch to slave role for full duplex */
 #if SOC_I2S_SUPPORTS_APLL
     bool                    apll_en;        /*!< Flag of wether APLL enabled */
 #endif

components/driver/i2s/i2s_std.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -33,9 +33,10 @@ static esp_err_t i2s_std_calculate_clock(i2s_chan_handle_t handle, const i2s_std
     uint32_t slot_bits = (slot_cfg->slot_bit_width == I2S_SLOT_BIT_WIDTH_AUTO) ||
                          ((int)slot_cfg->slot_bit_width < (int)slot_cfg->data_bit_width) ?
                          slot_cfg->data_bit_width : slot_cfg->slot_bit_width;
+    slot_cfg->slot_bit_width = slot_bits;
     /* Calculate multiple
      * Fmclk = bck_div*fbck = fsclk/(mclk_div+b/a) */
-    if (handle->role == I2S_ROLE_MASTER) {
+    if (handle->role == I2S_ROLE_MASTER || handle->full_duplex_slave) {
         clk_info->bclk = rate * handle->total_slot * slot_bits;
         clk_info->mclk = rate * clk_cfg->mclk_multiple;
         clk_info->bclk_div = clk_info->mclk / clk_info->bclk;
@@ -99,18 +100,13 @@ static esp_err_t i2s_std_set_slot(i2s_chan_handle_t handle, const i2s_std_slot_c
         ESP_RETURN_ON_ERROR(i2s_alloc_dma_desc(handle, buf_size),
                             TAG, "allocate memory for dma descriptor failed");
     }
-    bool is_slave = handle->role == I2S_ROLE_SLAVE;
     /* Share bck and ws signal in full-duplex mode */
     if (handle->controller->full_duplex) {
         i2s_ll_share_bck_ws(handle->controller->hal.dev, true);
-        /* Since bck and ws are shared, only tx or rx can be master
-           Force to set rx as slave to avoid conflict of clock signal */
-        if (handle->dir == I2S_DIR_RX) {
-            is_slave = true;
-        }
     } else {
         i2s_ll_share_bck_ws(handle->controller->hal.dev, false);
     }
+    bool is_slave = handle->role == I2S_ROLE_SLAVE;
 
     portENTER_CRITICAL(&g_i2s.spinlock);
     /* Configure the hardware to apply STD format */
@@ -154,46 +150,96 @@ static esp_err_t i2s_std_set_gpio(i2s_chan_handle_t handle, const i2s_std_gpio_c
         i2s_gpio_check_and_set(gpio_cfg->din, i2s_periph_signal[id].data_in_sig, true, false);
     }
 
-    if (handle->role == I2S_ROLE_SLAVE) {
-        /* For "tx + slave" mode, select TX signal index for ws and bck */
-        if (handle->dir == I2S_DIR_TX && !handle->controller->full_duplex) {
+    /* Set mclk pin */
+    ESP_RETURN_ON_ERROR(i2s_check_set_mclk(id, gpio_cfg->mclk, std_cfg->clk_cfg.clk_src, gpio_cfg->invert_flags.mclk_inv), TAG, "mclk config failed");
+
 #if SOC_I2S_HW_VERSION_2
+    /* Bind the MCLK signal to the TX or RX clock source */
+    if (!handle->controller->full_duplex) {
+        if (handle->dir == I2S_DIR_TX) {
             i2s_ll_mclk_bind_to_tx_clk(handle->controller->hal.dev);
-#endif
-            i2s_gpio_check_and_set(gpio_cfg->ws, i2s_periph_signal[id].s_tx_ws_sig, true, gpio_cfg->invert_flags.ws_inv);
-            i2s_gpio_check_and_set(gpio_cfg->bclk, i2s_periph_signal[id].s_tx_bck_sig, true, gpio_cfg->invert_flags.bclk_inv);
-            /* For "tx + rx + slave" or "rx + slave" mode, select RX signal index for ws and bck */
         } else {
-            i2s_gpio_check_and_set(gpio_cfg->ws, i2s_periph_signal[id].s_rx_ws_sig, true, gpio_cfg->invert_flags.ws_inv);
-            i2s_gpio_check_and_set(gpio_cfg->bclk, i2s_periph_signal[id].s_rx_bck_sig, true, gpio_cfg->invert_flags.bclk_inv);
+            i2s_ll_mclk_bind_to_rx_clk(handle->controller->hal.dev);
         }
-    } else {
-        /* mclk only available in master mode */
-#if SOC_I2S_SUPPORTS_APLL
-        bool is_apll = std_cfg->clk_cfg.clk_src == I2S_CLK_SRC_APLL;
-#else
-        bool is_apll = false;
-#endif
-        ESP_RETURN_ON_ERROR(i2s_check_set_mclk(id, gpio_cfg->mclk, is_apll, gpio_cfg->invert_flags.mclk_inv), TAG, "mclk config failed");
-        /* For "rx + master" mode, select RX signal index for ws and bck */
-        if (handle->dir == I2S_DIR_RX && !handle->controller->full_duplex) {
-#if SOC_I2S_HW_VERSION_2
+    } else if (handle->role == I2S_ROLE_MASTER) {
+        if (handle->dir == I2S_DIR_TX) {
+            i2s_ll_mclk_bind_to_tx_clk(handle->controller->hal.dev);
+        } else {
             i2s_ll_mclk_bind_to_rx_clk(handle->controller->hal.dev);
+        }
+    }
 #endif
-            i2s_gpio_check_and_set(gpio_cfg->ws, i2s_periph_signal[id].m_rx_ws_sig, false, gpio_cfg->invert_flags.ws_inv);
-            i2s_gpio_check_and_set(gpio_cfg->bclk, i2s_periph_signal[id].m_rx_bck_sig, false, gpio_cfg->invert_flags.bclk_inv);
-            /* For "tx + rx + master" or "tx + master" mode, select TX signal index for ws and bck */
+
+    uint32_t ws_sig = 0;
+    uint32_t bck_sig = 0;
+    bool is_input = handle->role == I2S_ROLE_SLAVE;
+    if (handle->role == I2S_ROLE_SLAVE) {
+        // Assign slave signals
+        if (handle->dir == I2S_DIR_TX) {
+            ws_sig = i2s_periph_signal[id].s_tx_ws_sig;
+            bck_sig = i2s_periph_signal[id].s_tx_bck_sig;
         } else {
-            i2s_gpio_check_and_set(gpio_cfg->ws, i2s_periph_signal[id].m_tx_ws_sig, false, gpio_cfg->invert_flags.ws_inv);
-            i2s_gpio_check_and_set(gpio_cfg->bclk, i2s_periph_signal[id].m_tx_bck_sig, false, gpio_cfg->invert_flags.bclk_inv);
+            ws_sig = i2s_periph_signal[id].s_rx_ws_sig;
+            bck_sig = i2s_periph_signal[id].s_rx_bck_sig;
+        }
+    } else {
+        // Assign master signals
+        if (handle->dir == I2S_DIR_TX) {
+            ws_sig = i2s_periph_signal[id].m_tx_ws_sig;
+            bck_sig = i2s_periph_signal[id].m_tx_bck_sig;
+        } else {
+            ws_sig = i2s_periph_signal[id].m_rx_ws_sig;
+            bck_sig = i2s_periph_signal[id].m_rx_bck_sig;
         }
     }
+    i2s_gpio_check_and_set(gpio_cfg->ws, ws_sig, is_input, gpio_cfg->invert_flags.ws_inv);
+    i2s_gpio_check_and_set(gpio_cfg->bclk, bck_sig, is_input, gpio_cfg->invert_flags.bclk_inv);
+
     /* Update the mode info: gpio configuration */
     memcpy(&(std_cfg->gpio_cfg), gpio_cfg, sizeof(i2s_std_gpio_config_t));
 
     return ESP_OK;
 }
 
+static esp_err_t s_i2s_channel_try_to_constitude_std_duplex(i2s_chan_handle_t handle, const i2s_std_config_t *std_cfg)
+{
+    /* Get another direction handle */
+    i2s_chan_handle_t another_handle = handle->dir == I2S_DIR_RX ? handle->controller->tx_chan : handle->controller->rx_chan;
+    /* Condition: 1. Another direction channel is registered
+     *            2. Not a full-duplex channel yet
+     *            3. Another channel is initialized, try to compare the configurations */
+    if (another_handle && another_handle->state >= I2S_CHAN_STATE_READY) {
+        /* Judge if the two channels can constitute full-duplex */
+        if (!handle->controller->full_duplex) {
+            i2s_std_config_t curr_cfg = *std_cfg;
+            /* Override the slot bit width to the actual slot bit width */
+            curr_cfg.slot_cfg.slot_bit_width = (int)curr_cfg.slot_cfg.slot_bit_width < (int)curr_cfg.slot_cfg.data_bit_width ?
+                                               curr_cfg.slot_cfg.data_bit_width : curr_cfg.slot_cfg.slot_bit_width;
+            /* Compare the hardware configurations of the two channels, constitute the full-duplex if they are the same */
+            if (memcmp(another_handle->mode_info, &curr_cfg, sizeof(i2s_std_config_t)) == 0) {
+                handle->controller->full_duplex = true;
+                ESP_LOGD(TAG, "Constitude full-duplex on port %d", handle->controller->id);
+            }
+#if SOC_I2S_HW_VERSION_1
+            else {
+                ESP_LOGE(TAG, "Can't set different channel configurations on a same port");
+                return ESP_ERR_INVALID_ARG;
+            }
+#endif
+        }
+        /* Switch to the slave role if needed */
+        if (handle->controller->full_duplex &&
+                handle->role == I2S_ROLE_MASTER &&
+                another_handle->role == I2S_ROLE_MASTER) {
+            /* The later initialized channel must be slave for full duplex */
+            handle->role = I2S_ROLE_SLAVE;
+            handle->full_duplex_slave = true;
+        }
+    }
+
+    return ESP_OK;
+}
+
 esp_err_t i2s_channel_init_std_mode(i2s_chan_handle_t handle, const i2s_std_config_t *std_cfg)
 {
 #if CONFIG_I2S_ENABLE_DEBUG_LOG
@@ -211,7 +257,11 @@ esp_err_t i2s_channel_init_std_mode(i2s_chan_handle_t handle, const i2s_std_conf
     handle->mode_info = calloc(1, sizeof(i2s_std_config_t));
     ESP_GOTO_ON_FALSE(handle->mode_info, ESP_ERR_NO_MEM, err, TAG, "no memory for storing the configurations");
     ESP_GOTO_ON_FALSE(handle->state == I2S_CHAN_STATE_REGISTER, ESP_ERR_INVALID_STATE, err, TAG, "the channel has initialized already");
-    ESP_GOTO_ON_ERROR(i2s_std_set_gpio(handle, &std_cfg->gpio_cfg), err, TAG, "initialize channel failed while setting gpio pins");
+    /* Try to constitute full-duplex mode if the STD configuration is totally same as another channel */
+    ret = s_i2s_channel_try_to_constitude_std_duplex(handle, std_cfg);
+#if SOC_I2S_HW_VERSION_1
+    ESP_GOTO_ON_ERROR(ret, err, TAG, "Failed to constitute full-duplex mode");
+#endif
     /* i2s_set_std_slot should be called before i2s_set_std_clock while initializing, because clock is relay on the slot */
     ESP_GOTO_ON_ERROR(i2s_std_set_slot(handle, &std_cfg->slot_cfg), err, TAG, "initialize channel failed while setting slot");
 #if SOC_I2S_SUPPORTS_APLL
@@ -222,6 +272,7 @@ esp_err_t i2s_channel_init_std_mode(i2s_chan_handle_t handle, const i2s_std_conf
     }
 #endif
     ESP_GOTO_ON_ERROR(i2s_std_set_clock(handle, &std_cfg->clk_cfg), err, TAG, "initialize channel failed while setting clock");
+    ESP_GOTO_ON_ERROR(i2s_std_set_gpio(handle, &std_cfg->gpio_cfg), err, TAG, "initialize channel failed while setting gpio pins");
     ESP_GOTO_ON_ERROR(i2s_init_dma_intr(handle, I2S_INTR_ALLOC_FLAGS), err, TAG, "initialize dma interrupt failed");
 #if SOC_I2S_HW_VERSION_2
     /* Enable clock to start outputting mclk signal. Some codecs will reset once mclk stop */