/*
 * Copyright (c) 2026 Huawei Technologies Co., Ltd.
 * openUBMC is licensed under Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
 * You may obtain a copy of Mulan PSL v2 at:
 *         http://license.coscl.org.cn/MulanPSL2
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 * See the Mulan PSL v2 for more details.
 */

#include "drivers/i2c.h"

#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/kernel.h>

#include <atomic>
#include <errno.h>

namespace DRIVER_I2C {

namespace {

constexpr uint8_t kMaxBusId = 15;

static const char* kBusNameById[kMaxBusId + 1] = {
    nullptr, "i2c_1", "i2c_2",  "i2c_3",  "i2c_4",  "i2c_5",  "i2c_6",  "i2c_7",
    "i2c_8", "i2c_9", "i2c_10", "i2c_11", "i2c_12", "i2c_13", "i2c_14", "i2c_15",
};

static const struct device* g_i2c_devices[kMaxBusId + 1];
static struct k_mutex       g_bus_mutexes[kMaxBusId + 1];
static std::atomic<bool>    g_initialized{false};

/* 初始化守卫用 K_MUTEX_DEFINE 编译期完成初始化,不存在"守卫自身还没
 * init 就被并发 lock"的自举问题;首次并发调用 ensure_init 时,后到者在
 * 守卫上等待先到者完成全部 k_mutex_init/device_get_binding 后直接返回。 */
K_MUTEX_DEFINE(g_init_guard);

static void ensure_init()
{
    if (g_initialized.load(std::memory_order_acquire)) {
        return;
    }

    k_mutex_lock(&g_init_guard, K_FOREVER);
    if (!g_initialized.load(std::memory_order_relaxed)) {
        for (uint8_t i = 0; i <= kMaxBusId; ++i) {
            k_mutex_init(&g_bus_mutexes[i]);
            const char* dev_name = kBusNameById[i];
            if (dev_name != nullptr) {
                g_i2c_devices[i] = device_get_binding(dev_name);
            }
        }
        g_initialized.store(true, std::memory_order_release);
    }
    k_mutex_unlock(&g_init_guard);
}

static const struct device* get_bus_device(uint8_t id)
{
    ensure_init();
    if (id > kMaxBusId) {
        return nullptr;
    }
    const struct device* dev = g_i2c_devices[id];
    if (dev == nullptr || !device_is_ready(dev)) {
        return nullptr;
    }
    return dev;
}

static uint32_t to_zephyr_speed_flags(uint32_t speed_khz)
{
    if (speed_khz >= 3400U) {
        return I2C_SPEED_SET(I2C_SPEED_HIGH);
    }
    if (speed_khz >= 400U) {
        return I2C_SPEED_SET(I2C_SPEED_FAST);
    }
    return I2C_SPEED_SET(I2C_SPEED_STANDARD);
}

} // namespace

void I2c::init(uint8_t id, uint32_t speed, uint8_t mode, uint8_t slave_addr)
{
    ARG_UNUSED(mode);
    ARG_UNUSED(slave_addr);

    ensure_init();
    m_bus_id       = id;
    m_offset_width = 1;

    const struct device* dev = get_bus_device(id);
    if (dev != nullptr) {
        const uint32_t cfg = I2C_MODE_CONTROLLER | to_zephyr_speed_flags(speed);
        (void)i2c_configure(dev, cfg);
    }
}

void I2c::lock()
{
    ensure_init();
    if (m_bus_id <= kMaxBusId) {
        k_mutex_lock(&g_bus_mutexes[m_bus_id], K_FOREVER);
    }
}

void I2c::unlock()
{
    ensure_init();
    if (m_bus_id <= kMaxBusId) {
        k_mutex_unlock(&g_bus_mutexes[m_bus_id]);
    }
}

std::tuple<int, std::optional<std::string>> I2c::read(const I2C_READ_S* read_data, std::string_view tx_buf)
{
    if (read_data == nullptr || tx_buf.empty()) {
        return {-EINVAL, std::nullopt};
    }

    const struct device* dev = get_bus_device(read_data->rv_id);
    if (dev == nullptr) {
        return {-ENODEV, std::nullopt};
    }

    if (tx_buf.size() < 1 + m_offset_width) {
        return {-EINVAL, std::nullopt};
    }

    const uint16_t slave_addr = static_cast<uint8_t>(tx_buf[0]);
    const uint8_t* addr_buf   = reinterpret_cast<const uint8_t*>(tx_buf.data() + 1);

    std::string result(read_data->length, '\0');

    /* 兑现 I2C_READ_S 的重试契约:re_read_cnt 为总尝试次数(bus_i2c 的
     * normal_read 传 1、extend_read 传 3)。time_out_cnt 无法映射——Zephyr
     * i2c API 没有单次传输超时参数,总线级超时/恢复由控制器驱动负责。 */
    const uint32_t attempts = read_data->re_read_cnt > 0 ? read_data->re_read_cnt : 1;
    int            ret      = -EIO;
    for (uint32_t attempt = 0; attempt < attempts; ++attempt) {
        ret = i2c_write_read(dev, slave_addr, addr_buf, m_offset_width, result.data(), read_data->length);
        if (ret == 0) {
            break;
        }
    }
    if (ret != 0) {
        return {ret, std::nullopt};
    }
    return {0, result};
}

int I2c::write(uint8_t id, std::string_view tx_buf, uint32_t timeout_ms, uint32_t flags)
{
    /* timeout_ms 在 Zephyr 实现中无法兑现:i2c_write 没有超时参数,总线
     * 挂死的检测与恢复由控制器驱动内部处理。契约见头文件 write() 声明。 */
    ARG_UNUSED(timeout_ms);

    if (tx_buf.empty()) {
        return -EINVAL;
    }

    const struct device* dev = get_bus_device(id);
    if (dev == nullptr) {
        return -ENODEV;
    }

    const uint16_t slave_addr  = static_cast<uint8_t>(tx_buf[0]);
    const uint8_t* payload     = reinterpret_cast<const uint8_t*>(tx_buf.data() + 1);
    const size_t   payload_len = tx_buf.size() - 1;

    int ret = i2c_write(dev, payload, payload_len, slave_addr);
    if (ret == 0 && flags > 0U) {
        /* 语义借用:flags 复用为"写后延时 ms"(EEPROM 写周期 tWR 等场景),
         * 两侧调用点当前仅传 0 或延时值。契约见头文件 write() 声明。 */
        k_msleep(flags);
    }
    return ret;
}

} // namespace DRIVER_I2C