/*
 * Copyright (c) 2025, LISTENAI
 *
 * SPDX-License-Identifier: Apache-2.0
 */

/**
 * @file lisa_spi_arcs.c
 * @brief LISA SPI ARCS 平台适配层
 *
 * 此文件实现 ARCS 芯片平台的 SPI 硬件适配
 */

#include "lisa_spi.h"
#include "Driver_SPI.h"
#include "ClockManager.h"
#include "dma.h"
#include <lisa_mutex.h>
#include <string.h>
#include "board.h"

#define LOG_TAG "lisa_spi_arcs"
#include <lisa_log.h>

/* 配置锁宏 - 用于保护配置和设备级控制操作 */
#define CONFIG_LOCK(priv)                                                                                              \
    do {                                                                                                               \
        if (priv->config_mutex) {                                                                                      \
            lisa_mutex_lock(priv->config_mutex, LISA_OS_WAIT_FOREVER);                                                 \
        }                                                                                                              \
    } while (0)

#define CONFIG_UNLOCK(priv)                                                                                            \
    do {                                                                                                               \
        if (priv->config_mutex) {                                                                                      \
            lisa_mutex_unlock(priv->config_mutex);                                                                     \
        }                                                                                                              \
    } while (0)

/* 传输锁宏 - 用于保护传输操作 */
#define TRANSFER_LOCK(priv)                                                                                            \
    do {                                                                                                               \
        if (priv->transfer_mutex) {                                                                                    \
            lisa_mutex_lock(priv->transfer_mutex, LISA_OS_WAIT_FOREVER);                                               \
        }                                                                                                              \
    } while (0)

#define TRANSFER_UNLOCK(priv)                                                                                          \
    do {                                                                                                               \
        if (priv->transfer_mutex) {                                                                                    \
            lisa_mutex_unlock(priv->transfer_mutex);                                                                   \
        }                                                                                                              \
    } while (0)

typedef struct {
    void *hal_handler;                      /* HAL SPI 句柄 (SPI0/SPI1)*/
    lisa_spi_config_t current_config;       /* 当前配置 */
    lisa_mutex_t *config_mutex;             /* 配置互斥锁 */
    lisa_mutex_t *transfer_mutex;           /* 传输互斥锁 */
    uint32_t rx_buf_addr;                   /* 用于DMA接收的缓存地址 */
    uint32_t rx_size;                       /* 用于DMA接收的缓存大小 */
    lisa_spi_transfer_callback_t callback;  /* 传输完成回调函数 */
    void *user_data;                        /* 用户自定义数据指针 */
} lisa_spi_priv_t;

/* ===== SPI 设备静态实例 ===== */
#ifdef CONFIG_LISA_SPI0
static lisa_spi_priv_t spi0_priv;
#endif
#ifdef CONFIG_LISA_SPI1
static lisa_spi_priv_t spi1_priv;
#endif
#ifdef CONFIG_LISA_SPI2
static lisa_spi_priv_t spi2_priv;
#endif

/**
 * @brief HAL SPI 事件回调函数
 */
static void spi_hal_event_callback(uint32_t event, uint32_t usr_param)
{
    lisa_spi_priv_t *priv = (lisa_spi_priv_t *)usr_param;

    if (event & CSK_SPI_EVENT_TRANSFER_COMPLETE) {
#if CONFIG_DCACHE_ENABLE
    if (priv->current_config.rx_transfer_mode == LISA_SPI_DMA_TRANSFER) {
        // DMA模式需要刷cache
        if (priv->rx_buf_addr && priv->rx_size) {
            HAL_InvalidateDCache_by_Addr((unsigned long)priv->rx_buf_addr, priv->rx_size);
            priv->rx_buf_addr = 0;
            priv->rx_size = 0;
        }
    }
#endif

        if (priv->callback) {
            priv->callback(priv->user_data);
        }
    }
}

