* 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};
* 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);
}
}
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');
* 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)
{
* 挂死的检测与恢复由控制器驱动内部处理。契约见头文件 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) {
* 两侧调用点当前仅传 0 或延时值。契约见头文件 write() 声明。 */
k_msleep(flags);
}
return ret;
}
}