嵌入式linux驱动框架 从0到1编写设备驱动 i2c_driver i2c_client

一、编写最简单的IIC驱动框架

在之前的文章中，我们已经深入探讨了I2C通信的基本原理、硬件架构以及时序等基础知识。现在，我们将进入一个更加实际和深入的层面，构建一个完整的I2C驱动程序，并阐述驱动框架的设计。这将帮助你不仅能够理解I2C驱动的实现细节，还能掌握如何将这种驱动框架迁移到其他外设或设备上，进而实现“一通百通”的开发思维。

上述也就是我们写驱动的相关流程了，我们首先要看别人的驱动如何写，然后精简成我们自己想要的驱动，我们在内核源码找到at24.c如下所示：

我们只要我们所需要的部分，也就是总线框架，更改后如下所示，并介绍主要代码内容。

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/mod_devicetable.h>
#include <linux/bitops.h>
#include <linux/jiffies.h>
#include <linux/property.h>
#include <linux/acpi.h>
#include <linux/i2c.h>
#include <linux/nvmem-provider.h>
#include <linux/regmap.h>
#include <linux/pm_runtime.h>
#include <linux/gpio/consumer.h>static const struct of_device_id of_match_ids_example[] = {{ .compatible = "com_name,chip_name", .data = NULL },{ /* sentinel */ }
};static const struct i2c_device_id I2C_example_ids[] = {{ "chip_name", 0 },{ /* END OF LIST */ }
};static int I2C_example_probe(struct i2c_client *client)
{pr_info("I2C device (%s) probed successfully.\n", client->name);return 0;
}static int I2C_example_remove(struct i2c_client *client)
{pr_info("I2C device (%s) removed.\n", client->name);return 0;
}static struct i2c_driver I2C_example_driver = {.driver = {.name = "chip_name",.of_match_table = of_match_ids_example,},.probe = I2C_example_probe,.remove = I2C_example_remove,.id_table = I2C_example_ids,
};static int __init I2C_driver_example_init(void)
{pr_info("I2C_example_driver loaded.\n");return i2c_add_driver(&I2C_example_driver);
}static void __exit I2C_driver_example_exit(void)
{pr_info("I2C_example_driver unloaded.\n");i2c_del_driver(&I2C_example_driver);
}module_init(I2C_driver_example_init);
module_exit(I2C_driver_example_exit);MODULE_DESCRIPTION("I2C Driver for example chip_name device");
MODULE_AUTHOR("7yewh");
MODULE_LICENSE("GPL");

用于 Linux 内核中与特定 I2C 设备的通信。驱动通过 of_device_id 和 i2c_device_id 来匹配设备，使得驱动能够识别与之兼容的 I2C 设备。首先，通过 of_device_id 表定义了设备树的匹配条件，设备树描述了硬件设备的信息，驱动通过匹配 "com_name,chip_name" 来确认是否支持某个特定的硬件设备。而 i2c_device_id 则为 I2C 设备注册了设备 ID，设备通过这些 ID 与驱动进行匹配。在设备匹配成功后，probe 函数被调用，进行设备初始化工作，主要的任务是在驱动中实现对硬件的访问，像是配置寄存器或初始化硬件模块；同样，在设备卸载时，remove 函数会被调用，负责清理资源。在驱动的初始化过程中，使用 i2c_add_driver 将驱动注册到内核，通知内核该驱动可以管理特定的 I2C 设备；在驱动卸载时，使用 i2c_del_driver 从内核中移除该驱动。代码中使用 pr_info 打印调试信息，方便查看驱动是否被正确加载和移除。

接下来我们就通过这个驱动框架变种设备出来供大家系统性的学习。

二、利用驱动框架实现a3216c驱动