/* ===== ARCS平台SPI实现函数 ===== */
static int arcs_spi_configure(lisa_device_t *dev, const lisa_spi_config_t *config)
{
    if (!lisa_device_is_initialized(dev) || !config) {
        return LISA_DEVICE_ERR_INVALID;
    }

    lisa_spi_priv_t *priv = (lisa_spi_priv_t *)dev->priv_data;
    uint32_t control = 0;
    int32_t ret;

    /* 验证 DMA 通道 (仅当使用 DMA 传输模式时) */
    if (config->tx_transfer_mode == LISA_SPI_DMA_TRANSFER) {
        if (config->tx_dma_channel > 3) {
            LISA_LOGE(LOG_TAG, "Invalid DMA TX channel: %d (valid range: 0-3)", config->tx_dma_channel);
            return LISA_DEVICE_ERR_INVALID;
        }
    }

    if (config->rx_transfer_mode == LISA_SPI_DMA_TRANSFER) {
        if (config->rx_dma_channel > 3) {
            LISA_LOGE(LOG_TAG, "Invalid DMA RX channel: %d (valid range: 0-3)", config->rx_dma_channel);
            return LISA_DEVICE_ERR_INVALID;
        }
    }

    CONFIG_LOCK(priv);

    /* 检查是否需要释放旧的DMA通道 */
    bool old_tx_is_dma = (priv->current_config.tx_transfer_mode == LISA_SPI_DMA_TRANSFER);
    bool old_rx_is_dma = (priv->current_config.rx_transfer_mode == LISA_SPI_DMA_TRANSFER);
    bool new_tx_is_dma = (config->tx_transfer_mode == LISA_SPI_DMA_TRANSFER);
    bool new_rx_is_dma = (config->rx_transfer_mode == LISA_SPI_DMA_TRANSFER);

    /* 如果从DMA模式切换到中断模式，释放DMA通道 */
    if (old_tx_is_dma && !new_tx_is_dma) {
        dma_channel_unreserve(priv->current_config.tx_dma_channel);
    }
    
    if (old_rx_is_dma && !new_rx_is_dma) {
        dma_channel_unreserve(priv->current_config.rx_dma_channel);
    }

    /* 配置SPI基本参数 */
    if (config->master_mode) {
        control |= CSK_SPI_MODE_MASTER;
    } else {
        control |= CSK_SPI_MODE_SLAVE;
    }

    if (config->mode == LISA_SPI_MODE_0) {
        control |= CSK_SPI_CPOL0_CPHA0;
    } else if (config->mode == LISA_SPI_MODE_1) {
        control |= CSK_SPI_CPOL0_CPHA1;
    } else if (config->mode == LISA_SPI_MODE_2) {
        control |= CSK_SPI_CPOL1_CPHA0;
    } else if (config->mode == LISA_SPI_MODE_3) {
        control |= CSK_SPI_CPOL1_CPHA1;
    }

    if (config->bit_order == LISA_SPI_BIT_ORDER_MSB_FIRST) {
        control |= CSK_SPI_MSB_LSB;
    } else {
        control |= CSK_SPI_LSB_MSB;
    }

    control |= CSK_SPI_DATA_BITS(config->data_bits);

    /* 配置传输模式 */
    if (config->tx_transfer_mode == LISA_SPI_DMA_TRANSFER) {
        control |= CSK_SPI_TXIO_DMA;
    } else {
        control |= CSK_SPI_TXIO_PIO;
    }

    if (config->rx_transfer_mode == LISA_SPI_DMA_TRANSFER) {
        control |= CSK_SPI_RXIO_DMA;
    } else {
        control |= CSK_SPI_RXIO_PIO;
    }

    /* 执行SPI控制配置 */
    if (priv->current_config.frequency == config->frequency) {
        ret = SPI_Control(priv->hal_handler, control, 0);
    }
    else {
        ret = SPI_Control(priv->hal_handler, control, config->frequency);
    }
    if (ret != CSK_DRIVER_OK) {
        LISA_LOGE(LOG_TAG, "SPI_Control failed: %d", ret);
        ret = LISA_DEVICE_ERR_NOT_SUPPORT;
        goto exit;
    }

    /* 如果新配置使用DMA模式，配置DMA通道 */
    if (new_tx_is_dma || new_rx_is_dma) {
        SPI_ADV_ATTR spi_attr = {0};

        if (new_tx_is_dma) {
            spi_attr.flags |= SPI_ATTR_TX_DMACH_RSVD | SPI_ATTR_TX_NSYNCA | SPI_ATTR_TX_DMA_BSIZE;
            spi_attr.tx_dmach_rsvd = config->tx_dma_channel;
            spi_attr.tx_nsynca = 1;
            spi_attr.tx_dma_bsize = DMA_WIDTH_HALFWORD;
        }

        if (new_rx_is_dma) {
            spi_attr.flags |= SPI_ATTR_RX_NSYNCA | SPI_ATTR_RX_DMACH_RSVD;
            spi_attr.rx_dmach_rsvd = config->rx_dma_channel;
            spi_attr.rx_nsynca = 1;
        }

        ret = SPI_Control(priv->hal_handler, CSK_SPI_SET_ADV_ATTR, (uint32_t)&spi_attr);
        if (ret != CSK_DRIVER_OK) {
            LISA_LOGE(LOG_TAG, "SPI_Control set ADV_ATTR failed: %d", ret);
            ret = LISA_DEVICE_ERR_NOT_SUPPORT;
            goto exit;
        }
    }

    /* 保存新配置 */
    memcpy(&priv->current_config, config, sizeof(lisa_spi_config_t));

    ret = LISA_DEVICE_OK;

exit:
    CONFIG_UNLOCK(priv);
    return ret;
}

