linux i2c驱动分析



 博主按：其实老早就想写这个I2C的了，期间有各种各样的事情给耽误了。借着五一放假的时间把这个写出来，供同志们参考。以后会花一些时间深入研究下内核，虽然以前对内核也有所了解，但是还不系统。I2C的硬件结构并不复杂，一个适配器加几个设备而已。Linux下驱动的体系结构看着挺复杂，实际也是比较简单的。在本文中我还是使用实际的例子，结合硬件和软件两个方面来介绍。希望能给初学的同志们一些帮助，另外抛砖引玉，希望高手能给一些指点。话不多说，开整！~

老婆的淘宝店，给自己的女友选一件吧：http://jellypie.taobao.com/

 

本文用到的一些资源：

   1. Source Insight软件

   2. mini2440原理图。 下载地址http://wenku.baidu.com/view/0521ab8da0116c175f0e48fe.html

   3. S3C2440 datasheet

   4. AT24C08 datasheet

   5. Bq27200 datasheet

   6. kernel 2.6.31中的At24.c ，Bq27x00_battery.c和i2c-s3c2410.c

   7. mini2440的板文件mach-mini2440.c

   8. 参考资料：《linux设备驱动开发详解（第2版）》 by 宋宝华

 

本文的结构：

第一部分：At24C08驱动

   1. mini2440中at24c08的电气连接

   2. Linux中I2C驱动框架分析

   3. I2C总线驱动代码分析

   4. at24c08驱动代码分析

第二部分：Bq27200驱动

   1. Bq27200的典型应用电路

   2. 主要分析一下ba27x00的代码，对比at24c08来加深理解。

 

---------------------我是分割线----------------------

 

第一部分

1. mini2440中at24c08的电气连接及其板文件

       如下图。

                                

24C08的I2C接口是与2440的IICSCL/IICSDA直接相连的。在2440内部集成了一个I2C控制器，可以通过寄存器来控制它。先来和这四个寄存器混个脸熟吧，后面分析时还会经常用到这四个寄存器。

   

 在mini2440的板文件中可以找到关于at24c08的内容，如下：

[c-sharp] view plaincopyprint?

1. /* 
2.  * I2C devices 
3.  */  
4. static struct at24_platform_data at24c08 = {  
5.     .byte_len   = SZ_8K / 8,  
6.     .page_size  = 16,  
7. };  
8.   
9. static struct i2c_board_info mini2440_i2c_devs[] __initdata = {  
10.     {  
11.         I2C_BOARD_INFO("24c08", 0x50),  
12.         .platform_data = &at24c08,  
13.     },  
14. };  
15.   
16. static void __init mini2440_init(void)  
17. {  
18.    ... ...  
19.    i2c_register_board_info(0, mini2440_i2c_devs,  
20.                 ARRAY_SIZE(mini2440_i2c_devs));  
21.    ... ...  
22. }  

/* * I2C devices */static struct at24_platform_data at24c08 = {.byte_len= SZ_8K / 8,.page_size= 16,};static struct i2c_board_info mini2440_i2c_devs[] __initdata = {{I2C_BOARD_INFO("24c08", 0x50),.platform_data = &at24c08,},};static void __init mini2440_init(void){ ... ... i2c_register_board_info(0, mini2440_i2c_devs,ARRAY_SIZE(mini2440_i2c_devs)); ... ...}

可以看出，在mini2440的init函数中注册了一个i2c的设备，这个设备我们使用了一个结构体i2c_board_info来描述。这个结构体定义在i2c.h文件中。如下：

[c-sharp] view plaincopyprint?

1. struct i2c_board_info {  
2.     char        type[I2C_NAME_SIZE];  
3.     unsigned short  flags;  
4.     unsigned short  addr;  
5.     void        *platform_data;  
6.     struct dev_archdata *archdata;  
7.     int     irq;  
8. };  

struct i2c_board_info {chartype[I2C_NAME_SIZE];unsigned shortflags;unsigned shortaddr;void*platform_data;struct dev_archdata*archdata;intirq;};

其中的platform_data又指向一个at24_platform_data结构体。

 

以上只是at24c08的部分，在板文件中还可以看到关于2440内部i2c控制器的部分，如下：

