linux GPIO-i2c驱动

来源：互联网发布：关联规则挖掘算法编辑：程序博客网时间：2024/05/04 14:07

转载链接地址:http://blog.chinaunix.net/uid-27717694-id-3519302.html
一、I2C概述
Linux的I2C体系结构分为3个组成部分：
1.I2C核心
I2C 核心提供了I2C总线驱动和设备驱动的注册、注销方法，I2C通信方法（即“algorithm”）上层的、与具体适配器无关的代码以及探测设备、检测设备地址的上层代码等。
2.I2C总线驱动
I2C总线驱动是对I2C硬件体系结构中适配器端的实现，适配器可由CPU控制，甚至直接集成在CPU内部。
I2C总线驱动主要包含了I2C适配器数据结构i2c_adapter、I2C适配器的algorithm数据结构i2c_algorithm和控制I2C适配器产生通信信号的函数。
经由I2C总线驱动的代码，我们可以控制I2C适配器以主控方式产生开始位、停止位、读写周期，以及以从设备方式被读写、产生ACK等。
3.I2C设备驱动
I2C设备驱动是对I2C硬件体系结构中设备端的实现，设备一般挂接在受CPU控制的I2C适配器上，通过I2C适配器与CPU交换数据。
I2C设备驱动主要包含了数据结构i2c_driver和i2c_client，我们需要根据具体设备实现其中的成员函数。
二、下面介绍i2c各核心数据结构的定义和它们之间的连接关系。
1. 一个i2c设备的驱动程序由i2c_driver数据结构描述，i2c_driver代表I2C从设备驱动,定义于include/linux/i2c.h：
struct i2c_driver {
unsigned int class;
/* 这两个接口已经被probe和remove取代 */
int (*attach_adapter)(struct i2c_adapter *);//attach_adapter回调函数在安装i2c设备驱动程序模块时、或者在安装i2c适配器驱动程序模块时被调用，
//用于检测、认领设备并为设备分配i2c_client数据结构。
int (*detach_adapter)(struct i2c_adapter *);//detach_client方法在卸载适配器或设备驱动程序模块时被调用，用于从总线上注销设备、并释放i2c_client及相应的私有数据结构。
int (*probe)(struct i2c_client *, const struct i2c_device_id *);
int (*remove)(struct i2c_client *);
void (*shutdown)(struct i2c_client *);
int (*suspend)(struct i2c_client *, pm_message_t mesg);
int (*resume)(struct i2c_client *);
void (*alert)(struct i2c_client *, unsigned int data);
int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
struct device_driver driver;/*设备驱动结构体*/
const struct i2c_device_id *id_table;//该驱动所支持的设备ID表
int (*detect)(struct i2c_client *, struct i2c_board_info *);
const unsigned short *address_list;
struct list_head clients;
};
2. 一个i2c适配器由i2c_adapter数据结构描述
/*
i2c adapter是软件上抽象出来的i2c总线控制器接口
物理上一条i2c总线可以挂接多个硬件设备(slave)，一个CPU可以挂接多条i2c总线(想象一下PCI总线)
i2c总线控制器就是CPU访问I2C总线的硬件接口，也就是你说的那几个寄存器 .
简单点了，你的开发板上有几个I2C接口，就有几个adapter , 也就是有几条I2C bus ， I2C CLIENT 对应的就是你的外围I2C 设备，
有几个就有几个CLIENT , 把这些设备插入开发板，对应其中的一条BUS, 那么相应的就对应了其中的一个ADAPTER ,
接下来的就是 CLIENT 与 ADAPTER 勾搭成对了，后面就是做该做的事了.
*/
struct i2c_adapter {
struct module *owner;/*所属模块*/
unsigned int id; /*algorithm的类型，定义于i2c-id.h，以I2C_ALGO_开始*/
unsigned int class;
struct i2c_algorithm *algo;/*总线通信方法结构体指针，一个i2c适配器上的i2c总线通信方法由其驱动程序提供的i2c_algorithm数据结构描述，由algo指针指向 */
void *algo_data; /* algorithm数据 */
int (*client_register)(struct i2c_client *); /*client注册时调用*/
int (*client_unregister)(struct i2c_client *); /*client注销时调用*/
struct semaphore bus_lock; /*控制并发访问的自旋锁*/
struct semaphore clist_lock;
int timeout;
int retries; /*重试次数*/
struct device dev; /* 适配器设备 */
struct class_device class_dev; /* 类设备 */
int nr;
struct list_head clients; /* client链表头,总线上每个设备的 i2c_client数据结构挂载在这里*/
struct list_head list;
char name[I2C_NAME_SIZE]; /*适配器名称*/
struct completion dev_released; /*用于同步*/
struct completion class_dev_released;
};
3.具体i2c适配器的通信方法由i2c_algorithm数据结构进行描述：
struct i2c_algorithm {
int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,int num);//I2C传输函数指针
int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,unsigned short flags, char read_write,u8 command, int size, union i2c_smbus_data *data);//SMbus传输函数指针
u32 (*functionality) (struct i2c_adapter *);//返回适配器支持的功能
};
4.一个i2c设备由i2c_client数据结构进行描述：
struct i2c_client {
unsigned int flags; /* 标志 */
/*需要说明的是，i2c设备的7位地址是就当前i2c总线而言的，是“相对地址”。不同的i2c总线上的设备
可以使用相同的7位地址，但是它们所在的i2c总线不同。所以在系统中一个i2c设备的“绝对地址”由二
元组（i2c适配器的ID和设备在该总线上的7位地址）表示。
*/
unsigned short addr; /* 低7位为芯片地址 */
struct i2c_adapter *adapter; /*依附的i2c_adapter*/
struct i2c_driver *driver; /*依附的i2c_driver */
int usage_count; /* 访问计数 */
struct device dev; /* 设备结构体 */
struct list_head list; /* 链表头 */
char name[I2C_NAME_SIZE]; /* 设备名称 */
struct completion released; /* 用于同步 */
};
5.下面分析一下i2c_driver、i2c_client、i2c_adapter和i2c_algorithm这4个数据结构的作用及其盘根错节的关系。
5.1 i2c_adapter与i2c_algorithm
i2c_adapter 对应于物理上的一个适配器，而i2c_algorithm对应一套通信方法。一个I2C适配器需要i2c_algorithm中提供的通信函数来控制适配器上产生特定的访问周期。缺少i2c_algorithm的i2c_adapter什么也做不了，因此i2c_adapter中包含其使用的 i2c_algorithm的指针。
i2c_algorithm中的关键函数master_xfer()用于产生I2C访问周期需要的信号，以i2c_msg（即I2C消息）为单位。i2c_msg结构体也非常关键。
//i2c_msg结构体:
struct i2c_msg {
__u16 addr; /* 设备地址*/
__u16 flags; /* 标志 */
__u16 len; /* 消息长度*/
__u8 *buf; /* 消息数据*/
};
5.2 i2c_driver与i2c_client
i2c_driver对应一套驱动方法，是纯粹的用于辅助作用的数据结构，它不对应于任何的物理实体。i2c_client对应于真实的物理设备，每个I2C设备都需要一个i2c_client来描述。i2c_client一般被包含在i2c字符设备的私有信息结构体中。
i2c_driver 与i2c_client发生关联的时刻在i2c_driver的attach_adapter()函数被运行时。attach_adapter()会探测物理设备，当确定一个client存在时，把该client使用的i2c_client数据结构的adapter指针指向对应的i2c_adapter， driver指针指向该i2c_driver，并会调用i2c_adapter的client_register()函数。相反的过程发生在 i2c_driver 的detach_client()函数被调用的时候。
5.3 i2c_adpater与i2c_client
i2c_adpater 与i2c_client的关系与I2C硬件体系中适配器和设备的关系一致，即i2c_client依附于i2c_adpater。由于一个适配器上可以连接多个I2C设备，所以一个i2c_adpater也可以被多个i2c_client依附，i2c_adpater中包括依附于它的i2c_client 的链表。
三、I2C驱动的实现工作
一方面，适配器驱动可能是Linux内核本身还不包含的。另一方面，挂接在适配器上的具体设备驱动可能也是Linux不存在的。即便上述设备驱动都存在于Linux内核中，其基于的平台也可能与我们的电路板不一样。因此，工程师要实现的主要工作将包括：
6.1 提供I2C适配器的硬件驱动，探测、初始化I2C适配器（如申请I2C的I/O地址和中断号）、驱动CPU控制的I2C适配器从硬件上产生各种信号以及处理I2C中断等。
6.2 提供I2C适配器的algorithm，用具体适配器的xxx_xfer()函数填充i2c_algorithm的master_xfer指针，并把i2c_algorithm指针赋值给i2c_adapter的algo指针。
6.3 实现I2C设备驱动与i2c_driver接口，用具体设备yyy的yyy_attach_adapter()函数指针、 yyy_detach_client()函数指针和yyy_command()函数指针的赋值给i2c_driver的attach_adapter、 detach_adapter和detach_client指针。
6.4 实现I2C设备驱动的文件操作接口，即实现具体设备yyy的yyy_read()、yyy_write()和yyy_ioctl()函数等。
四、核心层提供的接口函数
1、增加/删除I2C适配器
int i2c_add_adapter(struct i2c_adapter *adapter)
int i2c_del_adapter(struct i2c_adapter *adap)
2、增加/删除I2C从设备驱动
int i2c_register_driver(struct module *owner, structi2c_driver *driver)
static inline int i2c_add_driver(struct i2c_driver *driver)
void i2c_del_driver(struct i2c_driver *driver)
//i2c_add_driver是对i2c_register_driver简单的封装
3、i2c传输，发送和接收
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg*msgs, int num)
int i2c_master_send(const struct i2c_client *client, constchar *buf, int count)
int i2c_master_recv(const struct i2c_client *client, char*buf, int count)
//i2c_master_send和i2c_master_recv是i2c_transfer的封装
//3.1.0的内核中已经没有i2c_attach_client和i2c_detach_client接口
4、I2C总线通信方法
我们需要为特定的I2C适配器实现其通信方法，主要实现i2c_algorithm结构体中的两个函数：
struct i2c_algorithm {
int(*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
u32(*functionality) (struct i2c_adapter *);
};
Functionality函数用于返回algorithm所支持的通信协议；
Master_xfer函数在I2C适配器上完成数据的传输；
//Master_xfer函数实现模板
static int i2c_adapter_xxx_xfer(structi2c_adapter *adap, struct i2c_msg *msgs, int num)
{
......
for (i = 0; i < num; i++) {
i2c_adapter_xxx_start(); /*产生起始位*/
if (msgs[i]->flags & I2C_M_RD) { /*读取*/
i2c_adapter_xxx_setaddr((msg->addr << 1) | 1); /*发送从设备地址*/
i2c_adapter_xxx_wait_ack(); /*获得从设备的ACK*/
i2c_adapter_xxx_readbytes(msgs[i]->buf,msgs[i]->len); /*读取len长度的数据到buf中*/
} else {
i2c_adapter_xxx_setaddr(msg->addr << 1);
i2c_adapter_xxx_wait_ack();
i2c_adapter_xxx_writebytes(msgs[i]->buf, msgs[i]->len);
}
}
i2c_adapter_xxx_stop(); /*产生停止位*/
}
我们来大致分析一下匹配的过程：
当调用i2c_add_driver函数向I2C总线(i2c-core.c文件中注册的”i2c”总线)增加一个i2c_driver时，会遍历总线中的所有i2c_client，
调用总线注册的match函数I2C适配器上是否有与i2c_driver匹配的i2c_client，如果匹配会调用I2C注册的probe函数，然后再调用i2c_driver定义的probe来进行关联和初始化工作。
五、i2c的初始化
i2c子系统的初始化函数的执行先后顺序,结合vmlinux.lds和Makefile，可确定i2c初始化函数的执行顺序如下：
1./dricer/i2c/i2c-core.c中的函数：i2c_init()---------->postcore_initcall级别
2./arch/arm/mach-davinci/board-da850-evm.c中的函数：da850_evm_init()---------->arch_initcall级别
3.driver/i2c/buses/i2c-gpio.c中的函数：i2c_gpio_init()---------->subsys_initcall级别
4./driver/i2c/i2c-dev.c中的函数：i2c_dev_init()---------->module_init级别
1.在linux内核启动的时候最先执行的和I2C子系统相关的函数应该是driver/i2c/i2c-core.c文件中的i2c_init()函数。
static int __init i2c_init(void)
{
int retval;
//设备模型中，关心总线，设备，驱动这三个实体，总线将设备和驱动绑定，在系统每注册一个设备的时候，会寻找与之匹配的驱动。
//相反，在系统每注册一个驱动的时候，寻找与之匹配的设备，匹配是由总线来完成的。你还可以看一看链表的信息。它们都是关联的。
retval = bus_register(&i2c_bus_type);//可以发现i2c_inti的函数主要功能就是注册i2c总线
if (retval)
return retval;
retval = i2c_add_driver(&dummy_driver);
if (retval)
goto class_err;
return 0;
class_err:
bus_unregister(&i2c_bus_type);
return retval;
}
/*
struct bus_type i2c_bus_type = {
.name = "i2c",
.match = i2c_device_match,
.probe = i2c_device_probe,
.remove = i2c_device_remove,
.shutdown = i2c_device_shutdown,
.pm = &i2c_device_pm_ops,
};
match方法的用来进行client device和client driver的配对。在向总线i2c_bus_type注册设备或者驱动时会调用此方法。
probe方法在完成设备和驱动的配对后调用执行，i2c_bus_type的probe方法是通过传递进来的drv找到包含此drv的i2c_driver驱动，然后再去调用i2c_driver的probe方法，此处就是at24_probe。
为什么要这样呢？因为driver_register后，注册的是i2_driver->drv，而drv中的probe未初始化，我们需要调用的是i2c-driver的probe方法。
*/
2.设置i2c的复用管脚配置，以及注册platform设备
调用完函数i2c_init后，系统将成功创建i2c总线。初始化完毕总线后还需要接着初始化i2c设备和i2c驱动(一般是先初始化device)，
linux内核中的device初始化一般是通过platform device来初始化的，platform device的初始化在da850_evm_init().
static __init void da850_evm_init(void)
{
int ret;
char mask = 0;
//在\arch\arm\mach-davinci\include\mach\common.h中定义davinci_soc_info结构。
//而\arch\arm\mach-davinci\common.c中davinci_common_init（）对其初始化。
//davinci_soc_info真正的定义在\arch\arm\mach-davinci\da850.c中，定义达芬奇架构的各类资源的地址等
struct davinci_soc_info *soc_info = &davinci_soc_info;
//......
/*const short da850_i2c0_pins[] __initdata = {
DA850_GPIO1_4, DA850_GPIO1_5,
-1
};
*/
ret = davinci_cfg_reg_list(da850_i2c0_pins);//i2c的复用管脚配置
if (ret)
pr_warning("da850_evm_init: i2c0 mux setup failed: %d\n",ret);
/*
static struct i2c_gpio_platform_data da850_gpio_i2c_pdata = {
.sda_pin = GPIO_TO_PIN(1, 4),//20 #define GPIO_TO_PIN(bank, gpio) (16 * (bank) + (gpio))
.scl_pin = GPIO_TO_PIN(1, 5),//21
.udelay = 2,//250 KHz
//.sda_is_open_drain =1, //未设置
//.scl_is_open_drain =1, //未设置
//.scl_is_output_only =1, //未设置
};
static struct platform_device da850_gpio_i2c = {
.name = "i2c-gpio",
.id = 1,
.dev = {
.platform_data = &da850_gpio_i2c_pdata,
},
};
*/
platform_device_register(&da850_gpio_i2c);//注册i2c对应的platform设备
//......
}
3.在完成platform_device的添加之后，i2c子系统将进行platform_driver的注册过程。platform_driver的注册通过调用初始化函数i2c_gpio_init()函数来完成。
static int __init i2c_gpio_init(void)
{
int ret;
/*
static struct platform_driver i2c_gpio_driver = {
.driver = {
.name = "i2c-gpio",
.owner = THIS_MODULE,
},
.probe = i2c_gpio_probe,
.remove = __devexit_p(i2c_gpio_remove),
};
*/
//注册i2c设备对应的platform驱动,会调用i2c_gpio_probe
ret = platform_driver_register(&i2c_gpio_driver);
if (ret)
printk(KERN_ERR "i2c-gpio: probe failed: %d\n", ret);
return ret;
}
//3.1 platform_driver在注册到platform_bus总线的过程中会尝试将已注册的platform_driver与已注册到platform_bus上的所有platform_device进行配对。
//配对过程通过调用总线的match方法实现，即platform_match函数.就是根据platfor_device和platform_driver的名字来实现配对。
//但是platform_driver有好几个名字可以选择，通过id_table来实现配对。
//执行到此处，之前已注册到platform_bus的platform_device型设备da850_gpio_i2c和现在刚注册到platform_bus总线的platfor_drver型驱动i2c_gpio_driver将实现配对成功。
//因为他们的名字都是“i2c-gpio”。
//3.2 成功配对之后将尝试进行probe。成功配对后首先调用的是总线的probe，假如总线未初始化probe方法才会去调用驱动中的probe，即platform_driver.drv->probe，
//而platform_bus本身未初始化probe方法，所以此处调用驱动的probe方法，驱动的probe在注册过程中已被初始化。即i2c_gpio_probe（）。
static int __devinit i2c_gpio_probe(struct platform_device *pdev)
{
//传入的platform_device就是前边已经注册过的da850_gpio_i2c
struct i2c_gpio_platform_data *pdata;
struct i2c_algo_bit_data *bit_data;
struct i2c_adapter *adap;
int ret;
/*这个结构体主要描述gpio模拟i2c总线，sda_pin和scl_pin表示使用哪两个IO管脚来模拟I2C总线，
udelay和timeout分别为它的时钟频率和超时时间，sda_is_open_drain和scl_is_open_drain表示sda、scl这两个管脚是否是开漏(opendrain)电路，
如果是设置为1，scl_is_output_only表示scl这个管脚是否只是作为输出，如果是设置为1。
static struct i2c_gpio_platform_data da850_gpio_i2c_pdata = {
.sda_pin = GPIO_TO_PIN(1, 4),//20
.scl_pin = GPIO_TO_PIN(1, 5),//21
.udelay = 2,//250 KHz
};
*/
pdata = pdev->dev.platform_data;//得到设备的i2c_gpio_platform_data结构
if (!pdata)
return -ENXIO;
ret = -ENOMEM;
adap = kzalloc(sizeof(struct i2c_adapter), GFP_KERNEL);//分配适配器i2c_adapter结构空间
if (!adap)
goto err_alloc_adap;
bit_data = kzalloc(sizeof(struct i2c_algo_bit_data), GFP_KERNEL);//申请空间，这个结构主要用来定义对GPIO管脚的一些操作
if (!bit_data)
goto err_alloc_bit_data;
//使用gpio_request去申请这个两个GPIO管脚，申请的目的是为了防止重复使用管脚。
//然后是根据struct i2c_gpio_platform_data结构中定义的后面三个数据对struct i2c_algo_bit_data结构中的函数指针做一些赋值操作
ret = gpio_request(pdata->sda_pin, "sda");//向全局数组gpio_desc[]申请一个gpio，并设置对应的标志FLAG_REQUESTED表示申请。并取名为sda
if (ret)
goto err_request_sda;
ret = gpio_request(pdata->scl_pin, "scl");//同上
if (ret)
goto err_request_scl;
//然后是根据struct i2c_gpio_platform_data结构中定义的后面三个数据对struct i2c_algo_bit_data结构中的函数指针做一些赋值操作
if (pdata->sda_is_open_drain) {//未设置
gpio_direction_output(pdata->sda_pin, 1);
bit_data->setsda = i2c_gpio_setsda_val;
} else {
gpio_direction_input(pdata->sda_pin);//设置为输入
bit_data->setsda = i2c_gpio_setsda_dir;//设置sda管脚的方向函数
}
if (pdata->scl_is_open_drain || pdata->scl_is_output_only) {//未设置
gpio_direction_output(pdata->scl_pin, 1);
bit_data->setscl = i2c_gpio_setscl_val;
} else {
gpio_direction_input(pdata->scl_pin);//设置为输入
bit_data->setscl = i2c_gpio_setscl_dir;//设置scl管脚的方向
}
if (!pdata->scl_is_output_only)//未设置
bit_data->getscl = i2c_gpio_getscl;
bit_data->getsda = i2c_gpio_getsda;//读sda管脚数据的函数
//I2C时钟频率设置
if (pdata->udelay)//2,即250 KHz
bit_data->udelay = pdata->udelay;
else if (pdata->scl_is_output_only)
bit_data->udelay = 50;//10 kHz
else
bit_data->udelay = 5;//100 kHz
//I2C超时设置
if (pdata->timeout)
bit_data->timeout = pdata->timeout;
else
bit_data->timeout = HZ / 10;//100 ms
bit_data->data = pdata;//i2c_gpio_platform_data结构
//初始化i2c_adapter结构
adap->owner = THIS_MODULE;
snprintf(adap->name, sizeof(adap->name), "i2c-gpio%d", pdev->id);//设置adapter的名称：i2c-gpio1
adap->algo_data = bit_data;//通信算法的数据
adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
adap->dev.parent = &pdev->dev;//父设备指向platform_device
//pdev->id = 1,表示总线号
adap->nr = (pdev->id != -1) ? pdev->id : 0;
//继续初始化i2c_adapter结构，设置通信方法,然后在i2c-core中注册适配器。
ret = i2c_bit_add_numbered_bus(adap);
if (ret)
goto err_add_bus;
//保存i2c_adapter结构到pdev？？？
platform_set_drvdata(pdev, adap);
dev_info(&pdev->dev, "using pins %u (SDA) and %u (SCL%s)\n",pdata->sda_pin, pdata->scl_pin,pdata->scl_is_output_only? ", no clock stretching" : "");
return 0;
err_add_bus:
gpio_free(pdata->scl_pin);
err_request_scl:
gpio_free(pdata->sda_pin);
err_request_sda:
kfree(bit_data);
err_alloc_bit_data:
kfree(adap);
err_alloc_adap:
return ret;
}
int i2c_bit_add_numbered_bus(struct i2c_adapter *adap)
{
int err;
//初始化i2c_adapter的通信方法
err = i2c_bit_prepare_bus(adap);
if (err)
return err;
return i2c_add_numbered_adapter(adap);//注册adapter
}
static int i2c_bit_prepare_bus(struct i2c_adapter *adap)
{
struct i2c_algo_bit_data *bit_adap = adap->algo_data;
if (bit_test) {//bit_test =0
int ret = test_bus(bit_adap, adap->name);
if (ret < 0)
return -ENODEV;
}
/* static const struct i2c_algorithm i2c_bit_algo = {
.master_xfer = bit_xfer,//数据传输函数
.functionality = bit_func,
};
*/
//设置i2c_adapter的通信方法
adap->algo = &i2c_bit_algo;
adap->retries = 3;
return 0;
}
int i2c_add_numbered_adapter(struct i2c_adapter *adap)
{
int id;
int status;
if (adap->nr & ~MAX_ID_MASK)//adap->nr=1
return -EINVAL;
retry:
/*
在这里涉及到一个idr结构。idr结构本来是为了配合page cache中的radix tree而设计的。在这里我们只需要知道，它是一种高效的搜索树，且这个树预先存放了一些内存。避免在内存不够的时候出现问题。所以，在往idr中插入结构的时候，首先要调用idr_pre_get()为它预留足够的空闲内存，然后再调用idr_get_new_above()将结构插入idr中，该函数以参数的形式返回一个id.以后凭这个id就可以在idr中找到相对应的结构了。
*/
if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
return -ENOMEM;
mutex_lock(&core_lock);//上锁
//它是将adapter结构插入到i2c_adapter_idr中，存放位置的id必须要大于或者等于adap->nr,然后将对应的id号存放在adapter->nr中
status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
if (status == 0 && id != adap->nr) {
status = -EBUSY;
idr_remove(&i2c_adapter_idr, id);
}
mutex_unlock(&core_lock);//解锁
if (status == -EAGAIN)
goto retry;
if (status == 0)
status = i2c_register_adapter(adap);//对这个adapter进行进一步注册。
return status;
}
static int i2c_register_adapter(struct i2c_adapter *adap)
{
int res = 0;
if (unlikely(WARN_ON(!i2c_bus_type.p))) {
res = -EAGAIN;
goto out_list;
}
/* Sanity checks */
if (unlikely(adap->name[0] == '\0')) {//adapter的name不为空
pr_err("i2c-core: Attempt to register an adapter with ""no name!\n");
return -EINVAL;
}
if (unlikely(!adap->algo)) {//adapter的通信算法不能为空
pr_err("i2c-core: Attempt to register adapter '%s' with ""no algo!\n", adap->name);
return -EINVAL;
}
rt_mutex_init(&adap->bus_lock);
mutex_init(&adap->userspace_clients_lock);
INIT_LIST_HEAD(&adap->userspace_clients);
//若没设置超时时间，则缺省为HZ。实际已经设置
if (adap->timeout == 0)
adap->timeout = HZ;
//adapter中内嵌的struct device结构进行必须的初始化
dev_set_name(&adap->dev, "i2c-%d", adap->nr);//设置adapter->dev的设备名：i2c-1
adap->dev.bus = &i2c_bus_type;//adapter中内嵌的struct device所在总线为i2c_bus_type
adap->dev.type = &i2c_adapter_type;
//adapter内嵌的struct device注册
res = device_register(&adap->dev);
if (res)
goto out_list;
dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
//调用此函数i2c_scan_static_board_info之前，必须要调用i2c_register_board_info()将板子上的I2C设备信息预先注册到__i2c_board_list链表中，
//同时才会更改__i2c_first_dynamic_bus_num的值
if (adap->nr < __i2c_first_dynamic_bus_num)//__i2c_first_dynamic_bus_num=0,adap->nr=1,不会调用下边的函数
i2c_scan_static_board_info(adap);//遍历__i2c_board_list中挂载的i2c_devinfo结构，每个都是一个i2c_client即i2c设备。
//若i2c设备（i2c_client）与adapter位于同一i2c总线上，则调用i2c_new_device()进行i2c设备（i2c_client）注册
/* Notify drivers */
mutex_lock(&core_lock);
//在新的适配器加入内核时调用函数 bus_for_each_drv时调用的函数。
//函数bus_for_each_drv是在总线类型为i2c_bus_type的驱动中找到一个驱动与新加入的适配器匹配。
bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);//遍历该总线上所有的driver，并设用attach_adapter,因为i2c_driver还没注册，
//attach_adapter为空，设置会调用失败。
mutex_unlock(&core_lock);
return 0;
out_list:
mutex_lock(&core_lock);
idr_remove(&i2c_adapter_idr, adap->nr);
mutex_unlock(&core_lock);
return res;
}
static int __process_new_adapter(struct device_driver *d, void *data)
{
return i2c_do_add_adapter(to_i2c_driver(d), data);
}
static int i2c_do_add_adapter(struct i2c_driver *driver,struct i2c_adapter *adap)
{
i2c_detect(adap, driver);
if (driver->attach_adapter) {//这里还没有设置attach_adapter字段，所以下边的函数不会执行
driver->attach_adapter(adap);
}
return 0;
}
//这个函数比较简单， struct i2c_board_info用来表示I2C设备的一些情况，比如所在的总线。名称，地址，中断号等。最后，这些信息会被存放到__i2c_board_list链表。
/*
static struct i2c_board_info __initdata da850_evm_i2c_devices[] = {
{
I2C_BOARD_INFO("24c256", 0x50),
.platform_data = &da850_evm_i2c_eeprom_info,
},
{
I2C_BOARD_INFO("tlv320aic3x", 0x18),
},
{
I2C_BOARD_INFO("tca6416", 0x20),
.platform_data = &da850_evm_ui_expander_info,
},
{
I2C_BOARD_INFO("tca6416", 0x21),
.platform_data = &da850_evm_bb_expander_info,
},
{
I2C_BOARD_INFO("tps6507x", 0x48),
.platform_data = &tps_board,
},
{
I2C_BOARD_INFO("cdce913", 0x65),
},
{
I2C_BOARD_INFO("PCA9543A", 0x73),
},
};
*/
int __init i2c_register_board_info(int busnum,struct i2c_board_info const *info, unsigned len)
{
int status;
mutex_lock(&__i2c_board_lock);
if (busnum >= __i2c_first_dynamic_bus_num)
__i2c_first_dynamic_bus_num = busnum + 1;
for (status = 0; len; len--, info++) {
struct i2c_devinfo *devinfo;
devinfo = kzalloc(sizeof(*devinfo)， GFP_KERNEL);
if (!devinfo) {
pr_debug("i2c-core: can't register boardinfo!\n");
status = -ENOMEM;
break;
}
devinfo->busnum = busnum;
devinfo->board_info = *info;
list_add_tail(&devinfo->list, &__i2c_board_list);
}
mutex_unlock(&__i2c_board_lock);
return status;
}
static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
{
struct i2c_devinfo *devinfo;
down_read(&__i2c_board_lock);
list_for_each_entry(devinfo, &__i2c_board_list, list) {//遍历__i2c_board_list链表中挂载的i2c_devinfo结构
//如果指定设备是位于adapter所在的I2C总线上，那么，就调用i2c_new_device()。
if (devinfo->busnum == adapter->nr && !i2c_new_device(adapter,&devinfo->board_info))//adapter->nr = 1
dev_err(&adapter->dev,"Can't create device at 0x%02x\n",devinfo->board_info.addr);
}
up_read(&__i2c_board_lock);
}
struct i2c_client *i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
{
struct i2c_client *client;
int status;
//i2c_client表示一个具体的I2C设备，就是一个嵌入struct device的I2C设备的封装
client = kzalloc(sizeof *client, GFP_KERNEL);//分配空间
if (!client)
return NULL;
//client->adapter指向了它所在的adapter
client->adapter = adap;
//
client->dev.platform_data = info->platform_data;
if (info->archdata)
client->dev.archdata = *info->archdata;
//设置标志，地址以及中断号
client->flags = info->flags;
client->addr = info->addr;
client->irq = info->irq;
//设置i2c设备名
strlcpy(client->name, info->type, sizeof(client->name));
//检查设备地址的有效性
status = i2c_check_client_addr_validity(client);
if (status) {
dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
goto out_err_silent;
}
/* Check for address business */
status = i2c_check_addr_busy(adap, client->addr);
if (status)
goto out_err;
client->dev.parent = &client->adapter->dev;
client->dev.bus = &i2c_bus_type;
client->dev.type = &i2c_client_type;
#ifdef CONFIG_OF
client->dev.of_node = info->of_node;
#endif
//设置i2c设备的名称
dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),client->addr);
//将i2c设备内嵌的dev注册
status = device_register(&client->dev);
if (status)
goto out_err;
dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",client->name, dev_name(&client->dev));
return client;
out_err:
dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x ""(%d)\n", client->name, client->addr, status);
out_err_silent:
kfree(client);
return NULL;
}
4.运行i2c_dev_init函数，注册设备，注册设备驱动，以_init为头的函数，在运行过后系统将回收其内存
//前边已经注册了adapter设备device_register(&adap->dev);下边要注册设备的驱动i2c_add_driver(&i2cdev_driver);
//驱动注册成功会和前边才注册的adapter设备相匹配i2cdev_attach_adapter()，匹配成功则创建设备文件。
static int __init i2c_dev_init(void)
{
int res;
printk(KERN_INFO "i2c /dev entries driver\n");
//register_chrdev函数最终会向系统注册主设备为I2C_MAJOR，此设备号为0~255的设备。这表示系统最多可以容纳256个i2c adapter,其中注册的结构体&i2cdev_fops，给用户空间提供了调用接口，就是个字符型驱动
/*当read()、write()、open()、close()、ioctl()等系统调用发生时就会调用到这些函数。
static const struct file_operations i2cdev_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.read = i2cdev_read,
.write = i2cdev_write,
.unlocked_ioctl = i2cdev_ioctl,
.open = i2cdev_open,
.release = i2cdev_release,
};
*/
res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);
if (res)
goto out;
//创建设备类,字符设备注册完毕后通过class_create()函数初始化一个类i2c_dev_class，这个类稍后需要使用，用于在/dev/i2c-0下自动创建设备.
//注册一个类，使i2c可以在"/dev/"目录下面建立设备节点
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_add_driver函数注册i2c driver。这里所说的i2c其实对应的是系统中所有的i2c类设备(包括i2c_client and adapter)。
/*
static struct i2c_driver i2cdev_driver = {
.driver = {
.name = "dev_driver",
},
.attach_adapter = i2cdev_attach_adapter,
.detach_adapter = i2cdev_detach_adapter,
};
*/
//其作用在于为系统中所有已安装的i2c适配器调用i2cdev_driver的attach_adpter方法，
//即i2cdev_attach_adapter函数，为所有已安装的适配器创建相应的/dev/i2c-%d字符设备结点并注册设备访问方法。
res = i2c_add_driver(&i2cdev_driver);
if (res)
goto out_unreg_class;
return 0;
out_unreg_class:
class_destroy(i2c_dev_class);
out_unreg_chrdev:
unregister_chrdev(I2C_MAJOR, "i2c");
out:
printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
return res;
}
static inline int i2c_add_driver(struct i2c_driver *driver)
{
return i2c_register_driver(THIS_MODULE, driver);
}
int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
{
int res;
/* Can't register until after driver model init */
if (unlikely(WARN_ON(!i2c_bus_type.p)))
return -EAGAIN;
//关联到i2c_bus_types
driver->driver.owner = owner;
driver->driver.bus = &i2c_bus_type;
//注册i2c_driver结构中内嵌的device_driver
res = driver_register(&driver->driver);
if (res)
return res;
pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
INIT_LIST_HEAD(&driver->clients);
/* Walk the adapters that are already present */
mutex_lock(&core_lock);
bus_for_each_dev(&i2c_bus_type, NULL, driver, __process_new_driver);//遍历i2c_bus_type总线上所有的设备，与新加入的驱动相匹配，并调用驱动的attach_adapter
mutex_unlock(&core_lock);
return 0;
}
static int __process_new_driver(struct device *dev, void *data)
{
if (dev->type != &i2c_adapter_type)
return 0;
//前边adapter的dev已经注册，这里会找到注册的i2c_adapter设备
return i2c_do_add_adapter(data, to_i2c_adapter(dev));
}
static int i2c_do_add_adapter(struct i2c_driver *driver,struct i2c_adapter *adap)
{
i2c_detect(adap, driver);//空函数
if (driver->attach_adapter) {
driver->attach_adapter(adap);//调用i2cdev_attach_adapter()
}
return 0;
}
static int i2cdev_attach_adapter(struct i2c_adapter *adap)
{
struct i2c_dev *i2c_dev;
int res;
i2c_dev = get_free_i2c_dev(adap);//创建一个i2c_dev结构，并且指向adap( i2c_dev->adap = adap;)
if (IS_ERR(i2c_dev))
return PTR_ERR(i2c_dev);
/* 可见attach_adapter函数的作用就是调用device_create()函数通过之前class_create的类信息在/dev下自动创建设备文件。
并且此设备的设备号是由固定的主设备号I2C_MAJOR 和从设备号组成的，从设备号取的就是adapter的nr，此处为0。
并且可以推断出系统最多可以容纳0~255 总共256个i2c adapter。
*/
//创建一个设备节点，节点名为"i2c-1"
i2c_dev->dev = device_create(i2c_dev_class, &adap->dev,MKDEV(I2C_MAJOR, adap->nr), NULL,"i2c-%d", adap->nr);
if (IS_ERR(i2c_dev->dev)) {
res = PTR_ERR(i2c_dev->dev);
goto error;
}
res = device_create_file(i2c_dev->dev, &dev_attr_name);
if (res)
goto error_destroy;
pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",adap->name, adap->nr);
return 0;
error_destroy:
device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));
error:
return_i2c_dev(i2c_dev);
return res;
}
六、i2c的打开、读、写
初始化过后就可以通过用户空间对i2c进行读写。
6.1 i2c的打开
static int i2cdev_open(struct inode *inode, struct file *file)
{
unsigned int minor = iminor(inode);
struct i2c_client *client;
struct i2c_adapter *adap;
struct i2c_dev *i2c_dev;
i2c_dev = i2c_dev_get_by_minor(minor);
if (!i2c_dev)
return -ENODEV;
adap = i2c_get_adapter(i2c_dev->adap->nr);
if (!adap)
return -ENODEV;
client = kzalloc(sizeof(*client), GFP_KERNEL);
if (!client) {
i2c_put_adapter(adap);
return -ENOMEM;
}
snprintf(client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr);
client->driver = &i2cdev_driver;//设备驱动(adapter 也是这个设备驱动，共用)
client->adapter = adap;
file->private_data = client;//保存到文件的private_data字段中
return 0;
}
6.2 i2c的读数据
static ssize_t i2cdev_read(struct file *file, char __user *buf, size_t count,loff_t *offset)
{
char *tmp;
int ret;
struct i2c_client *client = file->private_data;
if (count > 8192)
count = 8192;
tmp = kmalloc(count, GFP_KERNEL);
if (tmp == NULL)
return -ENOMEM;
pr_debug("i2c-dev: i2c-%d reading %zu bytes.\n",iminor(file->f_path.dentry->d_inode), count);
ret = i2c_master_recv(client, tmp, count);
if (ret >= 0)
ret = copy_to_user(buf, tmp, count) ? -EFAULT : ret;
kfree(tmp);
return ret;
}
int i2c_master_recv(struct i2c_client *client, char *buf, int count)
{
struct i2c_adapter *adap = client->adapter;
struct i2c_msg msg;
int ret;
msg.addr = client->addr;//应用程序会通过ioctl(i2c_fd,I2C_SLAVE,slaveaddr)来设置client的地址
msg.flags = client->flags & I2C_M_TEN;
msg.flags |= I2C_M_RD;
msg.len = count;
msg.buf = buf;
ret = i2c_transfer(adap, &msg, 1);//传输1个msg
return (ret == 1) ? count : ret;
}
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
{
unsigned long orig_jiffies;
int ret, try;
if (adap->algo->master_xfer) {//存在通信方法
if (in_atomic() || irqs_disabled()) {
ret = i2c_trylock_adapter(adap);
if (!ret)/* I2C activity is ongoing. */
return -EAGAIN;
} else {
i2c_lock_adapter(adap);//给adapter上锁
}
orig_jiffies = jiffies;
for (ret = 0, try = 0; try <= adap->retries; try++) {
ret = adap->algo->master_xfer(adap, msgs, num);//最终转换为i2c_algorithm中的master_xfer传输，调用bit_xfer()
if (ret != -EAGAIN)
break;
if (time_after(jiffies, orig_jiffies + adap->timeout))//retry间隔时间
break;
}
i2c_unlock_adapter(adap);//给adapter解锁
return ret;
} else {
dev_dbg(&adap->dev, "I2C level transfers not supported\n");
return -EOPNOTSUPP;
}
}
static int bit_xfer(struct i2c_adapter *i2c_adap,struct i2c_msg msgs[], int num)
{
struct i2c_msg *pmsg;
struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
int i, ret;
unsigned short nak_ok;
if (adap->pre_xfer) {//这个字段没有设置
ret = adap->pre_xfer(i2c_adap);
if (ret < 0)
return ret;
}
bit_dbg(3, &i2c_adap->dev, "emitting start condition\n");
/*发送起始信号*/
i2c_start(adap);
for (i = 0; i < num; i++) {//这里的num代表有几个struct i2c_msg
pmsg = &msgs[i];
nak_ok = pmsg->flags & I2C_M_IGNORE_NAK;
/*
I2C_M_NOSTART标志，这个标志主要用于写操作时，不必重新发送起始信号和设备地址，但是对于读操作就不同了，
要调用i2c_repstart这个函数去重新发送起始信号，调用bit_doAddress函数去重新构造设备地址字节
*/
if (!(pmsg->flags & I2C_M_NOSTART)) {
if (i) {
bit_dbg(3, &i2c_adap->dev, "emitting ""repeated start condition\n");
i2c_repstart(adap);
}
ret = bit_doAddress(i2c_adap, pmsg);//重新构造设备地址字节
if ((ret != 0) && !nak_ok) {
bit_dbg(1, &i2c_adap->dev, "NAK from ""device addr 0x%02x msg #%d\n",msgs[i].addr, i);
goto bailout;
}
}
if (pmsg->flags & I2C_M_RD) {//读数据
ret = readbytes(i2c_adap, pmsg);
if (ret >= 1)
bit_dbg(2, &i2c_adap->dev, "read %d byte%s\n",ret, ret == 1 ? "" : "s");
if (ret < pmsg->len) {
if (ret >= 0)
ret = -EREMOTEIO;
goto bailout;
}
} else {//写数据
ret = sendbytes(i2c_adap, pmsg);
if (ret >= 1)
bit_dbg(2, &i2c_adap->dev, "wrote %d byte%s\n",ret, ret == 1 ? "" : "s");
if (ret < pmsg->len) {
if (ret >= 0)
ret = -EREMOTEIO;
goto bailout;
}
}
}
ret = i;
bailout:
bit_dbg(3, &i2c_adap->dev, "emitting stop condition\n");
i2c_stop(adap);
if (adap->post_xfer)
adap->post_xfer(i2c_adap);
return ret;
}
这里先做了一个判断，10位设备地址和7位设备地址分别做不同的处理，通常一条I2C总线上不会挂那么多I2C设备，所以10位地址不常用，直接看对7位地址的处理。struct i2c_msg中addr中是真正的设备地址，而这里发送的addr高7位才是设备地址，最低位为读写位，如果为读，最低位为1，如果为写，最低位为0。所以要将struct i2c_msg中addr向左移1位，如果定义了I2C_M_RD标志，就将addr或上1，前面就说过，这个标志就代表读，如果是写，这里就不用处理，因为最低位本身就是0。最后调用try_address函数将这个地址字节发送出去。
static int bit_doAddress(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
{
unsigned short flags = msg->flags;
unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK;
struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
unsigned char addr;
int ret, retries;
retries = nak_ok ? 0 : i2c_adap->retries;
if (flags & I2C_M_TEN) {
/* a ten bit address */
addr = 0xf0 | ((msg->addr >> 7) & 0x03);
bit_dbg(2, &i2c_adap->dev, "addr0: %d\n", addr);
/* try extended address code...*/
ret = try_address(i2c_adap, addr, retries);
if ((ret != 1) && !nak_ok) {
dev_err(&i2c_adap->dev,
"died at extended address code\n");
return -EREMOTEIO;
}
/* the remaining 8 bit address */
ret = i2c_outb(i2c_adap, msg->addr & 0x7f);
if ((ret != 1) && !nak_ok) {
/* the chip did not ack / xmission error occurred */
dev_err(&i2c_adap->dev, "died at 2nd address code\n");
return -EREMOTEIO;
}
if (flags & I2C_M_RD) {
bit_dbg(3, &i2c_adap->dev, "emitting repeated "
"start condition\n");
i2c_repstart(adap);
/* okay, now switch into reading mode */
addr |= 0x01;
ret = try_address(i2c_adap, addr, retries);
if ((ret != 1) && !nak_ok) {
dev_err(&i2c_adap->dev,
"died at repeated address code\n");
return -EREMOTEIO;
}
}
} else { /* normal 7bit address */
addr = msg->addr << 1;
if (flags & I2C_M_RD)
addr |= 1;
if (flags & I2C_M_REV_DIR_ADDR)
addr ^= 1;
ret = try_address(i2c_adap, addr, retries);
if ((ret != 1) && !nak_ok)
return -ENXIO;
}
return 0;
}
//最主要的就是调用i2c_outb发送一个字节，retries为重复次数，看前面adap->retries= 3;
//如果发送失败，也就是设备没有给出应答信号，那就发送停止信号，发送起始信号，再发送这个地址字节，这就叫retries。
static int try_address(struct i2c_adapter *i2c_adap,unsigned char addr, int retries)
{
struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
int i, ret = 0;
for (i = 0; i <= retries; i++) {
ret = i2c_outb(i2c_adap, addr);
if (ret == 1 || i == retries)
break;
bit_dbg(3, &i2c_adap->dev, "emitting stop condition\n");
i2c_stop(adap);
udelay(adap->udelay);
yield();
bit_dbg(3, &i2c_adap->dev, "emitting start condition\n");
i2c_start(adap);
}
if (i && ret)
bit_dbg(1, &i2c_adap->dev, "Used %d tries to %s client at ""0x%02x: %s\n", i + 1,addr & 1 ? "read from" : "write to", addr >> 1,ret == 1 ? "success" : "failed, timeout?");
return ret;
}
static int readbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
{
int inval;
int rdcount = 0; /* counts bytes read */
unsigned char *temp = msg->buf;
int count = msg->len;
const unsigned flags = msg->flags;
while (count > 0) {
inval = i2c_inb(i2c_adap);
if (inval >= 0) {
*temp = inval;
rdcount++;
} else { /* read timed out */
break;
}
temp++;
count--;
/* Some SMBus transactions require that we receive the
transaction length as the first read byte. */
if (rdcount == 1 && (flags & I2C_M_RECV_LEN)) {
if (inval <= 0 || inval > I2C_SMBUS_BLOCK_MAX) {
if (!(flags & I2C_M_NO_RD_ACK))
acknak(i2c_adap, 0);
dev_err(&i2c_adap->dev, "readbytes: invalid ""block length (%d)\n", inval);
return -EREMOTEIO;
}
count += inval;
msg->len += inval;
}
bit_dbg(2, &i2c_adap->dev, "readbytes: 0x%02x %s\n",inval,(flags & I2C_M_NO_RD_ACK)? "(no ack/nak)": (count ? "A" : "NA"));
if (!(flags & I2C_M_NO_RD_ACK)) {
inval = acknak(i2c_adap, count);
if (inval < 0)
return inval;
}
}
return rdcount;
}
6.3 i2c的写数据
static ssize_t i2cdev_write(struct file *file, const char __user *buf,size_t count, loff_t *offset)
{
int ret;
char *tmp;
struct i2c_client *client = file->private_data;
if (count > 8192)
count = 8192;
tmp = memdup_user(buf, count);
if (IS_ERR(tmp))
return PTR_ERR(tmp);
pr_debug("i2c-dev: i2c-%d writing %zu bytes.\n",iminor(file->f_path.dentry->d_inode), count);
ret = i2c_master_send(client, tmp, count);
kfree(tmp);
return ret;
}
int i2c_master_send(struct i2c_client *client, const char *buf, int count)
{
int ret;
struct i2c_adapter *adap = client->adapter;
struct i2c_msg msg;
msg.addr = client->addr;
msg.flags = client->flags & I2C_M_TEN;
msg.len = count;
msg.buf = (char *)buf;
ret = i2c_transfer(adap, &msg, 1);
return (ret == 1) ? count : ret;
}

0 0