编写一个通用的i2c设备驱动框架

🕗 发布于 2024-10-20 12:26 嵌入式 IIC arm开发 linux驱动开发

往期内容

I2C子系统专栏：

I2C（IIC）协议讲解-CSDN博客
SMBus 协议详解-CSDN博客
I2C相关结构体讲解:i2c_adapter、i2c_algorithm、i2c_msg-CSDN博客
内核提供的通用I2C设备驱动I2c-dev.c分析：注册篇
内核提供的通用I2C设备驱动I2C-dev.c分析：file_ops篇
设备驱动与设备树匹配机制详解

总线和设备树专栏：

总线和设备树_憧憬一下的博客-CSDN博客
设备树与 Linux 内核设备驱动模型的整合-CSDN博客

1.I2C总线驱动

I2C Core就是I2C核心层，它的作用：

提供统一的访问函数，比如i2c_transfer、i2c_smbus_xfer等
实现I2C总线-设备-驱动模型，管理：I2C设备(i2c_client)、I2C设备驱动(i2c_driver)、I2C控制器(i2c_adapter)

2.框图

在上一章节已经讲过，只要把i2c_client（一个i2c设备的抽象）当作platform_device就行，其实原理都差不多。具体直接看下图就行：

除了i2c client结构体，其它的结构体在之前的章节也全都介绍过：

3.结构体

3.1 i2c_driver

在 Linux 内核中，I2C (Inter-Integrated Circuit) 驱动框架用于处理连接在 I2C 总线上的设备。驱动程序通过 i2c_driver 结构体来表示，而每个 I2C 设备则通过 i2c_client 结构体来表示。

i2c_driver 是 Linux 内核中的结构体，用于描述 I2C 驱动。它包含与设备匹配的规则和驱动的核心操作函数，如 probe 和 remove。I2C 驱动可通过以下两种方式与设备匹配：

使用 of_match_table 来判断（第二种匹配方式）

设备树匹配：设备树 (Device Tree) 是硬件的描述文件，I2C 驱动程序通过 of_match_table 来与设备树中的设备节点匹配。

当设备树中某个 I2C 控制器节点下的 I2C 设备节点的 compatible 属性与 i2c_driver 中的 of_match_table 表中的compatible[128]相同时，匹配成功。

使用name 匹配：（第四种匹配方式）

当 i2c_client 结构体中的 name 字段与 i2c_driver.device_driver.name 的值相同，也会匹配成功。

使用 id_table 来判断（第三种匹配方式）

i2c_client.name 匹配：i2c_client 中的 name 字段与 id_table 中的某一项匹配时，也会匹配成功。

当 i2c_driver 和 i2c_client 成功匹配后，驱动的 probe 函数会被调用，开始初始化设备。

其实和上一章节讲的的平台设备匹配，道理是几乎相同的，具体看下面链接：

3.2 i2c_client

i2c_client表示一个I2C设备，创建i2c_client的方法有4种：

方法1

通过I2C bus number来创建
- 函数 i2c_register_board_info() 允许通过 I2C 总线编号创建 i2c_client。常用于板级文件中提前注册设备信息

int i2c_register_board_info(int busnum, struct i2c_board_info, const *info, unsigned len);

通过设备树来创建

i2c1: i2c@400a0000 {
/* ... master properties skipped ... */
clock-frequency = <100000>;

flash@50 {
compatible = "atmel,24c256";
reg = <0x50>;
};

pca9532: gpio@60 {
compatible = "nxp,pca9532";
gpio-controller;
#gpio-cells = <2>;
reg = <0x60>;
};
};

方法2

当设备的 I2C 总线编号不明确时，可以通过其他方式获取对应的 i2c_adapter，然后通过以下两种函数创建
i2c_client：

i2c_new_device()：即使设备并不存在，该函数仍然可以创建 i2c_client
可以使用下面两个函数来创建i2c_client：
 static struct i2c_board_info sfe4001_hwmon_info = {
I2C_BOARD_INFO("max6647", 0x4e),
 };

 int sfe4001_init(struct efx_nic *efx)
{
(...)
efx->board_info.hwmon_client =
i2c_new_device(&efx->i2c_adap, &sfe4001_hwmon_info);

(...)
 }
