实例解析linux内核I2C体系结构

作者：刘洪涛,讲师。

一、概述

谈到在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_data 、struct i2c_msg。使用的命令是I2C_RDWR。

         struct i2c_rdwr_ioctl_data {

             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 data */

         };

针对smbus算法，需要熟悉struct i2c_smbus_ioctl_data。使用的命令是I2C_SMBUS。对于smbus算法，不需要考虑“多开始信号时序”问题。

         struct i2c_smbus_ioctl_data {

             __u8 read_write; //读、写

             __u8 command; //命令

             __u32 size; //数据长度标识

             union i2c_smbus_data __user *data; //数据

         };

下面以一个实例讲解操作的具体过程。通过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

         */

         #include

         #include

         #include

         #include

         #include

         #include

         #include

         #include

         #define I2C_RETRIES 0x0701

         #define I2C_TIMEOUT 0x0702

         #define I2C_RDWR 0x0707

         /*********定义struct i2c_rdwr_ioctl_data和struct i2c_msg，要和内核一致*******/

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_data

         {

                 struct i2c_msg *msgs;

                 int nmsgs;

         /* nmsgs这个数量决定了有多少开始信号，对于“单开始时序”，取1*/

         };

/***********主程序***********/

         int main()

         {

                 int fd,ret;

                 struct i2c_rdwr_ioctl_data e2prom_data;

                 fd=open("/dev/i2c-0",O_RDWR);

         /*

         */dev/i2c-0是在注册i2c-dev.c后产生的，代表一个可操作的适配器。如果不使用i2c-dev.c

         *的方式，就没有，也不需要这个节点。

         */

                 if(fd<0)

                 {

                         perror("open error");

                 }

                 e2prom_data.nmsgs=2;

         /*

         *因为操作时序中，最多是用到2个开始信号（字节读操作中），所以此将

         *e2prom_data.nmsgs配置为2

         */

                 e2prom_data.msgs=(struct i2c_msg*)malloc(e2prom_data.nmsgs*sizeof(struct i2c_msg));

                 if(!e2prom_data.msgs)

                 {

                         perror("malloc error");

                         exit(1);

                 }

                 ioctl(fd,I2C_TIMEOUT,1);/*超时时间*/

                 ioctl(fd,I2C_RETRIES,2);/*重复次数*/

                 /***write data to e2prom**/

                 e2prom_data.nmsgs=1;

                 (e2prom_data.msgs[0]).len=2; //1个 e2prom 写入目标的地址和1个数据

                 (e2prom_data.msgs[0]).addr=0x50;//e2prom 设备地址

                 (e2prom_data.msgs[0]).flags=0; //write

                 (e2prom_data.msgs[0]).buf=(unsigned char*)malloc(2);

                 (e2prom_data.msgs[0]).buf[0]=0x10;// e2prom 写入目标的地址

                 (e2prom_data.msgs[0]).buf[1]=0x58;//the data to write

         ret=ioctl(fd,I2C_RDWR,(unsigned long)&e2prom_data);

                 if(ret<0)

                 {

                         perror("ioctl error1");

                 }

                 sleep(1);

         /******read data from e2prom*******/

                 e2prom_data.nmsgs=2;

                 (e2prom_data.msgs[0]).len=1; //e2prom 目标数据的地址

                 (e2prom_data.msgs[0]).addr=0x50; // e2prom 设备地址

                 (e2prom_data.msgs[0]).flags=0;//write

                 (e2prom_data.msgs[0]).buf[0]=0x10;//e2prom数据地址

                 (e2prom_data.msgs[1]).len=1;//读出的数据

                 (e2prom_data.msgs[1]).addr=0x50;// e2prom 设备地址

                 (e2prom_data.msgs[1]).flags=I2C_M_RD;//read

                 (e2prom_data.msgs[1]).buf=(unsigned char*)malloc(1);//存放返回值的地址。

                 (e2prom_data.msgs[1]).buf[0]=0;//初始化读缓冲

         ret=ioctl(fd,I2C_RDWR,(unsigned long)&e2prom_data);

                 if(ret<0)

                 {

                         perror("ioctl error2");

                 }

                 printf("buff[0]=%x\n",(e2prom_data.msgs[1]).buf[0]);

         /***打印读出的值，没错的话，就应该是前面写的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_data，定义这两个结构中的函数指针成员.并且用己经初始化好的i2c_algo_826o_data结构来初始化struct i2c_adapter结构的algo_data成员变量。其中，定义i2e_algo_8260_data结构为：

struct i2c_algo_8260_data rw8250_data={

setisr:rw8250_install_isr

}；

　　这里的成员变量rw8250_install__isr提供了MPC8250的I2C总线控制器向内核申请中端请求的功能。结构体i2c_adapter定义如下：

struct i2c_adapter rw8250_ops={"rw8250",I2C_HW_

MPC8250_RW8250,NULL,&rw8250_data,rw8250_inc_use,rw8250_dec_use,rw8250_reg,rw8250_unreg,}；

　　其中，"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_data算法模块中输出的接口函数传递给算法模块。

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来描述：

DE>DE>static struct i2c_adapter pb1550_board_adapter = { name: "pb1550 adapter", id: I2C_HW_AU1550_PSC, algo: NULL, algo_data: &pb1550_i2c_info, inc_use: pb1550_inc_use, dec_use: pb1550_dec_use, client_register: pb1550_reg, client_unregister: pb1550_unreg, client_count: 0,};

这个样例挂接了一个叫做“pb1550 adapter”的驱动。但这个模块并未提供读写函数，具体的读写方法由第二个模块，struct i2c_algorithm提供。

DE>DE>static struct i2c_algorithm au1550_algo = {　.name = "Au1550 algorithm",　.id = I2C_ALGO_AU1550,　.master_xfer = au1550_xfer,　.functionality = au1550_func,};i2c_adap->algo = &au1550_algo;

这个样例给上述总线驱动增加了读写“算法”。通常情况下每个I2C总线驱动都定义一个自己的读写算法，但鉴于有些总线使用相同的算法，因而可以共用同一套读写函数。本例中的驱动定义了自己的读写算法模块，起名叫“Au1550 algorithm”。

全部填妥后，通过调用：

DE>DE>i2c_add_adapter(i2c_adap);

将这两个模块注册到操作系统里，总线驱动就算装上了。对于AMD au1550，这部分已经由AMD提供了。

1.2 设备驱动

如前所述，总线驱动只是提供了对一条总线的读写机制，本身并不会去做通信。通信是由I2C设备驱动来做的，设备驱动透过I2C总线同具体的设备进行通讯。一个设备驱动有两个模块来描述，struct i2c_driver和struct i2c_client。

当系统开机、I2C总线驱动装入完成后，就可以装入设备驱动了。首先装入如下结构：

DE>DE>static struct i2c_driver driver = { .name = "i2c TV tuner driver", .id = I2C_DRIVERID_TUNER, .flags = I2C_DF_NOTIFY, .attach_adapter = tuner_probe, .detach_client = tuner_detach, .command = tuner_command,};i2c_add_driver(&driver);

这个i2c_driver一旦装入完成，其中的attach_adapter函数就会被调用。在其中可以遍历系统中的每个i2c总线驱动，探测想要访问的设备：

DE>DE>static int tuner_probe(struct i2c_adapter *adap) {　return i2c_probe(adap, &addr_data, tuner_attach); }

注意探测可能会找到多个设备，因而不仅一个I2C总线可以挂多个不同类型的设备，一个设备驱动也可以同时为挂在多个不同I2C总线上的设备服务。

每当设备驱动探测到了一个它能支持的设备，它就创建一个struct i2c_client来标识这个设备：

DE>DE>new_client->addr = address;new_client->adapter = adapter;new_client->driver = &driver;/* Tell the I2C layer a new client has arrived */err = i2c_attach_client(new_client);if (err) goto error;

可见，一个i2c_client代表着位于adapter总线上，地址为address，使用driver来驱动的一个设备。它将总线驱动与设备驱动，以及设备地址绑定在了一起。一个i2c_client就代表着一个I2C设备。

当得到I2C设备后，就可以直接对此设备进行读写：

DE>DE>/* * The master routines are the ones normally used to transmit data to devices * on a bus (or read from them). Apart from two basic transfer functions to * transmit one message at a time, a more complex version can be used to * transmit an arbitrary number of messages without interruption. */extern int i2c_master_send(struct i2c_client *,const char* ,int);extern int i2c_master_recv(struct i2c_client *,char* ,int);

与通常意义上的读写函数一样，这两个函数对i2c_client指针指定的设备，读写int个char。返回值为读写的字节数。对于我们现有的SLIC的驱动，只要将最后要往总线上进行读写的数据引出传输到这两个函数中，移植工作就算完成了，我们将得到一个Linux版的I2C设备驱动。