static int arcs_spi_get_config(lisa_device_t *dev, lisa_spi_config_t *config)
{
    if (!lisa_device_is_initialized(dev) || !config) {
        return LISA_DEVICE_ERR_INVALID;
    }

    lisa_spi_priv_t *priv = (lisa_spi_priv_t *)dev->priv_data;

    CONFIG_LOCK(priv);
    memcpy(config, &priv->current_config, sizeof(lisa_spi_config_t));
    CONFIG_UNLOCK(priv);

    return LISA_DEVICE_OK;
}

static int arcs_spi_register_callback(lisa_device_t *dev, lisa_spi_transfer_callback_t callback, void *user_data)
{
    if (!lisa_device_is_initialized(dev)) {
        return LISA_DEVICE_ERR_INVALID;
    }

    lisa_spi_priv_t *priv = (lisa_spi_priv_t *)dev->priv_data;

    CONFIG_LOCK(priv);
    priv->callback = callback;
    priv->user_data = user_data;
    CONFIG_UNLOCK(priv);

    return LISA_DEVICE_OK;
}

static int arcs_spi_transfer(lisa_device_t *dev, const lisa_spi_transfer_t *xfer)
{
    if (!lisa_device_is_initialized(dev) || !xfer || (!xfer->tx_buf || !xfer->rx_buf) || xfer->len == 0) {
        return LISA_DEVICE_ERR_INVALID;
    }
    lisa_spi_priv_t *priv = (lisa_spi_priv_t *)dev->priv_data;
    int ret;

    TRANSFER_LOCK(priv);

#if CONFIG_DCACHE_ENABLE
    if (priv->current_config.tx_transfer_mode == LISA_SPI_DMA_TRANSFER) {
        // DMA模式需要刷cache
        HAL_FlushDCache_by_Addr((unsigned long)xfer->tx_buf, xfer->len);
        HAL_FlushDCache_by_Addr((unsigned long)xfer->rx_buf, xfer->len);
    }
#endif

    ret = SPI_Transfer(priv->hal_handler, xfer->tx_buf, xfer->rx_buf, xfer->len);
    if (ret != CSK_DRIVER_OK) {
        LISA_LOGE(LOG_TAG, "SPI_Transfer failed: %d", ret);
        ret = LISA_DEVICE_ERR_NOT_SUPPORT;
        goto exit;
    }

    priv->rx_buf_addr = (uint32_t)xfer->rx_buf;
    priv->rx_size = xfer->len;

    ret = LISA_DEVICE_OK;
    TRANSFER_UNLOCK(priv);
exit:
    return ret;
}

static int arcs_spi_write(lisa_device_t *dev, const uint8_t *buf, uint32_t len)
{
    if (!lisa_device_is_initialized(dev) || !buf || len == 0) {
        return LISA_DEVICE_ERR_INVALID;
    }

    lisa_spi_priv_t *priv = (lisa_spi_priv_t *)dev->priv_data;
    int ret;

    TRANSFER_LOCK(priv);
#if CONFIG_DCACHE_ENABLE
    if (priv->current_config.tx_transfer_mode == LISA_SPI_DMA_TRANSFER) {
        // DMA模式需要刷cache
        HAL_FlushDCache_by_Addr((unsigned long)buf, len);
    }
#endif

    ret = SPI_Send(priv->hal_handler, buf, len);
    if (ret != CSK_DRIVER_OK) {
        LISA_LOGE(LOG_TAG, "SPI_Send failed: %d", ret);
        ret = LISA_DEVICE_ERR_NOT_SUPPORT;
        goto exit;
    }

    ret = LISA_DEVICE_OK;

exit:
    TRANSFER_UNLOCK(priv);
    return ret;
}