[c-sharp] view plaincopyprint?

1. static struct platform_device *mini2440_devices[] __initdata = {  
2.  ... ...  
3.  &s3c_device_i2c0,  
4.  ... ...  
5. };  
6.   
7. static void __init mini2440_init(void)  
8. {  
9.  ... ...  
10.  platform_add_devices(mini2440_devices, ARRAY_SIZE(mini2440_devices));  
11.  ... ...  
12. }  

static struct platform_device *mini2440_devices[] __initdata = { ... ... &s3c_device_i2c0, ... ...};static void __init mini2440_init(void){ ... ... platform_add_devices(mini2440_devices, ARRAY_SIZE(mini2440_devices)); ... ...}

其中s2c_device_i2c0定义在arch/arm/plat-s3c/Dev-i2c0.c中（在同一目录下还可以看到很多Dev-开头的c文件，都是2440内部集成的各种设备），仔细看下面的代码再对比2440的datasheet就可以很清楚的知道：

   * 控制器的IO起始地址为S3C_PA_IIC =0x54000000，大小是4K，中断号是43 = IRQ_IIC      S3C2410_IRQ(27)

   * 控制器名是"s3c2410-i2c"

[c-sharp] view plaincopyprint?

1. static struct resource s3c_i2c_resource[] = {  
2.     [0] = {  
3.         .start = S3C_PA_IIC,  
4.         .end   = S3C_PA_IIC + SZ_4K - 1,  
5.         .flags = IORESOURCE_MEM,  
6.     },  
7.     [1] = {  
8.         .start = IRQ_IIC,  
9.         .end   = IRQ_IIC,  
10.         .flags = IORESOURCE_IRQ,  
11.     },  
12. };  
13.   
14. struct platform_device s3c_device_i2c0 = {  
15.     .name         = "s3c2410-i2c",  
16. #ifdef CONFIG_S3C_DEV_I2C1  
17.     .id       = 0,  
18. #else  
19.     .id       = -1,  
20. #endif  
21.     .num_resources    = ARRAY_SIZE(s3c_i2c_resource),  
22.     .resource     = s3c_i2c_resource,  
23. };  

static struct resource s3c_i2c_resource[] = {[0] = {.start = S3C_PA_IIC,.end = S3C_PA_IIC + SZ_4K - 1,.flags = IORESOURCE_MEM,},[1] = {.start = IRQ_IIC,.end = IRQ_IIC,.flags = IORESOURCE_IRQ,},};struct platform_device s3c_device_i2c0 = {.name = "s3c2410-i2c",#ifdef CONFIG_S3C_DEV_I2C1.id = 0,#else.id = -1,#endif.num_resources = ARRAY_SIZE(s3c_i2c_resource),.resource = s3c_i2c_resource,};

   

2. Linux中I2C驱动框架分析

    这部分是本文的重点部分。根据上面的电气连接关系我们可以看出，我们要想操作24c08，必须要做两方面的驱动。

       第一方面： 2440中I2C控制器的驱动，有了这部分驱动，我们才可以操作控制器来产生I2C的时序信号，来发送数据和接收数据。

       第二方面： 24C08的驱动，有了这部分驱动，才能使用控制器正确操作芯片，来读取和存放数据。

    在Linux系统中，对上边第一方面的实现叫做I2C总线驱动，对第二方面的实现叫做I2C设备驱动。一般来说，如果CPU中集成了I2C控制器并且Linux内核支持这个CPU，那么总线驱动方面就不用我们操心了，内核已经做好了。但如果CPU中没有I2C控制器，而是外接的话，那么就要我们自己实现总线驱动了。对于设备驱动来说，一般常用的驱动也都包含在内核中了，如果我们用了一个内核中没有的芯片，那么就要自己来写了。

    Linux中I2C体系结构如下图所示（图片来源于网络）。图中用分割线分成了三个层次：用户空间（也就是应用程序），内核（也就是驱动部分）和硬件（也就是实际物理设备，这里就是2440中的i2c控制器和at24c08）。这个够清晰了吧？我们现在就是要研究中间那一层。

   

 由上图我们还可以看出哪些信息呢？