i2c_new_probed_device()：设备的地址可能会发生变化，如某些设备的地址可通过引脚配置。这种情况下，可以列出一组可能的设备地址，i2c_new_probed_device 会根据地址逐一检测设备是否存在。
static const unsigned short normal_i2c[] = { 0x2c, 0x2d, >I2C_CLIENT_END };

static int usb_hcd_nxp_probe(struct platform_device *pdev)
{
 (...)
 struct i2c_adapter *i2c_adap;
 struct i2c_board_info i2c_info;

 (...)
 i2c_adap = i2c_get_adapter(2);
 memset(&i2c_info, 0, sizeof(struct i2c_board_info));
 strscpy(i2c_info.type, "isp1301_nxp", sizeof(i2c_info.type));
 isp1301_i2c_client = i2c_new_probed_device(i2c_adap, &i2c_info,
    normal_i2c, NULL);
 i2c_put_adapter(i2c_adap);
 (...)
}

方法3(不推荐)：通过 i2c_driver.detect 函数可以检测到设备并生成 i2c_client，但这种方法较少使用。

方法4：可以通过用户空间命令手动生成 i2c_client，例如在调试过程中或不方便通过代码生成时：

  // 创建一个i2c_client, .name = "eeprom", .addr=0x50, .adapter是i2c-3
  # echo eeprom 0x50 > /sys/bus/i2c/devices/i2c-3/new_device
  
  // 删除一个i2c_client
  # echo 0x50 > /sys/bus/i2c/devices/i2c-3/delete_device

4.通用模板编写

4.1 代码

驱动程序：

#include "linux/i2c.h"
#include <linux/module.h>
#include <linux/poll.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/fcntl.h>
#include <linux/timer.h>

/* Global variables */
static int major = 0;
static struct class *my_i2c_class;
struct i2c_client *g_client;
static DECLARE_WAIT_QUEUE_HEAD(gpio_wait);
struct fasync_struct *i2c_fasync;

/* Implementing open/read/write functions for the file_operations structure */
static ssize_t i2c_drv_read(struct file *file, char __user *buf, size_t size, loff_t *offset)
{
int err;
struct i2c_msg msgs[2];

/* Initialize i2c_msg for reading */
/* Assuming two i2c messages: One for writing register address, the other for reading data */
err = i2c_transfer(g_client->adapter, msgs, 2);
if (err < 0)
return err;

/* Copy data to user space */
/* Handle buffer size and offset accordingly */
if (copy_to_user(buf, msgs[1].buf, size)) {
return -EFAULT;
}

return size;
}

static ssize_t i2c_drv_write(struct file *file, const char __user *buf, size_t size, loff_t *offset)
{
int err;
struct i2c_msg msgs[2];

/* Allocate buffer and copy data from user space */
char *kbuf = kmalloc(size, GFP_KERNEL);
if (!kbuf)
return -ENOMEM;

if (copy_from_user(kbuf, buf, size)) {
kfree(kbuf);
return -EFAULT;
}

/* Initialize i2c_msg for writing */
/* First message: the register address, Second message: data */
err = i2c_transfer(g_client->adapter, msgs, 2);
kfree(kbuf);

return (err < 0) ? err : size;
}

static unsigned int i2c_drv_poll(struct file *fp, poll_table *wait)
{
poll_wait(fp, &gpio_wait, wait);

/* Returning available read/write events */
// return is_key_buf_empty() ? 0 : POLLIN | POLLRDNORM;
return 0;
}

static int i2c_drv_fasync(int fd, struct file *file, int on)
{
return fasync_helper(fd, file, on, &i2c_fasync) >= 0 ? 0 : -EIO;
}

/* Define file_operations structure */
static struct file_operations i2c_drv_fops = {
.owner = THIS_MODULE,
.read = i2c_drv_read,
.write = i2c_drv_write,
.poll = i2c_drv_poll,
.fasync = i2c_drv_fasync,
};

