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

合集下载

Linux下I2C驱动架构全面分析概要

Linux下I2C驱动架构全面分析概要

Linux下I2C驱动架构全面分析I2C 概述I2C是philips提出的外设总线.I2C只有两条线,一条串行数据线:SDA,一条是时钟线SCL,使用SCL,SDA这两根信号线就实现了设备之间的数据交互,它方便了工程师的布线。

因此,I2C总线被非常广泛地应用在EEPROM,实时钟,小型LCD等设备与CPU的接口中。

linux下的驱动思路在linux系统下编写I2C驱动,目前主要有两种方法,一种是把I2C设备当作一个普通的字符设备来处理,另一种是利用linux下I2C驱动体系结构来完成。

下面比较下这两种方法:第一种方法:优点:思路比较直接,不需要花很多时间去了解linux中复杂的I2C子系统的操作方法。

缺点:要求工程师不仅要对I2C设备的操作熟悉,而且要熟悉I2C的适配器(I2C控制器)操作。

要求工程师对I2C的设备器及I2C的设备操作方法都比较熟悉,最重要的是写出的程序可以移植性差。

对内核的资源无法直接使用,因为内核提供的所有I2C设备器以及设备驱动都是基于I2C 子系统的格式。

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

I2C架构概述Linux的I2C体系结构分为3个组成部分:I2C核心:I2C核心提供了I2C总线驱动和设备驱动的注册,注销方法,I2C通信方法(”algorithm”)上层的,与具体适配器无关的代码以及探测设备,检测设备地址的上层代码等。

I2C总线驱动:I2C总线驱动是对I2C硬件体系结构中适配器端的实现,适配器可由CPU控制,甚至可以直接集成在CPU内部。

I2C设备驱动:I2C设备驱动(也称为客户驱动)是对I2C硬件体系结构中设备端的实现,设备一般挂接在受CPU控制的I2C适配器上,通过I2C适配器与CPU交换数据。

第二层:提供i2c adapter的algorithm,用具体适配器的xxx_xferf()函数来填充i2c_algorithm的master_xfer函数指针,并把赋值后的i2c_algorithm再赋值给i2c_adapter 的algo指针。

Linux I2C子系统

Linux I2C子系统

Linux I2C子系统一、硬件特性1.1 概述I2C总线是由Philips公司开发的两线式串行总线,这两根线为时钟线(SCL)和双向数据线(SDA)。

由于I2C总线仅需要两根线,因此在电路板上占用的空间更少,带来的问题是带宽较窄。

I2C在标准模式下传输速率最高100Kb/s,在快速模式下最高可达400kb/s。

属于半双工。

在嵌入式系统中,I2C应用非常广泛,大多数微控制器中集成了I2C总线,一般用于和RTC,EEPROM,智能电池电路,传感器,LCD以及其他类似设备之间的通信。

1.2 I2C总线传输时序1.3 I2C总线的信号状态1、空闲状态:SDA和SCL都是高电平;2、开始条件(S):SCL为高电平时,SDA由高电平向低电平跳变,开始传输数据;3、结束条件(P):SCL为高电平时,SDA由低电平向高电平跳变,结束传输数据;4、数据有效:在SCL的高电平期间,SDA保持稳定,数据有效。

SDA的改变只能发生在SCL的低电平期间;5、ACK信号:数据传输的过程中,接收器件每接收一个字节数据要产生一个ACK信号,向发送器件发出特定的低电平脉冲,表示已经收到数据。

1.4 从设备地址I2C总线从设备使用7位地址,最后一个为读写控制位。

下图是eeprom的原理图,我们可以计算出它的地址为0x50。

1.5 I2C读写方式多字节写的时序多字节读的时序二、I2C子系统2.1 LinuxI2C子系统架构在内核中已经提供I2C子系统,所以在做I2C驱动之前,就必须要熟悉该子系统。

2.2 三大组成部分1、I2C核心(i2c-core)I2C核心提供了I2C总线驱动和设备驱动的注册、注销方法,I2C通信方法(algorithm)上层的、与具体适配器无关的代码以及探测设备、检测设备地址的上层代码等。

2、I2C总线驱动(I2Cadapter/Algo driver)I2C总线驱动是I2C适配器的软件实现,提供I2C适配器与从设备间完成数据通信的能力。

内核中I2C体系结构-最强学习笔记!

内核中I2C体系结构-最强学习笔记!