  1). 可以看到几个重要的组成部分，它们是：Driver，Client，i2c-dev，i2c-core，Algorithm，Adapter。这几个部分在内核中都有相应的数据结构，定义在i2c.h文件中，尽量避免粘贴打断代码来凑数，就不贴出来了。简要概括一下每个结构体的意义。

       Driver --> struct i2c_driver 

          这个结构体对应了驱动方法，重要成员函数有probe，remove，suspend，resume。

          还包括一个重要的数据结构: struct i2c_device_id *id_table; 如果驱动可以支持好几个设备，那么这里面就要包含这些设备的ID

 

       Client --> struct i2c_client

          应用程序是选择性失明的，它只能看到抽象的设备文件，其他部分都是看不见的。图中只有Client与应用程序有联系，所以我们可以大胆得出结论：这个Client是对应于真实的物理设备，在本文就是at24c08。 所以很显然这个结构体中的内容应该是描述设备的。包含了芯片地址，设备名称，设备使用的中断号，设备所依附的控制器，设备所依附的驱动等内容。

 

       Algorithm -->struct i2c_algorithm

          Algorithm就是算法的意思。在这个结构体中定义了一套控制器使用的通信方法。其中关键函数是master_xfer()。我们实际工作中的重要一点就是要实现这个函数。

[c-sharp] view plaincopyprint?

1. int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);  

int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);

 

       Adapter --> struct i2c_adapter

           这个结构体对应一个控制器。其中包含了控制器名称，algorithm数据，控制器设备等。

 

 2). 可以看出，i2c-core起到了关键的承上启下的作用。事实上也是这样，我们将从这里展开来分析。源代码位于drivers/i2c/i2c-core.c中。在这个文件中可以看到几个重要的函数。

   *增加/删除i2c控制器的函数

 

[c-sharp] view plaincopyprint?

1. int i2c_add_adapter(struct i2c_adapter *adapter)  
2. int i2c_del_adapter(struct i2c_adapter *adap)  

int i2c_add_adapter(struct i2c_adapter *adapter)int i2c_del_adapter(struct i2c_adapter *adap)

  

   *增加/删除设备驱动的函数

[c-sharp] view plaincopyprint?

1. int i2c_register_driver(struct module *owner, struct i2c_driver *driver)  
2. void i2c_del_driver(struct i2c_driver *driver)  

int i2c_register_driver(struct module *owner, struct i2c_driver *driver)void i2c_del_driver(struct i2c_driver *driver)

 

    *增加/删除i2c设备的函数

[c-sharp] view plaincopyprint?

1. struct i2c_client *  
2. i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info);  
3. void i2c_unregister_device(struct i2c_client *client)  

struct i2c_client *i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info);void i2c_unregister_device(struct i2c_client *client)

注：在2.6.30版本之前使用的是i2c_attach_client()和i2c_detach_client()函数。之后attach被merge到了i2c_new_device中，而detach直接被unresister取代。实际上这两个函数内部都是调用了device_register()和device_unregister()。源码如下：

    *I2C传输、发送和接收函数

[c-sharp] view plaincopyprint?

1. int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);  
2.   
3. int i2c_master_send(struct i2c_client *client,const char *buf ,int count);  
4.   
5. int i2c_master_recv(struct i2c_client *client, char *buf ,int count);  

int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);int i2c_master_send(struct i2c_client *client,const char *buf ,int count);int i2c_master_recv(struct i2c_client *client, char *buf ,int count);

 其中send和receive分别都调用了transfer函数，而transfer也不是直接和硬件交互，而是调用algorithm中的master_xfer()函数，所以我们要想进行数据传输，必须自己来实现这个master_xfer()函数，这是总线驱动开发的重点之一。下面以read()系统调用的流程来简单梳理一下：

 

先说一下，本文中有个疑惑，一直没有搞懂，写在这里，望高人指点一二，不胜感激！

#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看起。

[c-sharp] view plaincopyprint?

1. static int __init i2c_adap_s3c_init(void)  
2. {  
3.     return platform_driver_register(&s3c24xx_i2c_driver);  
4. }  

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_driver

[c-sharp] view plaincopyprint?

