Linux 驱动 SPI 和I2C 读写函数

int i2c_read_regs(struct i2c_client *client, u8 reg, u8 *buf, u16 len) {    struct i2c_msg msgs[2] = {        { .addr = client->addr, .flags = 0, .len = 1, .buf = &reg },        { .addr = client->addr, .flags = I2C_M_RD, .len = len, .buf = buf },    };    int ret = i2c_transfer(client->adapter, msgs, 2);    if (ret != 2) {        dev_err(&client->dev, "I2C批量读失败，reg=0x%02x, len=%d\n", reg, len);        return ret < 0 ? ret : -EIO;    }    return 0;}// I2C 批量写寄存器int i2c_write_regs(struct i2c_client *client, u8 reg, const u8 *buf, u16 len) {    // 拼接寄存器地址 + 数据    u8 *tx_buf = devm_kzalloc(&client->dev, len + 1, GFP_KERNEL);    if (!tx_buf) return -ENOMEM;    tx_buf[0] = reg;    memcpy(&tx_buf[1], buf, len);    struct i2c_msg msg = {        .addr = client->addr,        .flags = 0,        .len = len + 1,        .buf = tx_buf,    };    int ret = i2c_transfer(client->adapter, &msg, 1);    devm_kfree(&client->dev, tx_buf);  // 释放临时缓冲区    if (ret != 1) {        dev_err(&client->dev, "I2C批量写失败，reg=0x%02x, len=%d\n", reg, len);        return ret < 0 ? ret : -EIO;    }    return 0;}

// SMBus 读字节（等价于单寄存器读）int i2c_smbus_read_byte(struct i2c_client *client, u8 reg) {    int ret = i2c_smbus_read_byte_data(client, reg);    if (ret < 0) {        dev_err(&client->dev, "SMBus读字节失败，reg=0x%02x\n", reg);        return ret;    }    return ret;  // 返回读取的字节值}// SMBus 写字节int i2c_smbus_write_byte(struct i2c_client *client, u8 reg, u8 val) {    int ret = i2c_smbus_write_byte_data(client, reg, val);    if (ret < 0) {        dev_err(&client->dev, "SMBus写字节失败，reg=0x%02x\n", reg);    }    return ret;}//其中 /** * i2c_smbus_read_byte_data - SMBus "read byte" protocol * @client: Handle to slave device * @command: Byte interpreted by slave * * This executes the SMBus "read byte" protocol, returning negative errno * else a data byte received from the device. */s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command){	union i2c_smbus_data data;	int status;	status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,				I2C_SMBUS_READ, command,				I2C_SMBUS_BYTE_DATA, &data);return (status < 0) ? status : data.byte;}EXPORT_SYMBOL(i2c_smbus_read_byte_data);/** * i2c_smbus_write_byte_data - SMBus "write byte" protocol * @client: Handle to slave device * @command: Byte interpreted by slave * @value: Byte being written * * This executes the SMBus "write byte" protocol, returning negative errno * else zero on success. */s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,			      u8 value){	union i2c_smbus_data data;data.byte = value;return i2c_smbus_xfer(client->adapter, client->addr, client->flags,			      I2C_SMBUS_WRITE, command,			      I2C_SMBUS_BYTE_DATA, &data);}EXPORT_SYMBOL(i2c_smbus_write_byte_data);

status = i2c_smbus_xfer(    client->adapter,    // 参数1：I2C适配器（对应硬件I2C控制器，如i2c-0）    client->addr,       // 参数2：目标I2C设备的7/10位地址    client->flags,      // 参数3：通信标志（如I2C_M_TEN表示10位地址、I2C_M_RECV_LEN等）    I2C_SMBUS_READ,     // 参数4：操作类型——读    command,            // 参数5：寄存器地址/命令码（要读的哪个寄存器）    I2C_SMBUS_BYTE_DATA,// 参数6：数据类型——单字节数据（寄存器+1字节）    &data// 参数7：输出缓冲区——存储读取到的字节数据);

static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,				   unsigned short flags,				   char read_write, u8 command, int size,				   union i2c_smbus_data *data)				   {......	status = i2c_transfer(adapter, msg, num);if (status < 0)return status;.........		}

i2c_read_reg(struct i2c_client *client, u8 reg, u8 *val)int i2c_read_regs(struct i2c_client *client, u8 reg, u8 *buf, u16 len) int i2c_smbus_read_byte(struct i2c_client *client, u8 reg)

if (in_atomic() || irqs_disabled()) {//中断关闭			ret = i2c_trylock_adapter(adap);if (!ret)/* I2C activity is ongoing. */return -EAGAIN;		} else {			i2c_lock_adapter(adap); // 2. 加总线锁（防止并发访问I2C总线）		}		ret = __i2c_transfer(adap, msgs, num);//3.适配器底层的xfer函数（真正的硬件操作入口）		i2c_unlock_adapter(adap); // 4. 释放总线锁return ret;	} else {		dev_dbg(&adap->dev, "I2C level transfers not supported\n");return -EOPNOTSUPP;	}

int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num){unsigned long orig_jiffies;int ret, try;/* Retry automatically on arbitration loss */	orig_jiffies = jiffies;for (ret = 0, try = 0; try <= adap->retries; try++) {		ret = adap->algo->master_xfer(adap, msgs, num);if (ret != -EAGAIN)break;if (time_after(jiffies, orig_jiffies + adap->timeout))break;	}return ret;}EXPORT_SYMBOL(__i2c_transfer);