内核中I2C体系结构1.总体框架 (2)1.1 I2C体系结构总体框图: (2)1.2 组成部分: (2)1.3 重要文件: (3)1.4 重要函数接口与结构体 (3)结构体: (3)函数: (3)各结构体的作用与它们之间的关系 (3)1.5 i2c子系统的初始化函数的执行先后顺序 (4)2.I2C核心 (4)2.1 i2c_init()函数 (4)2.1.1 i2c总线的注册 (5)2.1.2 i2c驱动注册 (6)2.1.3 i2c_init()函数总结 (6)3.总线驱动 (7)3.1 I2C platform_device初始化---smdk2440_machine_init() (7)3.1.1 s3c_i2c_set_platdata (8)3.1.2 i2c_register_board_info (9)3.1.3 platform_add_devices (10)3.2 I2C platform_drive适配器驱动初始化---i2c_adap_s3c_init() (10)3.3 platform_bus总线 (11)3.4总线设备和总线驱动初始化总结: (11)3.5 probe函数——adapter_device 和client_device的注册 (12)总结 (16)4,设备驱动 (17)4.1 i2c_dev_init() (17)4.1.1 register_chardev (17)4.1.2 i2c_add_drive 注册i2c_driver (i2cdev_driver) (18)总结i2c_dev_init() : (20)5,i2c子系统通信方法 (20)5.1 open设备/dev/i2c-0 (20)5.2 write (21)5.3 i2cdev_ioctl (27)5.2.1 I2C_SLA VE / I2C_SLA VE_FORCE (27)5.2.2 I2C_RDWR (27)6,I2C子系统总结: (29)附录: (30)说明:内核版本: 2.6.32 I2C设备: E2PROM (at24c02)/************************************************\跳过此内容不影响整体框架学习\************************************************/(标号)上下文相互提到1.总体框架1.1 I2C体系结构总体框图:从i2c驱动架构图中可以看出,linux内核对i2c架构抽象了一个叫核心层core的中间件,它分离了设备驱动device driver和硬件控制的实现细节(如操作i2c的寄存器),core层不但为上面的设备驱动提供封装后的内核注册函数,而且还为小面的硬件事件提供注册接口(也就是i2c 总线注册接口),可以说core层起到了承上启下的作用。

linux系统i2c协议详解

linux系统i2c协议详解

linux系统i2c协议详解I2C总线概述I2C(两线接口)是一种串行通信协议,用于连接嵌入式系统中的集成电路(IC)。

它以其低成本、低功耗和高可靠性著称。

I2C总线需要两条双向信号线:串行数据线(SDA)和串行时钟线(SCL)。

这些信号线由一个主设备控制,可以与多个从设备通信。

I2C通信I2C通信由以下步骤组成:起始条件:主设备将SDA线下拉至低电平,同时保持SCL线为高电平。

设备地址:主设备发送7位或10位从设备地址,后跟一个读/写位。

数据传输:主设备和从设备交换数据。

停止条件:主设备将SDA线拉至高电平,同时保持SCL线为高电平。

主设备和从设备I2C总线上的设备分为两种:主设备和从设备。

主设备:发起通信并控制总线。

通常是主微控制器或处理器。

从设备:响应主设备请求并提供或接收数据。

可以是传感器、执行器或其他外围设备。

I2C寻址从设备通过唯一的7位或10位地址进行寻址。

地址的最高位表示是否可读/写,0表示写,1表示读。

I2C模式I2C协议支持以下模式:主写从读:主设备向从设备写入数据,然后从从设备读取数据。

主读从写:主设备从从设备读取数据,然后向从设备写入数据。

从读从写:两个从设备在主设备的监督下进行通信。

I2C传输速率I2C传输速率通常在10kbps到400kbps之间。

速率由主设备设置。

I2C错误检测I2C协议包含几个错误检测机制,例如校验和和超时。

这些机制有助于确保数据的可靠传输。

I2C应用I2C总线用于各种应用,包括:传感器和执行器接口EEPROM和闪存编程LED和LCD控制模拟-数字转换器(ADC)和数字-模拟转换器(DAC)接口电源管理时钟同步I2C优点I2C协议的优点包括:低成本:无需额外的硬件接口低功耗:仅使用两根信号线高可靠性:错误检测机制确保数据完整性容易使用:简单的协议易于实施广泛采用:支持广泛的设备和库I2C缺点I2C协议的缺点包括:数据速率低:与其他串行接口相比,数据速率较低主机限制:总线上只能有一个主设备总线无仲裁:在总线冲突的情况下,没有内置的仲裁机制有限的寻址范围:仅支持有限数量的设备地址I2C技术演进I2C协议正在不断发展,以满足新应用的需求。

学习笔记1-I2C架构篇

学习笔记1-I2C架构篇

学习笔记1: Linux设备驱动程序之I2C 基础架构篇I2C (Inter-Integrated Circuit)总线是一种由PHILIPS 公司开发的两线式串行总线,用于连接微控制器及其外围设备。

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

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

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

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

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

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

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

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