1. static struct platform_driver s3c24xx_i2c_driver = {  
2.     .probe      = s3c24xx_i2c_probe,  
3.     .remove     = s3c24xx_i2c_remove,  
4.     .suspend_late   = s3c24xx_i2c_suspend_late,  
5.     .resume     = s3c24xx_i2c_resume,  
6.     .id_table   = s3c24xx_driver_ids,  
7.     .driver     = {  
8.         .owner  = THIS_MODULE,  
9.         .name   = "s3c-i2c",  
10.     },  
11. };  

static 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。再加上一个id_table和device_driver结构体变量。

下面逐个分析：

* probe函数

当调用platform_driver_register函数注册platform_driver结构体时，probe指针指向的s3c24xx_i2c_probe函数将会被调用。这部分详细解释参考本博客另一篇文章《S3C2410看门狗驱动分析》。细心的朋友可能会发现，在s3c24xx_i2c_driver中，驱动的名字是"s3c-i2c"，而在板文件中可以看到，设备的名字是"s3c2410-i2c"，这两个名字不一样，那驱动和设备是如何match的呢？答案就在于id_table。这个id_table包含了驱动所支持的设备ID表。在match的时候，判断这个表中的名字是不是和设备一致，一致则match成功。这也是为什么一个驱动可以同时match成功多个设备的原因。如果只是靠platform_driver-->driver中的名字来匹配的话，那么驱动和设备只能是一对一的关系了。

[c-sharp] view plaincopyprint?

1. static struct platform_device_id s3c24xx_driver_ids[] = {  
2.     {  
3.         .name       = "s3c2410-i2c",  
4.         .driver_data    = TYPE_S3C2410,  
5.     }, {  
6.         .name       = "s3c2440-i2c",  
7.         .driver_data    = TYPE_S3C2440,  
8.     }, { },  
9. };  

static struct platform_device_id s3c24xx_driver_ids[] = {{.name= "s3c2410-i2c",.driver_data= TYPE_S3C2410,}, {.name= "s3c2440-i2c",.driver_data= TYPE_S3C2440,}, { },};

扯远了，还是看看probe的代码吧~

[c-sharp] view plaincopyprint?