static int arcs_spi_read(lisa_device_t *dev, uint8_t *buf, uint32_t len)
{
    if (!lisa_device_is_initialized(dev) || !buf || len == 0) {
        return LISA_DEVICE_ERR_INVALID;
    }

    lisa_spi_priv_t *priv = (lisa_spi_priv_t *)dev->priv_data;
    int ret;

    TRANSFER_LOCK(priv);
#if CONFIG_DCACHE_ENABLE
    if (priv->current_config.rx_transfer_mode == LISA_SPI_DMA_TRANSFER) {
        // DMA模式需要刷cache
        HAL_FlushDCache_by_Addr((unsigned long)buf, len);
    }
#endif

    if (priv->current_config.flags == LISA_SPI_FLAG_SOFTWARE_CS && (!priv->current_config.master_mode)) {
        ret = SPI_Receive_NEnd(priv->hal_handler, buf, len);
    } else {
        ret = SPI_Receive(priv->hal_handler, buf, len);
    }
    if (ret != CSK_DRIVER_OK) {
        LISA_LOGE(LOG_TAG, "SPI_Receive failed: %d", ret);
        ret = LISA_DEVICE_ERR_NOT_SUPPORT;
        goto exit;
    }

    priv->rx_buf_addr = (uint32_t)buf;
    priv->rx_size = len;

    ret = LISA_DEVICE_OK;

exit:
    TRANSFER_UNLOCK(priv);
    return ret;
}

/* ===== 设备初始化函数 ===== */
#ifdef CONFIG_LISA_SPI0
static int arcs_spi0_init(void)
{
    int ret;
    
    memset(&spi0_priv, 0, sizeof(spi0_priv));

    spi0_priv.hal_handler = SPI0();
    if (!spi0_priv.hal_handler) {
        LISA_LOGE(LOG_TAG, "Failed to get SPI0 handler");
        return LISA_DEVICE_ERR_INIT_FAIL;
    }

    ret = SPI_Initialize(spi0_priv.hal_handler, spi_hal_event_callback, (uint32_t)&spi0_priv);
    if (ret != CSK_DRIVER_OK) {
        LISA_LOGE(LOG_TAG, "SPI_Initialize failed: %d", ret);
        return LISA_DEVICE_ERR_NOT_SUPPORT;
    }

    ret = SPI_PowerControl(spi0_priv.hal_handler, CSK_POWER_FULL);
    if (ret != CSK_DRIVER_OK) {
        LISA_LOGE(LOG_TAG, "SPI_PowerControl failed: %d", ret);
        return LISA_DEVICE_ERR_NOT_SUPPORT;
    }

    HAL_CRM_SetSpi0ClkSrc(CRM_IpSrcPeriClk);

    spi0_priv.config_mutex = lisa_mutex_create();
    if (!spi0_priv.config_mutex) {
        LISA_LOGE(LOG_TAG, "Failed to create config_mutex for SPI0");
        return LISA_DEVICE_ERR_INIT_FAIL;
    }

    spi0_priv.transfer_mutex = lisa_mutex_create();
    if (!spi0_priv.transfer_mutex) {
        LISA_LOGE(LOG_TAG, "Failed to create transfer_mutex for SPI0");
        return LISA_DEVICE_ERR_INIT_FAIL;
    }

    lisa_spi0_pinmux();

    return LISA_DEVICE_OK;
}
#endif