另外,I2C是一种多主机控制总线.它和USB总线不同,USB是基于master-slave机制,任何设备的通信必须由主机发起才可以.而 I2C 是基于multi master机制.一同总线上可允许多个master.I2C 总线在传送数据过程中共有三种类型信号,它们分别是:开始信号、结束信号和应答信号。

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

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

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

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

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

Linux 的I2C 驱动架构Linux 中I2C 总线的驱动分为两个部分,总线驱动(BUS)和设备驱动(DEVICE)。

嵌入式Linux 2.6内核下的I2C驱动架构及应用技术分析

嵌入式Linux 2.6内核下的I2C驱动架构及应用技术分析

嵌入式Linux 2.6内核下的I2C驱动架构及应用技术分析摘要:Linux系统下的设备-核心-总线三层的I2C驱动架构,是合理、高效开发I2C设备驱动程序的重要参考框架。

该文以结构化的视角深入分析了嵌入式Linux 系统下I2C驱动的层次结构、数据结构、驱动流程等,并着重分析了2种设备层驱动方法,对I2C驱动开发具有普遍的适用性。

关键词:嵌入式;Linux;I2C;驱动前言I2C总线是一种双线式总线,由PHILLIPS公司发明,由于其紧凑的尺寸及相对简单的时序,在嵌入式设备中获得了广泛的应用。

但是在Linux系统中,出于支持多设备、多任务的要求,I2C驱动架构变得非常复杂。

在此尝试以一种结构化的视角对嵌入式Linux下的I2C的架构及应用进行详细的阐述。

1 I2C驱动的分层结构1.1 驱动的层次构成Linux驱动按由调用层次可分为3层分别是:I2C设备层驱动、I2C核心层驱动、I2C总线(适配器)层驱动。

这3部分共同配合完成了适用性很强的I2C驱动框架。

I2C总线驱动和设备驱动通过内核驱动联系起来。

与驱动层次相对应的是I2C源码的文件层次结构。

1.2 I2C文件结构内核源码组织:I2C相关的源码位于linux kernel的i2c文件夹下:有i2c_core.c、i2c_dev.c及busses、chips、algorithm 等文件夹。

核心层功能由I2c_core.c实现。

设备层比较特殊,有2种等效的方法:①通过i2c_dev.c实现适配器文件接口(i2c_dev方法),即在应用层调用内核文件I2C_dev.C所创建的主设备节点(相当于适配器)接口函数如read、ioctl 等来访问设备。

这种方法相当于在应用层编写设备的驱动程序;②通过chips文件夹下c文件实现设备驱动文件接口(Dirver方法)。

即在chips下从设备对应的C文件中编写如XXX_command(xxx为自定义的从设备名称)等从功能函数完成设备的访问流程,并在应用层调用此功能函数。

Linux2.6内核i2c驱动架构

Linux2.6内核i2c驱动架构

