Esp32HardwareTwai.cxx

Go to the documentation of this file.

 
// Ensure we only compile this code for the ESP32 family of MCUs.
#if defined(ESP_PLATFORM)
 
#include "sdkconfig.h"
 
#if CONFIG_VFS_SUPPORT_TERMIOS
// remove defines added by arduino-esp32 core/esp32/binary.h which are
// duplicated in sys/termios.h which may be included by esp_vfs.h
#undef B110
#undef B1000000
#endif // CONFIG_VFS_SUPPORT_TERMIOS
 
#include <assert.h>
#include <driver/gpio.h>
#include <esp_idf_version.h>
 
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5,1,0)
#include <esp_clk_tree.h>
#endif
#include <esp_private/periph_ctrl.h>
#include <esp_ipc.h>
#include <esp_log.h>
#include <esp_rom_gpio.h>
#include <esp_intr_alloc.h>
#include <esp_task.h>
#include <esp_vfs.h>
#include <fcntl.h>
#include <hal/twai_types.h>
#include <hal/twai_hal.h>
#include <soc/gpio_sig_map.h>
#include <stdint.h>
 
#include "can_frame.h"
#include "can_ioctl.h"
#include "executor/Notifiable.hxx"
#include "freertos_drivers/common/DeviceBuffer.hxx"
#include "freertos_drivers/esp32/Esp32HardwareTwai.hxx"
#include "utils/Atomic.hxx"
#include "utils/logging.h"
 