#ifdef CONFIG_LISA_SPI1
static int arcs_spi1_init(void)
{
    
    int ret;
    memset(&spi1_priv, 0, sizeof(spi1_priv));

    spi1_priv.hal_handler = SPI1();
    if (!spi1_priv.hal_handler) {
        LISA_LOGE(LOG_TAG, "Failed to get SPI1 handler");
        return LISA_DEVICE_ERR_INIT_FAIL;
    }

    ret = SPI_Initialize(spi1_priv.hal_handler, spi_hal_event_callback, (uint32_t)&spi1_priv);
    if (ret != CSK_DRIVER_OK) {
        LISA_LOGE(LOG_TAG, "SPI_Initialize failed: %d", ret);
        return LISA_DEVICE_ERR_NOT_SUPPORT;
    }

    ret = SPI_PowerControl(spi1_priv.hal_handler, CSK_POWER_FULL);
    if (ret != CSK_DRIVER_OK) {
        LISA_LOGE(LOG_TAG, "SPI_PowerControl failed: %d", ret);
        return LISA_DEVICE_ERR_NOT_SUPPORT;
    }

    HAL_CRM_SetSpi1ClkSrc(CRM_IpSrcPeriClk);
    spi1_priv.config_mutex = lisa_mutex_create();
    if (!spi1_priv.config_mutex) {
        LISA_LOGE(LOG_TAG, "Failed to create config_mutex for SPI1");
        return LISA_DEVICE_ERR_INIT_FAIL;
    }

    spi1_priv.transfer_mutex = lisa_mutex_create();
    if (!spi1_priv.transfer_mutex) {
        LISA_LOGE(LOG_TAG, "Failed to create transfer_mutex for SPI1");
        return LISA_DEVICE_ERR_INIT_FAIL;
    }

    lisa_spi1_pinmux();

    return LISA_DEVICE_OK;
}
#endif

#ifdef CONFIG_LISA_SPI2
static int arcs_spi2_init(void)
{
    
    int ret;
    memset(&spi2_priv, 0, sizeof(spi2_priv));

    spi2_priv.hal_handler = SPI2();
    if (!spi2_priv.hal_handler) {
        LISA_LOGE(LOG_TAG, "Failed to get SPI2 handler");
        return LISA_DEVICE_ERR_INIT_FAIL;
    }

    ret = SPI_Initialize(spi2_priv.hal_handler, spi_hal_event_callback, (uint32_t)&spi2_priv);
    if (ret != CSK_DRIVER_OK) {
        LISA_LOGE(LOG_TAG, "SPI_Initialize failed: %d", ret);
        return LISA_DEVICE_ERR_NOT_SUPPORT;
    }

    ret = SPI_PowerControl(spi2_priv.hal_handler, CSK_POWER_FULL);
    if (ret != CSK_DRIVER_OK) {
        LISA_LOGE(LOG_TAG, "SPI_PowerControl failed: %d", ret);
        return LISA_DEVICE_ERR_NOT_SUPPORT;
    }

    HAL_CRM_SetSpi2ClkSrc(CRM_IpSrcPeriClk);
    spi2_priv.config_mutex = lisa_mutex_create();
    if (!spi2_priv.config_mutex) {
        LISA_LOGE(LOG_TAG, "Failed to create config_mutex for SPI2");
        return LISA_DEVICE_ERR_INIT_FAIL;
    }

    spi2_priv.transfer_mutex = lisa_mutex_create();
    if (!spi2_priv.transfer_mutex) {
        LISA_LOGE(LOG_TAG, "Failed to create transfer_mutex for SPI2");
        return LISA_DEVICE_ERR_INIT_FAIL;
    }

    lisa_spi2_pinmux();

    return LISA_DEVICE_OK;
}
#endif

 /* ===== ARCS SPI API 实例 ===== */
 static const lisa_spi_api_t arcs_spi_api = {
    .configure = arcs_spi_configure,
    .get_config = arcs_spi_get_config,
    .transfer = arcs_spi_transfer,
    .write = arcs_spi_write,
    .read = arcs_spi_read,
    .register_callback = arcs_spi_register_callback,
 };

 /* ===== 设备注册 ===== */
#ifdef CONFIG_LISA_SPI0
LISA_DEVICE_REGISTER(spi0, &arcs_spi_api, &spi0_priv, NULL, arcs_spi0_init, LISA_DEVICE_PRIORITY_NORMAL);
#endif
#ifdef CONFIG_LISA_SPI1
LISA_DEVICE_REGISTER(spi1, &arcs_spi_api, &spi1_priv, NULL, arcs_spi1_init, LISA_DEVICE_PRIORITY_NORMAL);
#endif
#ifdef CONFIG_LISA_SPI2
LISA_DEVICE_REGISTER(spi2, &arcs_spi_api, &spi2_priv, NULL, arcs_spi2_init, LISA_DEVICE_PRIORITY_NORMAL);
#endif