三. i2c驱动架构分析 i2c驱动架构分析
2、硬件抽象层 、 i2c-core.h和i2c-core.c为其主体框架代码,提供了 为其主体框架代码, 和 为其主体框架代码 核心数据结构的定义、 适配器驱动和设备驱动的注 核心数据结构的定义、i2c适配器驱动和设备驱动的注 注销管理等API。其为硬件平台无关层,向下屏 册、注销管理等 。其为硬件平台无关层, 蔽了物理总线适配器的差异, 蔽了物理总线适配器的差异,定义了统一的访问策略 和接口;其向上提供了统一的接口,以便I2C设备驱 和接口;其向上提供了统一的接口,以便 设备驱 动通过总线适配器进行数据收发。 动通过总线适配器进行数据收发。 3、用户接口层 、 i2c设备驱动层为用户接口层,其为用户提供了通 设备驱动层为用户接口层, 设备驱动层为用户接口层 总线访问具体设备的接口。 过I2C总线访问具体设备的接口。 I2c设备驱动主要包 总线访问具体设备的接口 设备驱动主要包 含了数据结构i2c_driver和i2c_client,我们需要根据 含了数据结构 和 , 具体设备实现其中的成员函数。 具体设备实现其中的成员函数。
Linux2.6内核i2c驱动架构
目录
一.i2c简介 i2c简介 二.驱动相关知识介绍 三.i2c驱动架构分析 i2c驱动架构分析
一. i2c简介 i2c简介
I2C 协议
I2C协议是有PHILIPS公司在1992年最先提出, PHILIPS公司专利。 I2C协议是有PHILIPS公司在1992年最先提出,乃PHILIPS公司专利。只要购 协议是有PHILIPS公司在1992年最先提出 公司专利 Philips的I2C元件同时传递了一个在Philips的 元件同时传递了一个在Philips 专利下, 买Philips的I2C元件同时传递了一个在Philips的I2C 专利下,在I2C 系统使用 元件使系统符合由Philips定义的I2C规范的许可证。任何使用I2C Philips定义的I2C规范的许可证 I2C的元件都必须 元件使系统符合由Philips定义的I2C规范的许可证。任何使用I2C的元件都必须 得到PHILIPS公司的授权。 PHILIPS公司的授权 得到PHILIPS公司的授权。 I2C总线的特征 I2C总线的特征 只要求两条总线线路一条串行数据线(SDA)一条串行时钟线(SCL)。 1.只要求两条总线线路一条串行数据线(SDA)一条串行时钟线(SCL)。 同时SDL SCL都是双向线路 分别通过上拉电阻连接到正的电源电压。 SDL和 都是双向线路, 同时SDL和SCL都是双向线路,分别通过上拉电阻连接到正的电源电压。 .每个连接到总线的器件都可以通过唯一的地址和一直存在的简单的主 2 .每个连接到总线的器件都可以通过唯一的地址和一直存在的简单的主 从机关系软件设定地址;主机可以作为主机发送器或主机接收器。 机/从机关系软件设定地址;主机可以作为主机发送器或主机接收器。 3.它是一个真正的多主机总线 它是一个真正的多主机总线, 3.它是一个真正的多主机总线,如果两个或更多主机同时初始化数据传输 可以通过冲突检测和仲裁防止数据被破坏。 可以通过冲突检测和仲裁防止数据被破坏。 串行的8 位双向数据传输位速率在标准模式下可达100kbit/s 100kbit/s。 4. 串行的8 位双向数据传输位速率在标准模式下可达100kbit/s。快速模 式下可达400kbit/s 高速模式下可达3.4Mbit/s 400kbit/s。 3.4Mbit/s。 式下可达400kbit/s。高速模式下可达3.4Mbit/s。 5.片上的滤波器可以滤去总线数据线上的毛刺波, 5.片上的滤波器可以滤去总线数据线上的毛刺波,保证数据完整 片上的滤波器可以滤去总线数据线上的毛刺波

Linux设备驱动之I2C架构分析

Linux设备驱动之I2C架构分析

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

Linux2.6.25平台下的I2C驱动架构分析

Linux2.6.25平台下的I2C驱动架构分析

Linux2.6.25平台下的I2C驱动架构分析【摘要】本文以PowerPC+Linux 2.6.25 平台为例,详细分析了I2C总线的驱动架构。

首先介绍了I2C的总体架构,从用户的角度将其分为三个层面,不同的开发者只需要关注相应的层面即可。

然后分析了主要数据结构及其之间的相互关系,接着分析了不同层的具体实现,最后以一款EEPEOM为例讲述了如何在用户空间访问I2C驱动。

对于ARM + Linux平台,只有平台依赖层即总线适配器驱动有差异。

【关键字】PowerPC, I2C, i2c-core, adapter , i2c_algorithm, RTC, EEPROM目录1 I2C概述 32 I2C总体架构 32.1 硬件抽象层 32.2 平台依赖层 32.3 用户接口层 33 主要的数据结构 43.1 Adapter 43.2 I2c_algorithm 53.3 i2c_driver 53.4 Client 64 平台依赖层-总线适配器驱动74.1 platform device 74.2 platform driver 94.3 Adapter及algorithm 125 硬件抽象层-I2C core 135.1 总线初始化135.2 Adapter注册155.3 驱动注册165.4 数据传输176 用户接口层-I2C设备驱动186.1 统一的设备模型186.1.1 关键数据结构186.1.2 初始化196.1.3 Open及release 216.1.4 数据收发226.2 特定的设备驱动266.2.1 关键数据结构266.2.2 初始化276.2.3 数据收发297 驱动访问示例297.1.1 写操作297.1.2 读操作318 参考鸣谢331 I2C概述I2C只有两条线,一条串行数据线:SDA,一条是时钟线SCL。

I2C是一种多主机控制总线,同一总线上可允许多个master,即总线上的设备都有主动发起数据传输的可能,依靠线与逻辑来实现无损仲裁。

《Linux4.0设备驱动开发详解》笔记--第十五章:LinuxI2C核心、总线与设备驱动

《Linux4.0设备驱动开发详解》笔记--第十五章:LinuxI2C核心、总线与设备驱动