本质还是如下的内容，我们实现驱动的过程可以先利用一些相关TOOLS先进行测试，如果可以我们也可以这样去读取，同理SPI也是，相关协议逻辑功能，各种GPIO都可以，重点在于思路。

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/mod_devicetable.h>
#include <linux/bitops.h>
#include <linux/jiffies.h>
#include <linux/property.h>
#include <linux/acpi.h>
#include <linux/i2c.h>
#include <linux/nvmem-provider.h>
#include <linux/regmap.h>
#include <linux/pm_runtime.h>
#include <linux/gpio/consumer.h>static int major = 0;
static struct class *ap3216c_class;
static struct i2c_client *ap3216c_client;static ssize_t ap3216c_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
{int err;char kernel_buf[6];int val;if (size != 6)return -EINVAL;val = i2c_smbus_read_word_data(ap3216c_client, 0xA); /* read IR */kernel_buf[0] = val & 0xff;kernel_buf[1] = (val>>8) & 0xff;val = i2c_smbus_read_word_data(ap3216c_client, 0xC); /* read 光强 */kernel_buf[2] = val & 0xff;kernel_buf[3] = (val>>8) & 0xff;val = i2c_smbus_read_word_data(ap3216c_client, 0xE); /* read 距离 */kernel_buf[4] = val & 0xff;kernel_buf[5] = (val>>8) & 0xff;err = copy_to_user(buf, kernel_buf, size);return size;
}static int ap3216c_open (struct inode *node, struct file *file)
{i2c_smbus_write_byte_data(ap3216c_client, 0, 0x4);/* delay for reset */mdelay(20);i2c_smbus_write_byte_data(ap3216c_client, 0, 0x3);return 0;
}static struct file_operations ap3216c_ops = {.owner = THIS_MODULE,.open  = ap3216c_open,.read  = ap3216c_read,
};static const struct of_device_id of_match_ids_ap3216c[] = {{ .compatible = "com_name,chip_name",		.data = NULL },{ /* END OF LIST */ },
};static const struct i2c_device_id ap3216c_ids[] = {{ "chip_name",	(kernel_ulong_t)NULL },{ /* END OF LIST */ }
};static int ap3216c_probe(struct i2c_client *client)
{printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);ap3216c_client = client;/* register_chrdev */major = register_chrdev(0, "ap3216c", &ap3216c_ops);ap3216c_class = class_create(THIS_MODULE, "ap3216c_class");device_create(ap3216c_class, NULL, MKDEV(major, 0), NULL, "ap3216c"); /* /dev/ap3216c */return 0;
}static int ap3216c_remove(struct i2c_client *client)
{printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);device_destroy(ap3216c_class, MKDEV(major, 0));class_destroy(ap3216c_class);/* unregister_chrdev */unregister_chrdev(major, "ap3216c");return 0;
}static struct i2c_driver i2c_ap3216c_driver = {.driver = {.name = "ap3216c",.of_match_table = of_match_ids_ap3216c,},.probe_new = ap3216c_probe,.remove = ap3216c_remove,.id_table = ap3216c_ids,
};static int __init i2c_driver_ap3216c_init(void)
{printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);return i2c_add_driver(&i2c_ap3216c_driver);
}
module_init(i2c_driver_ap3216c_init);static void __exit i2c_driver_ap3216c_exit(void)
{i2c_del_driver(&i2c_ap3216c_driver);
}
module_exit(i2c_driver_ap3216c_exit);MODULE_AUTHOR("7yewh");
MODULE_LICENSE("GPL");

文件操作函数 (ap3216c_ops)：

ap3216c_open：打开设备时，执行初始化操作，首先通过 i2c_smbus_write_byte_data 向设备写入数据，重置设备并延时 20 毫秒，然后恢复设备的正常工作状态。

ap3216c_read：读取设备数据。在 read 函数中，先使用 i2c_smbus_read_word_data 函数分别从设备读取红外(IR)值、光强值和距离值。读取的数据被保存在内核缓冲区，然后通过 copy_to_user 复制到用户空间缓冲区。

字符设备注册：

通过 register_chrdev 注册一个字符设备，设备的主设备号为 0，驱动为 "ap3216c"。

创建了一个字符设备类 ap3216c_class，并通过 device_create 创建设备文件 /dev/ap3216c，供用户空间程序访问。

设备匹配与驱动注册：

of_match_ids_ap3216c：通过设备树匹配设备。驱动会匹配所有 compatible 字段为 "com_name,chip_name" 的设备节点。

ap3216c_ids：定义了 I2C 设备 ID 以支持通过 I2C 总线与设备通信。设备 ID 为 "chip_name"。

ap3216c_probe：当设备被匹配到驱动时调用。此函数会执行设备初始化操作，注册字符设备并创建设备文件。

ap3216c_remove：在设备移除时调用，卸载驱动并清理相关资源，包括注销字符设备和销毁设备文件。

驱动初始化与卸载：

在 i2c_driver_ap3216c_init 中，使用 i2c_add_driver 注册 I2C 驱动，驱动将会管理所有匹配到的设备。