/* Probe function called when a compatible I2C device is found */
static int i2c_drv_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
/* Save the client handle for later use */
g_client = client;

/* Register the character device */
major = register_chrdev(0, "my_i2c_device", &i2c_drv_fops);
if (major < 0)
return major;

/* Create device class and device file node */
my_i2c_class = class_create(THIS_MODULE, "my_i2c_class");
if (IS_ERR(my_i2c_class)) {
unregister_chrdev(major, "my_i2c_device");
return PTR_ERR(my_i2c_class);
}

device_create(my_i2c_class, NULL, MKDEV(major, 0), NULL, "myi2c");
return 0;
}

/* Remove function to cleanup on driver removal */
static int i2c_drv_remove(struct i2c_client *client)
{
/* Destroy the device and class */
device_destroy(my_i2c_class, MKDEV(major, 0));
class_destroy(my_i2c_class);
unregister_chrdev(major, "my_i2c_device");

return 0;
}

/* Device tree match table */
static const struct of_device_id my_i2c_dt_match[] = {
{ .compatible = "myvendor,my_i2c_device" },
{},
};

/* I2C driver structure */
static struct i2c_driver my_i2c_driver = {
.driver = {
.name = "my_i2c_driver",
.owner = THIS_MODULE,
.of_match_table = my_i2c_dt_match,
},
.probe = i2c_drv_probe,
.remove = i2c_drv_remove,
};

/* Module initialization function */
static int __init i2c_drv_init(void)
{
return i2c_add_driver(&my_i2c_driver);
}

/* Module exit function */
static void __exit i2c_drv_exit(void)
{
i2c_del_driver(&my_i2c_driver);
}

/* Module macros */
module_init(i2c_drv_init);
module_exit(i2c_drv_exit);

MODULE_LICENSE("GPL");

测试：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <poll.h>
#include <signal.h>

static int fd;

int main(int argc, char **argv)
{
int val;
struct pollfd fds[1];
int timeout_ms = 5000;
int ret;
intflags;

int i;

if (argc != 2) 
{
printf("Usage: %s <dev>\n", argv[0]);
return -1;
}


fd = open(argv[1], O_RDWR | O_NONBLOCK);
if (fd == -1)
{
printf("can not open file %s\n", argv[1]);
return -1;
}

for (i = 0; i < 10; i++) 
{
if (read(fd, &val, 4) == 4)
printf("get button: 0x%x\n", val);
else
printf("get button: -1\n");
}

flags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);

while (1)
{
if (read(fd, &val, 4) == 4)
printf("get button: 0x%x\n", val);
else
printf("while get button: -1\n");
}

close(fd);

return 0;
}

4.2 分析

i2c_add_driver()

当作platform_driver_register吧

可以在上面编写的init中看到，调用了i2c_add_driver：

i2c_add_driver 是一个 Linux 内核函数，用于注册一个 I2C 驱动程序。当你有一个新的 I2C 设备驱动程序时，可以使用这个函数将其注册到内核中，以便在相应的 I2C 总线上匹配到设备时调用该驱动程序。

/* Device tree match table */
static const struct of_device_id my_i2c_dt_match[] = {
{ .compatible = "myvendor,my_i2c_device" },
{},
};

/* I2C driver structure */
static struct i2c_driver my_i2c_driver = {
.driver = {
.name = "my_i2c_driver",
.owner = THIS_MODULE,
.of_match_table = my_i2c_dt_match,
},
.probe = i2c_drv_probe,
.remove = i2c_drv_remove,
};

/* Module initialization function */
static int __init i2c_drv_init(void)
{
return i2c_add_driver(&my_i2c_driver);
}

之前不是在内核提供的通用I2C设备驱动I2c-dev.c分析：注册篇-CSDN博客讲解了关于内核提供的i2c-dev.c设备驱动程序吗，它里面的init的函数是这样的：