《Linux4.0设备驱动开发详解》笔记--第⼗五章:LinuxI2C核⼼、总线与设备驱动15.1 Linux I2C体系结构I2C核⼼I2C核⼼提供了I2C总线驱动和设备驱动的注册、注销的⽅法,I2C通信(Algorithm)⽅法上层的与具体适配器⽆关代码以及探测设备、检测设备地址的上层代码等I2C总线驱动是对I2C体系结构中适配器端的实现,适配器可由CPU控制,甚⾄可以直接集成在CPU内部总线驱动包含I2C适配器数据结构i2c_adapter、I2C适配器的Algorithm数据结构i2c_algorithm和控制I2C适配器产⽣通信信号的函数I2C设备驱动它是对I2C硬件体系结构中设备端的实现,设备⼀般挂接在受CPU控制的I2C适配器上,通过I2C适配器与CPU通信I2C驱动主要包含数据结构i2c_driver和i2c_client,需要根据的设备实现其中的成员函数所有的I2C设备都在sysfs⽂件系统中显⽰,存在/sys/bus/i2c⽬录下,以适配器地址和芯⽚地址的形式列出/drivers/i2c/下的⽂件介绍i2c-core.c:实现了I2C核⼼的功能以及/proc/bus/i2c*接⼝i2c-dev.c:实现I2C适配器设备⽂件的功能,每⼀个适配器被分配⼀个设备设配器的主设备号位89,次设备号位:0-255i2c_dev.c并不是根据具体的设备⽽设计的,只是提供了同⽤的read()、write()和ioctl()等接⼝,应⽤层可以通过这些接⼝访问挂接在适配器上的I2C设备的存储空间或寄存器,并控制I2C设备的⼯作⽅式busses⽂件夹:包含⼀些I2C主机控制器驱动,如i2c_omap.c、i2c_s3c2440c.等algos⽂件夹:实现了⼀些I2C总线适配器的通信⽅法i2c_adapter、i2c_algorithm、i2c_driver和i2c_client数据结构的作⽤及其之间的关系i2c_adapter与i2c_algorithmi2c_adapter对应于物理上的⼀个适配器,⽽i2c_algorithm对应于⼀套通信⽅法⼀个i2c_adapter需要i2c_algorithm提供的通信函数来控制适配器产⽣特定的访问周期i2c_algorithm中的关键函数master_xfer()⽤于产⽣I2C访问周期需要的信号,以i2c_msg(即I2C消息)为单位i2c_driver与i2c_clienti2c_driver对应于⼀套驱动⽅法,struct i2c_device_id形式的id_table是该驱动所⽀持的I2C设备的ID表i2c_client对应于真实的物理设备,每个I2C设备都需⼀个i2c_client来描述⼀个i2c_driver⽀持多个同类型的i2c_clienti2c_client的信息通常在BSP的板⽂件中通过i2c_board_info填充,包括设备的ID号、地址、中断号等信息在I2C总线驱动i2c_bus_type的match()函数i2c_device_match()中,会调⽤i2c_match_id()函数匹配在板⽂件中定义的ID和i2c_driver所⽀持的ID表i2c_adapter与i2c_client其关系与I2C设备体系中适配器与设备的关系⼀致,即i2c_client依附于i2c_driver⼀个i2c_driver可以被多个i2c_client依附,i2c_driver中包含有依附它的i2c_client的链表15.2 I2C核⼼增加、删除i2c_adapterint i2c_add_adapter(struct i2c_adapter *adap);int i2c_del_adapter(struct i2c_adapter *adap);增加、删除i2c_driverint i2c_register_driver(struct module *owner, struct i2c_driver *driver);int i2c_del_driver(struct i2c_driver *driver);inline int i2c_add_driver(struct i2c_driver *driver);i2c_client依附/脱离int i2c_attach_client(struct i2c_client *client);int i2c_detach_client(struct i2c_client *client);当⼀个具体的client被侦测到并被关联的时候,设备和sysfs⽂件将被注册。

Linux I2C总线体系结构及I2C设备的访问控制研究

Linux I2C总线体系结构及I2C设备的访问控制研究
18 2
福 建 电