在 i2c_driver_ap3216c_exit 中，使用 i2c_del_driver 删除驱动，清理注册的信息。

内核模块宏：

module_init 和 module_exit 宏分别指定了模块的初始化和退出函数。

MODULE_AUTHOR 和 MODULE_LICENSE 用于指定作者信息和许可证，标明这是一个 GPL 许可的开源驱动。

接下来就是完整的驱动代码了。如下所示：ap3216c_client.c

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/mod_devicetable.h>
#include <linux/bitops.h>
#include <linux/jiffies.h>
#include <linux/property.h>
#include <linux/acpi.h>
#include <linux/i2c.h>
#include <linux/nvmem-provider.h>
#include <linux/regmap.h>
#include <linux/pm_runtime.h>
#include <linux/gpio/consumer.h>
#include <linux/uaccess.h>
#include <linux/fs.h>#if 1
static struct i2c_client *ap3216c_client;static int __init i2c_client_ap3216c_init(void)
{struct i2c_adapter *adapter;static struct i2c_board_info board_info = {I2C_BOARD_INFO("ap3216c", 0x1e),};printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);/* register I2C device */adapter = i2c_get_adapter(0);ap3216c_client = i2c_new_device(adapter, &board_info);i2c_put_adapter(adapter);return 0;
}#elsestatic struct i2c_client *ap3216c_client;/* Addresses to scan */
static const unsigned short normal_i2c[] = {0x1e, I2C_CLIENT_END
};static int __init i2c_client_ap3216c_init(void)
{struct i2c_adapter *adapter;struct i2c_board_info board_info;memset(&board_info, 0, sizeof(struct i2c_board_info));strscpy(board_info.type, "ap3216c", sizeof(board_info.type));printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);/* register I2C device */adapter = i2c_get_adapter(0);ap3216c_client = i2c_new_probed_device(adapter, &board_info,normal_i2c, NULL);i2c_put_adapter(adapter);return 0;
}
#endifmodule_init(i2c_client_ap3216c_init);static void __exit i2c_client_ap3216c_exit(void)
{i2c_unregister_device(ap3216c_client);
}
module_exit(i2c_client_ap3216c_exit);MODULE_AUTHOR("7yewh");
MODULE_LICENSE("GPL");

imx6ull-14x14.dts：

&i2c1 {ap3216c@1e {compatible = "lite-on,ap3216c";reg = <0x1e>;};
};

三、利用驱动框架实现gt9271驱动

dtsi如下所示

    myts@5d {compatible = "my,touch";reg = <0x5d>;tp-size = <89>;max-x = <1280>;max-y = <800>;touch-gpio = <&gpio1 RK_PA0 IRQ_TYPE_LEVEL_LOW>;reset-gpio = <&gpio1 RK_PA1 GPIO_ACTIVE_HIGH>;};

接下来就是驱动文件：