static int __init i2c_dev_init(void)
{
    int res;  // 用于存储函数调用的返回结果

    // 打印内核信息，通知已启动 I²C 字符设备驱动
    printk(KERN_INFO "i2c /dev entries driver\n");

    // 注册字符设备区域，指定主设备号和次设备号范围
    res = register_chrdev_region(MKDEV(I2C_MAJOR, 0), I2C_MINORS, "i2c");
    if (res)
        goto out;  // 如果注册失败，跳转到错误处理

    // 创建一个设备类，用于 sysfs 中设备的表示和设备节点的自动创建
    i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");
    if (IS_ERR(i2c_dev_class)) {
        res = PTR_ERR(i2c_dev_class);  // 获取错误码
        goto out_unreg_chrdev;  // 跳转到字符设备取消注册
    }
    i2c_dev_class->dev_groups = i2c_groups;  // 设置设备类的属性组

    // 注册 I²C 总线的通知器，用于追踪总线上的设备添加和移除事件
    res = bus_register_notifier(&i2c_bus_type, &i2cdev_notifier);
    if (res)
        goto out_unreg_class;  // 如果通知器注册失败，跳转到类注销

    // 绑定当前系统中已存在的 I²C 适配器
    i2c_for_each_dev(NULL, i2cdev_attach_adapter); //---- （1）进入i2cdev_attach_adapter函数看下

    // 成功返回 0 表示初始化完成
    return 0;

out_unreg_class:
    // 如果类创建失败，销毁之前创建的类
    class_destroy(i2c_dev_class);
out_unreg_chrdev:
    // 如果字符设备区域注册失败，取消设备号注册
    unregister_chrdev_region(MKDEV(I2C_MAJOR, 0), I2C_MINORS);
out:
    // 打印错误信息，表明驱动初始化失败
    printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
    return res;  // 返回错误码
}

可以看到并没有像我们所编写的驱动框架那样去调用到i2c_add_driver()，其实来看一下这个函数内部实现，我们可以发现它和i2c-dev.c驱动模板的init函数其实是差不多的：

\Linux-4.9.88\include\linux\i2c.h
#define i2c_add_driver(driver) \
i2c_register_driver(THIS_MODULE, driver) //进入看
\Linux-4.9.88\drivers\i2c\i2c-core.c
int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
{
int res;

/* Can't register until after driver model init */
if (WARN_ON(!is_registered))
return -EAGAIN;

/* add the driver to the list of i2c drivers in the driver core */
driver->driver.owner = owner;
driver->driver.bus = &i2c_bus_type;
INIT_LIST_HEAD(&driver->clients);

/* When registration returns, the driver core
 * will have called probe() for all matching-but-unbound devices.
 */
res = driver_register(&driver->driver); //诶，注册驱动
if (res)
return res;

pr_debug("driver [%s] registered\n", driver->driver.name);

/* Walk the adapters that are already present */
i2c_for_each_dev(driver, __process_new_driver); //猜猜，没错，这里就是找到adapter进行绑定
    /*
        static int __process_new_driver(struct device *dev, void *data)
        {
        if (dev->type != &i2c_adapter_type)
        return 0;
        return i2c_do_add_adapter(data, to_i2c_adapter(dev));
        }
    */

return 0;

无非就是注册驱动绑定该i2c设备的adapter等，至于register_chrdev 注册、初始化字符设备等操作，使其在/dev下显示出来，则放在了probe中实现，其实道理是一样的。

i2c_transfer()

i2c_transfer 是 Linux 内核中用于在 I2C 总线上进行数据传输的函数之一。它允许驱动程序向设备发送数据或从设备接收数据。

以下是 i2c_transfer 函数的原型：

int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);

参数解释：

adap：指向表示特定 I2C 适配器的 struct i2c_adapter 结构的指针。这个结构提供了对 I2C 总线的访问方法。
msgs：一个指向 struct i2c_msg 结构数组的指针，其中每个元素描述了一条 I2C 消息（包含了要发送的数据、接收的数据、目标设备地址等信息）。
num：指定了消息数组的元素数量。