21 0 1年第 3 期
Ln xIC总线体 系结构及 IC设 备 的访 问控 制研 究 iu 2 2
莫 丽娟 .王 静 文
(黄 河水利 职 业技 术 学院 河 南 开封 4 50 7 0 3)
【 摘 要 】 RM iu 用 的越 来越 广 泛,iu :A Ln x应 Ln x驱动 程序 的设计 也成 了工程 师们 开发硬 件设 备 必须
Ln x的 IC体 系结 构 分 为 3个 部 分 : C核 心 、 iu 2 I 2 内核 中 ie 2. h文件 对 ic d vri _ l n 、 c aa 2 _ f e、 e ci ti — d p i 2 e 2 t 和 ic l r m这 四个数 据结构进 行 了定义 . 析 e r 2 a oi g t h 分 IC总线 驱动 、 C设备 驱动 。 2 I 2 IC核 心对 应 的源 码 在 Ln X2 2 iU . 6内核 d vr目录 这 四个 数据 结构 复杂 的关 系是理解 IC体 系结 构 的关 i re 2 下 的 ic c . 2 — oe 它提供 了 IC总线 和 IC设备 驱动 的 键 所在 rc 2 2
C U内部 P
e ( ) c d vr ic ci n 。 2 i _ f e 与 2 l t 2 i ic di r 2 r e 对应 一套驱 动方法 .是 纯粹辅 助作 用 的 v 数 据 结构 。 不对 应 任何 的物 理实 体 。ic ci t 应 于 2 l n 对 e
_
真 实 的物 理设 备 . 每个 IC设 备 都需 要 一 个 icci t 2 2_ l n e
来 描述 。
( ica a t 3) d pe与 ic. in 2 2 l t c e 。‘

Linux I2C核心、总线与设备驱动

