Linux驱动之i2c用户态调用

1、I2C概述I2C是philips公司提供的外设总线，I2C有两条数据线，一条是串行数据线SDA、一条是时钟线SCL，使用SDA和SCL实现了数据的交换，便于布线。

I2C总线方便用在EEPROM、实时钟、小型LCD等与CPU外部的接口上。

2、Linux下的驱动思路Linux系统下编写I2c驱动主要有两种方法：一种是把I2C当做普通字符设备来使用；另一种利用Linux下驱动的体系结构来实现。

第一种方法：优点：思路比较直接，不用花费大量时间去了解Linux系统下I2C体系结构缺点：不仅对I2C设备操作要了解，还有了解I2C的适配器操作不仅对I2C设备器和设备操作需要了解，编写的驱动移植性差，内核提供的I2C设备器都没有用上。

第二种方法：第一种的优点就是第二种的缺点，第一种的缺点就是第二种的优点。

3、I2C框架概述Linux的I2C体系结构分为3部分：1）I2C核心I2C核心提供了I2C总线驱动和设备驱动的注册和注销的方法，I2C 通信方法（algorithm）上层，与具体适配器无关的代码，检测设备上层的代码等。

2）I2C总线驱动I2C总线驱动是对I2C硬件体系结构中适配器端的实现，适配器可以直接受CPU来控制。

3）I2C设备驱动I2C设备驱动是对I2C硬件体系结构中设备端的实现，设备端挂在受CPU控制的适配器上，通过I2C适配器与CPU交换数据。

Linux下的I2C体系结构：1）Linux下的I2C体系结构4、I2C设备驱动编写方法首先让我们明白适配器驱动的作用是让我们能够通过它发出标准的I2C时序，在linux内核源代码中driver/I2C/buss包含一些适配器的驱动，例如s3c2410的驱动I2C-s3c2410.c,适配器被加载到内核中，接下的任务就是实现设备驱动的编写。

编写设备驱动的方法主要分为两种方法：第一种：利用设备提供的I2C-dev.c来实现I2C适配器设备文件，然后通过上层应用程序来操作I2C设备器来控制I2C设备。

Linux I2C驱动完全分析（二）先说一下，本文中有个疑惑，一直没有搞懂，写在这里，望高人指点一二，不胜感激！#define I2C_M_NOSTART 0x4000 /* if I2C_FUNC_PROTOCOL_MANGLING */#define I2C_M_REV_DIR_ADDR 0x2000 /* if I2C_FUNC_PROTOCOL_MANGLING */ #define I2C_M_IGNORE_NAK 0x1000 /* if I2C_FUNC_PROTOCOL_MANGLING */ #define I2C_M_NO_RD_ACK 0x0800 /* if I2C_FUNC_PROTOCOL_MANGLING */这里I2C_FUNC_PROTOCOL_MANGLING 是什么意思？为什么定义这些东东？看了注释也不太理解。

求解释！3. I2C总线驱动代码分析s3c2440的总线驱动代码在i2c-s3c2410.c中。

照例先从init看起。

static int __init i2c_adap_s3c_init(void){return platform_driver_register(&s3c24xx_i2c_driver);}在init中只是调用了平台驱动注册函数注册了一个i2c的平台驱动s3c24xx_i2c_driver。

这个驱动是一个platform_driver的结构体变量。

注意这里不是i2c_driver结构体，因为i2c_driver是对设备的驱动，而这里对控制器的驱动要使用platform_driverstatic struct platform_driver s3c24xx_i2c_driver = {.probe = s3c24xx_i2c_probe,.remove = s3c24xx_i2c_remove,.suspend_late = s3c24xx_i2c_suspend_late,.resume = s3c24xx_i2c_resume,.id_table = s3c24xx_driver_ids,.driver = {.owner = THIS_MODULE,.name = "s3c-i2c",},};同样的，重要的函数还是那几个：probe，remove，suspend_late，resume。

Linux环境下基于I2C总线的EEPROM 驱动程序1 引言I2C (Inter-Integrated Circuit1总线是一种由Philips公司开发的2线式串行总线，用于连接微控制器及其外围设备。

它是同步通信的一种特殊形式，具有接口线少、控制方式简单、器件封装形式小、通信速率较高等优点。

在主从通信中，可有多个I2C总线器件同时接到I2C总线上，通过地址来识别通信对象。

笔者在开发基于MPC8250的嵌入式Linux系统的过程中发现I2C总线在嵌入式系统中应用广泛，I2C总线控制器的类型比较多，对系统提供的操作接口差别也很大。

与I2C总线相连的从设备主要有微控制器、EEPROM、实时时钟、A/D转换器等.MPC8250处理器正是通过内部的I2C总线控制器来和这些连接在I2C总线上的设备进行数据交换的。

由于I2C总线的特性，Linux的I2C总线设备驱动程序的设计者在设计驱动程序时采用了独特的体系结构。

使开发I2C总线设备驱动程序与开发一般设备驱动程序的方法具有很大差别。

因此，开发I2C总线设备驱动程序除了要涉及一般Linux内核驱动程序的知识外.还要对I2C总线驱动的体系结构有深入的了解。

笔者在开发过程中使用设备型号为AT24C01A的EEPROM 来测试I2C总线驱动。

2 工作原理概述在介绍I2C总线结构之前。

要搞清楚两个概念：I2C总线控制器和I2C设备。

I2C总线控制器为微控制器或微处理器提供控制I2C总线的接口，它控制所有I2C总线的特殊序列、协议、仲裁、时序，这里指MPC8250提供的I2C总线控制接口。

I2C设备是指通过I2C总线与微控制器或微处理器相连的设备，如EEPROM、LCD驱动器等，这里指EEPROM。

在一个串行数据通道中.I2C总线控制器可以配置成主模式或从模式。

开发过程中，MPC8250的I2C总线控制器工作在主模式，作为主设备；与总线相连的I2C设备为AT24C01A 型EEPROM，作为从设备。

linux下S3C2440–I2C驱动学习之四“i2c我们进入I2C驱动的最后一个小节，在这个小节里，我们主要探讨 i2c_algorithm 数据结构和i2c-core.c 的一些主要函数及其作用。

i2c_algorithm 结构体struct i2c_algorithm {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);u32 (*functionality) (struct i2c_adapter *);};一个i2c 适配器上的i2c 总线通信方法由其驱动程序提供的i2c_algorithm 数据结构描述，由algo 指针指向。

i2c_algorithm 数据结构即为i2c_adapter 数据结构与具体i2c 适配器的总线通信方法的中间层，正是这个中间层使得上层的i2c 框架代码与与具体i2c 适配器的总线通信方法无关，从而实现了i2c 框架的可移植性和重用性。

当安装具体i2c 适配器的驱动程序时由相应驱动程序实现具体的i2c_algorithm 数据结构，其中的函数指针指向操作具体i2c 适配器的代码。

master_xfer/smbus_xfer 指针指向i2c 适配器驱动程序模块实现的i2c 通信协议或者smbus 通信协议。

在用户进程通过i2c-dev 提供的/dev/i2c/%d 设备节点访问i2c 设备时，最终是通过调用master_xfer 或者smbus_xfer 指向的方法完成的。

i2c-core.ci2c.h 和i2c-core.c 为i2c 框架的主体，提供了核心数据结构的定义、i2c 适配器驱动和设备驱动的注册、注销管理，i2c 通信方法上层的、与具体适配器无关的代码、检测设备地址的上层代码等；i2c-dev.c 用于创建i2c 适配器的/dev/i2c/%d 设备节点，提供i2c 设备访问方法等。