struct i2c_msg 结构包含了一条 I2C 消息的描述信息，包括以下字段：

addr：目标设备的 I2C 地址。
flags：标志位，指示是读操作、写操作还是特殊控制信息。
len：要传输的数据的字节数。
buf：指向包含要传输数据的缓冲区的指针。

调用 i2c_transfer 函数后，内核将按照消息数组中的顺序执行每一条消息，通过相应的 I2C 适配器在 I2C 总线上进行数据传输。根据每条消息的属性，数据可以从设备读取到缓冲区中，也可以从缓冲区写入到设备中。

这个函数通常由 I2C 设备驱动程序使用，用于与连接在 I2C 总线上的设备进行通信。

这个就不多讲了，主要是去配置i2c_msg的相关成员，然后就可以实现传输，要想深入了解可以看以往的内容：

内核提供的通用I2C设备驱动I2C-dev.c分析：file_ops篇-CSDN博客

I2C（IIC）协议讲解-CSDN博客

需要特别注意的是，这个i2c_transfer函数（i2c_core.c提供的接口）是将app要传输的数据借助i2c device driver传输给i2c控制器，其内部是调用了adapter->algo->master_xfer的，也就是i2c控制器的驱动（比如i2c-imx.c）中定义的函数（i2c_imx_xfer，下一文章将讲解）去传输给对应的实际的i2c硬件设备：

原文地址：https://blog.csdn.net/caiji0169/article/details/143029740

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Reflection 70B乌龙事件始末：揭开“最强大模型”背后的真相
下一篇：TikTok没有小黄车是为什么？该怎么解决？

leetcode289:生命游戏
根据，简称为，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。给定一个包含m × n个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态：1即为（live），或0即为
阅读更多2024-10-20
MongoDB数据恢复
注意：两个MongoDB的版本要一致，本文使用的是mongo:4.2.24。先把K8S上面的MongoDB 容器停止（可以把副本改成0）。1、将容器挂载MongoDB的数据目录备份到本地。经常是数据文
阅读更多2024-10-20
C#中实现事务
C#中实现事务
阅读更多2024-10-20
【LeetCode每日一题】——560.和为 K 的子数组
给你一个整数数组 nums 和一个整数 k ，请你统计并返回该数组中和为 k 的子数组的个数。子数组是数组中元素的连续非空序列。
阅读更多2024-10-20
「漏洞复现」满客宝智慧食堂系统 selectUserByOrgId 未授权访问漏洞
请勿利用文章内的相关技术从事非法测试，由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，作者不为此承担任何责任。工具来自网络，安全性自测，如有侵权请联系删除。本次
阅读更多2024-10-20
React面试题目（从基本到高级）
React前端面试常见题目涵盖了React的基础概念、组件、状态管理、生命周期、性能优化等多个方面。
阅读更多2024-10-20
12.个人博客系统（Java项目基于spring和vue）
1 在校学习的学生，可用于日常学习使用或是毕业设计使用 2 毕业一到两年的开发人员，用于锻炼自己的独立功能模块设计能力，增强代码编写能力。 3 亦可以部署为商化项目使用。 4 需要完整资料及源码
阅读更多2024-10-20
YoloV8改进策略：注意力改进|DeBiFormer，可变形双级路由注意力|引入DeBiLevelRoutingAttention注意力模块（全网首发）
本次改进的核心在于将DeBiLevelRoutingAttention模块嵌入到YoloV8的主干网络中，具体位置是在SPPF（Spatial Pyramid Pooling Fast）模块之后。这一
阅读更多2024-10-20
word取消自动单词首字母大写
情况说明：在word输入单词后首字母会自动变成大写取消单词首字母大写步骤：（1）点击菜单栏文件（2）点击“更多”——>“选项”（3）点击“校对”——>“自动更正选项”（4）取消“句首字母大
阅读更多2024-10-20
web前端网页用户注册页面
【代码】web前端网页用户注册页面。
阅读更多2024-10-20