Linux I2C核心、总线与设备驱动
在Linux内核源代码中的drivers目录下包含一个i2c目录,而在i2c目录下又包含如下文件和文件夹:
• i2c-core.c
这个文件实现了I2C核心的功能ቤተ መጻሕፍቲ ባይዱ及/proc/bus/i2c*接口。
• i2c-dev.c
实现了I2C适配器设备文件的功能,每一个I2C适配器都被分配一个设备。通过适配器访问设备时的主设备号都为89,次设备号为0~255。应用程序通过“i2c-%d” (i2c-0, i2c-1, ..., i2c-10, ...)文件名并使用文件操作接口open()、write()、read()、ioctl()和close()等来访问这个设备。
5 struct i2c_driver *driver; /*依附的i2c_driver */
6 int usage_count; /*访问计数*/
7 struct device dev; /*设备结构体*/
8 struct list_head list; /*链表头*/
9 char name[I2C_NAME_SIZE]; /*设备名称*/
代码清单15.1 i2c_adapter结构体
1 struct i2c_adapter {
2 struct module *owner;/*所属模块*/
3 unsigned int id; /*algorithm的类型,定义于i2c-id.h,以I2C_ALGO_开始*/
4 unsigned int class;
9 int (*algo_control)(struct i2c_adapter *, unsigned int, unsigned long); /*类似ioctl*/
10 u32 (*functionality) (struct i2c_adapter *);/*返回适配器支持的功能*/

LinuxI2C驱动整理(以RK3399Pro+Kernel4.4为例)

LinuxI2C驱动整理(以RK3399Pro+Kernel4.4为例)

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驱动。

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

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

实例解析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适配器的设备文件。

Linux内核i2c读写操作驱动架构

Linux内核i2c读写操作驱动架构
};
成员变量解说: 1) addr, flags 分别表示从设备的地址和访问操作标志,最初源头为由开发人员构造和初始
化的 i2c_board_info{}结构 2) adapter 在从设备与适配器匹配后,在后端的 i2c_new_device()中被初始化
struct i2c_msg { __u16 addr; __u16 flags; __u16 len; __u8 *buf;
struct i2c_algorithm { int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs, int num); u32 (*functionality) (struct i2c_adapter *);
};
成员变量解说: 1) master_xfer 启动 i2c 适配器,分流读写操作的总接口 2) functionality 表示当前 i2c 适配器,支持和实现的操作功能
struct i2c_board_info { unsigned short addr; unsigned short flags; ... ...;
};
成员变量解说: 1) addr 将初始化 i2c_client.addr 2) flags 将初始化 i2c_client.flags
struct i2c_client { unsigned short addr; unsigned short flags; struct i2c_adapter *adapter; ... ...;
具体适配器驱动读写
#define I2C_M_TEN
0x0010
#define I2C_M_RD
0x0001

I2C子系统分析

I2C子系统分析

I2C子系统分析与其他子系统类似,为了方便i2c设备驱动的开发,避免因为I2C控制器的硬件差异而导致设备驱动的差异性,linux对I2C总线进行了封装。

为I2C设备、控制器、及驱动提供了统一的注册平台,同时为数据传输提供了统一的接口。

I2C总线作为一类抽象的总线模型,具体的通信由总线控制器i2c_adapter所提供的总线驱动算法i2c_algorithm来完成(对应i2c-s3c2410.c文件)。

与用户空间的交互由设备驱动完成,由i2c-dev结构维护。

i2c_driver结构维护了一类设备的驱动方法,i2c_client结构维护i2c子系统中独立的i2c设备(对应i2c-dev.c文件)。

另外,设备只完成与I2C-core的数据交互,不能与适配器直接通信,真正数据的传输由i2c-core调用相应的i2c控制器完成。

I2C驱动架构如下所示:一、 关于设备驱动:以i2c-dev.c设备驱动的加载为例,当设备加载时,由module_init(i2c_dev_init);入口,对应的流程如下:对应程序如下:static int __init i2c_dev_init(void){int res;printk(KERN_INFO "i2c /dev entries driver\n");//以字符型设备驱动的形式注册设备res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);if (res)goto out;//为设备创建一个类,便于自动创建设备节点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;}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;}首先来看看描述设备驱动的一个重要数据结构:struct i2c_driver {unsigned int class;//所属的I2C设备类/* Notifies the driver that a new bus has appeared or is about to be* removed. You should avoid using this if you can, it will probably* be removed in a near future.*/int (*attach_adapter)(struct i2c_adapter *);//总线加入时的回调函数(legacy drivers使用)int (*detach_adapter)(struct i2c_adapter *);//总线移除时的回调函数/* Standard driver model interfaces */int (*probe)(struct i2c_client *, const struct i2c_device_id *);int (*remove)(struct i2c_client *);/* driver model interfaces that don't relate to enumeration */void (*shutdown)(struct i2c_client *);int (*suspend)(struct i2c_client *, pm_message_t mesg);int (*resume)(struct i2c_client *);/* a ioctl like command that can be used to perform specific functions* with the device.*/int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);struct device_driver driver; //设备驱动模型中的driver模型const struct i2c_device_id *id_table;//该驱动所支持的I2C设备的ID号/* Device detection callback for automatic device creation */int (*detect)(struct i2c_client *, int kind, struct i2c_board_info *);const struct i2c_client_address_data *address_data;struct list_head clients;//检查到的符合该驱动的I2C设备列表};完成了字符设备的注册后,将设备驱动通过i2c_add_driver注册进i2c-core。

LinuxI2C总线详解

LinuxI2C总线详解

Linux I2C 总线详解㈠ OverviewLinux的I2C体系结构分为3个组成部分:·I2C核心:I2C核心提供了I2C总线驱动和设备驱动的注册、注销方法,I2C通信方法(即“algorithm”)上层的、与具体适配器无关的代码以及探测设备、检测设备地址的上层代码等。

这部分是与平台无关的。

·I2C总线驱动:I2C总线驱动是对I2C硬件体系结构中适配器端的实现。

I2C总线驱动主要包含了I2C适配器数据结构i2c_adapter、I2C适配器的algorithm数据结构i2c_algorithm和控制I2C适配器产生通信信号的函数。

经由I2C总线驱动的代码,我们可以控制I2C适配器以主控方式产生开始位、停止位、读写周期,以及以从设备方式被读写、产生ACK等。

不同的CPU平台对应着不同的I2C 总线驱动。

总线驱动的职责,是为系统中每个I2C总线增加相应的读写方法。

但是总线驱动本身并不会进行任何的通讯,它只是存在在那里,等待设备驱动调用其函数。

这部分在MTK 6516中是由MTK已经帮我们实现了的,不需要我们更改。

· I2C设备驱动:I2C设备驱动是对I2C硬件体系结构中设备端的实现。

设备一般挂接在受CPU控制的I2C适配器上,通过I2C适配器与CPU交换数据。

I2C设备驱动主要包含了数据结构i2c_driver和i2c_client,我们需要根据具体设备实现其中的成员函数。

在Linux内核源代码中的drivers 目录下的i2c_dev.c文件,实现了I2C适配器设备文件的功能,应用程序通过“i2c-%d”文件名并使用文件操作接口open()、write()、read()、ioctl()和close()等来访问这个设备。

应用层可以借用这些接口访问挂接在适配器上的I2C设备的存储空间或寄存器并控制I2C设备的工作方式。

设备驱动则是与挂在I2C总线上的具体的设备通讯的驱动。

LinuxI2C驱动框架

LinuxI2C驱动框架

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子系统详解

linux的I2C子系统详解

Linux中I2C驱动子系统详解Author :AstonMail : astonqa@写在前面首先,本教程不来自于权威书籍或文献,完全为本人个人理解的描述。

限于水平,其中若有错误及不当,敬请指正、不胜感激。

其次,本教程撰写过程中虽参考了网络上各种资料,但不同于网上大部分资料的粗略介绍或只关注一个点。

相反,本教程从全局出发,全面描述了I2C总线及设备在linux系统中的实现方法,适合于希望对linux中I2C子系统进行详细、彻底学习的人士共享与阅读。

第一部分:框架描述第二部分:I2C总线与实际硬件介绍第三部分:linux中I2C子系统与主要数据结构分析一个I2C设备要在linux下使用,必须包含两个驱动:I2C总线驱动和I2C设备驱动。

涉及到的主要数据结构有i2c_adapter, i2c_client, i2c_driver,i2c_algorithm(均包含在include/linux/i2c.h中),这几个数据结构是I2C驱动中主要的数据抽象,搞清楚这几个数据结构的意义是理解I2C驱动架构的前提。

i2c_adapter用来虚拟I2C适配器,所谓的适配器即用来匹配其两端连接的设备的器件。

在这里,I2C适配器是一个虚拟的器件,该器件用来匹配I2C总线上连接的设备和I2C主控制器。

因此可以认为:i2c_adapter对应的物理实体就是SoC内部的I2C控制器。

i2c_algorithm是一个纯软件层面的数据抽象,没有对应的物理实体。

它用来描述一个i2c_adapter(实质是一个I2C控制器)的通信时序,这其实很好理解。

大家都知道,I2C总线上的通信双方要完成通信需要按照一定的时序吧,如下图即是S3C2440中I2C控制器的主发送时序(即2440作为I2C主设备向外部连接的从设备发送信息)。

i2c_algorithm中封装的方法旨在描述该种时序,I2C总线驱动中最终需要靠这里封装的方法来操作I2C控制器硬件发送通信时序。

Linux内核I2C子系统初始化驱动架构

Linux内核I2C子系统初始化驱动架构

device_driver{ }.name 在 驱 动中指定
i2c_driver{} .driver *id_table *probe ... ...
tv168_probe()
device_driver{} *p *bus *name ... ...
driver_private{} .knode_bus ... ...
I2C 子系统初始化驱动架构
目标:
分析整理 i2c 子系统初始化驱动架构;
本文要点:
1、i2c 重要数据结构及关系图; 2、i2c 子系统初始化驱动架构;
硬件框图:
2012 年 12 月 22 日
scl0 adapter i2c-0
sda0
scl1 adapter i2c-1
sda1
scl2 adapter i2c-2
i2c_register_board_info(busnum, ...)
复制到
i2c_board _info{}
i2c_devinfo{}
.busnum
.list
(等待与适配器匹配)
链入
__i2c_board_list
说明:
i2c_board_info{}
这 里 有 两 个 i2c_board_info{} 结 构 , 一 个 是 前 面 构 造 的 i2c_board_info{} , 另 一 个 在
*archdata
... ...
dev_archdata{} 开发人员自己使用
开发人员自己使用
i2c_board_info{}
i2c_devinfo{} int busnum .board_info struct list_head list
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实例解析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;__u32 nmsgs;};struct i2c_msg {_ _u16 addr;_ _u16 flags;_ _u16 len;_ _u8 *buf;};针对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_algorithms3c24xx_i2c_algorithm = {.master_xfer = s3c24xx_i2c_xfer,.functionality = s3c24xx_i2c_func,};另外一方面需要确定为了实现对AT24C02 e2prom的操作,需要确定AT24C02的地址及读写访问时序。

● AT24C02地址的确定原理图上将A2、A1、A0都接地了,所以地址是0x50。

● AT24C02任意地址字节写的时序可见此时序符合前面提到的“单开始信号时序”● AT24C02任意地址字节读的时序可见此时序符合前面提到的“多开始信号时序”下面开始具体代码的分析(代码在2.6.22内核上测试通过):#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 0x0707struct i2c_msg {unsigned short addr;unsigned short flags;#define I2C_M_TEN 0x0010#define I2C_M_RD 0x0001unsigned short len;unsigned char *buf;};struct i2c_rdwr_ioctl_data{struct i2c_msg *msgs;int nmsgs;};int main(){int fd,ret;struct i2c_rdwr_ioctl_datae2prom_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;e2prom_data.msgs=(structi2c_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);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=(unsig ned char*)malloc(2);(e2prom_data.msgs[0]).buf[0]=0x1 0;// e2prom 写入目标的地址(e2prom_data.msgs[0]).buf[1]=0x5 8;//the data to writeret=ioctl(fd,I2C_RDWR,(unsignedlong)&e2prom_data);if(ret<0){perror("ioctl error1");}sleep(1);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]=0x1 0;//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=(unsig ned char*)malloc(1);//存放返回值的地址。

(e2prom_data.msgs[1]).buf[0]=0;/ /初始化读缓冲ret=ioctl(fd,I2C_RDWR,(unsignedlong)&e2prom_data);if(ret<0){perror("ioctl error2");}printf("buff[0]=%x\n",(e2prom_da ta.msgs[1]).buf[0]);close(fd);return 0;}以上讲述了一种比较常用的利用i2c-dev.c操作i2c设备的方法,这种方法可以说是在应用层完成了对具体i2c设备的驱动工作。

相关文档
最新文档