1. static int s3c24xx_i2c_probe(struct platform_device *pdev)  
2. {  
3.     struct s3c24xx_i2c *i2c;  
4.     struct s3c2410_platform_i2c *pdata;  
5.     struct resource *res;  
6.     int ret;  
7.   
8.     pdata = pdev->dev.platform_data;  
9.     if (!pdata) {  
10.         dev_err(&pdev->dev, "no platform data/n");  
11.         return -EINVAL;  
12.     }  
13.         //给s3c24xx_i2c结构体申请空间  
14.     i2c = kzalloc(sizeof(struct s3c24xx_i2c), GFP_KERNEL);  
15.     if (!i2c) {  
16.         dev_err(&pdev->dev, "no memory for state/n");  
17.         return -ENOMEM;  
18.     }  
19.         //填充s3c24xx_i2c结构体中各项，包括名称、所有者、算法、所属class等等  
20.     strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));  
21.     i2c->adap.owner   = THIS_MODULE;  
22.     i2c->adap.algo    = &s3c24xx_i2c_algorithm; //这个下面会重点介绍  
23.     i2c->adap.retries = 2;  
24.     i2c->adap.class   = I2C_CLASS_HWMON | I2C_CLASS_SPD;  
25.     i2c->tx_setup     = 50;  
26.   
27.     spin_lock_init(&i2c->lock);  
28.     init_waitqueue_head(&i2c->wait);  
29.   
30.     /* find the clock and enable it */  
31.         // 找到i2c始终并且使能它  
32.     i2c->dev = &pdev->dev;  
33.     i2c->clk = clk_get(&pdev->dev, "i2c");  
34.     if (IS_ERR(i2c->clk)) {  
35.         dev_err(&pdev->dev, "cannot get clock/n");  
36.         ret = -ENOENT;  
37.         goto err_noclk;  
38.     }  
39.   
40.     dev_dbg(&pdev->dev, "clock source %p/n", i2c->clk);  
41.   
42.     clk_enable(i2c->clk);  
43.   
44.     /* map the registers */  
45.         /*映射寄存器*/  
46.     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);  
47.     if (res == NULL) {  
48.         dev_err(&pdev->dev, "cannot find IO resource/n");  
49.         ret = -ENOENT;  
50.         goto err_clk;  
51.     }  
52.   
53.     i2c->ioarea = request_mem_region(res->start, resource_size(res),  
54.                      pdev->name);  
55.   
56.     if (i2c->ioarea == NULL) {  
57.         dev_err(&pdev->dev, "cannot request IO/n");  
58.         ret = -ENXIO;  
59.         goto err_clk;  
60.     }  
61.   
62.     i2c->regs = ioremap(res->start, resource_size(res));  
63.   
64.     if (i2c->regs == NULL) {  
65.         dev_err(&pdev->dev, "cannot map IO/n");  
66.         ret = -ENXIO;  
67.         goto err_ioarea;  
68.     }  
69.   
70.     dev_dbg(&pdev->dev, "registers %p (%p, %p)/n",  
71.         i2c->regs, i2c->ioarea, res);  
72.   
73.     /* setup info block for the i2c core */  
74.   
75.     i2c->adap.algo_data = i2c;  
76.     i2c->adap.dev.parent = &pdev->dev;  
77.   
78.     /* initialise the i2c controller */  
79.         /*s3c24xx_i2c结构体变量i2c的必要的信息都填充完了以后，开始进行初始化*/  
80.     ret = s3c24xx_i2c_init(i2c);  
81.     if (ret != 0)  
82.         goto err_iomap;  
83.   
84.     /* find the IRQ for this unit (note, this relies on the init call to 
85.      * ensure no current IRQs pending 
86.      */  
87.         //接下来申请中断  
88.     i2c->irq = ret = platform_get_irq(pdev, 0);  
89.     if (ret <= 0) {  
90.         dev_err(&pdev->dev, "cannot find IRQ/n");  
91.         goto err_iomap;  
92.     }  
93.   
94.     ret = request_irq(i2c->irq, s3c24xx_i2c_irq, IRQF_DISABLED,  
95.               dev_name(&pdev->dev), i2c);  
96.   
97.     if (ret != 0) {  
98.         dev_err(&pdev->dev, "cannot claim IRQ %d/n", i2c->irq);  
99.         goto err_iomap;  
100.     }  
101.           
102.     ret = s3c24xx_i2c_register_cpufreq(i2c);  
103.     if (ret < 0) {  
104.         dev_err(&pdev->dev, "failed to register cpufreq notifier/n");  
105.         goto err_irq;  
106.     }  
107.   
108.     /* Note, previous versions of the driver used i2c_add_adapter() 
109.      * to add the bus at any number. We now pass the bus number via 
110.      * the platform data, so if unset it will now default to always 
111.      * being bus 0. 
112.      */  
113.   
114.     i2c->adap.nr = pdata->bus_num;  
115.   
116.         //看到了吧？下面调用了i2c-core中的i2c_add_adapter函数来添加一个i2c控制器  
117.           //i2c_add_numbered_adapter和i2c_add_adapter的区别在于前者用来添加一个在CPU内  
118.           //部集成的适配器，而后者用来添加一个CPU外部的适配器。显然这里应该用前者。  
119.     ret = i2c_add_numbered_adapter(&i2c->adap);  
120.     if (ret < 0) {  
121.         dev_err(&pdev->dev, "failed to add bus to i2c core/n");  
122.         goto err_cpufreq;  
123.     }  
124.   
125.     platform_set_drvdata(pdev, i2c);  
126.   
127.     dev_info(&pdev->dev, "%s: S3C I2C adapter/n", dev_name(&i2c->adap.dev));  
128.     return 0;  
129.   
130.  err_cpufreq:  
131.     s3c24xx_i2c_deregister_cpufreq(i2c);  
132.   
133.  err_irq:  
134.     free_irq(i2c->irq, i2c);  
135.   
136.  err_iomap:  
137.     iounmap(i2c->regs);  
138.   
139.  err_ioarea:  
140.     release_resource(i2c->ioarea);  
141.     kfree(i2c->ioarea);  
142.   
143.  err_clk:  
144.     clk_disable(i2c->clk);  
145.     clk_put(i2c->clk);  
146.   
147.  err_noclk:  
148.     kfree(i2c);  
149.     return ret;  
150. }  