namespace openmrn_arduino
{
 
static constexpr int TWAI_VFS_FD = 0;
 
static constexpr BaseType_t WATCHDOG_TASK_PRIORITY = ESP_TASK_TCPIP_PRIO - 1;
 
static constexpr BaseType_t WATCHDOG_TASK_STACK = 2548;
 
static constexpr TickType_t STATUS_PRINT_INTERVAL = pdMS_TO_TICKS(10000);
 
static constexpr uint32_t TWAI_DEFAULT_INTERRUPTS = 0xE7;
 
static constexpr uint32_t TWAI_INTERRUPT_FLAGS = ESP_INTR_FLAG_LOWMED;
 
static constexpr const char *TWAI_LOG_TAG = "ESP-TWAI";
 
typedef struct
{
    esp32_twai_stats_t stats;
 
    twai_hal_context_t context;
 
    intr_handle_t isr_handle;
 
    DeviceBuffer<struct can_frame> *tx_buf;
 
    DeviceBuffer<struct can_frame> *rx_buf;
 
    Atomic buf_lock;
 
    Notifiable* readable_notify;
 
    Notifiable* writable_notify;
 
    bool non_blocking;
 
#if CONFIG_VFS_SUPPORT_SELECT
    Atomic select_lock;
 
    esp_vfs_select_sem_t select_sem;
 
    fd_set *readfds;
 
    fd_set readfds_orig;
 
    fd_set *writefds;
 
    fd_set writefds_orig;
 
    fd_set *exceptfds;
 
    fd_set exceptfds_orig;
#endif // CONFIG_VFS_SUPPORT_SELECT
 
    bool active;
 
    os_thread_t wd_thread;
 
    bool report_stats;
} TwaiDriver;
 
static TwaiDriver twai;
 
static inline bool is_twai_running()
{
    return twai_hal_check_state_flags(&twai.context, TWAI_HAL_STATE_FLAG_RUNNING);
}
 
static inline bool is_twai_recovering()
{
    return twai_hal_check_state_flags(&twai.context, TWAI_HAL_STATE_FLAG_RECOVERING);
}
 
static inline bool is_twai_err_warn()
{
    return twai_hal_check_state_flags(&twai.context, TWAI_HAL_STATE_FLAG_ERR_WARN);
}
 
static inline bool is_twai_err_passive()
{
    return twai_hal_check_state_flags(&twai.context, TWAI_HAL_STATE_FLAG_ERR_PASSIVE);
}
 
static inline bool is_twai_bus_off()
{
    return twai_hal_check_state_flags(&twai.context, TWAI_HAL_STATE_FLAG_BUS_OFF);
}
 
static inline bool is_twai_tx_occupied()
{
    return twai_hal_check_state_flags(&twai.context, TWAI_HAL_STATE_FLAG_TX_BUFF_OCCUPIED);
}
 
static inline void twai_purge_rx_queue()
{
    Notifiable* n = nullptr;
    {
        AtomicHolder h(&twai.buf_lock);
        LOG(VERBOSE, "ESP-TWAI: purging RX-Q: %zu", twai.rx_buf->pending());
        twai.stats.rx_missed += twai.rx_buf->pending();
        twai.rx_buf->flush();
        std::swap(n, twai.readable_notify);
    }
    if (n)
    {
        n->notify();
    }
#if CONFIG_VFS_SUPPORT_SELECT
    AtomicHolder l(&twai.select_lock);
    if (FD_ISSET(TWAI_VFS_FD, &twai.exceptfds_orig))
    {
        FD_SET(TWAI_VFS_FD, twai.exceptfds);
        esp_vfs_select_triggered(twai.select_sem);
    }
#endif // CONFIG_VFS_SUPPORT_SELECT
}
 
static inline void twai_purge_tx_queue()
{
    Notifiable* n = nullptr;
    {
        AtomicHolder h(&twai.buf_lock);
        LOG(VERBOSE, "ESP-TWAI: purging TX-Q: %zu", twai.tx_buf->pending());
        twai.stats.tx_failed += twai.tx_buf->pending();
        twai.tx_buf->flush();
        std::swap(n, twai.writable_notify);
    }
    if (n)
    {
        n->notify();
    }
#if CONFIG_VFS_SUPPORT_SELECT
    AtomicHolder l(&twai.select_lock);
    if (FD_ISSET(TWAI_VFS_FD, &twai.exceptfds_orig))
    {
        FD_SET(TWAI_VFS_FD, twai.exceptfds);
        esp_vfs_select_triggered(twai.select_sem);
    }
#endif // CONFIG_VFS_SUPPORT_SELECT
}
 
static ssize_t twai_vfs_write(int fd, const void *buf, size_t size)
{
    LOG(VERBOSE, "ESP-TWAI: write(%d, %p, %zu)", fd, buf, size);
    DASSERT(fd == TWAI_VFS_FD);
    ssize_t sent = 0;
    const struct can_frame *data = (const struct can_frame *)buf;
    size /= sizeof(struct can_frame);
    bool bus_error = false;
    while (size && !bus_error)
    {
        if (is_twai_bus_off())
        {
            // If the TWAI bus is OFF initiate recovery and purge the pending TX queue.
            LOG_ERROR("ESP-TWAI: Bus is OFF, initiating recovery.");
            twai_hal_start_bus_recovery(&twai.context);
            bus_error = true;
            break;
        }
        else if (!is_twai_running())
        {
            LOG_ERROR("ESP-TWAI: TWAI driver is not running, unable to write "
                      "%zu frames.", size);
            bus_error = true;
            break;
        }
 
        size_t frames_written = 0;
        {
            AtomicHolder h(&twai.buf_lock);
            frames_written = twai.tx_buf->put(data, size < 8 ? size : 8);
        }
        if (frames_written == 0)
        {
            // No space in the TX queue
            break;
        }
        else
        {
            twai.stats.tx_processed += frames_written;
        }
 
        if (is_twai_running() && !is_twai_tx_occupied() && frames_written)
        {
            // since the TX buffer is not occupied, retrieve the first
            // frame and transmit it here.
            AtomicHolder h(&twai.buf_lock);
            struct can_frame *frame = nullptr;
            twai_message_t tx_frame;
            twai_hal_frame_t hal_frame;
            if (twai.tx_buf->data_read_pointer(&frame) && frame != nullptr)
            {
                memset(&tx_frame, 0, sizeof(twai_message_t));
                tx_frame.identifier = frame->can_id;
                tx_frame.extd = IS_CAN_FRAME_EFF(*frame);
                tx_frame.rtr = IS_CAN_FRAME_RTR(*frame);
                tx_frame.data_length_code = frame->can_dlc;
                memcpy(tx_frame.data, frame->data, frame->can_dlc);
                twai_hal_format_frame(&tx_frame, &hal_frame);
                twai_hal_set_tx_buffer_and_transmit(&twai.context, &hal_frame);
            }
        }
        sent += frames_written;
        size -= frames_written;
    }
 
    if (bus_error)
    {
        twai_purge_tx_queue();
    }
 
    if (!sent)
    {
        errno = EWOULDBLOCK;
    }
    LOG(VERBOSE, "ESP-TWAI: write() %zu", sent * sizeof(struct can_frame));
    return sent * sizeof(struct can_frame);
}
 
static ssize_t twai_vfs_read(int fd, void *buf, size_t size)
{
    LOG(VERBOSE, "ESP-TWAI: read(%d, %p, %zu)", fd, buf, size);
    DASSERT(fd == TWAI_VFS_FD);
 
    ssize_t received = 0;
    struct can_frame *data = (struct can_frame *)buf;
    size /= sizeof(struct can_frame);
    while (size)
    {
        size_t received_frames = 0;
        {
            AtomicHolder h(&twai.buf_lock);
            received_frames = twai.rx_buf->get(data, size < 8 ? size : 8);
        }
        if (received_frames == 0)
        {
            break;
        }
        twai.stats.rx_processed += received_frames;
        size -= received_frames;
        received += received_frames;
        data += received_frames;
    }
    if (!received)
    {
        errno = EWOULDBLOCK;
        return -1;
    }
 
    LOG(VERBOSE, "ESP-TWAI: read() %zu", received * sizeof(struct can_frame));
    return received * sizeof(struct can_frame);
}
 
static int twai_vfs_open(const char *path, int flags, int mode)
{
    // skip past the '/' that is passed in as first character
    path++;
    twai.non_blocking = (flags & O_NONBLOCK);
 
    LOG(INFO, "ESP-TWAI: Starting TWAI driver on:%s mode:%x (%s) fd:%d",
        path, mode, twai.non_blocking ? "non-blocking" : "blocking", 
        TWAI_VFS_FD);
    twai_purge_rx_queue();
    twai_purge_tx_queue();
    twai_hal_start(&twai.context, TWAI_MODE_NORMAL);
    return TWAI_VFS_FD;
}
 
static int twai_vfs_close(int fd)
{
    LOG(INFO, "ESP-TWAI: Disabling TWAI driver using fd:%d", fd);
    twai_purge_rx_queue();
    twai_purge_tx_queue();
    twai_hal_stop(&twai.context);
    return 0;
}
 
static int twai_vfs_ioctl(int fd, int cmd, va_list args)
{
    /* sanity check to be sure we have a valid key for this device */
    HASSERT(IOC_TYPE(cmd) == CAN_IOC_MAGIC);
 
    // Will be called at the end if non-null.
    Notifiable* n = nullptr;
 
    if (IOC_SIZE(cmd) == NOTIFIABLE_TYPE)
    {
        n = reinterpret_cast<Notifiable*>(va_arg(args, uintptr_t));
    }
 
    switch (cmd)
    {
        default:
            return -EINVAL;
        case CAN_IOC_READ_ACTIVE:
            {
                AtomicHolder h(&twai.buf_lock);
                if (!twai.rx_buf->pending())
                {
                    std::swap(n, twai.readable_notify);
                }
            }
            break;
        case CAN_IOC_WRITE_ACTIVE:
            {
                AtomicHolder h(&twai.buf_lock);
                if (!twai.tx_buf->space())
                {
                    std::swap(n, twai.writable_notify);
                }
            }
            break;
    }
    if (n)
    {
        n->notify();
    }
    return 0;
}
 
static int twai_vfs_fcntl(int fd, int cmd, int arg)
{
    HASSERT(fd == TWAI_VFS_FD);
    int result = 0;
 
    if (cmd == F_GETFL)
    {
        if (twai.non_blocking)
        {
            result |= O_NONBLOCK;
        }
    }
    else if (cmd == F_SETFL)
    {
        twai.non_blocking = arg & O_NONBLOCK;
    }
    else
    {
        errno = ENOSYS;
        result = -1;
    }
 
    return result;
}
 
#if CONFIG_VFS_SUPPORT_SELECT
static esp_err_t twai_vfs_start_select(int nfds, fd_set *readfds,
                                       fd_set *writefds, fd_set *exceptfds,
                                       esp_vfs_select_sem_t sem,
                                       void **end_select_args)
{
    AtomicHolder l(&twai.select_lock);
    // zero the cached copy of the fd_sets before setting the incoming copy in
    // case the TWAI VFS FD is not set so we do not raise the alert when there
    // is an interesting event.
    FD_ZERO(&twai.readfds_orig);
    FD_ZERO(&twai.writefds_orig);
    FD_ZERO(&twai.exceptfds_orig);
 
    // If the TWAI FD is present in any of the FD sets we should process the
    // select call.
    if (FD_ISSET(TWAI_VFS_FD, readfds) || FD_ISSET(TWAI_VFS_FD, writefds) ||
        FD_ISSET(TWAI_VFS_FD, exceptfds))
    {
        twai.select_sem = sem;
        twai.readfds = readfds;
        twai.readfds_orig = *readfds;
        twai.writefds = writefds;
        twai.writefds_orig = *writefds;
        twai.exceptfds = exceptfds;
        twai.exceptfds_orig = *exceptfds;
 
        // zero the fd_sets so we can mark the correct signals when we trigger
        // the VFS layer.
        FD_ZERO(readfds);
        FD_ZERO(writefds);
        FD_ZERO(exceptfds);
 
        // Check if we have pending frames to RX, if so trigger an early exit
        // from select()
        if (FD_ISSET(TWAI_VFS_FD, &twai.readfds_orig))
        {
            AtomicHolder h(&twai.buf_lock);
            if (twai.rx_buf->pending())
            {
                FD_SET(TWAI_VFS_FD, readfds);
                esp_vfs_select_triggered(sem);
            }
        }
    }
    return ESP_OK;
}
 
static esp_err_t twai_vfs_end_select(void *end_select_args)
{
    AtomicHolder l(&twai.select_lock);
    // zero the cached copy of the fd_sets to prevent triggering the VFS wakeup
    // since the select() has ended.
    FD_ZERO(&twai.readfds_orig);
    FD_ZERO(&twai.writefds_orig);
    FD_ZERO(&twai.exceptfds_orig);
    return ESP_OK;
}
 
#endif // CONFIG_VFS_SUPPORT_SELECT
 
static inline uint32_t twai_rx_frames()
{
    AtomicHolder h(&twai.buf_lock);
    uint32_t rx_ready_count = twai_hal_get_rx_msg_count(&twai.context);
    struct can_frame *can_frame = nullptr;
    uint32_t rx_count = 0;
    ESP_EARLY_LOGV(TWAI_LOG_TAG, "rx-ready-count: %" PRIu32, rx_ready_count);
    for (uint32_t idx = 0; idx < rx_ready_count; idx++)
    {
        twai_hal_frame_t frame;
        if (twai_hal_read_rx_buffer_and_clear(&twai.context, &frame))
        {
            if (frame.dlc > TWAI_FRAME_MAX_DLC)
            {
                // DLC is longer than supported, discard the frame.
                twai.stats.rx_discard++;
                ESP_EARLY_LOGE(TWAI_LOG_TAG, "rx-discard:%" PRIu32,
                               twai.stats.rx_discard);
            }
            else if (twai.rx_buf->data_write_pointer(&can_frame))
            {
                twai_message_t rx_frame;
                twai_hal_parse_frame(&frame, &rx_frame);
                memcpy(can_frame->data, rx_frame.data, TWAI_FRAME_MAX_DLC);
                can_frame->can_dlc = rx_frame.data_length_code;
                can_frame->can_id = rx_frame.identifier;
                if (rx_frame.extd)
                {
                    SET_CAN_FRAME_EFF(*can_frame);
                }
                else
                {
                    CLR_CAN_FRAME_EFF(*can_frame);
                }
                if (rx_frame.rtr)
                {
                    SET_CAN_FRAME_RTR(*can_frame);
                }
                else
                {
                    CLR_CAN_FRAME_RTR(*can_frame);
                }
                rx_count += twai.rx_buf->advance(1);
                ESP_EARLY_LOGV(TWAI_LOG_TAG, "rx-OK");
            }
            else
            {
                twai.stats.rx_missed++;
                ESP_EARLY_LOGV(TWAI_LOG_TAG, "rx-missed:%" PRIu32,
                               twai.stats.rx_missed);
            }
        }
        else
        {
            ESP_EARLY_LOGV(TWAI_LOG_TAG, "rx-overrun");
// If the SOC does not support automatic clearing of the RX FIFO we need to
// handle it here and break out of the loop.
#ifndef SOC_TWAI_SUPPORTS_RX_STATUS
            twai.stats.rx_overrun +=
                twai_hal_clear_rx_fifo_overrun(&twai.context);
            break;
#else
            twai.stats.rx_overrun++;
#endif // SOC_TWAI_SUPPORTS_RX_STATUS
        }
    }
 
    return rx_count;
}
 
static inline uint32_t twai_tx_frame()
{
    AtomicHolder h(&twai.buf_lock);
    if (twai_hal_check_last_tx_successful(&twai.context))
    {
        ESP_EARLY_LOGV(TWAI_LOG_TAG, "TX-OK");
        twai.stats.tx_success++;
        twai.tx_buf->consume(1);
    }
    else
    {
        ESP_EARLY_LOGV(TWAI_LOG_TAG, "TX-FAIL");
        twai.stats.tx_failed++;
    }
 
    // Check if we have a pending frame to transmit in the queue
    struct can_frame *can_frame = nullptr;
    if (twai.tx_buf->data_read_pointer(&can_frame) && can_frame != nullptr)
    {
        twai_message_t tx_frame;
        twai_hal_frame_t hal_frame;
        memset(&tx_frame, 0, sizeof(twai_message_t));
        tx_frame.identifier = can_frame->can_id;
        tx_frame.extd = IS_CAN_FRAME_EFF(*can_frame);
        tx_frame.rtr =  IS_CAN_FRAME_RTR(*can_frame);
        tx_frame.data_length_code = can_frame->can_dlc;
        memcpy(tx_frame.data, can_frame->data, can_frame->can_dlc);
        twai_hal_format_frame(&tx_frame, &hal_frame);
        twai_hal_set_tx_buffer_and_transmit(&twai.context, &hal_frame);
        return 1;
    }
    return 0;
}
 
static void twai_isr(void *arg)
{
    BaseType_t wakeup = pdFALSE;
    uint32_t events = twai_hal_get_events(&twai.context);
    ESP_EARLY_LOGV(TWAI_LOG_TAG, "events: %04" PRIx32, events);
 
#if defined(CONFIG_TWAI_ERRATA_FIX_RX_FRAME_INVALID) || \
    defined(CONFIG_TWAI_ERRATA_FIX_RX_FIFO_CORRUPT)
    if (events & TWAI_HAL_EVENT_NEED_PERIPH_RESET)
    {
        ESP_EARLY_LOGV(TWAI_LOG_TAG, "periph-reset");
        twai_hal_prepare_for_reset(&twai.context);
        periph_module_reset(PERIPH_TWAI_MODULE);
        twai_hal_recover_from_reset(&twai.context);
        twai.stats.rx_lost += twai_hal_get_reset_lost_rx_cnt(&twai.context);
#if CONFIG_VFS_SUPPORT_SELECT
        AtomicHolder l(&twai.select_lock);
        if (FD_ISSET(TWAI_VFS_FD, &twai.exceptfds_orig))
        {
            FD_SET(TWAI_VFS_FD, twai.exceptfds);
            esp_vfs_select_triggered_isr(twai.select_sem, &wakeup);
        }
#endif // CONFIG_VFS_SUPPORT_SELECT
    }
#endif // TWAI_ERRATA_FIX_RX_FRAME_INVALID || TWAI_ERRATA_FIX_RX_FIFO_CORRUPT
 
    // RX completed
    if ((events & TWAI_HAL_EVENT_RX_BUFF_FRAME) && twai_rx_frames())
    {
#if CONFIG_VFS_SUPPORT_SELECT
        AtomicHolder l(&twai.select_lock);
        if (FD_ISSET(TWAI_VFS_FD, &twai.readfds_orig))
        {
            FD_SET(TWAI_VFS_FD, twai.readfds);
            esp_vfs_select_triggered_isr(twai.select_sem, &wakeup);
        }
#endif // CONFIG_VFS_SUPPORT_SELECT
        // std::swap is not ISR safe so it is not used here.
        if (twai.readable_notify)
        {
            twai.readable_notify->notify_from_isr();
            twai.readable_notify = nullptr;
        }
    }
 
    // TX completed
    if ((events & TWAI_HAL_EVENT_TX_BUFF_FREE) && twai_tx_frame())
    {
#if CONFIG_VFS_SUPPORT_SELECT
        AtomicHolder l(&twai.select_lock);
        if (FD_ISSET(TWAI_VFS_FD, &twai.writefds_orig))
        {
            FD_SET(TWAI_VFS_FD, twai.writefds);
            esp_vfs_select_triggered_isr(twai.select_sem, &wakeup);
        }
#endif // CONFIG_VFS_SUPPORT_SELECT
        // std::swap is not ISR safe so it is not used here.
        if (twai.writable_notify)
        {
            twai.writable_notify->notify_from_isr();
            twai.writable_notify = nullptr;
        }
    }
 
    // Bus recovery complete, trigger a restart
    if (events & TWAI_HAL_EVENT_BUS_RECOV_CPLT)
    {
        ESP_EARLY_LOGV(TWAI_LOG_TAG, "bus recovery complete");
        // start the driver automatically
        twai_hal_start(&twai.context, TWAI_MODE_NORMAL);
    }
 
    // Bus error detected
    if (events & TWAI_HAL_EVENT_BUS_ERR)
    {
        twai.stats.bus_error++;
        ESP_EARLY_LOGV(TWAI_LOG_TAG, "bus-error:%" PRIu32,
                       twai.stats.bus_error);
    }
 
    // Arbitration error detected
    if (events & TWAI_HAL_EVENT_ARB_LOST)
    {
        twai.stats.arb_loss++;
        ESP_EARLY_LOGV(TWAI_LOG_TAG, "arb-lost:%" PRIu32,
                       twai.stats.arb_loss);
    }
 
    if (wakeup == pdTRUE)
    {
        portYIELD_FROM_ISR();
    }
}
 
void* twai_watchdog(void* param)
{
    LOG(INFO, "ESP-TWAI: Starting TWAI watchdog and reporting task");
    size_t last_rx_pending = 0;
    size_t last_tx_pending = 0;
    uint32_t last_twai_state = 0;
 
    while (twai.active)
    {
        // delay until the next reporting interval, this is being used instead
        // of vTaskDelay to allow early wake up in the case of shutdown of the
        // TWAI driver.
        ulTaskNotifyTake(pdTRUE, STATUS_PRINT_INTERVAL);
 
        // If we wake up and the TWAI driver is no longer active we should exit
        // this loop for shutdown.
        if (!twai.active)
        {
            break;
        }
 
        // If the last status of the bus and current status are the same and it
        // is in a recovery state, retrigger the recovery as it will remain
        // stuck indefinitely without a retrigger.
        if (last_twai_state == twai.context.state_flags &&
            is_twai_recovering())
        {
            LOG(WARNING,
                "ESP-TWAI: Bus appears to be stuck, initiating bus recovery.");
            twai_hal_start_bus_recovery(&twai.context);
        }
        last_twai_state = twai.context.state_flags;
 
        // If the RX queue has not changed since our last check, purge the RX
        // queue and track it as missed frames.
        if (last_rx_pending && last_rx_pending == twai.rx_buf->pending())
        {
            LOG_ERROR("ESP-TWAI: RX-Q appears stuck, purging RX-Q!");
            twai_purge_rx_queue();
        }
        last_rx_pending = twai.rx_buf->pending();
 
        // If the TX queue has not changed since our last check, purge the RX
        // queue and track it as failed frames.
        if (last_tx_pending && last_tx_pending == twai.tx_buf->pending())
        {
            LOG_ERROR("ESP-TWAI: TX-Q appears stuck, purging TX-Q!");
            twai_purge_tx_queue();
        }
        last_tx_pending = twai.tx_buf->pending();
 
        if (twai.report_stats)
        {
            LOG(INFO,
                "ESP-TWAI: "
                "RX:%" PRIu32 " (pending:%zu,overrun:%" PRIu32
                ",discard:%" PRIu32 ",missed:%" PRIu32 ",lost:%" PRIu32 ") "
                "TX:%" PRIu32 " (pending:%zu,suc:%" PRIu32
                ",fail:%" PRIu32 ") "
                "Bus (arb-err:%" PRIu32 ",err:%" PRIu32 ",state:%s)",
                twai.stats.rx_processed, twai.rx_buf->pending(),
                twai.stats.rx_overrun, twai.stats.rx_discard,
                twai.stats.rx_missed, twai.stats.rx_lost,
                twai.stats.tx_processed, twai.tx_buf->pending(),
                twai.stats.tx_success, twai.stats.tx_failed,
                twai.stats.arb_loss, twai.stats.bus_error,
                is_twai_running() ? "Running" :
                is_twai_recovering() ? "Recovering" :
                is_twai_err_warn() ? "Err-Warn" :
                is_twai_err_passive() ? "Err-Pasv" :
                "Bus Off");
        }
    }
    LOG(VERBOSE, "ESP-TWAI: Stopping TWAI watchdog and reporting task");
 
    return NULL;
}
 
Esp32HardwareTwai::Esp32HardwareTwai(
    int rx, int tx, bool report, size_t rx_size, size_t tx_size,
    const char *path, int clock_out, int bus_status, uint32_t isr_core)
    : rxPin_(rx), txPin_(tx), extClockPin_(clock_out),
    busStatusPin_(bus_status), preferredIsrCore_(isr_core), vfsPath_(path)
{
    HASSERT(GPIO_IS_VALID_GPIO(rxPin_));
    HASSERT(GPIO_IS_VALID_OUTPUT_GPIO(txPin_));
 
    if (extClockPin_ != GPIO_NUM_NC)
    {
        HASSERT(GPIO_IS_VALID_OUTPUT_GPIO(extClockPin_));
    }
 
    if (busStatusPin_ != GPIO_NUM_NC)
    {
        HASSERT(GPIO_IS_VALID_OUTPUT_GPIO(busStatusPin_));
    }
 
    memset(&twai.stats, 0, sizeof(esp32_twai_stats_t));
 
    twai.rx_buf = DeviceBuffer<struct can_frame>::create(rx_size);
    HASSERT(twai.rx_buf != nullptr);
 
    twai.tx_buf =
        DeviceBuffer<struct can_frame>::create(tx_size, tx_size / 2);
    HASSERT(twai.tx_buf != nullptr);
 
    twai.report_stats = report;
}
 
Esp32HardwareTwai::~Esp32HardwareTwai()
{
    if (twai.active)
    {
        esp_intr_free(twai.isr_handle);
        twai_hal_deinit(&twai.context);
    }
    twai.active = false;
 
    esp_vfs_unregister(vfsPath_);
 
    twai.tx_buf->destroy();
    twai.rx_buf->destroy();
 
    if (twai.wd_thread)
    {
        xTaskNotifyGive(twai.wd_thread);
    }
}
 
static void esp32_twai_isr_init(void *param)
{
    LOG(VERBOSE, "ESP-TWAI: Allocating ISR");
    ESP_ERROR_CHECK(
        esp_intr_alloc(ETS_TWAI_INTR_SOURCE, TWAI_INTERRUPT_FLAGS, twai_isr,
            nullptr, &twai.isr_handle));
}
 
void Esp32HardwareTwai::hw_init()
{
    LOG(INFO,
        "ESP-TWAI: Configuring TWAI (TX:%d, RX:%d, EXT-CLK:%d, BUS-CTRL:%d)",
        txPin_, rxPin_, extClockPin_, busStatusPin_);
    gpio_set_pull_mode((gpio_num_t)txPin_, GPIO_FLOATING);
    esp_rom_gpio_connect_out_signal(txPin_, TWAI_TX_IDX, false, false);
    esp_rom_gpio_pad_select_gpio(txPin_);
 
    gpio_set_pull_mode((gpio_num_t)rxPin_, GPIO_FLOATING);
    esp_rom_gpio_connect_in_signal(rxPin_, TWAI_RX_IDX, false);
    esp_rom_gpio_pad_select_gpio(rxPin_);
    gpio_set_direction((gpio_num_t)rxPin_, GPIO_MODE_INPUT);
 
    if (extClockPin_ != GPIO_NUM_NC)
    {
        gpio_set_pull_mode((gpio_num_t)extClockPin_, GPIO_FLOATING);
        esp_rom_gpio_connect_out_signal(extClockPin_, TWAI_CLKOUT_IDX, false,
            false);
        esp_rom_gpio_pad_select_gpio((gpio_num_t)extClockPin_);
    }
 
    if (busStatusPin_ != GPIO_NUM_NC)
    {
        gpio_set_pull_mode((gpio_num_t)busStatusPin_, GPIO_FLOATING);
        esp_rom_gpio_connect_out_signal(extClockPin_, TWAI_BUS_OFF_ON_IDX,
            false, false);
        esp_rom_gpio_pad_select_gpio((gpio_num_t)busStatusPin_);
    }
 
    esp_vfs_t vfs = {};
    vfs.write = twai_vfs_write;
    vfs.read = twai_vfs_read;
    vfs.open = twai_vfs_open;
    vfs.close = twai_vfs_close;
    vfs.fcntl = twai_vfs_fcntl;
    vfs.ioctl = twai_vfs_ioctl;
#if CONFIG_VFS_SUPPORT_SELECT
    vfs.start_select = twai_vfs_start_select;
    vfs.end_select = twai_vfs_end_select;
#endif // CONFIG_VFS_SUPPORT_SELECT
    vfs.flags = ESP_VFS_FLAG_DEFAULT;
    ESP_ERROR_CHECK(esp_vfs_register(vfsPath_, &vfs, this));
 
    periph_module_reset(PERIPH_TWAI_MODULE);
    periph_module_enable(PERIPH_TWAI_MODULE);
 
    twai_timing_config_t timingCfg = TWAI_TIMING_CONFIG_125KBITS();
    twai_filter_config_t filterCfg = TWAI_FILTER_CONFIG_ACCEPT_ALL();
 
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5,1,0)
    // default clock source if not specified in config.
    if (timingCfg.clk_src == 0)
    {
        timingCfg.clk_src = TWAI_CLK_SRC_DEFAULT;
    }
    twai_hal_config_t twai_hal_cfg = 
    {
        .controller_id = 0,
        .clock_source_hz = 0,
    };
 
