Merge branch 'feat/c5_twaifd_new_driver_c5_only' into 'master'

feat(driver_twai): c5 twaifd new driver (part_1, c5 only)

Closes IDF-8691 and IDF-8692

See merge request espressif/esp-idf!37271

Author: wanckl

components/driver/CMakeLists.txt

@@ -81,9 +81,9 @@ if(CONFIG_SOC_TOUCH_SENSOR_SUPPORTED)
 endif()
 
 # TWAI related source files
-if(CONFIG_SOC_TWAI_SUPPORTED)
+# TWAIFD is not supported by the legacy driver
+if(CONFIG_SOC_TWAI_SUPPORTED AND NOT CONFIG_SOC_TWAI_SUPPORT_FD)
     list(APPEND srcs "twai/twai.c")
-
     list(APPEND ldfragments "twai/linker.lf")
 endif()
 

components/driver/test_apps/.build-test-rules.yml

@@ -82,7 +82,8 @@ components/driver/test_apps/touch_sensor_v2:
 
 components/driver/test_apps/twai:
   disable:
-    - if: SOC_TWAI_SUPPORTED != 1
+    - if: SOC_TWAI_SUPPORTED != 1 or SOC_TWAI_SUPPORT_FD == 1
+      reason: legacy driver doesn't support FD
   depends_filepatterns:
     - components/driver/twai/**/*
   depends_components:

components/esp_driver_twai/CMakeLists.txt

@@ -0,0 +1,22 @@
+idf_build_get_property(target IDF_TARGET)
+
+if(${target} STREQUAL "linux")
+    return() # This component is not supported by the POSIX/Linux simulator
+endif()
+
+set(srcs "esp_twai.c")
+set(public_include "include")
+set(priv_req esp_driver_gpio esp_pm)
+
+# Currently support only FD targets
+if(CONFIG_SOC_TWAI_SUPPORT_FD)
+    list(APPEND srcs "onchip/esp_twai_onchip.c")
+    list(APPEND public_include "onchip/include")
+endif()
+
+idf_component_register(
+    SRCS ${srcs}
+    INCLUDE_DIRS ${public_include}
+    PRIV_REQUIRES ${priv_req}
+    LDFRAGMENTS "linker.lf"
+)

components/esp_driver_twai/Kconfig

@@ -0,0 +1,18 @@
+menu "ESP-Driver:TWAI Configurations"
+    depends on SOC_TWAI_SUPPORTED
+
+    config TWAI_ISR_INTO_IRAM
+        bool "Place TWAI ISR in IRAM to reduce latency"
+        default n
+        help
+            Place ISR functions to IRAM to increase performance
+
+    config TWAI_ISR_CACHE_SAFE
+        bool "Allow TWAI ISR to execute when cache is disabled"
+        select TWAI_ISR_INTO_IRAM
+        default n
+        help
+            Allow TWAI works under Cache disabled, to enabled this config,
+            all callbacks and user_ctx should also place in IRAM
+
+endmenu # TWAI Configuration

components/esp_driver_twai/esp_twai.c