static int s3c24xx_i2c_probe(struct platform_device *pdev){struct s3c24xx_i2c *i2c;struct s3c2410_platform_i2c *pdata;struct resource *res;int ret;pdata = pdev->dev.platform_data;if (!pdata) {dev_err(&pdev->dev, "no platform data/n");return -EINVAL;} //给s3c24xx_i2c结构体申请空间i2c = kzalloc(sizeof(struct s3c24xx_i2c), GFP_KERNEL);if (!i2c) {dev_err(&pdev->dev, "no memory for state/n");return -ENOMEM;} //填充s3c24xx_i2c结构体中各项，包括名称、所有者、算法、所属class等等strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));i2c->adap.owner = THIS_MODULE;i2c->adap.algo = &s3c24xx_i2c_algorithm; //这个下面会重点介绍i2c->adap.retries = 2;i2c->adap.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;i2c->tx_setup = 50;spin_lock_init(&i2c->lock);init_waitqueue_head(&i2c->wait);/* find the clock and enable it */ // 找到i2c始终并且使能它i2c->dev = &pdev->dev;i2c->clk = clk_get(&pdev->dev, "i2c");if (IS_ERR(i2c->clk)) {dev_err(&pdev->dev, "cannot get clock/n");ret = -ENOENT;goto err_noclk;}dev_dbg(&pdev->dev, "clock source %p/n", i2c->clk);clk_enable(i2c->clk);/* map the registers */ /*映射寄存器*/res = platform_get_resource(pdev, IORESOURCE_MEM, 0);if (res == NULL) {dev_err(&pdev->dev, "cannot find IO resource/n");ret = -ENOENT;goto err_clk;}i2c->ioarea = request_mem_region(res->start, resource_size(res), pdev->name);if (i2c->ioarea == NULL) {dev_err(&pdev->dev, "cannot request IO/n");ret = -ENXIO;goto err_clk;}i2c->regs = ioremap(res->start, resource_size(res));if (i2c->regs == NULL) {dev_err(&pdev->dev, "cannot map IO/n");ret = -ENXIO;goto err_ioarea;}dev_dbg(&pdev->dev, "registers %p (%p, %p)/n",i2c->regs, i2c->ioarea, res);/* setup info block for the i2c core */i2c->adap.algo_data = i2c;i2c->adap.dev.parent = &pdev->dev;/* initialise the i2c controller */ /*s3c24xx_i2c结构体变量i2c的必要的信息都填充完了以后，开始进行初始化*/ret = s3c24xx_i2c_init(i2c);if (ret != 0)goto err_iomap;/* find the IRQ for this unit (note, this relies on the init call to * ensure no current IRQs pending */ //接下来申请中断i2c->irq = ret = platform_get_irq(pdev, 0);if (ret <= 0) {dev_err(&pdev->dev, "cannot find IRQ/n");goto err_iomap;}ret = request_irq(i2c->irq, s3c24xx_i2c_irq, IRQF_DISABLED, dev_name(&pdev->dev), i2c);if (ret != 0) {dev_err(&pdev->dev, "cannot claim IRQ %d/n", i2c->irq);goto err_iomap;} ret = s3c24xx_i2c_register_cpufreq(i2c);if (ret < 0) {dev_err(&pdev->dev, "failed to register cpufreq notifier/n");goto err_irq;}/* Note, previous versions of the driver used i2c_add_adapter() * to add the bus at any number. We now pass the bus number via * the platform data, so if unset it will now default to always * being bus 0. */i2c->adap.nr = pdata->bus_num; //看到了吧？下面调用了i2c-core中的i2c_add_adapter函数来添加一个i2c控制器 //i2c_add_numbered_adapter和i2c_add_adapter的区别在于前者用来添加一个在CPU内 //部集成的适配器，而后者用来添加一个CPU外部的适配器。显然这里应该用前者。ret = i2c_add_numbered_adapter(&i2c->adap);if (ret < 0) {dev_err(&pdev->dev, "failed to add bus to i2c core/n");goto err_cpufreq;}platform_set_drvdata(pdev, i2c);dev_info(&pdev->dev, "%s: S3C I2C adapter/n", dev_name(&i2c->adap.dev));return 0; err_cpufreq:s3c24xx_i2c_deregister_cpufreq(i2c); err_irq:free_irq(i2c->irq, i2c); err_iomap:iounmap(i2c->regs); err_ioarea:release_resource(i2c->ioarea);kfree(i2c->ioarea); err_clk:clk_disable(i2c->clk);clk_put(i2c->clk); err_noclk:kfree(i2c);return ret;}

 

*remove函数

这是和probe相反的一个函数，在i2c_adap_s3c_exit时调用。主要功能是注销适配器，释放中断，释放内存区域，禁止始终等等。看到上边代码中的err_的各个部分了吧？ remove是它们的汇总。

 

*suspend函数和resume函数

把这两个放一起说吧，挂起和恢复函数。挂起时保存状态并置标志位，恢复时重新初始化i2c适配器并置标志位。

 

Algorithm

 哎呀我去，终于到这了。憋得我难受啊。这里要重点介绍一下，不仅要知其然，还要知其所以然，这样我们以后自己写驱动的时候就有把握了。

[c-sharp] view plaincopyprint?

1. static const struct i2c_algorithm s3c24xx_i2c_algorithm = {  
2.     .master_xfer        = s3c24xx_i2c_xfer,  
3.     .functionality      = s3c24xx_i2c_func,  
4. };  

static const struct i2c_algorithm s3c24xx_i2c_algorithm = {.master_xfer= s3c24xx_i2c_xfer,.functionality= s3c24xx_i2c_func,};

这里实现的就是这个s3c24xx_i2c_xfer。这个是控制器能不能动作的关键，缺了这个，控制器就是废铜烂铁。

[c-sharp] view plaincopyprint?

1. static int s3c24xx_i2c_xfer(struct i2c_adapter *adap,  
2.             struct i2c_msg *msgs, int num)  
3. {  
4.     struct s3c24xx_i2c *i2c = (struct s3c24xx_i2c *)adap->algo_data;  
5.     int retry;  
6.     int ret;  
7.   
8.     for (retry = 0; retry < adap->retries; retry++) {  
9.   
10.         ret = s3c24xx_i2c_doxfer(i2c, msgs, num);  
11.   
12.         if (ret != -EAGAIN)  
13.             return ret;  
14.   
15.         dev_dbg(i2c->dev, "Retrying transmission (%d)/n", retry);  
16.   
17.         udelay(100);  
18.     }  
19.   
20.     return -EREMOTEIO;  
21. }  

static int s3c24xx_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg *msgs, int num){struct s3c24xx_i2c *i2c = (struct s3c24xx_i2c *)adap->algo_data;int retry;int ret;for (retry = 0; retry < adap->retries; retry++) {ret = s3c24xx_i2c_doxfer(i2c, msgs, num);if (ret != -EAGAIN)return ret;dev_dbg(i2c->dev, "Retrying transmission (%d)/n", retry);udelay(100);}return -EREMOTEIO;}

 