    // retrieve the clock frequency from the SoC
    esp_clk_tree_src_get_freq_hz((soc_module_clk_t)timingCfg.clk_src,
        ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &twai_hal_cfg.clock_source_hz);
 
    // BRP validations
    uint32_t brp = timingCfg.brp;
    if (timingCfg.quanta_resolution_hz)
    {
        HASSERT(twai_hal_cfg.clock_source_hz % timingCfg.quanta_resolution_hz == 0);
        brp = twai_hal_cfg.clock_source_hz / timingCfg.quanta_resolution_hz;
    }
    HASSERT(twai_ll_check_brp_validation(brp));
 
    // Initialize the low level HAL APIs
    HASSERT(twai_hal_init(&twai.context, &twai_hal_cfg));
#else
    // Initialize the low level HAL APIs
    HASSERT(twai_hal_init(&twai.context));
#endif // IDF v5.1+
 
    LOG(VERBOSE, "ESP-TWAI: Initiailizing peripheral");
    twai_hal_configure(&twai.context, &timingCfg, &filterCfg,
        TWAI_DEFAULT_INTERRUPTS, 0);
 
#if SOC_CPU_CORES_NUM > 1
    ESP_ERROR_CHECK(
        esp_ipc_call_blocking(preferredIsrCore_, esp32_twai_isr_init, nullptr));
#else
    esp32_twai_isr_init(nullptr);
#endif // SOC_CPU_CORES_NUM > 1
    twai.active = true;
 
    os_thread_create(&twai.wd_thread, "TWAI-WD", WATCHDOG_TASK_PRIORITY,
        WATCHDOG_TASK_STACK, twai_watchdog, this);
}
 
void Esp32HardwareTwai::get_driver_stats(esp32_twai_stats_t *stats)
{
    HASSERT(stats != nullptr);
    memcpy(stats, &twai.stats, sizeof(esp32_twai_stats_t));
}
 
} // namespace openmrn_arduino
 
#endif // ESP_PLATFORM