linux指导：LinuxI2C驱动分析

会计考友

最近在看Linux 2.6.21内核的I2C驱动，也在网上查了一下资料，有错也有对，有些心得，记录下来吧。里面认识或许多有不当之处，还恳请指正。
   
    1. I2C 协议
! P- J  L, ^1 g6 z8 C, V( U7 ^2 C   
    1.1  I2C总线工作原理
  P! {: w/ v, k   
1 A  X! l0 Y4 X8 B    I2C总线是由数据线SDA和时钟SCL构成的串行总线，各种被控制器件均并联在这条总线上，每个器件都有一个唯一的地址识别，可以作为总线上的一个发送器件或接收器件（具体由器件的功能决定）
! E* p' U, C1 [/ x: F   
    1.2  I2C总线的几种信号状态
! P) ^0 L' q1 z. G! s) ^7 h   
" k6 p1 P) }4 z2 }$ x3 l/ t    1.  空闲状态：SDA和SCL都为高电平。
9 c1 v9 q1 e, R1 K; z+ Z  y2 r   
    2.  开始条件（S）：SCL为高电平时，SDA由高电平向低电平跳变，开始传送数据。
# T! t6 |2 Q, z   
  F# v7 l, H$ \: w( N% j" x; M    3.  结束条件（P）：SCL为低电平时，SDA由低电平向高电平跳变，结束传送数据。
   
  x8 [2 d" e( r! u/ }) ^) l    4.  数据有效：在SCL的高电平期间， SDA保持稳定，数据有效。SDA的改变只能发生在SCL的底电平期间。
   
    5.  ACK信号： 数据传输的过程中，接收器件每接收一个字节数据要产生一个ACK信号，向发送器件发出特定的低电平脉冲，表示已经收到数据。
   
. h- S: a  b/ `    1.3  I2C总线基本操作
   
    I2C总线必须由主器件（通常为微控制器）控制，主器件产生串行时钟（SCL），同时控制总线的传输方向，并产生开始和停止条件。
" `$ ?3 ^7 Q0 q# R   
    数据传输中，首先主器件产生开始条件，随后是器件的控制字节（前七位是从器件的地址，最后一位为读写位 ）。接下来是读写操作的数据，以及 ACK响应信号。数据传输结束时，主器件产生停止条件
   
9 q, _) Z3 q2 ~0 _% i! m    2. Linux I2C 结构分析
   
    2.1 层次分析
* S. J# X0 j- `' h   
( L( p' W4 [/ s# @7 R+ ~    1. I2C Core
   
    I2C Core用于维护Linux的I2C核心部分，其中维护了两个静态的List,分别记录系统中的I2C driver结构和I2C adapter结构。
9 J3 w& a' c( O5 M! q( S" E   
3 ?/ h4 I4 M5 Y& ^    static LIST_HEAD（adapters）；
   
4 T; Y; v# i0 C& N9 D5 V    static LIST_HEAD（drivers）；
   
- G' R0 b( \1 X8 {8 e) a( ?    I2C core提供接口函数，允许一个I2C adatper,I2C driver和I2C client初始化时在I2C core中进行注册，以及退出时进行注销。具体可以参见i2c_core.c代码。
   
    同时还提供了I2C总线读写访问的一般接口（具体的实现在与I2C控制器相关的I2C adapter中实现），主要应用在I2C设备驱动中。
   
    常用的主要是
   
    i2c_master_send（）
: C* V! X3 g4 ?) a( a1 {5 `  e   
6 [% i) x# v5 D) X& U8 V5 s  R, `    i2c_master_recv（）
( t; z1 Q3 j4 w0 Z3 ]   
) n: V- Q( u* n& t    i2c_transfer（）
. L, T  l9 S" K8 l; G' `2 ~   
) b3 ]0 H4 F( |0 V: o0 V    2. I2C bus driver

会计考友

总线驱动的职责，是为系统中每个I2C总线增加相应的读写方法。但是总线驱动本身并不会进行任何的通讯，它只是存在在那里，等待设备驱动调用其函数。
   
    在系统开机时，首先装载的是I2C总线驱动。一个总线驱动用于支持一条特定的I2C总线的读写。一个总线驱动通常需要两个模块，一个struct i2c_adapter和一个struct i2c_algorithm来描述：
   
    在 buses目录下的i2c-pxa.c中实现了PXA的I2C总线适配器，I2C adapter 构造一个对I2C core层接口的数据结构，并通过接口函数向I2C core注册一个控制器。I2C adapter主要实现对I2C总线访问的算法，iic_xfer（） 函数就是I2C adapter底层对I2C总线读写方法的实现。同时I2C adpter 中还实现了对I2C控制器中断的处理函数。
4 Q. ^: ?" ]# q- y' O0 V2 c   
8 s# X9 t) I& T# q" w    1） i2c-pxa.c定义了i2c_algorithm,并且实现了master的发送函数i2c_pxa_xfer（），以及设备查询总线的模式的函数i2c_pxa_functionality（）
+ U2 ^5 e( q# c7 x   
    static const struct i2c_algorithm i2c_pxa_algorithm = {
" a. x, t/ X8 z- R' \- ^4 i5 p   
    .master_xfer = i2c_pxa_xfer,
7 ?" q& a# y7 R( d' f5 i   
    .functionality = i2c_pxa_functionality,
& n1 d6 H" d+ F$ E7 J   
    };
   
    2） i2c-pxa.c中，实现了i2c_adapter,主要是在定义pxa-i2c时进行初始化，并且i2c_pxa_probe（）中进行填充parent指针，并且调用
   
& S% K0 R5 R( |5 {9 X& g) R    ret = i2c_add_adapter（&i2c->adap）；
   
    进行添加。
4 ~5 j3 g) L) o3 j, n6 ?/ G   
    static struct pxa_i2c i2c_pxa = {
   
# M; h* F2 \! V  ~    .lock = SPIN_LOCK_UNLOCKED,
+ j' I1 G8 m* k0 Z' c" A   
    .adap = {
   
    .owner  = THIS_MODULE,
: s4 |+ f0 F1 a: w0 |- b1 Z   
    .algo  = &i2c_pxa_algorithm,
+ e0 m1 |: }" Y- Y! X, j! u, `7 g   
    .name  = "pxa2xx-i2c.0",
" J7 K$ O+ }! l. f* h& K8 ]   
3 G: A  l6 a+ h    .retries = 5,
   
* ^5 c, N4 t: o7 n' ?$ w    },
   
+ ~% e/ G2 a) k+ \0 E2 e4 _' H+ S    };
. O; }# B% x; J% b; `  O! b( Y   
    总的来说，在i2c-pxa中，使用platform驱动模型，完成了i2c的总线两种模块struct i2c_adapter和struct i2c_algorithm
/ ]( ?: ~; l* J' H+ u& P   
    3. I2C device driver
4 @% G# ]$ h7 W1 [   
8 p  S+ q0 Q5 D    I2C只有总线驱动是不够的，必须有设备才能工作。这就是I2C device driver的必要性。I2C的device是有两个模块来描述的，struct i2c_driver和struct i2c_client.
   
    在介绍chips目录下的device driver前有必要介绍一下i2c-dev.c文件。
& K9 G. x; z' @8 \2 @   
5 b2 I- R/ p4 g/ D! `- |( Q1 W0 u6 j    i2c-dev.c中提供了一个通用的I2C设备的驱动程序，实现了字符类型设备的访问接口，对设备的具体访问是通过I2C adapter来实现的。构造一个对I2C core层接口的数据结构，通过接口函数向 I2C Core注册一个I2C设备驱动。同时构造一个对用户层接口的数据结构，并通过接口函数向内核注册为一个主设备号为89的字符类型设备。
1 a, ?$ O* Y. C" g  J   
    static struct i2c_driver i2cdev_driver = {
   
/ N: ^! ^2 c+ X6 i    .driver = {
   
    .name = "dev_driver",
   
. }  b9 T# o5 Q4 X' r* U    },
2 Y% l, U3 {% Q/ C; c9 v   
3 U  G/ b+ Q/ Q! i- {- O    .id  = I2C_DRIVERID_I2CDEV,
   
    .attach_adapter = i2cdev_attach_adapter,
/ @! O$ r" J9 ]* [1 y3 M   
& }; N: V. J: v9 F4 V2 J    .detach_adapter = i2cdev_detach_adapter,
. S; @' ~0 Q9 p9 _% b   
* F9 D! Q9 y. K# x( [    .detach_client = i2cdev_detach_client,
   
    };
( K( R& c2 `9 ?   
) `% X! r% w8 W5 G/ j    struct i2c_dev {
$ i* r. Z* ]) H! d6 F) k8 z2 e   
/ `) |# ^1 n8 ?+ \) W9 l' P    struct list_head list;
   