#include "linux/stddef.h"
#include <linux/kernel.h>
#include <linux/hrtimer.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/proc_fs.h>
#include <linux/string.h>
#include <linux/uaccess.h>
#include <linux/vmalloc.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/slab.h>
#include <linux/timer.h>
#include <linux/input/mt.h>
#include <linux/random.h>#define MY_SWAP(x, y)                 do{\typeof(x) z = x;\x = y;\y = z;\}while (0)#if 1
#define MY_DEBUG(fmt,arg...)  printk("MY_TOUCH:%s %d "fmt"",__FUNCTION__,__LINE__,##arg);
#else
#define MY_DEBUG(fmt,arg...)
#endifstruct my_touch_dev {struct i2c_client *client;	//i2c_client 用于描述I2C设备 包括I2C总线 设备地址等信息struct input_dev *input_dev;//input_dev 提供输入设备的信息，例如设备类型（鼠标、键盘、触摸屏）、事件类型（如触摸、移动、点击等），并负责向用户空间报告输入事件。int rst_pin;int irq_pin;u32 abs_x_max;u32 abs_y_max;int irq;
};s32 my_touch_i2c_read(struct i2c_client *client,u8 *addr,u8 addr_len, u8 *buf, s32 len)
{struct i2c_msg msgs[2];s32 ret=-1;msgs[0].flags = !I2C_M_RD;msgs[0].addr  = client->addr;msgs[0].len   = addr_len;msgs[0].buf   = &addr[0];msgs[1].flags = I2C_M_RD;msgs[1].addr  = client->addr;msgs[1].len   = len;msgs[1].buf   = &buf[0];ret = i2c_transfer(client->adapter, msgs, 2);if(ret == 2)return 0;if(addr_len == 2){MY_DEBUG("I2C Read: 0x%04X, %d bytes failed, errcode: %d! Process reset.", (((u16)(addr[0] << 8)) | addr[1]), len, ret);}else {MY_DEBUG("I2C Read: 0x%02X, %d bytes failed, errcode: %d! Process reset.", addr[0], len, ret);}return -1;
}s32 my_touch_i2c_write(struct i2c_client *client, u8 *addr, u8 addr_len, u8 *buf,s32 len)
{struct i2c_msg msg;s32 ret = -1;u8 *temp_buf;msg.flags = !I2C_M_RD;msg.addr  = client->addr;msg.len   = len+addr_len;temp_buf= kzalloc(msg.len, GFP_KERNEL);if (!temp_buf){goto error;}// 装填地址memcpy(temp_buf, addr, addr_len);// 装填数据memcpy(temp_buf + addr_len, buf, len);msg.buf = temp_buf;ret = i2c_transfer(client->adapter, &msg, 1);if (ret == 1) {kfree(temp_buf);return 0;}error:if(addr_len == 2){MY_DEBUG("I2C Read: 0x%04X, %d bytes failed, errcode: %d! Process reset.", (((u16)(addr[0] << 8)) | addr[1]), len, ret);}else {MY_DEBUG("I2C Read: 0x%02X, %d bytes failed, errcode: %d! Process reset.", addr[0], len, ret);}if (temp_buf)kfree(temp_buf);return -1;
}static irqreturn_t my_touch_irq_handler(int irq, void *dev_id)
{s32 ret = -1;struct my_touch_dev *ts = dev_id;u8 addr[2] = {0x81,0x4E};u8 clear_buf[1] = {0};u8 point_data[1+8*1]={0};//1个状态位置+10个触摸点，一个点是8个数据组成u8 touch_num = 0;u8 buf_stats = 0;u8 *coor_data;int id,input_x,input_y,input_w;MY_DEBUG("irq");ret = my_touch_i2c_read(ts->client, addr,sizeof(addr), point_data, sizeof(point_data));if (ret < 0){MY_DEBUG("I2C write end_cmd error!");}touch_num = point_data[0]&0x0f;buf_stats = point_data[0]&0x80>>7;MY_DEBUG("0x814E=:%0x,touch_num:%d,buf_stats:%d",point_data[0],touch_num,buf_stats);//获取if (touch_num){coor_data = &point_data[1];id = coor_data[0] & 0x0F;input_x  = coor_data[1] | (coor_data[2] << 8);input_y  = coor_data[3] | (coor_data[4] << 8);input_w  = coor_data[5] | (coor_data[6] << 8);MY_DEBUG("id:%d,x:%d,y:%d,w:%d",id,input_x,input_y,input_w);//     // 设定输入设备的触摸槽位input_mt_slot(ts->input_dev, 0);// 报告输入设备的触摸槽位状态，MT_TOOL_FINGER 表示手指状态，isDown 表示是否按下input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);// 翻转 isDown 的值模仿手抬起和按下MY_SWAP(input_x, input_y);// 报告输入设备的绝对位置信息：x、y 坐标，触摸面积，触摸宽度input_report_abs(ts->input_dev, ABS_MT_POSITION_X, 800-input_x);input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, input_y);}else {input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);}// 清除寄存器，要不然回反复触发ret = my_touch_i2c_write(ts->client,  addr,sizeof(addr), clear_buf, sizeof(clear_buf));if (ret < 0){MY_DEBUG("I2C write end_cmd error!");}// 报告输入设备的指针仿真信息input_mt_report_pointer_emulation(ts->input_dev, true);// 同步输入事件input_sync(ts->input_dev);return IRQ_HANDLED;
}s32 gt9271_read_version(struct i2c_client *client)
{s32 ret = -1;u8 addr[2] = {0x81,0x40};u8 buf[6] = {0};ret = my_touch_i2c_read(client, addr,sizeof(addr), buf, sizeof(buf));if (ret < 0){MY_DEBUG("GTP read version failed");return ret;}if (buf[5] == 0x00){MY_DEBUG("IC Version: %c%c%c_%02x%02x", buf[0], buf[1], buf[2], buf[5], buf[4]);}else{MY_DEBUG("IC Version: %c%c%c%c_%02x%02x", buf[0], buf[1], buf[2], buf[3], buf[5], buf[4]);}return ret;
}static int my_touch_ts_probe(struct i2c_client *client,const struct i2c_device_id *id)
{int ret;struct my_touch_dev *ts;struct device_node *np = client->dev.of_node;// 打印调试信息MY_DEBUG("locat");// ts = kzalloc(sizeof(*ts), GFP_KERNEL);ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);if (ts == NULL){dev_err(&client->dev, "Alloc GFP_KERNEL memory failed.");return -ENOMEM;}ts->client = client;i2c_set_clientdata(client, ts);if (of_property_read_u32(np, "max-x", &ts->abs_x_max)) {dev_err(&client->dev, "no max-x defined\n");return -EINVAL;}MY_DEBUG("abs_x_max:%d",ts->abs_x_max);if (of_property_read_u32(np, "max-y", &ts->abs_y_max)) {dev_err(&client->dev, "no max-y defined\n");return -EINVAL;}MY_DEBUG("abs_x_max:%d",ts->abs_y_max);//找复位gpiots->rst_pin = of_get_named_gpio(np, "reset-gpio", 0);//申请复位gpioret = devm_gpio_request(&client->dev,ts->rst_pin,"my touch touch gpio");if (ret < 0){dev_err(&client->dev, "gpio request failed.");return -ENOMEM;}//找中断引进ts->irq_pin = of_get_named_gpio(np, "touch-gpio", 0);/* 申请使用管脚 */ret = devm_gpio_request_one(&client->dev, ts->irq_pin,GPIOF_IN, "my touch touch gpio");if (ret < 0)return ret;gpio_direction_output(ts->rst_pin,0);msleep(20); gpio_direction_output(ts->irq_pin,0);msleep(2); gpio_direction_output(ts->rst_pin,1);msleep(6); gpio_direction_output(ts->irq_pin, 0);gpio_direction_output(ts->irq_pin, 0);msleep(50);//申请中断ts->irq = gpio_to_irq(ts->irq_pin); if(ts->irq){ret = devm_request_threaded_irq(&(client->dev), ts->irq, NULL, my_touch_irq_handler, IRQF_TRIGGER_FALLING | IRQF_ONESHOT , client->name, ts);if (ret != 0) {MY_DEBUG("Cannot allocate ts INT!ERRNO:%d\n", ret);return ret;}}// 分配输入设备对象ts->input_dev = devm_input_allocate_device(&client->dev);if (!ts->input_dev) {dev_err(&client->dev, "Failed to allocate input device.\n");return -ENOMEM;}// 设置输入设备的名称和总线类型ts->input_dev->name = "my touch screen";ts->input_dev->id.bustype = BUS_I2C;/*设置触摸 x 和 y 的最大值*/// 设置输入设备的绝对位置参数input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, 800, 0, 0);input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, 1280, 0, 0);// 初始化多点触摸设备的槽位ret = input_mt_init_slots(ts->input_dev, 5, INPUT_MT_DIRECT);if (ret) {dev_err(&client->dev, "Input mt init error\n");return ret;}// 注册输入设备ret = input_register_device(ts->input_dev);if (ret)return ret;gt9271_read_version(client);return 0;
}static int my_touch_ts_remove(struct i2c_client *client)
{struct my_touch_dev *ts = i2c_get_clientdata(client);MY_DEBUG("locat");input_unregister_device(ts->input_dev);return 0;
}static const struct of_device_id my_touch_of_match[] = {{ .compatible = "my,touch", },{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, my_touch_of_match);static struct i2c_driver my_touch_ts_driver = {.probe      = my_touch_ts_probe,.remove     = my_touch_ts_remove,.driver = {.name     = "my-touch",.of_match_table = of_match_ptr(my_touch_of_match),},
};static int __init my_ts_init(void)
{MY_DEBUG("locat");return i2c_add_driver(&my_touch_ts_driver);
}static void __exit my_ts_exit(void)
{MY_DEBUG("locat");i2c_del_driver(&my_touch_ts_driver);
}module_init(my_ts_init);
module_exit(my_ts_exit);MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("My touch driver");
MODULE_AUTHOR("7yewh");