先粘贴到这，以后再整理，另外我的资源里面我上传了原文件：
一、概述
谈到在linux系统下编写I2C驱动，目前主要有两种方式，一种是把I2C设备当作一个普通的字符设备来处理，另一种是利用linux I2C驱动体系结构来完成。下面比较下这两种驱动。
第一种方法的好处（对应第二种方法的劣势）有：
● 思路比较直接，不需要花时间去了解linux内核中复杂的I2C子系统的操作方法。
第一种方法问题（对应第二种方法的好处）有：
● 要求工程师不仅要对I2C设备的操作熟悉，而且要熟悉I2C的适配器操作；
● 要求工程师对I2C的设备器及I2C的设备操作方法都比较熟悉，最重要的是写出的程序可移植性差；
● 对内核的资源无法直接使用。因为内核提供的所有I2C设备器及设备驱动都是基于I2C子系统的格式。I2C适配器的操作简单还好，如果遇到复杂的I2C适配器（如：基于PCI的I2C适配器），工作量就会大很多。
本文针对的对象是熟悉I2C协议，并且想使用linux内核子系统的开发人员。
网络和一些书籍上有介绍I2C子系统的源码结构。但发现很多开发人员看了这些文章后，还是不清楚自己究竟该做些什么。究其原因还是没弄清楚I2C子系统为我们做了些什么，以及我们怎样利用I2C子系统。本文首先要解决是如何利用现有内核支持的I2C适配器，完成对I2C设备的操作，然后再过度到适配器代码的编写。本文主要从解决问题的角度去写，不会涉及特别详细的代码跟踪。
二、I2C设备驱动程序编写
首先要明确适配器驱动的作用是让我们能够通过它发出符合I2C标准协议的时序。
在Linux内核源代码中的drivers/i2c/busses目录下包含着一些适配器的驱动。如S3C2410的驱动i2c-s3c2410.c。当适配器加载到内核后，接下来的工作就要针对具体的设备编写设备驱动了。
编写I2C设备驱动也有两种方法。一种是利用系统给我们提供的i2c-dev.c来实现一个i2c适配器的设备文件。然后通过在应用层操作i2c适配器来控制i2c设备。另一种是为i2c设备，独立编写一个设备驱动。注意：在后一种情况下，是不需要使用i2c-dev.c的。
1、利用i2c-dev.c操作适配器，进而控制i2c设备
i2c-dev.c并没有针对特定的设备而设计，只是提供了通用的read()、write()和ioctl()等接口，应用层可以借用这些接口访问挂接在适配器上的i2c设备的存储空间或寄存器，并控制I2C设备的工作方式。
需要特别注意的是：i2c-dev.c的read()、write()方法都只适合于如下方式的数据格式（可查看内核相关源码）
图1 单开始信号时序
所以不具有太强的通用性，如下面这种情况就不适用（通常出现在读目标时）。
图2 多开始信号时序
而且read()、write()方法只适用用于适配器支持i2c算法的情况，如：
static const struct i2c_algorithm s3c24xx_i2c_algorithm = {
.master_xfer = s3c24xx_i2c_xfer,
.functionality = s3c24xx_i2c_func,
};
而不适合适配器只支持smbus算法的情况，如：
static const struct i2c_algorithm smbus_algorithm = {
.smbus_xfer = i801_access,
.functionality = i801_func,
};
基于上面几个原因，所以一般都不会使用i2c-dev.c的read()、write()方法。最常用的是ioctl()方法。ioctl()方法可以实现上面所有的情况（两种数据格式、以及I2C算法和smbus算法）。
针对i2c的算法，需要熟悉struct i2c_rdwr_ioctl_da
struct i2c_rdwr_ioctl_da
struct i2c_msg __user *msgs; /* pointers to i2c_msgs */
__u32 nmsgs; /* number of i2c_msgs */
};
struct i2c_msg {
_ _u16 addr; /* slave address */
_ _u16 flags; /* 标志（读、写） */
_ _u16 len; /* msg length */
_ _u8 *buf; /* pointer to msg da
};
针对smbus算法，需要熟悉struct i2c_smbus_ioctl_da
struct i2c_smbus_ioctl_da
__u8 read_write; //读、写
__u8 command; //命令
__u32 size; //数据长度标识
union i2c_smbus_da
};
下面以一个实例讲解操作的具体过程。通过S3C2410操作AT24C02 e2prom。实现在AT24C02中任意位置的读、写功能。
首先在内核中已经包含了对s3c2410 中的i2c控制器驱动的支持。提供了i2c算法（非smbus类型的，所以后面的ioctl的命令是I2C_RDWR）
static const struct i2c_algorithm s3c24xx_i2c_algorithm = {
.master_xfer = s3c24xx_i2c_xfer,
.functionality = s3c24xx_i2c_func,
};
另外一方面需要确定为了实现对AT24C02 e2prom的操作，需要确定AT24C02的地址及读写访问时序。
● AT24C02地址的确定
原理图上将A2、A1、A0都接地了，所以地址是0x50。
● AT24C02任意地址字节写的时序
可见此时序符合前面提到的“单开始信号时序”
● AT24C02任意地址字节读的时序
可见此时序符合前面提到的“多开始信号时序”
下面开始具体代码的分析（代码在2.6.22内核上测试通过）：
/*i2c_test.c
* hongtao_liu <lht@farsight.com.cn>
*/
#include <stdio.h>
#include <linux/types.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <errno.h>
#define I2C_RETRIES 0x0701
#define I2C_TIMEOUT 0x0702
#define I2C_RDWR 0x0707
/*********定义struct i2c_rdwr_ioctl_da
struct i2c_msg
{
unsigned short addr;
unsigned short flags;
#define I2C_M_TEN 0x0010
#define I2C_M_RD 0x0001
unsigned short len;
unsigned char *buf;
};
struct i2c_rdwr_ioctl_da
{
struct i2c_msg *msgs;
int nmsgs;
/* nmsgs这个数量决定了有多少开始信号，对于“单开始时序”，取1*/
};
/***********主程序***********/
int main()
{
int fd,ret;
struct i2c_rdwr_ioctl_da
fd=open("/dev/i2c-0",O_RDWR);
/*
*/dev/i2c-0是在注册i2c-dev.c后产生的，代表一个可操作的适配器。如果不使用i2c-dev.c
*的方式，就没有，也不需要这个节点。
*/
if(fd<0)
{
perror("open error");
}
e2prom_da
/*
*因为操作时序中，最多是用到2个开始信号（字节读操作中），所以此将
*e2prom_da
*/
e2prom_da
if(!e2prom_da
{
perror("malloc error");
exit(1);
}
ioctl(fd,I2C_TIMEOUT,1);/*超时时间*/
ioctl(fd,I2C_RETRIES,2);/*重复次数*/
/***write da
e2prom_da
(e2prom_da
(e2prom_da
(e2prom_da
(e2prom_da
(e2prom_da
(e2prom_da
ret=ioctl(fd,I2C_RDWR,(unsigned long)&e2prom_da
if(ret<0)
{
perror("ioctl error1");
}
sleep(1);
/******read da
e2prom_da
(e2prom_da
(e2prom_da
(e2prom_da
(e2prom_da
(e2prom_da
(e2prom_da
(e2prom_da
(e2prom_da
(e2prom_da
ret=ioctl(fd,I2C_RDWR,(unsigned long)&e2prom_da
if(ret<0)
{
perror("ioctl error2");
}
printf("buff[0]=%x\n",(e2prom_da
/***打印读出的值，没错的话，就应该是前面写的0x58了***/
close(fd);
return 0;
}
以上讲述了一种比较常用的利用i2c-dev.c操作i2c设备的方法，这种方法可以说是在应用层完成了对具体i2c设备的驱动工作。
计划下一篇总结以下几点：
（1）在内核里写i2c设备驱动的两种方式：
● Probe方式（new style），如：
static struct i2c_driver pca953x_driver = {
.driver = {
.name = "pca953x",
},
.probe = pca953x_probe,
.remove = pca953x_remove,
.id_table = pca953x_id,
};
● Adapter方式（LEGACY），如：
static struct i2c_driver pcf8575_driver = {
.driver = {
.owner = THIS_MODULE,
.name = "pcf8575",
},
.attach_adapter = pcf8575_attach_adapter,
.detach_client = pcf8575_detach_client,
};
（2）适配器驱动编写方法
（3）分享一些项目中遇到的问题
希望大家多提意见，多多交流。
2. Linux I2C 结构分析
2.1 层次分析
1. I2C Core
I2C Core用于维护Linux的I2C核心部分，其中维护了两个静态的List，分别记录系统中的I2C driver结构和I2C adapter结构。
static LIST_HEAD(adapters);
static LIST_HEAD(drivers);
I2C core提供接口函数，允许一个I2C adatper，I2C driver和I2C client初始化时在I2C core中进行注册，以及退出时进行注销。具体可以参见i2c_core.c代码。
同时还提供了I2C总线读写访问的一般接口（具体的实现在与I2C控制器相关的I2C adapter中实现），主要应用在I2C设备驱动中。
常用的主要是
i2c_master_send()
i2c_master_recv()
i2c_transfer()
2. I2C bus driver
总线驱动的职责，是为系统中每个I2C总线增加相应的读写方法。但是总线驱动本身并不会进行任何的通讯，它只是存在在那里，等待设备驱动调用其函数。
在系统开机时，首先装载的是I2C总线驱动。一个总线驱动用于支持一条特定的I2C总线的读写。一个总线驱动通常需要两个模块，一个struct i2c_adapter和一个struct i2c_algorithm来描述：
在 buses目录下的i2c-pxa.c中实现了PXA的I2C总线适配器，I2C adapter 构造一个对I2C core层接口的数据结构，并通过接口函数向I2C core注册一个控制器。I2C adapter主要实现对I2C总线访问的算法，iic_xfer() 函数就是I2C adapter底层对I2C总线读写方法的实现。同时I2C adpter 中还实现了对I2C控制器中断的处理函数。
1) i2c-pxa.c定义了i2c_algorithm，并且实现了master的发送函数i2c_pxa_xfer()，以及设备查询总线的模式的函数i2c_pxa_functionality()
| static const struct i2c_algorithm i2c_pxa_algorithm = {
.master_xfer = i2c_pxa_xfer, .functionality = i2c_pxa_functionality, }; |
2) i2c-pxa.c中，实现了i2c_adapter，主要是在定义pxa-i2c时进行初始化，并且i2c_pxa_probe()中进行填充parent指针，并且调用
ret = i2c_add_adapter(&i2c->adap);
进行添加。
| static struct pxa_i2c i2c_pxa = {
.lock = SPIN_LOCK_UNLOCKED, .adap = { .owner = THIS_MODULE, .algo = &i2c_pxa_algorithm, .name = "pxa2xx-i2c.0", .retries = 5, }, }; |
总的来说，在i2c-pxa中，使用platform驱动模型，完成了i2c的总线两种模块struct i2c_adapter和struct i2c_algorithm
3. I2C device driver
I2C只有总线驱动是不够的，必须有设备才能工作。这就是I2C device driver的必要性。I2C的device是有两个模块来描述的，struct i2c_driver和struct i2c_client。
在介绍chips目录下的device driver前有必要介绍一下i2c-dev.c文件。
i2c-dev.c中提供了一个通用的I2C设备的驱动程序，实现了字符类型设备的访问接口，对设备的具体访问是通过I2C adapter来实现的。构造一个对I2C core层接口的数据结构，通过接口函数向 I2C Core注册一个I2C设备驱动。同时构造一个对用户层接口的数据结构，并通过接口函数向内核注册为一个主设备号为89的字符类型设备。
|
static struct i2c_driver i2cdev_driver = { .driver = { .name = "dev_driver", }, .id = I2C_DRIVERID_I2CDEV, .attach_adapter = i2cdev_attach_adapter, .detach_adapter = i2cdev_detach_adapter, .detach_client = i2cdev_detach_client, }; struct i2c_dev { struct list_head list; struct i2c_adapter *adap; struct device *dev; }; |
该文件提供了用户层对I2C设备的访问，包括open，read，write，ioctl，release等常规文件操作，我们可以通过open函数打开 I2C的设备文件，通过ioctl函数设定要访问从设备的地址，然后就可以通过 read和write函数完成对I2C设备的读写操作。
| static const struct file_operations i2cdev_fops = {
.owner = THIS_MODULE, .llseek = no_llseek, .read = i2cdev_read, .write = i2cdev_write, .ioctl = i2cdev_ioctl, .open = i2cdev_open, .release = i2cdev_release, }; |
注：通过I2C driver提供的通用方法可以访问任何一个I2C的设备，但是其中实现的read，write及ioctl等功能完全是基于一般设备的实现，所有的操作数据都是基于字节流，没有明确的格式和意义。为了更方便和有效地使用I2C设备，我们可以为一个具体的I2C设备开发特定的I2C设备驱动程序，在驱动中完成对特定的数据格式的解释以及实现一些专用的功能。
在chips目录下包含着各种device 的driver，完成各种从设备的注册。作为一般的I2C设备，使用i2c-dev.c里的操作足够完成操作了。
当然如果不能完成，则需要独立完成该驱动，这就是chips目录下的代码。因为i2c-dev.c已经实现了I2C设备的文件操作接口，所以只要实现struct i2c_driver就可以了。对于某些特殊的操作，可以使用command接口进行控制。 当然，对于i2接口的fm芯片，则将struct i2c_driver放在i2c的chips目录
Linux中I2C总线驱动体系结构
在Linux系统中，对于一个给定的I2C总线硬件配置系统，I2C总线驱动程序体系结构由I2C总线驱动和I2C设备驱动组成。其中I2C总线驱动包括一个具体的控制器驱动和I2C总线的算法驱动.一个算法驱动适用于一类总线控制器.而一个具体的总线控制器驱动要使用某一种算法。例如，Linux内核中提供的算法i2e-algo-8260可以用在MPC82xx系列处理器提供的I2C总线控制器上。Linux内核中提供了一些常见处理器如MPC82xx系列的算法驱动。对于I2C设备，基本上每种具体设备都有自己的基本特性.其驱动程序一般都需要特别设计。
在I2C总线驱动程序体系结构中.使用数据结构Driver来表示I2C设备驱动，使用数据结构Client表示一个具体的I2C设备。而对于I2C总线
控制器，各种总线控制器在进行数据传输时采用的算法有好多种，使用相同算法的控制器提供的控制接口也可能不同。在I2C总线驱动程序体系结构中，用数据结构Algorithm来表示算法，用数据结构Adapter来表示不同的总线控制器。Linux内核的I2C总线驱动程序体系结构如图5所示。
图5 Linux内核I2C总线驱动程序体系结构
在图5中，一个Client对象对应一个具体的I2C总线设备，而一种I2C设备的Driver可以同时支持多个Client。每个Adapter对应一个具体的I2C总线控制器.不同的I2C总线控制器可以使用相同的算法Algorithm。i2c-core是I2C总线驱动程序体系结构的核心，在这个模块中，除了为总线设备驱动提供了一些统一的调用接口来访问具体的总线驱动程序功能，以进行读写或设置操作外，还提供了将各种支持的总线设备驱动和总线驱动添加到这个体系中的方法，以及当不再使用这些驱动时将其从体系中删除的方法。i2c-core将总线驱动程序体系一分为二，相互独立。可以针对某个I2C总线设备来设计一个I2C设备驱动程序，而不需要关心系统的I2C总线控制器是何种类型，所以提高了其可移植性。另一方面，在设计I2C总线驱动时也可以不要考虑其将用来支持何种设备。因为i2c-core提供了统一的接口，所以也为设计这两类驱动
提供了方便。
4 开发实例
Linux内核已经提供了I2C驱动中所需要的基本模块。i2c-core、i2c-dev和i2c-proc是总线控制器和I2C设备所需要的核心模块。对于MPC8250处理器，内核中还有MPC8260的算法模块i2c-algo-8260，它也适用于MPC8250的I2C控制接口。这些模块程序在默认条件下是不会被编译到内核里的，所以需要在配置Linux内核时把这些模块选中。在笔者的开发中需要实现的是I2C总线控制器驱动和I2C设备EEPROM驱动。
4.1 I2C总线控制器驱动的设计
MPC8250的I2C总线驱动程序由i2c-algo-8260算法模块和MPC8250具体的I2C总线控制器驱动组成。其中i2c-algo-8260算法模块已经在内核中实现，所以主要实现FC总线控制器驱动。
i2c-algo-8260算法模块主要用来描述MPC82xx处理器如何在I2C总线上传输数据。该模块中主要实现了MPC82xx处理器上I2C总线的初始化、读写、ioctl控制和中断请求等功能。另外，还有i2c_8260_add_bus和i2c_8260_del_bus两个函数，它们是使用这个算法的Adapter初始化时和退出时调用的函数，用来注册和注销一个总线控制器，需要从模块导出。这些函数功能都被封装在一个i2c-algorithm结构中，传递给使用这个算法的Adapter。算法模块中这些函数需要调用特定控制器模块中的函数来实现具体的操作。
在I2C总线控制器驱动模块中主要要实现两个结构体i2c_adapter和i2c_algo_8260_da
struct i2c_algo_8260_da
setisr:rw8250_install_isr
}；
这里的成员变量rw8250_install__isr提供了MPC8250的I2C总线控制器向内核申请中端请求的功能。结构体i2c_adapter定义如下：
struct i2c_adapter rw8250_ops={"rw8250",I2C_HW_
MPC8250_RW8250,NULL,&rw8250_da
其中，"rw8250"是该总线控制器的标识名，宏名I2C_HW_MPC8250_RW8250定义了内核中注册该适配器的ID号，而成员函数rw8250_inc_use和rw8250_dec_use用来增加和减少内核使用该模块的次数。
另外，该模块还要完成一个注册模块时的初始化函数rw8250_iic_init，在该函数中要初始化I2C控制器使用的通用端口号PortD14、PortD15，并在双端口RAM 中为发送和接受数据的缓冲区分配空间。函数rw8250_iic_init在进行模块初始化时将被init_module调用。
总之。I2C控制器模块中设计的这些函数都是为i2c_algo_8650算法模块服务的.最后需要封装在i2c-adapter结构中.通过i2c_algo_8260_da
4.2 I2C设备驱动的设计
I2C设备EEPROM 驱动除了要根据EEPROM的具体特性进行设计外.还要考虑I2C总线驱动程序体系结构的特性。在EEPROM设备驱动程序中需要实现一个i2c_driver结构.每个对应于具体设备的Client都从这个结构来构造。在i2c_driver结构中有两个函数attach_adapter和detach_client必须要实现。i2c_driver结构的定义如下：
struct i2c_driver eeprom_driver = {
/*name*/ "I2C_EEPROM_DRIVER",/*id*/I2C_DRIVERID_EEPROM,
/*flags*/ I2C_DF_NOTIFY,/*attach_ adapter*/&eeprom_attach_adapter,/*detach_client */&eeprom_detach_client,
/*command*/&eeprom_command,/*inc_use*/ &eeprom_inc_use,/*dec_use*/ &eeprom_dec_use
}；
在设备驱动中。向EEPROM 写数据通过调用i2c-core提供的i2c_master_send函数来完成。从EEPROM 读取数据通过另一个函数i2c_master_read来完成。与一般设备驱动不同的地方就是在EEPROM驱动模块初始函数中要调用i2c-core提供的i2c_add_driver函数来注册该设备。在模块退出函数中调用i2c_del_driver函数来注销该设备。
---------------------------------------------------------------------------------------------------
最近因为工作需要涉及到了I2C总线。虽然我过去用过I2c，但看了 Linux kernel 后才发现，一个 layer 能被做到这样完善。
1.Linux的I2C驱动架
Linux中I2C总线的驱动分为两个部分，总线驱动（BUS）和设备驱动（DEVICE）。其中总线驱动的职责，是为系统中每个I2C总线增加相应的读写方法。但是总线驱动本身并不会进行任何的通讯，它只是存在在那里，等待设备驱动调用其函数。
设备驱动则是与挂在I2C总线上的具体的设备通讯的驱动。通过I2C总线驱动提供的函数，设备驱动可以忽略不同总线控制器的差异，不考虑其实现细节地与硬件设备通讯。
1.1. 总线驱动
在系统开机时，首先装载的是I2C总线驱动。一个总线驱动用于支持一条特定的I2C总线的读写。一个总线驱动通常需要两个模块，一个struct i2c_adapter和一个struct i2c_algorithm来描述：
|
|
这个样例挂接了一个叫做“pb1550 adapter”的驱动。但这个模块并未提供读写函数，具体的读写方法由第二个模块，struct i2c_algorithm提供。
|
|
这个样例给上述总线驱动增加了读写“算法”。通常情况下每个I2C总线驱动都定义一个自己的读写算法，但鉴于有些总线使用相同的算法，因而可以共用同一套读写函数。本例中的驱动定义了自己的读写算法模块，起名叫“Au1550 algorithm”。
全部填妥后，通过调用：
|
|
将这两个模块注册到操作系统里，总线驱动就算装上了。对于AMD au1550，这部分已经由AMD提供了。
1.2 设备驱动
如前所述，总线驱动只是提供了对一条总线的读写机制，本身并不会去做通信。通信是由I2C设备驱动来做的，设备驱动透过I2C总线同具体的设备进行通讯。一个设备驱动有两个模块来描述，struct i2c_driver和struct i2c_client。
当系统开机、I2C总线驱动装入完成后，就可以装入设备驱动了。首先装入如下结构：
|
|
这个i2c_driver一旦装入完成，其中的attach_adapter函数就会被调用。在其中可以遍历系统中的每个i2c总线驱动，探测想要访问的设备：
|
|
注意探测可能会找到多个设备，因而不仅一个I2C总线可以挂多个不同类型的设备，一个设备驱动也可以同时为挂在多个不同I2C总线上的设备服务。
每当设备驱动探测到了一个它能支持的设备，它就创建一个struct i2c_client来标识这个设备：
|
|
可见，一个i2c_client代表着位于adapter总线上，地址为address，使用driver来驱动的一个设备。它将总线驱动与设备驱动，以及设备地址绑定在了一起。一个i2c_client就代表着一个I2C设备。
当得到I2C设备后，就可以直接对此设备进行读写：
|
|
与通常意义上的读写函数一样，这两个函数对i2c_client指针指定的设备，读写int个char。返回值为读写的字节数。对于我们现有的SLIC的驱动，只要将最后要往总线上进行读写的数据引出传输到这两个函数中，移植工作就算完成了，我们将得到一个Linux版的I2C设备驱动。
前文介绍了利用/dev/i2c-0在应用层完成对i2c设备的操作，但很多时候我们还是习惯为i2c设备在内核层编写驱动程序。目前内核支持两种编写i2c驱动程序的方式。下面分别介绍这两种方式的实现。这里分别称这两种方式为“Adapter方式（LEGACY）”和“Probe方式（new style）”。
（1） Adapter方式（LEGACY）
（下面的实例代码是在2.6.27内核的pca953x.c基础上修改的，原始代码采用的是本文将要讨论的第2种方式，即Probe方式）
● 构建i2c_driver
static struct i2c_driver pca953x_driver = {
.driver = {
.name= "pca953x", //名称
},
.id= ID_PCA9555,//id号
.attach_adapter= pca953x_attach_adapter, //调用适配器连接设备
.detach_client= pca953x_detach_client,//让设备脱离适配器
};
● 注册i2c_driver
static int __init pca953x_init(void)
{
return i2c_add_driver(&pca953x_driver);
}
module_init(pca953x_init);
● attach_adapter动作
执行i2c_add_driver(&pca953x_driver)后会，如果内核中已经注册了i2c适配器，则顺序调用这些适配器来连接我们的i2c设备。此过程是通过调用i2c_driver中的attach_adapter方法完成的。具体实现形式如下：
static int pca953x_attach_adapter(struct i2c_adapter *adapter)
{
return i2c_probe(adapter, &addr_data, pca953x_detect);
/*
adapter:适配器
addr_data:地址信息
pca953x_detect：探测到设备后调用的函数
*/
}
地址信息addr_data是由下面代码指定的。
/* Addresses to scan */
static unsigned short normal_i2c[] = {0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,I2C_CLIENT_END};
I2C_CLIENT_INSMOD;
注意：normal_i2c里的地址必须是你i2c芯片的地址。否则将无法正确探测到设备。而I2C_ CLIENT_INSMOD是一个宏，它会利用normal_i2c构建addr_data。
● 构建i2c_client，并注册字符设备驱动
i2c_probe在探测到目标设备后，后调用pca953x_detect，并把当时的探测地址address作为参数传入。
static int pca953x_detect(struct i2c_adapter *adapter, int address, int kind)
{
struct i2c_client *new_client;
struct pca953x_chip *chip; //设备结构体
int err = 0,result;
dev_t pca953x_dev=MKDEV(pca953x_major,0);//构建设备号，根据具体情况设定，这里我只考虑了normal_i2c中只有一个地址匹配的情况。
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA| I2C_FUNC_SMBUS_WORD_DATA))//判定适配器能力
goto exit;
if (!(chip = kzalloc(sizeof(struct pca953x_chip), GFP_KERNEL))) {
err = -ENOMEM;
goto exit;
}
/****构建i2c-client****/
chip->client=kzalloc(sizeof(struct i2c_client),GFP_KERNEL);
new_client = chip->client;
i2c_set_clientdata(new_client, chip);
new_client->addr = address;
new_client->adapter = adapter;
new_client->driver = &pca953x_driver;
new_client->flags = 0;
strlcpy(new_client->name, "pca953x", I2C_NAME_SIZE);
if ((err = i2c_attach_client(new_client)))//注册i2c_client
goto exit_kfree;
if (err)
goto exit_detach;
if(pca953x_major)
{
result=register_chrdev_region(pca953x_dev,1,"pca953x");
}
else{
result=alloc_chrdev_region(&pca953x_dev,0,1,"pca953x");
pca953x_major=MAJOR(pca953x_dev);
}
if (result < 0) {
printk(KERN_NOTICE "Unable to get pca953x region, error %d\n", result);
return result;
}
pca953x_setup_cdev(chip,0); //注册字符设备，此处不详解
return 0;
exit_detach:
i2c_detach_client(new_client);
exit_kfree:
kfree(chip);
exit:
return err;
}
i2c_check_functionality用来判定设配器的能力，这一点非常重要。你也可以直接查看对应设配器的能力，如
static const struct i2c_algorithm smbus_algorithm = {
.smbus_xfer= i801_access,
.functionality= i801_func,
};
static u32 i801_func(struct i2c_adapter *adapter)
{
return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_WRITE_I2C_BLOCK
| (isich4 ? I2C_FUNC_SMBUS_HWPEC_CALC : 0);
}
● 字符驱动的具体实现
struct file_operations pca953x_fops = {
.owner = THIS_MODULE,
.ioctl= pca953x_ioctl,
.open= pca953x_open,
.release =pca953x_release,
};
字符设备驱动本身没有什么好说的，这里主要想说一下，如何在驱动中调用i2c设配器帮我们完成数据传输。
目前设配器主要支持两种传输方法：smbus_xfer和master_xfer。一般来说，如果设配器支持了master_xfer那么它也可以模拟支持smbus的传输。但如果只实现smbus_xfer，则不支持一些i2c的传输。
int (*master_xfer)(struct i2c_adapter *adap,struct i2c_msg *msgs,int num);
int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,
unsigned short flags, char read_write,
u8 command, int size, union i2c_smbus_data * data);
master_xfer中的参数设置，和前面的用户空间编程一致。现在只是要在驱动中构建相关的参数然后调用i2c_transfer来完成传输既可。
int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
smbus_xfer中的参数设置及调用方法如下：
static int pca953x_write_reg(struct pca953x_chip *chip, int reg, uint16_t val)
{
int ret;
ret = i2c_smbus_write_word_data(chip->client, reg << 1, val);
if (ret < 0) {
dev_err(&chip->client->dev, "failed writing register\n");
return -EIO;
}
return 0;
}
上面函数完成向芯片的地址为reg的寄存器写一个16bit的数据。i2c_smbus_write_word_data的实现如下：
s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
{
union i2c_smbus_data data;
data.word = value;
return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
I2C_SMBUS_WRITE,command,
I2C_SMBUS_WORD_DATA,&data);
}
从中可以看出smbus传输一个16位数据的方法。其它操作如：字符写、字符读、字读、块操作等，可以参考内核的i2c-core.c中提供的方法。
● 注销i2c_driver
static void __exit pca953x_exit(void)
{
i2c_del_driver(&pca953x_driver);
}
module_exit(pca953x_exit);
● detach_client动作
顺序调用内核中注册的适配器来断开我们注册过的i2c设备。此过程通过调用i2c_driver中的attach_adapter方法完成的。具体实现形式如下：
static int pca953x_detach_client(struct i2c_client *client)
{
int err;
struct pca953x_chip *data;
if ((err = i2c_detach_client(client)))//断开i2c_client
return err;
data=i2c_get_clientdata(client);
cdev_del(&(data->cdev));
unregister_chrdev_region(MKDEV(pca953x_major, 0), 1);
kfree(data->client);
kfree(data);
return 0;
}
（2） Probe方式（new style）
● 构建i2c_driver
和LEGACY方式一样，也需要构建i2c_driver，但是内容有所不同。
static struct i2c_driver pca953x_driver = {
.driver = {
.name= "pca953x",
},
.probe= pca953x_probe, //当有i2c_client和i2c_driver匹配时调用
.remove= pca953x_remove,//注销时调用
.id_table= pca953x_id,//匹配规则
};
● 注册i2c_driver
static int __init pca953x_init(void)
{
return i2c_add_driver(&pca953x_driver);
}
module_init(pca953x_init);
在注册i2c_driver的过程中，是将driver注册到了i2c_bus_type的总线上。此总线的匹配规则是：
static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
const struct i2c_client *client)
{
while (id->name[0]) {
if (strcmp(client->name, id->name) == 0)
return id;
id++;
}
return NULL;
}
可以看出是利用i2c_client的名称和id_table中的名称做匹配的。本驱动中的id_table为
static const struct i2c_device_id pca953x_id[] = {
{ "pca9534", 8, },
{ "pca9535", 16, },
{ "pca9536", 4, },
{ "pca9537", 4, },
{ "pca9538", 8, },
{ "pca9539", 16, },
{ "pca9554", 8, },
{ "pca9555", 16, },
{ "pca9557", 8, },
{ "max7310", 8, },
{ }
};
看到现在我们应该会有这样的疑问，在Adapter模式中，i2c_client是我们自己构造出来的，而现在的i2c_client是从哪来的呢？看看下面的解释
● 注册i2c_board_info
对于Probe模式，通常在平台代码中要完成i2c_board_info的注册。方法如下：
static struct i2c_board_info __initdata test_i2c_devices[] = {
{
I2C_BOARD_INFO("pca9555", 0x27),//pca9555为芯片名称，0x27为芯片地址
.platform_data = &pca9555_data,
}, {
I2C_BOARD_INFO("mt9v022", 0x48),
.platform_data = &iclink[0], /* With extender */
}, {
I2C_BOARD_INFO("mt9m001", 0x5d),
.platform_data = &iclink[0], /* With extender */
},
};
i2c_register_board_info(0, test_i2c_devices,ARRAY_SIZE(test_i2c_devices)); //注册
i2c_client就是在注册过程中构建的。但有一点需要注意的是i2c_register_board_info并没有EXPORT_SYMBOL给模块使用。
● 字符驱动注册
在Probe方式下，添加字符驱动的位置在pca953x_probe中。
static int __devinit pca953x_probe(struct i2c_client *client,const struct i2c_device_id *id)
{
……
/****字符设备驱动注册位置****/
……
return 0;
}
● 注销i2c_driver
static void __exit pca953x_exit(void)
{
i2c_del_driver(&pca953x_driver);
}
module_exit(pca953x_exit);
● 注销字符设备驱动
在Probe方式下，注销字符驱动的位置在pca953x_remove中。
static int __devinit pca953x_remove (struct i2c_client *client)
{
……
/****字符设备驱动注销的位置****/
……
return 0;
}
● I2C设备的数据交互方法(即：调用适配器操作设备的方法)和Adapter方式下相同。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