2 j0 l6 [0 v+ G    struct i2c_adapter *adap;
   
5 t* t+ ~0 [3 @: Q    struct device *dev;
   
5 i  o( ]1 m. }. J' |    };

会计考友

该文件提供了用户层对I2C设备的访问，包括open,read,write,ioctl,release等常规文件操作，我们可以通过open函数打开 I2C的设备文件，通过ioctl函数设定要访问从设备的地址，然后就可以通过 read和write函数完成对I2C设备的读写操作。
0 i" k% D5 c4 i; c7 i7 N   
" }) d/ b7 O  w8 f    static const struct file_operations i2cdev_fops = {
   
    .owner  = THIS_MODULE,
   
6 a. _/ A% f8 P' z9 V2 F    .llseek  = no_llseek,
3 c4 X* t9 v& ?0 l, d4 [7 |   
" X5 L( V' A' e9 k$ T0 J    .read  = i2cdev_read,
3 V$ Y/ Q) X7 E   
6 c8 l. S/ n9 B" q6 l2 [    .write  = i2cdev_write,
. m5 \$ i  ]9 L: [   
    .ioctl  = i2cdev_ioctl,
   
    .open  = i2cdev_open,
   
) E" H! t' d: r+ N/ i2 x2 u    .release = i2cdev_release,
3 Q/ `8 A2 r1 H5 `   
    };
  o3 k6 d/ b/ v8 h3 ~: `$ I+ O   
    注：通过I2C driver提供的通用方法可以访问任何一个I2C的设备，但是其中实现的read,write及ioctl等功能完全是基于一般设备的实现，所有的操作数据都是基于字节流，没有明确的格式和意义。为了更方便和有效地使用I2C设备，我们可以为一个具体的I2C设备开发特定的I2C设备驱动程序，在驱动中完成对特定的数据格式的解释以及实现一些专用的功能。
  L6 [& m, {2 Z1 n8 M: [   
    在chips目录下包含着各种device 的driver,完成各种从设备的注册。作为一般的I2C设备，使用i2c-dev.c里的操作足够完成操作了。
6 b- I% F5 Q1 ~; A) D   
    当然如果不能完成，则需要独立完成该驱动，这就是chips目录下的代码。因为i2c-dev.c已经实现了I2C设备的文件操作接口，所以只要实现struct i2c_driver就可以了。对于某些特殊的操作，可以使用command接口进行控制。 当然，对于i2接口的fm芯片，则将struct i2c_driver放在i2c的chips目录下，而将另外fm操作相关的代码放在了/media/radio目录下了。在这个目录下需要完成读写接口的完成，这个大部分使用V4L2架构。
. W- O# G1 q8 C) m5 \   
    i2c总线使用
( o3 ~4 q$ l, }5 H) F9 [   
( U3 C8 }: {1 V5 q( n/ p    了解了i2c总线的主要结构成员及适配器、设备驱动的注册后，现在我们从上而下的来研究一下i2c总线的使用（仍然以i2c-dev.c为例）：
   
    1、这是面向用户的虚拟字符设备所提供的所有i2c总线操作接口函数：
   
    static const struct file_operations i2cdev_fops = {
   
1 ]9 E/ c7 ^& ~' L, y    .owner          = THIS_MODULE,
   
2 f* g# N8 C! [0 _    .llseek         = no_llseek,
   
    .read           = i2cdev_read,
   
6 T( L# D) r) s0 T- q    .write          = i2cdev_write,
$ Y& e6 ~* v/ u- p* ^+ N# g) F6 N   
    .ioctl          = i2cdev_ioctl,
   
) c0 s7 R; a7 Y- q/ N    .open           = i2cdev_open,
   
    .release        = i2cdev_release,
   
: t, n, `7 B: J5 c( a" ~9 e; Y    };
   
    1）drivers/i2c/i2c-dev.c
) M  Z7 I8 S- e* {+ l   
    static int i2cdev_open（struct inode *inode, struct file *file）
   
0 J/ C! @0 G6 \* y) {7 Q- w6 j    {

会计考友

unsigned int minor = iminor（inode）；
, x8 u* @# y# P; f' L: I   
9 L& |3 v6 {% Y4 K    struct i2c_client *client;
5 [$ t' @: i. ~  \5 h8 d! D0 Y+ V   
    struct i2c_adapter *adap;
% K" p5 c8 s' D  c) ~) s   
7 {, M7 S: u! S    struct i2c_dev *i2c_dev;
1 X$ o3 A% X( j( Z# W+ E8 a2 f* u   
    i2c_dev = i2c_dev_get_by_minor（minor）；    //通过设备文件的从设备号查找对应的i2c_dev
   
    if （！i2c_dev）
   
    return -ENODEV;
" f3 I+ R. j# X4 s$ i6 A   
& u7 E. i$ v5 b6 i. G" M1 \  i    adap = i2c_get_adapter（i2c_dev->adap->nr）；    //查找对于的adap
   
    if （！adap）
   
    return -ENODEV;
   
* A* o1 I4 u% _; N6 a: m- ^% `8 E7 p4 |    client = kzalloc（sizeof（*client）， GFP_KERNEL）；    //i2c从设备描述结构体
8 S  F5 ], K2 Y0 Y5 M1 z   
7 m) {6 h# U; \" m) q6 @: s    if （！client） {
, ^% Z/ b) a) @* i  Q1 q   
, q" H# H2 H# a/ c7 V" h; x    i2c_put_adapter（adap）；
   
    return -ENOMEM;
2 d4 c7 p- X! m1 n, m: j$ U5 B8 M   
5 |: @# ^9 \3 W# t# I2 `    }
   
    snprintf（client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr）；
   
8 J& h" S" d: q$ _% d2 T    client->driver = &i2cdev_driver;
   
    /* registered with adapter, passed as client to user */
3 w5 ?; H3 [; f! V   
5 ^8 i- W/ y. \; F! h    client->adapter = adap;
) `2 F! c! R' e8 d" X. ^+ t7 E   
$ x9 r+ Y- \6 \, _    file->private_data = client;
   
2 |/ {8 `* s; z! X    return 0;
, c1 Z! o) v3 g0 `' v   
    }
; M  i; m) N: N6 s/ o" x/ {  I$ F   
    注：
   
/ B' m' V1 f) ~! {) u1 u" R: V5 s    i2cdev_open的主要作用是构建并初始化用于描述i2c从设备的结构体struct i2c_client.
   
    2）drivers/i2c/i2c-dev.c
4 P# a+ U$ ?) D# G; }- \   
    i2cdev_read
   
    -> i2c_master_recv
0 f8 \5 b# ]5 Z0 U# g3 U   
    -> i2c_transfer
   
    -> adap->algo->master_xfer（s3c24xx_i2c_xfer）
5 o- H% ~. y5 j* {" V   
    3）drivers/i2c/i2c-dev.c
+ G5 B" U4 h/ s& A" O5 m' M   
! B1 d; X2 L0 `, x( Y    i2cdev_write
   
! e, h# c3 C0 g. u% ?9 w4 Q" B    -> i2c_master_send
   
. D( p4 }! i3 t* E: E    -> i2c_transfer
   
1 ]# }3 V0 A; S5 o  @0 @    -> adap->algo->master_xfer（s3c24xx_i2c_xfer）
. [- m0 H+ k3 I, }5 X   
    7）drivers/i2c/busses/i2c-s3c2410.c
1 f8 s1 ^- |' z! J   
    s3c24xx_i2c_xfer
: V! }8 L3 F* ~3 R2 D7 J   
4 C/ v2 U- c* N* [  N    -> s3c24xx_i2c_doxfer（wait_event_timeout（i2c->wait, i2c->msg_num == 0, HZ * 5））  s3c24xx_i2c_irq                                                               |
1 \& e& y- Z) V$ E5 R( b   
    -> i2s_s3c_irq_nextbyte                                                      |
   
, B) N% m- v& ?5 M& _; k5 y    -> s3c24xx_i2c_stop                                                      |
0 w$ T- X' y. \) P   
# [+ n' G$ A! q8 B6 m    -> s3c24xx_i2c_master_complete（wake_up（&i2c->wait））------------------|