@@ -0,0 +1,153 @@
+/*
+ * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <sys/param.h>
+#include "esp_check.h"
+#include "esp_twai.h"
+#include "esp_private/twai_interface.h"
+#include "esp_private/twai_priv.h"
+
+static const char *TAG = "esp_twai";
+
+/**
+ * @brief Calculate twai timing param by giving bitrate and hardware limit.
+ *
+ * +---------------------------------------------------+
+ * |         bit time in time quanta (total_tq)        |
+ * +--------------+----------+------------+------------+
+ * |   sync_seg   | prop_seg | phase_seg1 | phase_seg2 |
+ * +--------------+----------+------------+------------+
+ * |      1       |        tseg1          |   tseg2    |
+ * +--------------+----------+------------+------------+
+ *                | tseg2/2  ^            ^
+ *                          sjw      sample_point
+ */
+uint32_t twai_node_timing_calc_param(const uint32_t source_freq, const twai_timing_basic_config_t *in_param, const twai_timing_constraint_t *hw_limit, twai_timing_advanced_config_t *out_param)
+{
+    uint32_t total_div = (source_freq + in_param->bitrate / 2) / in_param->bitrate;
+    uint32_t pre_div = hw_limit->brp_min;
+    uint16_t tseg = 0;
+    for (; pre_div <= hw_limit->brp_max; pre_div ++) {
+        tseg = total_div / pre_div;
+        if (total_div != tseg * pre_div) {
+            continue;   // no integer tseg
+        }
+        if ((tseg < (hw_limit->tseg1_max + hw_limit->tseg2_max)) && (tseg >= (hw_limit->tseg1_min + hw_limit->tseg2_min))) {
+            break;
+        }
+    }
+    if (pre_div > hw_limit->brp_max) {  // no valid pre_div
+        return 0;
+    }
+
+    uint16_t default_point = (in_param->bitrate >= 800000) ? 750 : ((in_param->bitrate >= 500000) ? 800 : 875);
+    uint16_t sample_point = in_param->sample_point ? in_param->sample_point : default_point;  // default sample point based on bitrate if not configured
+    uint16_t tseg_1 = (tseg * sample_point) / 1000;
+    tseg_1 = MAX(hw_limit->tseg1_min, MIN(tseg_1, hw_limit->tseg1_max));
+    uint16_t tseg_2 = tseg - tseg_1 - 1;
+    tseg_2 = MAX(hw_limit->tseg2_min, MIN(tseg_2, hw_limit->tseg2_max));
+    tseg_1 = tseg - tseg_2 - 1;
+    uint16_t prop = tseg_1 / 2;     // distribute tseg1 evenly between prop_seg and tseg_1
+    tseg_1 -= prop;
+
+    out_param->quanta_resolution_hz = 0;    // going to deprecated IDF-12725
+    out_param->brp = pre_div;
+    out_param->prop_seg = prop;
+    out_param->tseg_1 = tseg_1;
+    out_param->tseg_2 = tseg_2;
+    out_param->sjw = MAX(1, MIN(tseg_2 >> 1, hw_limit->sjw_max));
+    out_param->ssp_offset = (tseg * in_param->ssp_permill) / 1000;  // ssp is optional, default 0 if not configured
+
+    return source_freq / (pre_div * (prop + tseg_1 + tseg_2 + 1));
+}
+
+esp_err_t twai_node_enable(twai_node_handle_t node)
+{
+    ESP_RETURN_ON_FALSE(node, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null handle");
+    ESP_RETURN_ON_FALSE(node->enable, ESP_ERR_NOT_SUPPORTED, TAG, "enable func null");
+
+    return node->enable(node);
+}
+
+esp_err_t twai_node_disable(twai_node_handle_t node)
+{
+    ESP_RETURN_ON_FALSE(node, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null handle");
+    ESP_RETURN_ON_FALSE(node->disable, ESP_ERR_NOT_SUPPORTED, TAG, "disable func null");
+
+    return node->disable(node);
+}
+
+esp_err_t twai_node_delete(twai_node_handle_t node)
+{
+    ESP_RETURN_ON_FALSE(node, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null handle");
+    ESP_RETURN_ON_FALSE(node->del, ESP_ERR_NOT_SUPPORTED, TAG, "delete func null");
+
+    return node->del(node);
+}
+
+esp_err_t twai_node_config_mask_filter(twai_node_handle_t node, uint8_t filter_id, const twai_mask_filter_config_t *mask_cfg)
+{
+    ESP_RETURN_ON_FALSE(node && mask_cfg, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null");
+    ESP_RETURN_ON_FALSE(node->config_mask_filter, ESP_ERR_NOT_SUPPORTED, TAG, "config_mask_filter func null");
+
+    return node->config_mask_filter(node, filter_id, mask_cfg);
+}
+
+esp_err_t twai_node_config_range_filter(twai_node_handle_t node, uint8_t filter_id, const twai_range_filter_config_t *range_cfg)
+{
+    ESP_RETURN_ON_FALSE(node && range_cfg, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null");
+    ESP_RETURN_ON_FALSE(node->config_range_filter, ESP_ERR_NOT_SUPPORTED, TAG, "config_range_filter func null");
+
+    return node->config_range_filter(node, filter_id, range_cfg);
+}
+
+esp_err_t twai_node_reconfig_timing(twai_node_handle_t node, const twai_timing_advanced_config_t *bit_timing, const twai_timing_advanced_config_t *data_timing)
+{
+    ESP_RETURN_ON_FALSE(node && (bit_timing || data_timing), ESP_ERR_INVALID_ARG, TAG, "invalid argument: null");
+    ESP_RETURN_ON_FALSE(node->timing_reconfig, ESP_ERR_NOT_SUPPORTED, TAG, "timing_reconfig func null");
+
+    return node->timing_reconfig(node, bit_timing, data_timing);
+}
+
+esp_err_t twai_node_register_event_callbacks(twai_node_handle_t node, const twai_event_callbacks_t *cbs, void *user_data)
+{
+    ESP_RETURN_ON_FALSE(node && cbs, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null");
+    ESP_RETURN_ON_FALSE(node->register_cbs, ESP_ERR_NOT_SUPPORTED, TAG, "register_cbs func null");
+
+    return node->register_cbs(node, cbs, user_data);
+}
+
+esp_err_t twai_node_recover(twai_node_handle_t node)
+{
+    ESP_RETURN_ON_FALSE(node, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null handle");
+    ESP_RETURN_ON_FALSE(node->recover, ESP_ERR_NOT_SUPPORTED, TAG, "recover func null");
+
+    return node->recover(node);
+}
+
+esp_err_t twai_node_get_info(twai_node_handle_t node, twai_node_status_t *status_ret, twai_node_record_t *statistics_ret)
+{
+    ESP_RETURN_ON_FALSE(node, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null handle");
+    ESP_RETURN_ON_FALSE(node->get_info, ESP_ERR_NOT_SUPPORTED, TAG, "get_info func null");
+
+    return node->get_info(node, status_ret, statistics_ret);
+}
+
+esp_err_t twai_node_transmit(twai_node_handle_t node, const twai_frame_t *frame, int timeout_ms)
+{
+    ESP_RETURN_ON_FALSE(node && frame, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null");
+    ESP_RETURN_ON_FALSE(node->transmit, ESP_ERR_NOT_SUPPORTED, TAG, "transmit func null");
+
+    return node->transmit(node, frame, timeout_ms);
+}
+
+esp_err_t twai_node_receive_from_isr(twai_node_handle_t node, twai_frame_header_t *header, uint8_t *rx_buffer, size_t buf_sz, size_t *received_len)
+{
+    ESP_RETURN_ON_FALSE_ISR(node && header, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null");
+    ESP_RETURN_ON_FALSE_ISR(node->receive_isr, ESP_ERR_NOT_SUPPORTED, TAG, "receive func null");
+
+    return node->receive_isr(node, header, rx_buffer, buf_sz, received_len);
+}

components/esp_driver_twai/include/esp_private/twai_interface.h

@@ -0,0 +1,145 @@
+/*
+ * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include <stdbool.h>
+#include "esp_err.h"
+#include "esp_twai_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief ESP TWAI driver API set definition
+ */
+struct twai_node_base {
+    /**
+     * @brief Enable the TWAI node
+     *
+     * @param[in] node Pointer to the TWAI node base
+     * @return esp_err_t
+     *      - ESP_OK: Success
+     *      - ESP_FAIL: Failed to enable the node
+     */
+    esp_err_t (*enable)(struct twai_node_base *node);
+
+    /**
+     * @brief Disable the TWAI node
+     *
+     * @param[in] node Pointer to the TWAI node base
+     * @return esp_err_t
+     *      - ESP_OK: Success
+     *      - ESP_FAIL: Failed to disable the node
+     */
+    esp_err_t (*disable)(struct twai_node_base *node);
+
+    /**
+     * @brief Delete the TWAI node and free its resources
+     *
+     * @param[in] node Pointer to the TWAI node base
+     * @return esp_err_t
+     *      - ESP_OK: Success
+     *      - ESP_FAIL: Failed to delete the node
+     */
+    esp_err_t (*del)(struct twai_node_base *node);
+
+    /**
+     * @brief Configure the mask filter of the TWAI node
+     *
+     * @param node Pointer to the TWAI node base
+     * @param filter_id Index of the filter to configure
+     * @param mask_cfg Pointer to the mask filter configuration
+     * @return ESP_OK on success, error code otherwise
+     */
+    esp_err_t (*config_mask_filter)(struct twai_node_base *node, uint8_t filter_id, const twai_mask_filter_config_t *mask_cfg);
+
+    /**
+     * @brief Configure the range filter of the TWAI node
+     *
+     * @param node Pointer to the TWAI node base
+     * @param filter_id Index of the filter to configure
+     * @param range_cfg Pointer to the range filter configuration
+     * @return ESP_OK on success, error code otherwise
+     */
+    esp_err_t (*config_range_filter)(struct twai_node_base *node, uint8_t filter_id, const twai_range_filter_config_t *range_cfg);
+
+    /**
+     * @brief Reconfigure the timing parameters for the TWAI node
+     *
+     * @param[in] node Pointer to the TWAI node base
+     * @param bit_timing Pointer to new twai cc(classic) or arbitration phase of twai fd timing configuration
+     * @param data_timing Pointer to new twai fd timing configuration
+     * @return esp_err_t
+     *      - ESP_OK: Success
+     *      - ESP_ERR_INVALID_ARG: Invalid timing configuration
+     */
+    esp_err_t (*timing_reconfig)(struct twai_node_base *node, const twai_timing_advanced_config_t *bit_timing, const twai_timing_advanced_config_t *data_timing);
+
+    /**
+     * @brief Transmit a TWAI frame through the TWAI node
+     *
+     * @param[in] node Pointer to the TWAI node base
+     * @param[in] frame Pointer to the frame to transmit
+     * @param[in] timeout Timeout in milliseconds
+     * @return esp_err_t
+     *      - ESP_OK: Success
+     *      - ESP_FAIL: Failed to transmit frame
+     */
+    esp_err_t (*transmit)(struct twai_node_base *node, const twai_frame_t *frame, int timeout);
+
+    /**
+     * @brief Receive a TWAI frame through the ISR callback
+     *
+     * @param[in] node Pointer to the TWAI node base
+     * @param[out] header Where to store frame header
+     * @param[out] rx_buffer Where to store frame data
+     * @param[in] buf_sz Bytes length of rx_buffer
+     * @param[out] received_len Optional, the real data length of rx frame comes from 'header->dlc'
+     * @return esp_err_t
+     *      - ESP_OK: Success
+     *      - ESP_ERR_TIMEOUT: Reception timeout
+     */
+    esp_err_t (*receive_isr)(struct twai_node_base *node, twai_frame_header_t *header, uint8_t *rx_buffer, size_t buf_sz, size_t *received_len);
+
+    /**
+     * @brief Recover the TWAI node from a bus-off state
+     *
+     * @param[in] node Pointer to the TWAI node base
+     * @return esp_err_t
+     *      - ESP_OK: Success
+     *      - ESP_FAIL: Failed to recover node
+     */
+    esp_err_t (*recover)(struct twai_node_base *node);
+
+    /**
+     * @brief Register event callbacks for the TWAI node
+     *
+     * @param[in] node Pointer to the TWAI node base
+     * @param[in] cbs Pointer to the event callback configuration
+     * @param[in] user_data User data to pass to the callbacks
+     * @return esp_err_t
+     *      - ESP_OK: Success
+     *      - ESP_ERR_INVALID_ARG: Invalid callback configuration
+     */
+    esp_err_t (*register_cbs)(struct twai_node_base *node, const twai_event_callbacks_t *cbs, void *user_data);
+
+    /**
+     * @brief Get the status and statistics of the TWAI node
+     *
+     * @param[in] node Pointer to the TWAI node base
+     * @param[out] status_ret Pointer to return the node status
+     * @param[out] record_ret Pointer to return the node statistics
+     * @return esp_err_t
+     *      - ESP_OK: Success
+     *      - ESP_FAIL: Failed to retrieve information
+     */
+    esp_err_t (*get_info)(struct twai_node_base *node, twai_node_status_t *status_ret, twai_node_record_t *record_ret);
+};
+
+#ifdef __cplusplus
+}
+#endif