完成任务的函数是s3c24xx_i2c_doxfer()，源码清单如下，

[c-sharp] view plaincopyprint?

1. static int s3c24xx_i2c_doxfer(struct s3c24xx_i2c *i2c,  
2.                   struct i2c_msg *msgs, int num)  
3. {  
4.     unsigned long timeout;  
5.     int ret;  
6.   
7.     if (i2c->suspended)  
8.         return -EIO;  
9.   
10.     ret = s3c24xx_i2c_set_master(i2c);  
11.     if (ret != 0) {  
12.         dev_err(i2c->dev, "cannot get bus (error %d)/n", ret);  
13.         ret = -EAGAIN;  
14.         goto out;  
15.     }  
16.   
17.     spin_lock_irq(&i2c->lock);  
18.   
19.     i2c->msg     = msgs;  
20.     i2c->msg_num = num;  
21.     i2c->msg_ptr = 0;  
22.     i2c->msg_idx = 0;  
23.     i2c->state   = STATE_START;  
24.   
25.     s3c24xx_i2c_enable_irq(i2c);  
26.     s3c24xx_i2c_message_start(i2c, msgs);  
27.     spin_unlock_irq(&i2c->lock);  
28.   
29.     timeout = wait_event_timeout(i2c->wait, i2c->msg_num == 0, HZ * 5);  
30.   
31.     ret = i2c->msg_idx;  
32.   
33.     /* having these next two as dev_err() makes life very 
34.      * noisy when doing an i2cdetect */  
35.   
36.     if (timeout == 0)  
37.         dev_dbg(i2c->dev, "timeout/n");  
38.     else if (ret != num)  
39.         dev_dbg(i2c->dev, "incomplete xfer (%d)/n", ret);  
40.   
41.     /* ensure the stop has been through the bus */  
42.   
43.     msleep(1);  
44.   
45.  out:  
46.     return ret;  
47. }  