LinuxI2C驱动--⽤户态驱动简单⽰例1. Linux内核⽀持I2C通⽤设备驱动（⽤户态驱动：由应⽤层实现对硬件的控制可以称之为⽤户态驱动），实现⽂件位于drivers/i2c/i2c-dev.c，设备⽂件为/dev/i2c-02. I2C通⽤设备驱动以字符设备注册进内核的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);3. 对设备⽂件进⾏读写时，可以调⽤read、write或者ioctl等⽅法，他们都是通过调⽤函数i2c_transfer来实现对I2C设备的操作的int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num){int ret;/* REVISIT the fault reporting model here is weak:** - When we get an error after receiving N bytes from a slave,* there is no way to report "N".** - When we get a NAK after transmitting N bytes to a slave,* there is no way to report "N" ... or to let the master* continue executing the rest of this combined message, if* that's the appropriate response.** - When for example "num" is two and we successfully complete* the first message but get an error part way through the* second, it's unclear whether that should be reported as* one (discarding status on the second message) or errno* (discarding status on the first one).*/if (adap->algo->master_xfer) {#ifdef DEBUGfor (ret = 0; ret < num; ret++) {dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, ""len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)'R' : 'W', msgs[ret].addr, msgs[ret].len,(msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");}#endifif (in_atomic() || irqs_disabled()) {ret = mutex_trylock(&adap->bus_lock);if (!ret)/* I2C activity is ongoing. */return -EAGAIN;} else {mutex_lock_nested(&adap->bus_lock, adap->level);}ret = adap->algo->master_xfer(adap,msgs,num);mutex_unlock(&adap->bus_lock);return ret;} else {dev_dbg(&adap->dev, "I2C level transfers not supported\n");return -EOPNOTSUPP;}}4. i2c_transfer通过代码可以看出，i2c_transfer 通过调⽤相应的 adapter 的 master_xfer ⽅法实现的，⽽ master_xfer 主要是根据 struct i2c_msg 类型的msgs来进⾏处理的。

linux 应用访问i2c设备原理Linux是一个开放源代码的操作系统内核，支持许多硬件设备的驱动程序。

其中一种常用的硬件接口是I2C（Inter-Integrated Circuit）总线。

I2C总线允许多个设备通过共享同一组线路进行通信，这些设备可以是传感器、存储器、转换器等外围设备。

Linux提供了一种访问I2C设备的机制，通过此机制，应用程序可以与I2C设备进行通信。

在本文中，将介绍Linux应用程序访问I2C设备的原理及步骤。

1.硬件连接：首先，需要将I2C设备连接到主机上。

I2C总线由两根线路组成，即SDA（Serial Data Line）和SCL（Serial Clock Line）。

SDA用于传输数据，SCL用于提供时钟信号。

I2C设备通常具有一个I2C地址，用于在总线上识别不同的设备。

2. Linux内核驱动：Linux内核提供了I2C总线的驱动程序，用于与I2C设备进行通信。

通常，这些驱动程序已经包含在内核中，不需要单独安装。

但是，可能需要通过编译内核时打开相应的配置选项来启用I2C支持。

3. I2C设备驱动：每个I2C设备都需要一个设备驱动程序，用于与应用程序进行交互。

这些驱动程序通常由设备制造商提供，也有一些常见的驱动程序包含在Linux内核中。

设备驱动程序将设备上的读写操作映射到I2C总线上的读写操作。

4.用户空间库：为了更方便地编写应用程序，Linux提供了一些用户空间库，用于访问I2C设备。

其中最常用的库是libi2c-dev，它提供了一组API函数，可以通过文件描述符进行I2C通信。

此库通常已经安装在Linux系统中，可以通过编译时链接到应用程序中。

5.应用程序访问：应用程序需要通过打开I2C总线来访问I2C设备。

首先，需要获取I2C总线的文件描述符，可以通过调用open()函数并传递文件路径来实现。

常见的I2C总线路径为"/dev/i2c-x"，其中"x"是总线号。

Linux设备驱动之I2C架构分析一:前言I2c是philips提出的外设总线.I2C只有两条线,一条串行数据线:SDA,一条是时钟线SCL.正因为这样,它方便了工程人员的布线.另外,I2C是一种多主机控制总线.它和USB总线不同,USB是基于master-slave 机制,任何设备的通信必须由主机发起才可以.而 I2C 是基于multi master机制.一同总线上可允许多个master.关于I2C协议的知识,这里不再赘述.可自行下载spec阅读即可.二:I2C架构概述在linux中,I2C驱动架构如下所示:如上图所示,每一条I2C对应一个adapter.在kernel中,每一个adapter提供了一个描述的结构(struct i2c_adapter),也定义了adapter支持的操作(struct i2c_adapter).再通过i2c core层将i2c设备与i2c adapter关联起来.这个图只是提供了一个大概的框架.在下面的代码分析中,从下至上的来分析这个框架图.以下的代码分析是基于linux 2.6.26.分析的代码基本位于: linux-2.6.26.3/drivers/i2c/位置.三:adapter注册在kernel中提供了两个adapter注册接口,分别为i2c_add_adapter()和i2c_add_numbered_adapter().由于在系统中可能存在多个adapter,因为将每一条I2C总线对应一个编号,下文中称为 I2C总线号.这个总线号的PCI中的总线号不同.它和硬件无关,只是软件上便于区分而已.对于i2c_add_adapter()而言,它使用的是动态总线号,即由系统给其分析一个总线号,而i2c_add_numbered_adapter()则是自己指定总线号,如果这个总线号非法或者是被占用,就会注册失败.分别来看一下这两个函数的代码:int i2c_add_adapter(struct i2c_adapter *adapter){int id, res = 0;retry:if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)return -ENOMEM;mutex_lock(&core_lock);/* "above" here means "above or equal to", sigh */res = idr_get_new_above(&i2c_adapter_idr, adapter,__i2c_first_dynamic_bus_num, &id);mutex_unlock(&core_lock);if (res < 0) {if (res == -EAGAIN)goto retry;return res;}adapter->nr = id;return i2c_register_adapter(adapter);}在这里涉及到一个idr结构.idr结构本来是为了配合page cache中的radix tree而设计的.在这里我们只需要知道,它是一种高效的搜索树,且这个树预先存放了一些内存.避免在内存不够的时候出现问题.所在,在往idr中插入结构的时候,首先要调用idr_pre_get()为它预留足够的空闲内存,然后再调用idr_get_new_above()将结构插入idr中,该函数以参数的形式返回一个id.以后凭这个id就可以在idr中找到相对应的结构了.对这个数据结构操作不太理解的可以查阅本站<< linux文件系统之文件的读写>>中有关radix tree的分析.注意一下 idr_get_new_above(&i2c_adapter_idr, adapter,__i2c_first_dynamic_bus_num, &id)的参数的含义,它是将adapter结构插入到i2c_adapter_idr中,存放位置的id必须要大于或者等于__i2c_first_dynamic_bus_num,然后将对应的id号存放在adapter->nr中.调用i2c_register_adapter(adapter)对这个adapter进行进一步注册.看一下另外一人注册函数: i2c_add_numbered_adapter( ),如下所示:int i2c_add_numbered_adapter(struct i2c_adapter *adap){int id;int status;if (adap->nr & ~MAX_ID_MASK)return -EINVAL;retry:if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)return -ENOMEM;mutex_lock(&core_lock);/* "above" here means "above or equal to", sigh;* we need the "equal to" result to force the result*/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);return status;}对比一下就知道差别了,在这里它已经指定好了adapter->nr了.如果分配的id不和指定的相等,便返回错误.过一步跟踪i2c_register_adapter().代码如下:static int i2c_register_adapter(struct i2c_adapter *adap){int res = 0, dummy;mutex_init(&adap->bus_lock);mutex_init(&adap->clist_lock);INIT_LIST_HEAD(&adap->clients);mutex_lock(&core_lock);/* Add the adapter to the driver core.* If the parent pointer is not set up,* we add this adapter to the host bus.*/if (adap->dev.parent == NULL) {adap->dev.parent = &platform_bus;pr_debug("I2C adapter driver [%s] forgot to specify ""physical device\n", adap->name);}sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);adap->dev.release = &i2c_adapter_dev_release;adap->dev.class = &i2c_adapter_class;res = device_register(&adap->dev);if (res)goto out_list;dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);/* create pre-declared device nodes for new-style drivers */if (adap->nr < __i2c_first_dynamic_bus_num)i2c_scan_static_board_info(adap);/* let legacy drivers scan this bus for matching devices */dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,i2c_do_add_adapter);out_unlock:mutex_unlock(&core_lock);return res;out_list:idr_remove(&i2c_adapter_idr, adap->nr);goto out_unlock;}首先对adapter和adapter中内嵌的struct device结构进行必须的初始化.之后将adapter内嵌的struct device注册.在这里注意一下adapter->dev的初始化.它的类别为i2c_adapter_class,如果没有父结点,则将其父结点设为platform_bus.adapter->dev的名字为i2c + 总线号.测试一下:[eric@mochow i2c]$ cd /sys/class/i2c-adapter/[eric@mochow i2c-adapter]$ lsi2c-0可以看到,在我的PC上,有一个I2C adapter,看下详细信息:[eric@mochow i2c-adapter]$ tree.`-- i2c-0|-- device -> ../../../devices/pci0000:00/0000:00:1f.3/i2c-0|-- name|-- subsystem -> ../../../class/i2c-adapter`-- uevent3 directories, 2 files可以看到,该adapter是一个PCI设备.继续往下看:之后,在注释中看到,有两种类型的driver,一种是new-style drivers,另外一种是legacy drivers New-style drivers是在2.6近版的kernel加入的.它们最主要的区别是在adapter和i2c driver的匹配上.3.1: new-style 形式的adapter注册对于第一种,也就是new-style drivers,将相关代码再次列出如下:if (adap->nr < __i2c_first_dynamic_bus_num)i2c_scan_static_board_info(adap);如果adap->nr 小于__i2c_first_dynamic_bus_num的话,就会进入到i2c_scan_static_board_info().结合我们之前分析的adapter的两种注册分式: i2c_add_adapter()所分得的总线号肯会不会小于__i2c_first_dynamic_bus_num.只有i2c_add_numbered_adapter()才有可能满足:(adap->nr < __i2c_first_dynamic_bus_num)而且必须要调用i2c_register_board_info()将板子上的I2C设备信息预先注册时才会更改__i2c_first_dynamic_bus_num的值.在x86上只没有使用i2c_register_board_info()的.因此,x86平台上的分析可以忽略掉new-style driver的方式.不过,还是详细分析这种情况下.首先看一下i2c_register_board_info(),如下:int __initi2c_register_board_info(int busnum,struct i2c_board_info const *info, unsigned len){int status;mutex_lock(&__i2c_board_lock);/* dynamic bus numbers will be assigned after the last static one */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;}这个函数比较简单, struct i2c_board_info用来表示I2C设备的一些情况,比如所在的总线.名称,地址,中断号等.最后,这些信息会被存放到__i2c_board_list链表.跟踪i2c_scan_static_board_info():代码如下:static void i2c_scan_static_board_info(struct i2c_adapter *adapter){struct i2c_devinfo *devinfo;mutex_lock(&__i2c_board_lock);list_for_each_entry(devinfo, &__i2c_board_list, list) {if (devinfo->busnum == adapter->nr&& !i2c_new_device(adapter,&devinfo->board_info))printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",i2c_adapter_id(adapter),devinfo->board_info.addr);}mutex_unlock(&__i2c_board_lock);}该函数遍历挂在__i2c_board_list链表上面的i2c设备的信息,也就是我们在启动的时候指出的i2c 设备的信息.如果指定设备是位于adapter所在的I2C总线上,那么,就调用i2c_new_device().代码如下:struct i2c_client *i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info){struct i2c_client *client;int status;client = kzalloc(sizeof *client, GFP_KERNEL);if (!client)return NULL;client->adapter = adap;client->dev.platform_data = info->platform_data;device_init_wakeup(&client->dev, info->flags & I2C_CLIENT_WAKE);client->flags = info->flags & ~I2C_CLIENT_WAKE;client->addr = info->addr;client->irq = info->irq;strlcpy(client->name, info->type, sizeof(client->name));/* a new style driver may be bound to this device when we* return from this function, or any later moment (e.g. maybe* hotplugging will load the driver module). and the device* refcount model is the standard driver model one.*/status = i2c_attach_client(client);if (status < 0) {kfree(client);client = NULL;}return client;}我们又遇到了一个新的结构:struct i2c_client,不要被这个结构吓倒了,其实它就是一个嵌入struct device的I2C设备的封装.它和我们之前遇到的struct usb_device结构的作用是一样的.首先,在clinet里保存该设备的相关消息.特别的, client->adapter指向了它所在的adapter.特别的,clinet->name为info->name.也是指定好了的.一切初始化完成之后,便会调用i2c_attach_client( ).看这个函数的字面意思,是将clinet关联起来.到底怎么样关联呢?继续往下看:int i2c_attach_client(struct i2c_client *client){struct i2c_adapter *adapter = client->adapter;int res = 0;//初始化client内嵌的dev结构//父结点为所在的adapter,所在bus为i2c_bus_typeclient->dev.parent = &client->adapter->dev;client->dev.bus = &i2c_bus_type;//如果client已经指定了driver,将driver和内嵌的dev关联起来if (client->driver)client->dev.driver = &client->driver->driver;//指定了driver, 但不是newstyle的if (client->driver && !is_newstyle_driver(client->driver)) {client->dev.release = i2c_client_release;client->dev.uevent_suppress = 1;} elseclient->dev.release = i2c_client_dev_release;//clinet->dev的名称snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),"%d-%04x", i2c_adapter_id(adapter), client->addr);//将内嵌的dev注册res = device_register(&client->dev);if (res)goto out_err;//将clinet链到adapter->clients中mutex_lock(&adapter->clist_lock);list_add_tail(&client->list, &adapter->clients);mutex_unlock(&adapter->clist_lock);dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",client->name, client->dev.bus_id);//如果adapter->cleinet_reqister存在,就调用它if (adapter->client_register) {if (adapter->client_register(client)) {dev_dbg(&adapter->dev, "client_register ""failed for client [%s] at 0x%02x\n",client->name, client->addr);}}return 0;out_err:dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x ""(%d)\n", client->name, client->addr, res);return res;}参考上面添加的注释,应该很容易理解这段代码了,就不加详细分析了.这个函数的名字不是i2c_attach_client()么?怎么没看到它的关系过程呢?这是因为:在代码中设置了client->dev所在的bus为i2c_bus_type .以为只需要有bus为i2c_bus_type的driver注册,就会产生probe了.这个过程呆后面分析i2c driver的时候再来详细分析.3.2: legacy形式的adapter注册Legacy形式的adapter注册代码片段如下:dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,i2c_do_add_adapter);这段代码遍历挂在i2c_bus_type上的驱动,然后对每一个驱动和adapter调用i2c_do_add_adapter().代码如下:static int i2c_do_add_adapter(struct device_driver *d, void *data){struct i2c_driver *driver = to_i2c_driver(d);struct i2c_adapter *adap = data;if (driver->attach_adapter) {/* We ignore the return code; if it fails, too bad */driver->attach_adapter(adap);}return 0;}该函数很简单,就是调用driver的attach_adapter()接口.到此为止,adapter的注册已经分析完了.四:i2c driver注册在分析i2c driver的时候,有必要先分析一下i2c架构的初始化代码如下:static int __init i2c_init(void){int retval;retval = bus_register(&i2c_bus_type);if (retval)return retval;retval = class_register(&i2c_adapter_class);if (retval)goto bus_err;retval = i2c_add_driver(&dummy_driver);if (retval)goto class_err;return 0;class_err:class_unregister(&i2c_adapter_class);bus_err:bus_unregister(&i2c_bus_type);return retval;}subsys_initcall(i2c_init);很明显,i2c_init()会在系统初始化的时候被调用.在i2c_init中,先注册了i2c_bus_type的bus,i2c_adapter_class的class.然后再调用i2c_add_driver()注册了一个i2c driver.I2c_bus_type结构如下:static struct bus_type i2c_bus_type = {.name = "i2c",.dev_attrs = i2c_dev_attrs,.match = i2c_device_match,.uevent = i2c_device_uevent,.probe = i2c_device_probe,.remove = i2c_device_remove,.shutdown = i2c_device_shutdown,.suspend = i2c_device_suspend,.resume = i2c_device_resume,};这个结构先放在这里吧,以后还会用到里面的信息的.从上面的初始化函数里也看到了,注册i2c driver的接口为i2c_add_driver().代码如下: 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;/* new style driver methods can't mix with legacy ones *///如果是一个newstyle的driver.但又定义了attach_adapter/detach_adapter.非法 if (is_newstyle_driver(driver)) {if (driver->attach_adapter || driver->detach_adapter|| driver->detach_client) {printk(KERN_WARNING"i2c-core: driver [%s] is confused\n",driver->);return -EINVAL;}}/* add the driver to the list of i2c drivers in the driver core *///关联到i2c_bus_typesdriver->driver.owner = owner;driver->driver.bus = &i2c_bus_type;/* for new style drivers, when registration returns the driver core* will have called probe() for all matching-but-unbound devices.*///注册内嵌的driverres = driver_register(&driver->driver);if (res)return res;mutex_lock(&core_lock);pr_debug("i2c-core: driver [%s] registered\n", driver->);/* legacy drivers scan i2c busses directly *///遍历所有的adapter,对其都调用driver->attach_adapterif (driver->attach_adapter) {struct i2c_adapter *adapter;down(&i2c_adapter_class.sem);list_for_each_entry(adapter, &i2c_adapter_class.devices,dev.node) {driver->attach_adapter(adapter);}up(&i2c_adapter_class.sem);}mutex_unlock(&core_lock);return 0;}这里也有两种形式的区分,对于第一种,只需要将内嵌的driver注册就可以了,对于legacy的情况,对每一个adapter都调用driver->attach_adapter().现在,我们可以将adapter和i2c driver关联起来考虑一下了:1:如果是news style形式的,在注册adapter的时候,将它上面的i2c 设备转换成了struct client.struct client->dev->bus又指定了和i2c driver同一个bus.因为,它们可以发生probe.2:如果是legacy形式,就直接找到对应的对象,调用driver->attach_adapter().五: i2c_bus_type的相关操作I2c_bus_type的操作主要存在于new-style形式的驱动中.接下来分析一下对应的probe过程:5.1:match过程分析Match对应的操作函数为i2c_device_match().代码如下static int i2c_device_match(struct device *dev, struct device_driver *drv){struct i2c_client *client = to_i2c_client(dev);struct i2c_driver *driver = to_i2c_driver(drv);/* make legacy i2c drivers bypass driver model probing entirely;* such drivers scan each i2c adapter/bus themselves.*/if (!is_newstyle_driver(driver))return 0;/* match on an id table if there is one */if (driver->id_table)return i2c_match_id(driver->id_table, client) != NULL;return 0;}如果该驱动不是一个new-style形式的.或者driver没有定义匹配的id_table.都会匹配失败. 继续跟踪进i2c_match_id():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;}由此可见.如果client的名字和driver->id_table[]中的名称匹配即为成功.5.2:probe过程分析Probe对应的函数为: i2c_device_probe()static int i2c_device_probe(struct device *dev){struct i2c_client *client = to_i2c_client(dev);struct i2c_driver *driver = to_i2c_driver(dev->driver);const struct i2c_device_id *id;int status;if (!driver->probe)return -ENODEV;client->driver = driver;dev_dbg(dev, "probe\n");if (driver->id_table)id = i2c_match_id(driver->id_table, client);elseid = NULL;status = driver->probe(client, id);if (status)client->driver = NULL;return status;}这个函数也很简单,就是将probe流程回溯到i2c driver的probe()六:其它的扩展分析完adapter和i2c driver的注册之后,好像整个架构也差不多了,其它,扩展的东西还有很多.我们举一个legacy形式的例子,这个例子是在kernel中随便搜索出来的:在linux-2.6.26.3/drivers/hwmon/ad7418.c中,初始化函数为:static int __init ad7418_init(void){return i2c_add_driver(&ad7418_driver);}i2c_driver ad7418_driver结构如下:static struct i2c_driver ad7418_driver = {.driver = {.name = "ad7418",},.attach_adapter = ad7418_attach_adapter,.detach_client = ad7418_detach_client,};该结构中没有probe()函数,可以断定是一个legacy形式的驱动.这类驱动注册的时候,会调用driver 的attach_adapter函数.在这里也就是ad7418_attach_adapter.这个函数代码如下:static int ad7418_attach_adapter(struct i2c_adapter *adapter){if (!(adapter->class & I2C_CLASS_HWMON))return 0;return i2c_probe(adapter, &addr_data, ad7418_detect);}在这里我们又遇到了一个i2c-core中的函数,i2c_probe().在分析这个函数之前,先来看下addr_data 是什么?#define I2C_CLIENT_MODULE_PARM(var,desc) \static unsigned short var[I2C_CLIENT_MAX_OPTS] = I2C_CLIENT_DEFAULTS; \static unsigned int var##_num; \module_param_array(var, short, &var##_num, 0); \MODULE_PARM_DESC(var,desc)#define I2C_CLIENT_MODULE_PARM_FORCE(name) \I2C_CLIENT_MODULE_PARM(force_##name, \"List of adapter,address pairs which are " \"unquestionably assumed to contain a `" \# name "' chip")#define I2C_CLIENT_INSMOD_COMMON \I2C_CLIENT_MODULE_PARM(probe, "List of adapter,address pairs to scan " \"additionally"); \I2C_CLIENT_MODULE_PARM(ignore, "List of adapter,address pairs not to " \"scan"); \static const struct i2c_client_address_data addr_data = { \.normal_i2c = normal_i2c, \.probe = probe, \.ignore = ignore, \.forces = forces, \}#define I2C_CLIENT_FORCE_TEXT \"List of adapter,address pairs to boldly assume to be present"由此可知道,addr_data中的三个成员都是模块参数.在加载模块的时候可以用参数的方式对其赋值.三个模块参数为别为probe,ignore,force.另外需要指出的是normal_i2c不能以模块参数的方式对其赋值,只能在驱动内部静态指定.从模块参数的模述看来, probe是指"List of adapter,address pairs to scan additionally"Ignore是指"List of adapter,address pairs not to scan "Force是指"List of adapter,address pairs to boldly assume to be present"事实上,它们里面的数据都是成对出现的.前面一部份表示所在的总线号,ANY_I2C_BUS表示任一总线.后一部份表示设备的地址.现在可以来跟踪i2c_probe()的代码了.如下:int i2c_probe(struct i2c_adapter *adapter,const struct i2c_client_address_data *address_data,int (*found_proc) (struct i2c_adapter *, int, int)){int i, err;int adap_id = i2c_adapter_id(adapter);/* Force entries are done first, and are not affected by ignoreentries *///先扫描force里面的信息,注意它是一个二级指针.ignore里的信息对它是无效的if (address_data->forces) {const unsigned short * const *forces = address_data->forces;int kind;for (kind = 0; forces[kind]; kind++) {for (i = 0; forces[kind] != I2C_CLIENT_END;i += 2) {if (forces[kind] == adap_id|| forces[kind] == ANY_I2C_BUS) {dev_dbg(&adapter->dev, "found force ""parameter for adapter %d, ""addr 0x%02x, kind %d\n",adap_id, forces[kind][i + 1],kind);err = i2c_probe_address(adapter,forces[kind][i + 1],kind, found_proc);if (err)return err;}}}}/* Stop here if we can't use SMBUS_QUICK *///如果adapter不支持quick.不能够遍历这个adapter上面的设备if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {if (address_data->probe[0] == I2C_CLIENT_END&& address_data->normal_i2c[0] == I2C_CLIENT_END)return 0;dev_warn(&adapter->dev, "SMBus Quick command not supported, ""can't probe for chips\n");return -1;}/* Probe entries are done second, and are not affected by ignoreentries either *///遍历probe上面的信息.ignore上的信息也对它是没有影响的for (i = 0; address_data->probe != I2C_CLIENT_END; i += 2) {if (address_data->probe == adap_id|| address_data->probe == ANY_I2C_BUS) {dev_dbg(&adapter->dev, "found probe parameter for ""adapter %d, addr 0x%02x\n", adap_id,address_data->probe[i + 1]);err = i2c_probe_address(adapter,address_data->probe[i + 1],-1, found_proc);if (err)return err;}}/* Normal entries are done last, unless shadowed by an ignore entry */ //最后遍历normal_i2c上面的信息.它上面的信息不能在ignore中.for (i = 0; address_data->normal_i2c != I2C_CLIENT_END; i += 1) {int j, ignore;ignore = 0;for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;j += 2) {if ((address_data->ignore[j] == adap_id ||address_data->ignore[j] == ANY_I2C_BUS)&& address_data->ignore[j + 1]== address_data->normal_i2c) {dev_dbg(&adapter->dev, "found ignore ""parameter for adapter %d, ""addr 0x%02x\n", adap_id,address_data->ignore[j + 1]);ignore = 1;break;}}if (ignore)continue;dev_dbg(&adapter->dev, "found normal entry for adapter %d, ""addr 0x%02x\n", adap_id,address_data->normal_i2c);err = i2c_probe_address(adapter, address_data->normal_i2c,-1, found_proc);if (err)return err;}return 0;}这段代码很简单,结合代码上面添加的注释应该很好理解.如果匹配成功,则会调用i2c_probe_address ().这个函数代码如下:static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,int (*found_proc) (struct i2c_adapter *, int, int)){int err;/* Make sure the address is valid *///地址小于0x03或者大于0x77都是不合法的if (addr < 0x03 || addr > 0x77) {dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",addr);return -EINVAL;}/* Skip if already in use *///adapter上已经有这个设备了if (i2c_check_addr(adapter, addr))return 0;/* Make sure there is something at this address, unless forced *///如果kind小于0.检查adapter上是否有这个设备if (kind < 0) {if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,I2C_SMBUS_QUICK, NULL) < 0)return 0;/* prevent 24RF08 corruption */if ((addr & ~0x0f) == 0x50)i2c_smbus_xfer(adapter, addr, 0, 0, 0,I2C_SMBUS_QUICK, NULL);}/* Finally call the custom detection function *///调用回调函数err = found_proc(adapter, addr, kind);/* -ENODEV can be returned if there is a chip at the given addressbut it isn't supported by this chip driver. We catch it here asthis isn't an error. */if (err == -ENODEV)err = 0;if (err)dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",addr, err);return err;}首先,对传入的参数进行一系列的合法性检查.另外,如果该adapter上已经有了这个地址的设备了.也会返回失败.所有adapter下面的设备都是以 adapter->dev为父结点的.因此只需要遍历adapter->dev下面的子设备就可以得到当前地址是不是被占用了.如果kind < 0.还得要adapter检查该总线是否有这个地址的设备.方法是向这个地址发送一个Read 的Quick请求.如果该地址有应答,则说明这个地址上有这个设备.另外还有一种情况是在24RF08设备的特例.如果adapter上确实有这个设备,就会调用驱动调用时的回调函数.在上面涉及到了IIC的传输方式,有疑问的可以参考intel ICH5手册的有关smbus部份.跟踪i2c_smbus_xfer().代码如下:s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,char read_write, u8 command, int size,union i2c_smbus_data * data){s32 res;flags &= I2C_M_TEN | I2C_CLIENT_PEC;if (adapter->algo->smbus_xfer) {mutex_lock(&adapter->bus_lock);res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,command,size,data);mutex_unlock(&adapter->bus_lock);} elseres = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,command,size,data);return res;}如果adapter有smbus_xfer()函数,则直接调用它发送,否则,也就是在adapter不支持smbus协议的情况下,调用i2c_smbus_xfer_emulated()继续处理.跟进i2c_smbus_xfer_emulated().代码如下:static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,unsigned short flags,char read_write, u8 command, int size,union i2c_smbus_data * data){/* So we need to generate a series of msgs. In the case of writing, weneed to use only one message; when reading, we need two. We initializemost things with sane defaults, to keep the code below somewhatsimpler. *///写操作只会进行一次交互,而读操作,有时会有两次操作.//因为有时候读操作要先写command,再从总线上读数据//在这里为了代码的简洁.使用了两个缓存区,将两种情况统一起来.unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];//一般来说,读操作要交互两次.例外的情况我们在下面会接着分析int num = read_write == I2C_SMBUS_READ?2:1;//与设备交互的数据,一般在msg[0]存放写入设备的信息,在msb[1]里存放接收到的//信息.不过也有例外的//msg[2]的初始化,默认发送缓存区占一个字节,无接收缓存struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },{ addr, flags | I2C_M_RD, 0, msgbuf1 }};int i;u8 partial_pec = 0;//将要发送的信息copy到发送缓存区的第一字节msgbuf0[0] = command;switch(size) {//quick类型的,其它并不传输有效数据,只是将地址写到总线上,等待应答即可//所以将发送缓存区长度置为0 .再根据读/写操作,调整msg[0]的标志位//这类传输只需要一次总线交互case I2C_SMBUS_QUICK:msg[0].len = 0;/* Special case: The read/write field is used as data */msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;num = 1;break;case I2C_SMBUS_BYTE://BYTE类型指一次写和读只有一个字节.这种情况下,读和写都只会交互一次//这种类型的读有例外,它读取出来的数据不是放在msg[1]中的,而是存放在msg[0]if (read_write == I2C_SMBUS_READ) {/* Special case: only a read! */msg[0].flags = I2C_M_RD | flags;num = 1;}break;case I2C_SMBUS_BYTE_DATA://Byte_Data是指命令+数据的传输形式.在这种情况下,写只需要一次交互,读却要两次//第一次将command写到总线上,第二次要转换方向.要将设备地址和read标志写入总线. //应回答之后再进行read操作//写操作占两字节,分别是command+data.读操作的有效数据只有一个字节//交互次数用初始化值就可以了if (read_write == I2C_SMBUS_READ)msg[1].len = 1;else {msg[0].len = 2;msgbuf0[1] = data->byte;}break;case I2C_SMBUS_WORD_DATA://Word_Data是指命令+双字节的形式.这种情况跟Byte_Data的情况类似//两者相比只是交互的数据大小不同if (read_write == I2C_SMBUS_READ)msg[1].len = 2;else {msg[0].len=3;msgbuf0[1] = data->word & 0xff;msgbuf0[2] = data->word >> 8;}break;case I2C_SMBUS_PROC_CALL://Proc_Call的方式与write 的Word_Data相似,只不过写完Word_Data之后,要等待它的应答//应该它需要交互两次,一次写一次读num = 2; /* Special case */read_write = I2C_SMBUS_READ;msg[0].len = 3;msg[1].len = 2;msgbuf0[1] = data->word & 0xff;msgbuf0[2] = data->word >> 8;break;case I2C_SMBUS_BLOCK_DATA://Block_Data:指command+N段数据的情况.//如果是读操作,它首先要写command到总线,然后再读N段数据.要写的command已经//放在msg[0]了.现在只需要将msg[1]的标志置I2C_M_RECV_LEN位,msg[1]有效长度为1字节.因为//adapter驱动会处理好的.现在现在还不知道要传多少段数据.//对于写的情况:msg[1]照例不需要.将要写的数据全部都放到msb[0]中.相应的也要更新 //msg[0]中的缓存区长度if (read_write == I2C_SMBUS_READ) {msg[1].flags |= I2C_M_RECV_LEN;msg[1].len = 1; /* block length will be added bythe underlying bus driver */} else {//data->block[0]表示后面有多少段数据.总长度要加2是因为command+count+N段数据 msg[0].len = data->block[0] + 2;if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {dev_err(&adapter->dev, "smbus_access called with ""invalid block write size (%d)\n",data->block[0]);return -1;}for (i = 1; i < msg[0].len; i++)msgbuf0 = data->block[i-1];}break;case I2C_SMBUS_BLOCK_PROC_CALL://Proc_Call:表示写完Block_Data之后,要等它的应答消息它和Block_Data相比,只是多了一部份应答而已num = 2; /* Another special case */read_write = I2C_SMBUS_READ;if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {dev_err(&adapter->dev, "%s called with invalid ""block proc call size (%d)\n", __func__,data->block[0]);return -1;}msg[0].len = data->block[0] + 2;for (i = 1; i < msg[0].len; i++)msgbuf0 = data->block[i-1];msg[1].flags |= I2C_M_RECV_LEN;msg[1].len = 1; /* block length will be added bythe underlying bus driver */break;case I2C_SMBUS_I2C_BLOCK_DATA://I2c Block_Data与Block_Data相似,只不过read的时候,数据长度是预先定义好了的.另外//与Block_Data相比,中间不需要传输Count字段.(Count表示数据段数目)if (read_write == I2C_SMBUS_READ) {msg[1].len = data->block[0];} else {msg[0].len = data->block[0] + 1;if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with ""invalid block write size (%d)\n",data->block[0]);return -1;}for (i = 1; i <= data->block[0]; i++)msgbuf0 = data->block;}break;default:dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",size);return -1;}//如果启用了PEC.Quick和I2c Block_Data是不支持PEC的i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK&& size != I2C_SMBUS_I2C_BLOCK_DATA);if (i) {/* Compute PEC if first message is a write */。

Linux IIC驱动在嵌入式系统中，IIC设备是非常常见的。

下面就讨论下在LINUX如何实现IIC设备的驱动。

因为IIC的主机适配驱动程序一般芯片厂家在BSP里面都会提供，这里就不详细说明了，下面主要介绍下客户驱动程序如何实现。

首先，我们需要在驱动的初始化函数中注册IIC。

我们需要调用i2c_add_driver 。

这个函数的原形是int i2c_add_driver（struct i2c_driver * IIC），在驱动的exit函数里面需要调用i2c_del_driver释放资源。

下面是注册和释放的例子：static const struct i2c_device_id tsc2003_id[] = {{ “ts_2003”, 0 },{ }};static struct i2c_driver tsc2003_driver = {.probe = tsc2003_probe,.remove = tsc2003_remove,.id_table = tsc2003_id,.driver = {.name = “ts_2003”,},};static int __init tsc2003_init(void){int res;res = i2c_add_driver(&tsc2003_driver);if(res){return res;}return 0;}void __exit tsc2003_exit(void){i2c_del_driver(&tsc2003_driver);}在tsc2003_init这个函数里面调用了i2c_add_driver注册IIC。

下面介绍下i2c_driver这个结构：这个结构里面定义了.probe = tsc2003_probe，那么系统在检测到IIC核心定义了.name指定的设备名。

那么系统会调用tsc2003_probe，并且将struct i2c_client的指针作为参数传递进来。

linux自带i2c工具使用总线被全球超过50个公司的1000+个ICs所使用,已然是一个世界标.另外,I2C总线与多种不同的控制总线是兼容的,比如SMBus(系统管理),PMBus(电源管理总线),IPMI(智能平台管理总线),DDC(显示数据通)以及ATCA(高级电信架构).如果没记错的话,linux中的I2C框架是完SMBus的.要全面了解I2C,可以从《I2C-bus specification and user manual》看起.I2C最初是由Philips提出的,那么这文档就是由NXP维护的.我们接下来要了解I2C总线是如何工作的,在一个具体应用中如何设计.I2C的数据传输,握手以及总线仲裁机制都需要了解.I2C总线在每种操作模式下的时序和电气特性都需要了解,这里还是从嵌入式软件工程师的角度着重了解时序特性.安装工具：apt-get install i2c-toolsI2C总线的特性:在消费电子,通信以及工业电子中,看起来不相关的设计中有很多类似的地方.例如,基本上每个系统都包括:1.一些智能控制,通常是单芯片的微控制器2.通用的电路:LCD和LED驱动器,远程IO口,RAM,EEPROM,RTC 或者DAC\ADC.3.面向应用的电路:比如收音机和视频系统的数字调谐和信号处理电路,温度传感器和智能卡.为了让这些共同之处对于系统设计者和设备厂商都有用,也为了最大化硬件的有效性和电路的简单性,Philips半导体开发了一个简单的双向2线的总线,实现了IC之间的有效控制.这个总线就被称为I2C总线.所有兼容I2C总线的设备都包含一个片上的接口,允许它们直接通过I2C 总线进行通信.这个设计解决了在设计数字控制电路时带来的很多接口问题.下面是I2C总线的一些特性:1.只需要两根线,一个串行数据线(SDA)额一个串行时钟线(SCL).2.可以通过软件方式和一个唯一的地址来寻找到每一个连接到总线的设备,简单的主从关系一直存在.主机可以作为主机发送器或者主机接收器.3.它是真正的多主机总线,如果有两个或多个主机初始化数据传输,可以通过冲突检测和仲裁来防止数据被破坏.4.串行的8位双向数据传输在标准模式下达到100kb/s,快速模式下是400kb/s,超速模式下是3.4Mb/s.5.串行的8位单向数据在快速模式下可以达到5Mb/s.6.片上的滤波器可以保护数据完整性.7.总线上连接的最大IC数量由总线最大的电容所限制.系统设计者的好处:由于I2C总线是个是一个标准的总线,不需要额外的接口.所以在系统升级或者修改时,可以简单的换IC.厂商的好处:符合I2C总线的IC不仅帮助了设计者,同样给设备厂商很多好处,因为:1.I2C只有两根线,所以IC的pin脚会少,PCB的面积会小,成本会降.2.完整的I2C总线协议不需要地址译码器或其他逻辑电路.这只是一些好处.另外,符合I2C总线的IC会增加系统设计的灵活性.IC很容易升级,比如需要一个更大的ROM,只需要选择一个有更大ROM的微控制器就可以了.IC设计者的好处:微控制器的设计者经常要考虑输出pin脚.I2C协议允许在没有单独寻址信号和芯片使能信号的条件下各种外设的连接.另外,带I2C接口的微控制器在市场上更受欢迎,因为有很多外设可以选.通过i2cdetect -l指令可以查看TX1上的I2C总线，从返回的结果来看TX1含有七个I2C总线。

一、概述I2C只有两条线，一条串行数据线：SDA,一条是时钟线SCL.正因为这样，它方便了工程人员的布线.二、用户态实现设备驱动在Linux内核代码文件i2c-dev.c中实现了I2C适配器设备文件的功能，针对每个适配器生成一个主设备号为89的设备节点（次设备号为0-255），I2c-dev.c并没有针对特定的设备而设计，只是提供了通用的read(),write(),和ioctl()等文件操作接口，在用户空间的应用层就可以借用这些接口访问挂接在适配器上的I2C设备的存储空间或寄存器，并控制I2C设备的工作方式。

i2c适配器的设备节点是/dev/i2c-x，其中x是数字。

由于适配器编号是动态分配的（和注册次序有关），所以想了解哪一个适配器对应什么编号，可以查看/sys/class/i2c-dev/目录下的文件内容。

三、用户态调用3.1、i2c-dev用户空间操作i2c,需要包含以下头文件。

打开适配器对应的设备节点i2c-dev为打开的线程建立一个i2c_client，但是这个i2c_client并不加到i2c_adapter的client链表当中。

他是一个虚拟的临时client,当用户打开设备节点时，它自动产生，当用户关闭设备节点时，它自动被释放。

3.2、ioctl()查看include/linux/i2c-dev.h文件，可以看到i2c支持的IOCTL命令1.#define I2C_RETRIES0x0701/*设置收不到ACK时的重试次数*/2.#define I2C_TIMEOUT0x0702/*设置超时时限的jiffies*/3.#define I2C_SLAVE0x0703/*设置从机地址*/4.#define I2C_SLAVE_FORCE0x0706/*强制设置从机地址*/5.#define I2C_TENBIT0x0704/*选择地址位长:=0for7bit,!=0for10bit*/6.#define I2C_FUNCS0x0705/*获取适配器支持的功能*/7.#define I2C_RDWR0x0707/*Combin ed R/W transfer(one STOP only)*/8.#define I2C_PEC0x0708/* !=0to use PEC with SMBus*/9.#define I2C_SMBUS0x0720/*SMBus transfer*/例如：1、设置重试次数：ioctl(fd, I2C_RETRIES,m);设置适配器收不到ACK时重试的次数为m。

linux驱动学习i2c驱动架构davinc dm368 i2c驱动分析但是Linux的i2c驱动体系结构却有相当的复杂度，不管是叫linux i2c驱动还是单片机i2c驱动，其根本还是操作soc芯片内部的i2c模块（也叫i2c adapter）（读写i2c相关的寄存器）来产生start、stop还有ack信号而已。

linux设备驱动到底复杂在什么地方？假设soc芯片dm368有两个i2c adapter（368内部真正只有一个i2c模块）：i2c_adapter1，i2c_adapter1；然后外部有三个i2c接口的设备i2c_device1，i2c_device2，i2c_device3。

现在要求在裸机下写出他们的驱动函数。

那么肯定要写出6个不同的驱动函数：i2c_adapter1_ReadWrite_i2c_device1();i2c_adapter1_ReadWrite_i2c_device2()i2c_adapter1_ReadWrite_i2c_device3()i2c_adapter2_ReadWrite_i2c_device1()i2c_adapter2_ReadWrite_i2c_device2()i2c_adapter2_ReadWrite_i2c_device3()设想一共有m个i2c adapter和n个外设i2c device，那么将需要m*n个驱动。

并且这m*n个驱动程序必要会有很大部分重复的代码，而且不利于驱动程序的移植。

如果采用adapter和device分离的思想来写这样的驱动会是怎样呢？图1这样分离之后，只需要m+n个驱动，而且Adapter和Device的几乎没有耦合性，增加一个Adapter或者device并不会影响其余的驱动。

这就是分离思想带来的好处。

除此之外，linux虽然是C写的，但是大量使用了面向对象的变成方法（可以理解为分层的思想），仅仅分离细想和分层思想的引入，就大大增加了linux设备驱动的复杂度。

Linux下I2C设备驱动开发和实现2008-05-16嵌入式在线收藏|打印I2C总线具有结构简单使用方便的特点。

本文描述了Linux下I2C驱动的结构，并在此基础上给出了I2C设备驱动和应用的实现。

1引言I2C(Inter－Integrated Circuit)总线是一种由PHILIPS公司开发的两线式串行总线，用于连接微控制器及其外围设备。

I2C总线最主要的优点是其简单性和有效性。

由于接口直接在组件之上，因此I2C总线占用的空间非常小，减少了电路板的空间和芯片管脚的数量，降低了互联成本。

I2C总线最初为音频和视频设备开发，现已应用于各种服务与管理场合，来实现配置或掌握组件的功能状态，如电源、系统风扇、系统温度等参数，增加了系统的安全性，方便了管理。

2I2C总线概述I2C总线是由数据线SDA和时钟SCL构成的串行总线，可发送和接收数据，每个器件都有一个惟一的地址识别。

I2C规程运用主/从双向通讯。

器件发送数据到总线上，则定义为发送器，器件接收数据则定义为接收器。

主器件和从器件都可以工作于接收和发送状态。

总线必须由主器件（通常为微控制器）控制，主器件产生串行时钟（SCL）控制总线的传输方向，并产生起始和停止条件。

SDA 线上的数据状态仅在SCL为低电平的期间才能改变，SCL为高电平的期间，SDA 状态的改变被用来表示起始和停止条件。

I2C总线在传送数据过程中共有三种类型信号，它们分别是：开始信号、结束信号和应答信号。

开始信号：SCL为高电平时，SDA由高电平向低电平跳变，开始传送数据。

结束信号：SCL为低电平时，SDA由低电平向高电平跳变，结束传送数据。

应答信号：接收数据的IC在接收到8bit数据后，向发送数据的IC发出特定的低电平脉冲，表示已收到数据。

CPU向受控单元发出一个信号后，等待受控单元发出一个应答信号，CPU接收到应答信号后，根据实际情况作出是否继续传递信号的判断。

若未收到应答信号，由判断为受控单元出现故障。

LinuxI2C驱动整理（以RK3399Pro+Kernel4.4为例）⼀. Linux I2C驱动架构Linux内核⾥，I2C驱动框架可以分为两层，adapter驱动和deivce驱动。

Adapter驱动也可以理解为I2C总线驱动，指的是SOC⾥的I2C控制器驱动。

⼀个SOC可能包含多个I2C控制器，⽽每个控制器的使⽤⽅式是相同的（寄存器参数、收发数据的⽅法等），因此多个控制器可以共⽤⼀套adapter驱动；Deivce驱动，对应的是SOC外围的I2C设备，不同类型I2C设备需要开发不同的设备驱动，同⼀类型的I2C设备可以使⽤⼀种驱动，但是每⼀个I2C设备都由⼀个唯⼀的client来描述。

⼆. Adapter配置DTSI⽂件(kernel/arch/arm64/boot/dts/rockchip/rk3399.dtsi)描述了RK3399Pro所有的I2C控制器信息：i2c0: i2c@ff3c0000 {compatible = "rockchip,rk3399-i2c";reg = <0x00xff3c00000x00x1000>;clocks = <&pmucru SCLK_I2C0_PMU>, <&pmucru PCLK_I2C0_PMU>;clock-names = "i2c", "pclk";interrupts = <GIC_SPI 57 IRQ_TYPE_LEVEL_HIGH 0>;pinctrl-names = "default";pinctrl-0 = <&i2c0_xfer>;#address-cells = <1>;#size-cells = <0>;status = "disabled";};i2c1: i2c@ff110000 {compatible = "rockchip,rk3399-i2c";reg = <0x00xff1100000x00x1000>;clocks = <&cru SCLK_I2C1>, <&cru PCLK_I2C1>;clock-names = "i2c", "pclk";interrupts = <GIC_SPI 59 IRQ_TYPE_LEVEL_HIGH 0>;pinctrl-names = "default";pinctrl-0 = <&i2c1_xfer>;#address-cells = <1>;#size-cells = <0>;status = "disabled";};i2c2: i2c@ff120000 {compatible = "rockchip,rk3399-i2c";reg = <0x00xff1200000x00x1000>;clocks = <&cru SCLK_I2C2>, <&cru PCLK_I2C2>;clock-names = "i2c", "pclk";interrupts = <GIC_SPI 35 IRQ_TYPE_LEVEL_HIGH 0>;pinctrl-names = "default";pinctrl-0 = <&i2c2_xfer>;#address-cells = <1>;#size-cells = <0>;status = "disabled";};i2c3: i2c@ff130000 {compatible = "rockchip,rk3399-i2c";reg = <0x00xff1300000x00x1000>;clocks = <&cru SCLK_I2C3>, <&cru PCLK_I2C3>;clock-names = "i2c", "pclk";interrupts = <GIC_SPI 34 IRQ_TYPE_LEVEL_HIGH 0>;pinctrl-names = "default";pinctrl-0 = <&i2c3_xfer>;#address-cells = <1>;#size-cells = <0>;status = "disabled";};i2c5: i2c@ff140000 {compatible = "rockchip,rk3399-i2c";reg = <0x00xff1400000x00x1000>;clocks = <&cru SCLK_I2C5>, <&cru PCLK_I2C5>;clock-names = "i2c", "pclk";interrupts = <GIC_SPI 38 IRQ_TYPE_LEVEL_HIGH 0>;pinctrl-names = "default";pinctrl-0 = <&i2c5_xfer>;#address-cells = <1>;#size-cells = <0>;status = "disabled";};i2c6: i2c@ff150000 {compatible = "rockchip,rk3399-i2c";reg = <0x00xff1500000x00x1000>;clocks = <&cru SCLK_I2C6>, <&cru PCLK_I2C6>;clock-names = "i2c", "pclk";interrupts = <GIC_SPI 37 IRQ_TYPE_LEVEL_HIGH 0>;pinctrl-names = "default";pinctrl-0 = <&i2c6_xfer>;#address-cells = <1>;#size-cells = <0>;status = "disabled";};i2c7: i2c@ff160000 {compatible = "rockchip,rk3399-i2c";reg = <0x00xff1600000x00x1000>;clocks = <&cru SCLK_I2C7>, <&cru PCLK_I2C7>;clock-names = "i2c", "pclk";interrupts = <GIC_SPI 36 IRQ_TYPE_LEVEL_HIGH 0>;pinctrl-names = "default";pinctrl-0 = <&i2c7_xfer>;#address-cells = <1>;#size-cells = <0>;status = "disabled";};i2c4: i2c@ff3d0000 {compatible = "rockchip,rk3399-i2c";reg = <0x00xff3d00000x00x1000>;clocks = <&pmucru SCLK_I2C4_PMU>, <&pmucru PCLK_I2C4_PMU>;clock-names = "i2c", "pclk";interrupts = <GIC_SPI 56 IRQ_TYPE_LEVEL_HIGH 0>;pinctrl-names = "default";pinctrl-0 = <&i2c4_xfer>;#address-cells = <1>;#size-cells = <0>;status = "disabled";};i2c8: i2c@ff3e0000 {compatible = "rockchip,rk3399-i2c";reg = <0x00xff3e00000x00x1000>;clocks = <&pmucru SCLK_I2C8_PMU>, <&pmucru PCLK_I2C8_PMU>;clock-names = "i2c", "pclk";interrupts = <GIC_SPI 58 IRQ_TYPE_LEVEL_HIGH 0>;pinctrl-names = "default";pinctrl-0 = <&i2c8_xfer>;#address-cells = <1>;#size-cells = <0>;status = "disabled";};可以看出，该SOC共有9个I2C控制器，分别为I2C0~I2C8, 每个控制器对应了不同的寄存器基地址（例如I2C0对应0xff3c0000），它们的compatible匹配属性都是"rockchip,rk3399-i2c"，也就是对应了同⼀个adapter驱动。

LinuxI2C驱动框架⼀、I2C总线概述I2C是由Philips公司开发的⼀种简单的、双向同步串⾏总线，它只需要两条线即可在连接于总线上的器件之间传送信息，其硬件连接框图如下所⽰：SCL：串⾏时钟线，数据传输过程中⽤于同步的时钟信号，低电平时允许SDA线上数据改变。

SDA：串⾏数据线，在时钟信号作⽤下，数据按位在数据线上进⾏传输。

I2C总线上的设备之间通信都要遵从I2C总线协议，I2C总线由起始信号、停⽌信号、应答信号、⾮应答信号组成。

起始信号：当时钟线SCL为⾼期间，数据线SDA由⾼到低的跳变。

停⽌信号：当时钟线SCL为⾼期间，数据线SDA由低到⾼的跳变。

应答信号（ACK）：应答位为低电平时，规定为有效应答位，表⽰接收器已经成功接收到该字节。

⾮应答信号（NACK）：应答位为⾼电平时，规定为⾮应答位，⼀般表⽰接收器接收该字节没有成功。

挂接在同⼀条I2C总线上的设备都要⾃⼰的物理地址，I2C主机控制器在和设备通信前需要先发送设备的地址，设备接收到总线上传过来的地址，看是否是⾃⼰的地址，如果是产⽣后续的应答。

主机控制器和设备通信⼀般是由⼀个起始信号开始和⼀个停⽌信号结束，地址信息⼀般是7bit，发送地址的最后⼀位代表数据传输的⽅向，1表⽰是读，0表⽰写操作，其发送时序⼀般如下所⽰：主机发送数据主机读取数据前⾯对I2C总线的⼀些基本概念和I2C协议的做了简单的介绍，下⾯开始来分析Linux内核的I2C驱动框架，看看内核中如何实现对I2C设备的⽀持。

⼆、Linux内核I2C驱动1、⼏个重要对象内核中的I2C驱动框架使⽤了总线设备驱动模型，在分析内核I2C驱动之前，先讨论这⼏个重要的数据结构。

1.1、I2C总线I2C总线是⼀条虚拟的bus总线（同platform总线⼀样，位于/sys/bus⽬录），其在drivers\i2c\i2c-core.c实现，具体内容如下：struct bus_type i2c_bus_type = {.name = "i2c",.dev_attrs = i2c_dev_attrs,.match = i2c_device_match,.uevent = i2c_device_uevent,.probe = i2c_device_probe,.remove = i2c_device_remove,.shutdown = i2c_device_shutdown,.suspend = i2c_device_suspend,.resume = i2c_device_resume,};这个i2c总线结构管理着I2C设备与I2C驱动的匹配、删除等操作。

Linux i2c驱动详细分析.首先在S3C2440平台的初始化函数中，主要是将开发平台的设备注册进了系统，也就是将device注册到了platform虚拟的总线上，并进行了一些初始化的工作，这里我们只关注I2C的部分。

static void __init smdk2440_machine_init(void){s3c24xx_fb_set_platdata(&smdk2440_fb_info);s3c_i2c0_set_platdata(NULL);platform_add_devices(smdk2440_devices,ARRAY_SIZE(smdk2440_devices));smdk_machine_init();}s3c_i2c0_set_platdata（）函数将S3C2440上的I2C控制器进行了一些初始化，但是并没有写入硬件寄存器，仅仅是保存在了s3c2410_platform_i2c结构体中。

void __init s3c_i2c0_set_platdata(struct s3c2410_platform_i2c *pd){struct s3c2410_platform_i2c *npd;if (!pd)pd = &default_i2c_data0;npd = kmemdup(pd, sizeof(struct s3c2410_platform_i2c),GFP_KERNEL);if (!npd)printk(KERN_ERR "%s: no memory for platform data\n",__func__);else if (!npd->cfg_gpio)npd->cfg_gpio = s3c_i2c0_cfg_gpio;/* s3c_i2c0_cfg_gpio为 配置I2C控制器GPIO函数指针 */ s3c_device_i2c0.dev.platform_data = npd;/*最后将struct device 中的platform_data指针直指向了初始化后的 s3c2410_platform_i2c结构体 */}函数s3c_i2c0_cfg_gpio()很简单，实际上就是配置GPIO为I2C的工作模式void s3c_i2c0_cfg_gpio(struct platform_device *dev){s3c2410_gpio_cfgpin(S3C2410_GPE(15), S3C2410_GPE15_IICSDA);s3c2410_gpio_cfgpin(S3C2410_GPE(14), S3C2410_GPE14_IICSCL); }s3c_i2c0_set_platdata(struct s3c2410_platform_i2c *pd)函数实际上就是把初始化数据段中的default_i2c_data0结构体复制过来，然后对GPIO进行配置的函数指针进行了初始化。