#include<linux/spi/spi.h>// SPI 读单寄存器（cmd：读写指令，val：接收值）intspi_read_reg(struct spi_device *spi, u8 cmd, u8 *val){    u8 tx_buf[2] = {cmd | 0x80, 0x00};  // 读指令（最高位1表示读）    u8 rx_buf[2] = {0};    // 组装SPI传输段    struct spi_transfer t = {        .tx_buf = tx_buf,        // 发送缓冲区（指令）        .rx_buf = rx_buf,        // 接收缓冲区（数据）        .len = ARRAY_SIZE(tx_buf), // 传输长度        .speed_hz = spi->max_speed_hz, // 传输速率（可用自定义值）        .cs_change = 0,          // 传输后不释放片选    };    // 组装SPI消息    struct spi_message msg;    spi_message_init(&msg);    spi_message_add_tail(&t, &msg);    // 执行传输    int ret = spi_sync(spi, &msg);    if (ret < 0) {        dev_err(&spi->dev, "SPI读寄存器0x%02x失败，ret=%d\n", cmd, ret);        return ret;    }    *val = rx_buf[1];  // 提取读取的值（根据外设协议调整）    return 0;}// SPI 写单寄存器intspi_write_reg(struct spi_device *spi, u8 cmd, u8 val){    u8 tx_buf[2] = {cmd & 0x7F, val};  // 写指令（最高位0表示写）    struct spi_transfer t = {        .tx_buf = tx_buf,        .len = ARRAY_SIZE(tx_buf),        .speed_hz = spi->max_speed_hz,        .cs_change = 0,    };    struct spi_message msg;    spi_message_init(&msg);    spi_message_add_tail(&t, &msg);    int ret = spi_sync(spi, &msg);    if (ret < 0) {        dev_err(&spi->dev, "SPI写寄存器0x%02x失败，ret=%d\n", cmd, ret);    }    return ret;}

// SPI 批量读（cmd：起始指令，buf：接收缓冲区，len：读取长度）int spi_read_bulk(struct spi_device *spi, u8 cmd, u8 *buf, u16 len) {    // 分配发送缓冲区（指令 + 占位符）    u8 *tx_buf = devm_kzalloc(&spi->dev, len + 1, GFP_KERNEL);    if (!tx_buf) return -ENOMEM;    tx_buf[0] = cmd | 0x80;  // 读指令    struct spi_transfer t = {        .tx_buf = tx_buf,        .rx_buf = buf,        .len = len + 1,        // 指令1字节 + 数据len字节        .speed_hz = spi->max_speed_hz,    };    struct spi_message msg;    spi_message_init(&msg);    spi_message_add_tail(&t, &msg);    int ret = spi_sync(spi, &msg);    devm_kfree(&spi->dev, tx_buf);    if (ret < 0) {        dev_err(&spi->dev, "SPI批量读失败，cmd=0x%02x, len=%d\n", cmd, len);        return ret;    }    // 注意：buf[0]是指令回显，有效数据从buf[1]开始（根据外设调整）    memmove(buf, &buf[1], len);    return 0;}// SPI 批量写int spi_write_bulk(struct spi_device *spi, u8 cmd, const u8 *buf, u16 len) {    u8 *tx_buf = devm_kzalloc(&spi->dev, len + 1, GFP_KERNEL);    if (!tx_buf) return -ENOMEM;    tx_buf[0] = cmd & 0x7F;  // 写指令    memcpy(&tx_buf[1], buf, len);    struct spi_transfer t = {        .tx_buf = tx_buf,        .len = len + 1,        .speed_hz = spi->max_speed_hz,    };    struct spi_message msg;    spi_message_init(&msg);    spi_message_add_tail(&t, &msg);    int ret = spi_sync(spi, &msg);    devm_kfree(&spi->dev, tx_buf);    if (ret < 0) {        dev_err(&spi->dev, "SPI批量写失败，cmd=0x%02x, len=%d\n", cmd, len);    }    return ret;}

// 纯写（无寄存器地址，直接发数据）int spi_write_simple(struct spi_device *spi, const u8 *buf, u16 len) {    return spi_write(spi, buf, len);  // 封装好的简化函数}// 纯读（先发送dummy数据，再读）int spi_read_simple(struct spi_device *spi, u8 *buf, u16 len) {    // 分配dummy发送缓冲区    u8 *tx_buf = devm_kzalloc(&spi->dev, len, GFP_KERNEL);    if (!tx_buf) return -ENOMEM;    struct spi_transfer t = {        .tx_buf = tx_buf,        .rx_buf = buf,        .len = len,    };    struct spi_message msg;    spi_message_init(&msg);    spi_message_add_tail(&t, &msg);    int ret = spi_sync(spi, &msg);    devm_kfree(&spi->dev, tx_buf);    return ret;}

# I2C 调试日志echo 7 > /sys/module/i2c_core/parameters/debug# SPI 调试日志echo 1 > /sys/module/spi_core/parameters/debug