static int s3c24xx_i2c_doxfer(struct s3c24xx_i2c *i2c, struct i2c_msg *msgs, int num){unsigned long timeout;int ret;if (i2c->suspended)return -EIO;ret = s3c24xx_i2c_set_master(i2c);if (ret != 0) {dev_err(i2c->dev, "cannot get bus (error %d)/n", ret);ret = -EAGAIN;goto out;}spin_lock_irq(&i2c->lock);i2c->msg = msgs;i2c->msg_num = num;i2c->msg_ptr = 0;i2c->msg_idx = 0;i2c->state = STATE_START;s3c24xx_i2c_enable_irq(i2c);s3c24xx_i2c_message_start(i2c, msgs);spin_unlock_irq(&i2c->lock);timeout = wait_event_timeout(i2c->wait, i2c->msg_num == 0, HZ * 5);ret = i2c->msg_idx;/* having these next two as dev_err() makes life very * noisy when doing an i2cdetect */if (timeout == 0)dev_dbg(i2c->dev, "timeout/n");else if (ret != num)dev_dbg(i2c->dev, "incomplete xfer (%d)/n", ret);/* ensure the stop has been through the bus */msleep(1); out:return ret;}

上面代码可以分成几个部分来看：

  * s3c24xx_i2c_set_master() 这个函数每隔1ms查看一次i2c总线状态，timeout是400ms，如果在这期间总线状态不忙，则返回零。否则返回-ETIMEDOUT

  * 将要发送的消息和其他信息付给i2c->msg和其他变量，并将状态设置为STATE_START

  * s3c24xx_i2c_enable_irq() 使能中断

  * s3c24xx_i2c_message_start() 重中之重啊。在看代码之前先来看看2440的datasheet上是怎么说的吧。

代码清单如下：

[c-sharp] view plaincopyprint?

1. static void s3c24xx_i2c_message_start(struct s3c24xx_i2c *i2c,  
2.                       struct i2c_msg *msg)  
3. {  
4.     unsigned int addr = (msg->addr & 0x7f) << 1;  
5.     unsigned long stat;  
6.     unsigned long iiccon;  
7.   
8.     stat = 0;  
9.     stat |=  S3C2410_IICSTAT_TXRXEN;  
10.   
11.     if (msg->flags & I2C_M_RD) {//如果是read data, from slave to master     stat |= S3C2410_IICSTAT_MASTER_RX;  
12.         addr |= 1;  
13.     } else  
14.         stat |= S3C2410_IICSTAT_MASTER_TX;  
15.   
16.     if (msg->flags & I2C_M_REV_DIR_ADDR)  
17.         addr ^= 1;  
18.   
19.     /* todo - check for wether ack wanted or not */  
20.     s3c24xx_i2c_enable_ack(i2c);  
21.   
22.     iiccon = readl(i2c->regs + S3C2410_IICCON);  
23.     writel(stat, i2c->regs + S3C2410_IICSTAT);  
24.   
25.     dev_dbg(i2c->dev, "START: %08lx to IICSTAT, %02x to DS/n", stat, addr);  
26.     writeb(addr, i2c->regs + S3C2410_IICDS);  
27.   
28.     /* delay here to ensure the data byte has gotten onto the bus 
29.      * before the transaction is started */  
30.   
31.     ndelay(i2c->tx_setup);  
32.   
33.     dev_dbg(i2c->dev, "iiccon, %08lx/n", iiccon);  
34.     writel(iiccon, i2c->regs + S3C2410_IICCON);  
35.   
36.     stat |= S3C2410_IICSTAT_START;  
37.     writel(stat, i2c->regs + S3C2410_IICSTAT);  
38. }