davinci平台的I2C驱动(非GPIO口模拟i2c)

    1. 一、概述
    2. 前边介绍过将普通GPIO口模拟成I2C,本文介绍davinci平台的硬件I2C驱动。Linux的I2C体系结构分为3个组成部分:
    3. 1.I2C核心
    4. I2C 核心提供了I2C总线驱动和设备驱动的注册、注销方法,I2C通信方法(即“algorithm”)上层的、与具体适配器无关的代码以及探测设备、检测设备地址的上层代码等。
    5. 2.I2C总线驱动
    6. I2C总线驱动是对I2C硬件体系结构中适配器端的实现,适配器可由CPU控制,甚至直接集成在CPU内部。
    7. I2C总线驱动主要包含了I2C适配器数据结构i2c_adapter、I2C适配器的algorithm数据结构i2c_algorithm和控制I2C适配器产生通信信号的函数。
    8. 经由I2C总线驱动的代码,我们可以控制I2C适配器以主控方式产生开始位、停止位、读写周期,以及以从设备方式被读写、产生ACK等。
    9. 3.I2C设备驱动
    10. I2C设备驱动是对I2C硬件体系结构中设备端的实现,设备一般挂接在受CPU控制的I2C适配器上,通过I2C适配器与CPU交换数据。
    11. I2C设备驱动主要包含了数据结构i2c_driver和i2c_client,我们需要根据具体设备实现其中的成员函数。
    12. 4.I2C驱动框架:
    13. I2C驱动实在platform机制上实现的,因为linux内核存在I2c的总线i2c_bus_type,为什么还要注册在platform的虚拟总线上?这是因为使用platform 总线在驱动中大体有以下几个好处:
    14. a) 使得设备被挂接在一个总线上,使配套的sysfs节点、设备电源管理都成为可能。
    15. b) 隔离了BSP 和驱动。BSP 中定义platform 设备和设备使用的资源(可以使用platform_data的形式来包括platform 设备的设备),设备的具体配置信息。而在驱动中,只需要通过通用API 去获取资源和数据,做到了板相关代码和驱动代码的分离,使得驱动具有更好的可扩展性和跨平台性。
    16. 但是真正达i2c设备和驱动还是要注册在i2c_bus_type总线上。
    17. 所以i2c驱动框架如下:
    18. (1).向内核注册i2c_bus_type总线。
    19. (2).定义i2c的板级资源到platform_device结构中的resource字段,注册i2c的platform_device结构。
    20. (3).注册i2c的platform_driver结构。注册时会调用platform_driver中的probe函数,即davinci_i2c_probe()函数。
    21. (4).在davinci_i2c_probe()函数中,进行i2c内存资源的申请、中断申请、寄存器初始化、时钟设置等等(platform机制的优势),添加到davinci_i2c_dev结构(这个结构封装davinci平台cpu的i2c模块的所有资源,包括adapter,对底层硬件的操作也是通过此结构)。并注册davinci_i2c_dev结构中的adapter设备到i2c_bus_type总线上。(下面会注册该设备的驱动)
    22. (5).接下来调用i2c_dev_init()函数中,注册adapter字符设备,创建与设备节点相关的sysfs文件系统文件和目录(为udev创建设备节点有关),注册adapter设备的驱动到i2c_bus_type总线上。驱动注册时,会扫描i2c_bus_type总线上的设备,将之前注册的adapter设备依附到此driver上。此时会将adapter设备与i2c_dev相关联起来,同时将此i2c_dev结构挂接到全局链表i2c_dev_list中,为用户空间使用时,打开设备方便找到该i2c_dev,再找到对应的adapter结构,再找到对应的davinci_i2c_dev结构,就可以对硬件进行操作了。
    23. 6.其中davinci_i2c_dev结构、i2c_dev结构和i2c_adapter结构的联系
    24. adapter设备注册时,davinci_i2c_dev结构中的i2c_adapter结构的字段adapter指向前边注册的adapter。(davinci_i2c_dev.adapter->adapter)
    25. adapter驱动注册时,i2c_dev结构中的i2c_adapter结构的字段adapter也指向前边注册的adapter。(i2c_dev.adapter->adapter)
    26. i2c_dev结构用于上层使用,davinci_i2c_dev结构用于底层硬件操作使用,而两者共同指向的adapter结构将两者联系起来。当用户打i2c设备时,会首先找到i2c_dev结构,通过adapter字段找到底层的davinci_i2c_dev结构,进而就可以进行底层硬件寄存器的操作了。
    27. 驱动框架如下图:
    28. davinci平台的I2C驱动(非GPIO口模拟i2c)_第1张图片
    29. 二、下面介绍i2c各核心数据结构的定义和它们之间的连接关系。
    30. 1. 一个i2c适配器由i2c_adapter数据结构描述
    31. /*
    32. i2c adapter是软件上抽象出来的i2c总线控制器接口,i2c总线适配器(adapter)就是一条 i2c总线的控制器,i2c_adapter对应于物理上的一个适配器
    33. 物理上一条i2c总线可以挂接多个硬件设备(slave),一个CPU可以挂接多条i2c总线(想象一下PCI总线),i2c总线控制器就是CPU访问I2C总线的硬件接口,也就是你说的那几个寄存器 .

    34. 简单点了, 你的开发板上有几个I2C接口,就有几个adapter , 也就是有几条I2C bus , I2C CLIENT 对应的就是你的外围I2C 设备,有几个就有几个CLIENT , 把这些设备插入开发板, 对应其中的一条BUS, 那么相应的就对应了其中的一个ADAPTER , 接下来的就是 CLIENT 与 ADAPTER 勾搭成对了, 后面就是做该做的事了.
    35. */
    36. struct i2c_adapter {
    37.     struct module *owner;/*所属模块*/
    38.     unsigned int id; /*algorithm的类型,定义于i2c-id.h,以I2C_ALGO_开始*/
    39.     unsigned int class;
    40.     struct i2c_algorithm *algo;/*总线通信方法结构体指针,一个i2c适配器上的i2c总线通信方法由其驱动程序提供的i2c_algorithm数据结构描述,由algo指针指向 */
    41.     void *algo_data; /* algorithm数据 */
    42.     int (*client_register)(struct i2c_client *); /*client注册时调用*/
    43.     int (*client_unregister)(struct i2c_client *); /*client注销时调用*/
    44.     struct semaphore bus_lock; /*控制并发访问的自旋锁*/
    45.     struct semaphore clist_lock;
    46.     int timeout;
    47.     int retries; /*重试次数*/
    48.     struct device dev; /* 适配器设备 */
    49.     struct class_device class_dev; /* 类设备 */
    50.     int nr;
    51.     struct list_head clients; /* client链表头,总线上每个设备的 i2c_client数据结构挂载在这里*/
    52.     struct list_head list;
    53.     char name[I2C_NAME_SIZE]; /*适配器名称*/
    54.     struct completion dev_released; /*用于同步*/
    55.     struct completion class_dev_released;
    56. };

    57. 2.具体i2c适配器的通信方法由i2c_algorithm数据结构进行描述:
    58. struct i2c_algorithm {
    59.     int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,int num);//I2C传输函数指针
    60.     int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,unsigned short flags, char read_write,u8 command, int size, union i2c_smbus_data *data);//SMbus传输函数指针
    61.     u32 (*functionality) (struct i2c_adapter *);//返回适配器支持的功能
    62. };

    63. 3. 一个i2c设备的驱动程序由i2c_driver数据结构描述,i2c_driver代表I2C从设备驱动,定义于include/linux/i2c.h:
    64. struct i2c_driver {
    65.     unsigned int class;
    66.     /* 这两个接口已经被probe和remove取代 */
    67.     int (*attach_adapter)(struct i2c_adapter *);//attach_adapter回调函数在安装i2c设备驱动程序模块时、或者在安装i2c适配器驱动程序模块时被调用,
    68.                                                                                             //用于检测、认领设备并为设备分配i2c_client数据结构。
    69.     int (*detach_adapter)(struct i2c_adapter *);//detach_client方法在卸载适配器或设备驱动程序模块时被调用,用于从总线上注销设备、并释放i2c_client及相应的私有数据结构。    
    70.     int (*probe)(struct i2c_client *, const struct i2c_device_id *);
    71.     int (*remove)(struct i2c_client *);    
    72.     void (*shutdown)(struct i2c_client *);
    73.     int (*suspend)(struct i2c_client *, pm_message_t mesg);
    74.     int (*resume)(struct i2c_client *);
    75.     void (*alert)(struct i2c_client *, unsigned int data);
    76.     int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
    77.     struct device_driver driver;/*设备驱动结构体*/
    78.     const struct i2c_device_id *id_table;//该驱动所支持的设备ID表
    79.     int (*detect)(struct i2c_client *, struct i2c_board_info *);
    80.     const unsigned short *address_list;
    81.     struct list_head clients;
    82. };

    83. 4.一个i2c设备由i2c_client数据结构进行描述:
    84. struct i2c_client {
    85.     unsigned int flags; /* 标志 */
    86.     /*需要说明的是,i2c设备的7位地址是就当前i2c总线而言的,是“相对地址”。不同的i2c总线上的设备可以使用相同的7位地址,
    87.     但是它们所在的i2c总线不同。所以在系统中一个i2c设备的“绝对地址”由二元组(i2c适配器的ID和设备在该总线上的7位地址)表示。
    88.     */
    89.     unsigned short addr; /* 低7位为芯片地址 */
    90.     struct i2c_adapter *adapter; /*依附的i2c_adapter*/
    91.     struct i2c_driver *driver; /*依附的i2c_driver */
    92.     int usage_count; /* 访问计数 */
    93.     struct device dev; /* 设备结构体 */
    94.     struct list_head list; /* 链表头 */
    95.     char name[I2C_NAME_SIZE]; /* 设备名称 */
    96.     struct completion released; /* 用于同步 */
    97. };

    98. 5.下面分析一下i2c_driver、i2c_client、i2c_adapter和i2c_algorithm这4个数据结构的作用及其盘根错节的关系。
    99. 5.1 i2c_adapter与i2c_algorithm
    100. i2c_adapter 对应于物理上的一个适配器,而i2c_algorithm对应一套通信方法。一个I2C适配器需要i2c_algorithm中提供的通信函数来控制适配器上产生特定的访问周期。缺少i2c_algorithm的i2c_adapter什么也做不了,因此i2c_adapter中包含其使用的 i2c_algorithm的指针。
    101. i2c_algorithm中的关键函数master_xfer()用于产生I2C访问周期需要的信号,以i2c_msg(即I2C消息)为单位。
    102. struct i2c_msg {//i2c_msg结构体:
    103.     __u16 addr; /* 设备地址*/
    104.     __u16 flags; /* 标志 */
    105.     __u16 len; /* 消息长度*/
    106.     __u8 *buf; /* 消息数据*/
    107. };

    108. 5.2 i2c_driver与i2c_client
    109. i2c_driver对应一套驱动方法,是纯粹的用于辅助作用的数据结构,它不对应于任何的物理实体。i2c_client对应于真实的物理设备,每个I2C设备都需要一个i2c_client来描述。i2c_client一般被包含在i2c字符设备的私有信息结构体中。同一类的i2c设备device对应一个驱动driver。driver与device的关系是一对多的关系。
    110. i2c_driver 与i2c_client发生关联的时刻在i2c_driver的attach_adapter()函数被运行时。attach_adapter()会探测物理设备,当确定一个client存在时,把该client使用的i2c_client数据结构的adapter指针指向对应的i2c_adapter, driver指针指向该i2c_driver,并会调用i2c_adapter的client_register()函数。相反的过程发生在 i2c_driver 的detach_client()函数被调用的时候。

    111. 5.3 i2c_adpater与i2c_client
    112. i2c_adpater 与i2c_client的关系与I2C硬件体系中适配器和设备的关系一致,即i2c_client依附于i2c_adpater。由于一个适配器上可以连 接多个I2C设备,所以一个i2c_adpater也可以被多个i2c_client依附,i2c_adpater中包括依附于它的i2c_client 的链表。

    113. 三、I2C驱动的实现工作
    114. 一方面,适配器驱动可能是Linux内核本身还不包含的。另一方面,挂接在适配器上的具体设备驱动可能也是Linux不存在的。即便上述设备驱动都存在于Linux内核中,其基于的平台也可能与我们的电路板不一样。因此,工程师要实现的主要工作将包括:
    115. 6.1 提供I2C适配器的硬件驱动,探测、初始化I2C适配器(如申请I2C的I/O地址和中断号)、驱动CPU控制的I2C适配器从硬件上产生各种信号以及处理I2C中断等。
    116. 6.2 提供I2C适配器的algorithm,用具体适配器的xxx_xfer()函数填充i2c_algorithm的master_xfer指针,并把i2c_algorithm指针赋值给i2c_adapter的algo指针。
    117. 6.3 实现I2C设备驱动与i2c_driver接口,用具体设备yyy的yyy_attach_adapter()函数指针、 yyy_detach_client()函数指针和yyy_command()函数指针的赋值给i2c_driver的attach_adapter、 detach_adapter和detach_client指针。
    118. 6.4 实现I2C设备驱动的文件操作接口,即实现具体设备yyy的yyy_read()、yyy_write()和yyy_ioctl()函数等。

    119. 四、核心层提供的接口函数
    120. 1、增加/删除I2C适配器
    121. int i2c_add_adapter(struct i2c_adapter *adapter)
    122. int i2c_del_adapter(struct i2c_adapter *adap)
    123. 2、增加/删除I2C从设备驱动
    124. int i2c_register_driver(struct module *owner, structi2c_driver *driver)
    125. static inline int i2c_add_driver(struct i2c_driver *driver)
    126. void i2c_del_driver(struct i2c_driver *driver)
    127. //i2c_add_driver是对i2c_register_driver简单的封装
    128. 3、i2c传输,发送和接收
    129. int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg*msgs, int num)
    130. int i2c_master_send(const struct i2c_client *client, constchar *buf, int count)
    131. int i2c_master_recv(const struct i2c_client *client, char*buf, int count)
    132. //i2c_master_send和i2c_master_recv是i2c_transfer的封装
    133. //3.1.0的内核中已经没有i2c_attach_client和i2c_detach_client接口
    134. 4、I2C总线通信方法
    135. 我们需要为特定的I2C适配器实现其通信方法,主要实现i2c_algorithm结构体中的两个函数:
    136. struct i2c_algorithm {
    137.          int(*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
    138.          u32(*functionality) (struct i2c_adapter *);
    139. };
    140. Functionality函数用于返回algorithm所支持的通信协议;
    141. Master_xfer函数在I2C适配器上完成数据的传输;
    142. //Master_xfer函数实现模板
    143. static int i2c_adapter_xxx_xfer(structi2c_adapter *adap, struct i2c_msg *msgs, int num)
    144. {
    145.    ......
    146.    for (i = 0; i < num; i++) {
    147.        i2c_adapter_xxx_start(); /*产生起始位*/
    148.        if (msgs[i]->flags & I2C_M_RD) { /*读取*/
    149.            i2c_adapter_xxx_setaddr((msg->addr << 1) | 1); /*发送从设备地址*/
    150.            i2c_adapter_xxx_wait_ack(); /*获得从设备的ACK*/
    151.                     i2c_adapter_xxx_readbytes(msgs[i]->buf,msgs[i]->len); /*读取len长度的数据到buf中*/
    152.        } else {
    153.            i2c_adapter_xxx_setaddr(msg->addr << 1);
    154.            i2c_adapter_xxx_wait_ack();
    155.            i2c_adapter_xxx_writebytes(msgs[i]->buf, msgs[i]->len);
    156.        }
    157.     }
    158.    i2c_adapter_xxx_stop(); /*产生停止位*/
    159. }
    160. 我们来大致分析一下匹配的过程:
    161. 当调用i2c_add_driver函数向I2C总线(i2c-core.c文件中注册的”i2c”总线)增加一个i2c_driver时,会遍历总线中的所有i2c_client,
    162. 调用总线注册的match函数I2C适配器上是否有与i2c_driver匹配的i2c_client,如果匹配会调用I2C注册的probe函数,然后再调用i2c_driver定义的probe来进行关联和初始化工作。

    163. 五、i2c的初始化
    164. i2c子系统的初始化函数的执行先后顺序,结合vmlinux.lds和Makefile,可确定i2c初始化函数的执行顺序如下:
    165. 1./dricer/i2c/i2c-core.c中的函数:i2c_init()---------->postcore_initcall级别

    166. 2./arch/arm/mach-davinci/board-da850-evm.c中的函数:da850_evm_init()---------->arch_initcall级别

    167. 3.driver/i2c/buses/i2c-davinci.c中的函数:davinci_i2c_init_driver()---------->subsys_initcall级别

    168. 4./driver/i2c/i2c-dev.c中的函数:i2c_dev_init()---------->module_init级别

    169. 1.i2c总线注册
    170. static int __init i2c_init(void)
    171. {
    172.     int retval;
    173.     //设备模型中,关心总线,设备,驱动这三个实体,总线将设备和驱动绑定,在系统每注册一个设备的时候,会寻找与之匹配的驱动。
    174.     //相反,在系统每注册一个驱动的时候,寻找与之匹配的设备,匹配是由总线来完成的。 你还可以看一看链表的信息。它们都是关联的。
    175.     retval = bus_register(&i2c_bus_type);//可以发现i2c_inti的函数主要功能就是注册i2c总线,并且在sysfs文件系统/bus目录下创建i2c目录,并在i2c目录下建立devices和drivers目录等
    176.     if (retval)
    177.         return retval;
    178.     
    179.     /*
    180.     static struct i2c_driver dummy_driver = {
    181.         .driver.name = "dummy",
    182.         .probe = dummy_probe,
    183.         .remove = dummy_remove,
    184.         .id_table = dummy_id,
    185.     };
    186.     */
    187.     retval = i2c_add_driver(&dummy_driver);//注册一个虚拟驱动
    188.     if (retval)
    189.         goto class_err;
    190.     return 0;

    191. class_err:
    192.     bus_unregister(&i2c_bus_type);
    193.     return retval;
    194. }
    195. /*
    196. struct bus_type i2c_bus_type = {
    197.     .name = "i2c",
    198.     .match = i2c_device_match,
    199.     .probe = i2c_device_probe,
    200.     .remove = i2c_device_remove,
    201.     .shutdown = i2c_device_shutdown,
    202.     .pm = &i2c_device_pm_ops,
    203. };
    204. match方法的用来进行client device和client driver的配对。在向总线i2c_bus_type注册设备或者驱动时会调用此方法。
    205. probe方法在完成设备和驱动的配对后调用执行,i2c_bus_type的probe方法是通过传递进来的drv找到包含此drv的i2c_driver驱动,然后再去调用i2c_driver的probe方法,此处就是at24_probe。
    206. 为什么要这样呢?因为driver_register后,注册的是i2_driver->drv,而drv中的probe未初始化,我们需要调用的是i2c-driver的probe方法。
    207. */

    208. 2.设置i2c的复用管脚配置,以及注册i2c的platform_device设备
    209. 调用完函数i2c_init后,系统将成功创建i2c总线。初始化完毕总线后还需要接着初始化i2c设备和i2c驱动(一般是先初始化device),linux内核中的device初始化一般是通过platform device来初始化的,platform device的初始化在da850_evm_init().
    210. static __init void da850_evm_init(void)
    211. {
    212.     int ret;
    213.     char mask = 0;
    214.     //archarmmach-davinciincludemachcommon.h中定义davinci_soc_info结构。
    215.     //archarmmach-davincicommon.c中davinci_common_init()对其初始化。
    216.     //davinci_soc_info真正的定义在archarmmach-davincida850.c中,定义达芬奇架构的各类资源的地址等
    217.     struct davinci_soc_info *soc_info = &davinci_soc_info;

    218.     //......
    219.     /* 寄存器端口配置为I2C
    220.     MUX_CFG(DA850, I2C0_SDA,    4,    12,    15,    2,    false)
    221.     MUX_CFG(DA850, I2C0_SCL,    4,    8,    15,    2,    false)
    222.     ......
    223.     const short da850_i2c0_pins[] __initdata = {
    224.             DA850_I2C0_SDA, DA850_I2C0_SCL,//修改1
    225.             -1
    226.     };
    227.     */
    228.     ret = davinci_cfg_reg_list(da850_i2c0_pins);//i2c的复用管脚配置
    229.     if (ret)
    230.         pr_warning("da850_evm_init: i2c0 mux setup failed: %dn",ret);

    231.     /*
    232.     static struct resource i2c_davinci_resources[] = {
    233.         {
    234.                              .name = "i2c_davinci",
    235.                 .start = 0x01C22000,
    236.                 .end = 0x01C2205C,
    237.                 .flags = IORESOURCE_MEM,
    238.         },
    239.              {
    240.                 .start = 15,
    241.                 .end = 16,
    242.                 .flags = IORESOURCE_IRQ,
    243.         },
    244.     };
    245.     
    246.     static struct davinci_i2c_platform_data da850_davinci_i2c_pdata = {//wbl test 0514
    247.         .bus_freq    = 20,
    248.         .bus_delay    = 100,
    249.     };
    250.     
    251.     static struct platform_device davinci_i2c_device = {//wbl test 0514
    252.         .name        = "i2c_davinci",
    253.         .num_resources = ARRAY_SIZE(i2c_davinci_resources),
    254.      .resource = i2c_davinci_resources,
    255.         .id        = 1,
    256.         .dev        = {
    257.             .platform_data    = &da850_davinci_i2c_pdata,
    258.         },
    259.     };
    260.     */
    261.     //注册i2c对应的platform设备,把它注册到总线platform_bus_type上,即在sys的platform目录下建立文件和目录,参见platform驱动
    262.     platform_device_register(&davinci_i2c_device);
    263.     
    264.     //......
    265. }

    266. 3.在完成platform_device的添加之后,i2c子系统将进行platform_driver的注册过程。platform_driver的注册通过调用初始化函数davinci_i2c_init_driver()函数来完成。
    267. static struct platform_driver davinci_i2c_driver = {
    268.     .probe        = davinci_i2c_probe,
    269.     .remove        = davinci_i2c_remove,
    270.     .driver        = {
    271.         .name    = "i2c_davinci",
    272.         .owner    = THIS_MODULE,
    273.         .pm    = davinci_i2c_pm_ops,
    274.     },
    275. };

    276. //i2c通信方法结构
    277. static struct i2c_algorithm i2c_davinci_algo = {
    278.     .master_xfer    = i2c_davinci_xfer,
    279.     .functionality    = i2c_davinci_func,
    280. };

    281. //davinci平台封装的i2c设备结构
    282. struct davinci_i2c_dev {
    283.     struct device *dev;//内嵌device结构
    284.     void __iomem *base;//寄存器起始地址
    285.     struct completion cmd_complete;
    286.     struct clk *clk;//时钟
    287.     int cmd_err;
    288.     u8 *buf;//读写数据的buf
    289.     size_t buf_len;//读写数据长度
    290.     int irq;//中断号
    291.     int stop;
    292.     u8 terminate;
    293.     struct i2c_adapter adapter;//设备对应的adapter
    294. #ifdef CONFIG_CPU_FREQ//是否支持cpu变频技术
    295.     struct completion xfr_complete;
    296.     struct notifier_block freq_transition;
    297. #endif
    298.     struct davinci_i2c_platform_data *pdata;
    299. };

    300. //注册驱动
    301. static int __init davinci_i2c_init_driver(void)
    302. {
    303.     //platform_driver_register()同样也是进行其它的一些初始化后调用driver_register()将驱动注册到platform_bus_type总线上.
    304.     return platform_driver_register(&davinci_i2c_driver);
    305. }

    306. //driver_register()函数会扫描platform_bus_type总线上的设备与驱动进行配对,配对成功就会调用i2c的probe函数
    307. //因为之前的platform_device的name为i2c_davinci与platform_driver的name一致,故会match成功
    308. static int davinci_i2c_probe(struct platform_device *pdev)
    309. {
    310.     struct davinci_i2c_dev *dev;
    311.     struct i2c_adapter *adap;
    312.     struct resource *mem, *irq, *ioarea;
    313.     int r;

    314.     //获得platform_device设备对应的寄存器内存资源
    315.     mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    316.     if (!mem) {
    317.         dev_err(&pdev->dev, "no mem resource?n");
    318.         return -ENODEV;
    319.     }
    320.     //获得platform_device设备对应的中断资源
    321.     irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
    322.     if (!irq) {
    323.         dev_err(&pdev->dev, "no irq resource?n");
    324.         return -ENODEV;
    325.     }
    326.     
    327.     //申请寄存器的内存空间
    328.     ioarea = request_mem_region(mem->start, resource_size(mem),pdev->name);
    329.     if (!ioarea) {
    330.         dev_err(&pdev->dev, "I2C region already claimedn");
    331.         return -EBUSY;
    332.     }
    333.     
    334.     //分配davinci_i2c_dev空间
    335.     dev = kzalloc(sizeof(struct davinci_i2c_dev), GFP_KERNEL);
    336.     if (!dev) {
    337.         r = -ENOMEM;
    338.         goto err_release_region;
    339.     }
    340.     
    341.     //初始化davinci_i2c_dev结构
    342.     init_completion(&dev->cmd_complete);
    343. #ifdef CONFIG_CPU_FREQ
    344.     init_completion(&dev->xfr_complete);
    345. #endif
    346.     dev->dev = get_device(&pdev->dev);//将platform_device结构中的device字段赋值给davinci_i2c_dev结构中的device字段
    347.     dev->irq = irq->start;//设置中断号
    348.     platform_set_drvdata(pdev, dev);//将davinci_i2c_dev结构的dev保存在platform_device结构中

    349.     //获得时钟并使能时钟
    350.     dev->clk = clk_get(&pdev->dev, NULL);
    351.     if (IS_ERR(dev->clk)) {
    352.         r = -ENODEV;
    353.         goto err_free_mem;
    354.     }
    355.     clk_enable(dev->clk);

    356.     //将寄存器的起始地址映射到内存
    357.     dev->base = ioremap(mem->start, resource_size(mem));
    358.     if (!dev->base) {
    359.         r = -EBUSY;
    360.         goto err_mem_ioremap;
    361.     }
    362.     
    363.     //设置i2c器件的寄存器,设置时钟分频,设置中断,设置从地址等
    364.     i2c_davinci_init(dev);
    365.     
    366.     //申请中断号,中断处理函数是i2c_davinci_isr()
    367.     r = request_irq(dev->irq, i2c_davinci_isr, 0, pdev->name, dev);
    368.     if (r) {
    369.         dev_err(&pdev->dev, "failure requesting irq %in", dev->irq);
    370.         goto err_unuse_clocks;
    371.     }
    372.     
    373.     //与cpu变频技术有关
    374.     r = i2c_davinci_cpufreq_register(dev);
    375.     if (r) {
    376.         dev_err(&pdev->dev, "failed to register cpufreqn");
    377.         goto err_free_irq;
    378.     }
    379.     
    380.     //初始化davinci_i2c_dev结构中对应的adapter字段
    381.     adap = &dev->adapter;
    382.     i2c_set_adapdata(adap, dev);//将davinci_i2c_dev结构的dev保存在adapter结构中
    383.     adap->owner = THIS_MODULE;
    384.     adap->class = I2C_CLASS_HWMON;
    385.     strlcpy(adap->name, "DaVinci I2C adapter", sizeof(adap->name));
    386.     adap->algo = &i2c_davinci_algo;//adapter的通信方法
    387.     adap->dev.parent = &pdev->dev;
    388.     adap->timeout = DAVINCI_I2C_TIMEOUT;
    389.     adap->nr = pdev->id;//1
    390.     
    391.     //注册davinci_i2c_dev结构中对应的adapter设备(之后还会注册adapter的驱动)
    392.     r = i2c_add_numbered_adapter(adap);//将adapter设备注册到i2c_bus_type总线上
    393.     if (r) {
    394.         dev_err(&pdev->dev, "failure adding adaptern");
    395.         goto err_free_irq;
    396.     }
    397.     return 0;

    398. err_free_irq:
    399.     free_irq(dev->irq, dev);
    400. err_unuse_clocks:
    401.     iounmap(dev->base);
    402. err_mem_ioremap:
    403.     clk_disable(dev->clk);
    404.     clk_put(dev->clk);
    405.     dev->clk = NULL;
    406. err_free_mem:
    407.     platform_set_drvdata(pdev, NULL);
    408.     put_device(&pdev->dev);
    409.     kfree(dev);
    410. err_release_region:
    411.     release_mem_region(mem->start, resource_size(mem));

    412.     return r;
    413. }

    414. static int i2c_davinci_init(struct davinci_i2c_dev *dev)
    415. {
    416.     struct davinci_i2c_platform_data *pdata = dev->dev->platform_data;

    417.     if (!pdata)
    418.         pdata = &davinci_i2c_platform_data_default;

    419.     //reset I2C,即使i2c无效
    420.     davinci_i2c_reset_ctrl(dev, 0);

    421.     //计算时钟分频
    422.     i2c_davinci_calc_clk_dividers(dev);

    423.     //为I2C提供从地址为0x08
    424.     davinci_i2c_write_reg(dev, DAVINCI_I2C_OAR_REG, 0x08);
    425.     //调试
    426.     dev_dbg(dev->dev, "PSC = %dn",davinci_i2c_read_reg(dev, DAVINCI_I2C_PSC_REG));
    427.     dev_dbg(dev->dev, "CLKL = %dn",davinci_i2c_read_reg(dev, DAVINCI_I2C_CLKL_REG));
    428.     dev_dbg(dev->dev, "CLKH = %dn",davinci_i2c_read_reg(dev, DAVINCI_I2C_CLKH_REG));
    429.     dev_dbg(dev->dev, "bus_freq = %dkHz, bus_delay = %dn",pdata->bus_freq, pdata->bus_delay);

    430.     //使能I2C器件
    431.     davinci_i2c_reset_ctrl(dev, 1);

    432.     //使能所有i2c中断
    433.     davinci_i2c_write_reg(dev, DAVINCI_I2C_IMR_REG, I2C_DAVINCI_INTR_ALL);
    434.     return 0;
    435. }

    436. static inline void davinci_i2c_reset_ctrl(struct davinci_i2c_dev *i2c_dev,int val)
    437. {
    438.     u16 w;
    439.     //读I2C Mode Register (ICMDR)寄存器
    440.     w = davinci_i2c_read_reg(i2c_dev, DAVINCI_I2C_MDR_REG);
    441.     
    442.     if (!val)//reset
    443.         w &= ~DAVINCI_I2C_MDR_IRS; //DAVINCI_I2C_MDR_IRS = BIT(5),即1<<5,即ICMDR寄存器第五位清0,表示reset i2c
    444.     else//enable
    445.         w |= DAVINCI_I2C_MDR_IRS;//ICMDR寄存器第五位置1,表示使能i2c
    446.     //重新写会ICMDR寄存器
    447.     davinci_i2c_write_reg(i2c_dev, DAVINCI_I2C_MDR_REG, w);
    448. }

    449. static inline void davinci_i2c_write_reg(struct davinci_i2c_dev *i2c_dev,int reg, u16 val)
    450. {
    451.     __raw_writew(val, i2c_dev->base + reg);
    452. }

    453. static inline u16 davinci_i2c_read_reg(struct davinci_i2c_dev *i2c_dev, int reg)
    454. {
    455.     return __raw_readw(i2c_dev->base + reg);
    456. }

    457. static void i2c_davinci_calc_clk_dividers(struct davinci_i2c_dev *dev)
    458. {
    459.     struct davinci_i2c_platform_data *pdata = dev->dev->platform_data;
    460.     u16 psc;
    461.     u32 clk;
    462.     u32 d;
    463.     u32 clkh;
    464.     u32 clkl;
    465.     u32 input_clock = clk_get_rate(dev->clk);

    466.     /* NOTE: I2C Clock divider programming info
    467.      * As per I2C specs the following formulas provide prescaler
    468.      * and low/high divider values
    469.      * input clk --> PSC Div -----------> ICCL/H Div --> output clock
    470.      * module clk
    471.      *
    472.      * output clk = module clk / (PSC + 1) [ (ICCL + d) + (ICCH + d) ]
    473.      *
    474.      * Thus,
    475.      * (ICCL + ICCH) = clk = (input clk / ((psc +1) * output clk)) - 2d;
    476.      *
    477.      * where if PSC == 0, d = 7,
    478.      * if PSC == 1, d = 6
    479.      * if PSC > 1 , d = 5
    480.      */

    481.     /* get minimum of 7 MHz clock, but max of 12 MHz */
    482.     psc = (input_clock / 7000000) - 1;
    483.     if ((input_clock / (psc + 1)) > 12000000)
    484.         psc++;    /* better to run under spec than over */
    485.     d = (psc >= 2) ? 5 : 7 - psc;

    486.     clk = ((input_clock / (psc + 1)) / (pdata->bus_freq * 1000)) - (d << 1);
    487.     clkh = clk >> 1;
    488.     clkl = clk - clkh;

    489.     davinci_i2c_write_reg(dev, DAVINCI_I2C_PSC_REG, psc);
    490.     davinci_i2c_write_reg(dev, DAVINCI_I2C_CLKH_REG, clkh);
    491.     davinci_i2c_write_reg(dev, DAVINCI_I2C_CLKL_REG, clkl);

    492.     dev_dbg(dev->dev, "input_clock = %d, CLK = %dn", input_clock, clk);
    493. }

    494. static inline void i2c_set_adapdata(struct i2c_adapter *dev, void *data)
    495. {
    496.     dev_set_drvdata(&dev->dev, data);
    497. }

    498. int dev_set_drvdata(struct device *dev, void *data)
    499. {
    500.     int error;
    501.     
    502.     if (!dev->p) {
    503.         error = device_private_init(dev);//为dev->p分配空间,并且初始化
    504.         if (error)
    505.         return error;
    506.     }
    507.     dev->p->driver_data = data;
    508.     return 0;
    509. }

    510. int device_private_init(struct device *dev)
    511. {
    512.     dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
    513.     if (!dev->p)
    514.         return -ENOMEM;
    515.     dev->p->device = dev;
    516.     klist_init(&dev->p->klist_children, klist_children_get,klist_children_put);
    517.     INIT_LIST_HEAD(&dev->p->deferred_probe);
    518.     return 0;
    519. }

    520. int i2c_add_numbered_adapter(struct i2c_adapter *adap)
    521. {
    522.     int    id;
    523.     int    status;

    524.     if (adap->nr & ~MAX_ID_MASK)//adap->nr=1
    525.         return -EINVAL;

    526. retry:
    527.     /*
    528.     在这里涉及到一个idr结构。idr结构本来是为了配合page cache中的radix tree而设计的。在这里我们只需要知道,它是一种高效的搜索树,且这个树预先存放了一些内存。避免在内存不够的时候出现问题。所以,在往idr中插入结构的时候,首先要调用idr_pre_get()为它预留足够的空闲内存,然后再调用idr_get_new_above()将结构插入idr中,该函数以参数的形式返回一个id.以后凭这个id就可以在idr中找到相对应的结构了。
    529.     */
    530.     if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
    531.         return -ENOMEM;

    532.     mutex_lock(&core_lock);//上锁
    533.     
    534.     //它是将adapter结构插入到i2c_adapter_idr中,存放位置的id必须要大于或者等于adap->nr,然后将对应的id号存放在adapter->nr中
    535.     status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
    536.     if (status == 0 && id != adap->nr) {
    537.         status = -EBUSY;
    538.         idr_remove(&i2c_adapter_idr, id);
    539.     }
    540.     mutex_unlock(&core_lock);//解锁
    541.     if (status == -EAGAIN)
    542.         goto retry;

    543.     if (status == 0)
    544.         status = i2c_register_adapter(adap);//对这个adapter进行进一步注册。
    545.     return status;
    546. }

    547. static int i2c_register_adapter(struct i2c_adapter *adap)
    548. {
    549.     int res = 0;

    550.     if (unlikely(WARN_ON(!i2c_bus_type.p))) {
    551.         res = -EAGAIN;
    552.         goto out_list;
    553.     }

    554.     /* Sanity checks */
    555.     if (unlikely(adap->name[0] == '0')) {//adapter的name不为空
    556.         pr_err("i2c-core: Attempt to register an adapter with ""no name!n");
    557.         return -EINVAL;
    558.     }
    559.     if (unlikely(!adap->algo)) {//adapter的通信算法不能为空
    560.         pr_err("i2c-core: Attempt to register adapter '%s' with ""no algo!n", adap->name);
    561.         return -EINVAL;
    562.     }

    563.     rt_mutex_init(&adap->bus_lock);
    564.     mutex_init(&adap->userspace_clients_lock);
    565.     INIT_LIST_HEAD(&adap->userspace_clients);

    566.     //若没设置超时时间,则缺省为HZ。实际已经设置
    567.     if (adap->timeout == 0)
    568.         adap->timeout = HZ;
    569.     
    570.     //adapter中内嵌的struct device结构进行必须的初始化
    571.     dev_set_name(&adap->dev, "i2c-%d", adap->nr);//设置adapter->dev的设备名:i2c-1
    572.     adap->dev.bus = &i2c_bus_type;//adapter中内嵌的struct device所在总线为i2c_bus_type
    573.     adap->dev.type = &i2c_adapter_type;//adapter设备类型设为i2c_adapter_type
    574.     
    575.     //adapter内嵌的struct device注册
    576.     res = device_register(&adap->dev);//注册adapter设备,即在sysfs文件系统的bus/i2c目录下创建adapter相应的文件和目录
    577.     if (res)
    578.         goto out_list;

    579.     dev_dbg(&adap->dev, "adapter [%s] registeredn", adap->name);

    580.     //调用此函数i2c_scan_static_board_info之前,必须要调用i2c_register_board_info()将板子上的I2C设备信息预先注册到__i2c_board_list链表中,
    581.     //同时才会更改__i2c_first_dynamic_bus_num的值
    582.     if (adap->nr < __i2c_first_dynamic_bus_num)//__i2c_first_dynamic_bus_num=0,adap->nr=1,不会调用下边的函数
    583.         i2c_scan_static_board_info(adap);//遍历__i2c_board_list中挂载的i2c_devinfo结构,每个都是一个i2c_client即i2c设备。
    584.                                                                         //若i2c设备(i2c_client)与adapter位于同一i2c总线上,则调用i2c_new_device()进行i2c设备(i2c_client)注册
    585.     /* Notify drivers */
    586.     mutex_lock(&core_lock);
    587.     //在新的适配器加入内核时调用函数 bus_for_each_drv时调用的函数。
    588.   //函数bus_for_each_drv是在总线类型为i2c_bus_type的驱动中找到一个驱动与新加入的适配器匹配。
    589.     bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);//遍历该总线上所有的driver,并设用attach_adapter,因为adapter的驱动还没注册,
    590.                                                                                                                                         //attach_adapter为空,设置会调用失败。
    591.     mutex_unlock(&core_lock);

    592.     return 0;

    593. out_list:
    594.     mutex_lock(&core_lock);
    595.     idr_remove(&i2c_adapter_idr, adap->nr);
    596.     mutex_unlock(&core_lock);
    597.     return res;
    598. }

    599. 4.i2c-dev模块为系统中所有的i2c适配器创建相应的/dev/i2c/%d字符设备节点,并注册设备访问方法,从而使得用户进程可以访问该i2c总线上的设备。
    600. 运行i2c_dev_init函数,注册adapter设备驱动,以_init为头的函数,在运行过后系统将回收其内存
    601. //前边已经注册了adapter设备device_register(&adap->dev);下边要注册设备的驱动i2c_add_driver(&i2cdev_driver);
    602. //驱动注册成功会和前边才注册的adapter设备相匹配i2cdev_attach_adapter(),匹配成功则创建设备文件。
    603. static int __init i2c_dev_init(void)
    604. {
    605.     int res;

    606.     printk(KERN_INFO "i2c /dev entries drivern");
    607.     //register_chrdev函数最终会向系统注册主设备为I2C_MAJOR,此设备号为0~255的设备。这表示系统最多可以容纳256个i2c adapter,其中注册的结构体&i2cdev_fops,给用户空间提供了调用接口,就是个字符型驱动
    608.     /*当read()、write()、open()、close()、ioctl()等系统调用发生时就会调用到这些函数。
    609.     static const struct file_operations i2cdev_fops = {
    610.         .owner        = THIS_MODULE,
    611.         .llseek        = no_llseek,
    612.         .read        = i2cdev_read,
    613.         .write        = i2cdev_write,
    614.         .unlocked_ioctl    = i2cdev_ioctl,
    615.         .open        = i2cdev_open,
    616.         .release    = i2cdev_release,
    617.     };
    618.     */
    619.     res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);//注册i2C的字符设备
    620.     if (res)
    621.         goto out;

    622.     //创建设备类,字符设备注册完毕后通过class_create()函数初始化一个类i2c_dev_class,为sysfs系统创建一个i2c-dev的设备类
    623.     i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");
    624.     if (IS_ERR(i2c_dev_class)) {
    625.         res = PTR_ERR(i2c_dev_class);
    626.         goto out_unreg_chrdev;
    627.     }
    628.     //调用函数i2c_add_driver函数注册i2c driver。这里所说的i2c其实对应的是系统中所有的i2c类设备(包括i2c_client 和 adapter)
    629.     /*
    630.         static struct i2c_driver i2cdev_driver = {
    631.          .driver = {
    632.          .name = "dev_driver",
    633.          },
    634.          .attach_adapter = i2cdev_attach_adapter,
    635.          .detach_adapter = i2cdev_detach_adapter,
    636.         };

    637.     */
    638.     //其作用在于为系统中所有已安装的i2c适配器调用i2cdev_driver的attach_adpter方法,
    639.     //即i2cdev_attach_adapter函数,为所有已安装的适配器创建相应的/dev/i2c-%d字符设备结点并注册设备访问方法。
    640.     res = i2c_add_driver(&i2cdev_driver);//注册adapter的驱动
    641.     if (res)
    642.         goto out_unreg_class;

    643.     return 0;

    644. out_unreg_class:
    645.     class_destroy(i2c_dev_class);
    646. out_unreg_chrdev:
    647.     unregister_chrdev(I2C_MAJOR, "i2c");
    648. out:
    649.     printk(KERN_ERR "%s: Driver Initialisation failedn", __FILE__);
    650.     return res;
    651. }

    652. static inline int i2c_add_driver(struct i2c_driver *driver)
    653. {
    654.     return i2c_register_driver(THIS_MODULE, driver);
    655. }

    656. int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
    657. {
    658.     int res;

    659.     /* Can't register until after driver model init */
    660.     if (unlikely(WARN_ON(!i2c_bus_type.p)))
    661.         return -EAGAIN;

    662.     //关联到i2c_bus_types
    663.     driver->driver.owner = owner;
    664.     driver->driver.bus = &i2c_bus_type;//设置i2c驱动的总线

    665.     //注册i2c_driver结构中内嵌的device_driver,即创建相应的sysfs文件系统的文件或属性文件
    666.     res = driver_register(&driver->driver);
    667.     if (res)
    668.         return res;

    669.     pr_debug("i2c-core: driver [%s] registeredn", driver->driver.name);

    670.     INIT_LIST_HEAD(&driver->clients);
    671.     /* Walk the adapters that are already present */
    672.     mutex_lock(&core_lock);
    673.     bus_for_each_dev(&i2c_bus_type, NULL, driver, __process_new_driver);//遍历i2c_bus_type总线上所有的设备,与新加入的驱动相匹配,并调用驱动的attach_adapter
    674.     mutex_unlock(&core_lock);

    675.     return 0;
    676. }

    677. int bus_for_each_dev(struct bus_type *bus, struct device *start,void *data, int (*fn)(struct device *, void *))
    678. {
    679.     struct klist_iter i;
    680.     struct device *dev;
    681.     int error = 0;

    682.     if (!bus)
    683.         return -EINVAL;

    684.     klist_iter_init_node(&bus->p->klist_devices, &i,(start ? &start->p->knode_bus : NULL)); //将bus中的已注册的device列表放到迭代器中,方便索引
    685.     while ((dev = next_device(&i)) && !error) //将驱动逐个地与列表中每一个的device匹配,可能一个驱动匹配好几个设备
    686.         error = fn(dev, data); //这个fn就是上面传下来的__process_new_driver
    687.     klist_iter_exit(&i);
    688.     return error;
    689. }

    690. static int __process_new_driver(struct device *dev, void *data)
    691. {
    692.     if (dev->type != &i2c_adapter_type)//设备的类型是adapter,才能配对成功。由于之前已经注册过adapter设备了,所以在这里会找到adapter的设备
    693.         return 0;
    694.     //前边adapter的dev已经注册,这里会找到注册的i2c_adapter设备
    695.     return i2c_do_add_adapter(data, to_i2c_adapter(dev));
    696. }

    697. static int i2c_do_add_adapter(struct i2c_driver *driver,struct i2c_adapter *adap)
    698. {
    699.     i2c_detect(adap, driver);//空函数

    700.     if (driver->attach_adapter) {
    701.         driver->attach_adapter(adap);//调用i2cdev_attach_adapter()
    702.     }
    703.     return 0;
    704. }

    705. static int i2cdev_attach_adapter(struct i2c_adapter *adap)
    706. {
    707.     struct i2c_dev *i2c_dev;
    708.     int res;
    709.     /*打开一个i2c设备时,会看到此结构的用处:
    710.     struct i2c_dev {
    711.         struct list_head list;
    712.         struct i2c_adapter *adap;//指向对应的adapter
    713.         struct device *dev;
    714.     };
    715.     */
    716.     i2c_dev = get_free_i2c_dev(adap);//创建一个i2c_dev结构,添加到全局链表i2c_dev_list中,并且指向adap( i2c_dev->adap = adap;)
    717.     if (IS_ERR(i2c_dev))
    718.         return PTR_ERR(i2c_dev);

    719.     /* 可见attach_adapter函数的作用就是调用device_create()函数 通过之前class_create的类信息在/dev下自动创建设备文件。
    720.     并且此设备的设备号是由固定的主设备号I2C_MAJOR 和 从设备号组成的,从设备号取的就是adapter的nr,此处为1。
    721.     并且可以推断出系统最多可以容纳0~255 总共256个i2c adapter。
    722.  */
    723.      //创建adapter设备在sysfs文件系统中的相应文件或目录,并在sysfs文件系统类目录下的i2c-dev目录下创建i2c-1目录,此目录下创建设备节点的dev文件
    724.      ///sys/class/i2c-dev/i2c-1/...(其中这里的i2c_dev->dev结构就是为创建目录i2c-1而使用的)
    725.      //系统启动后udev程序会根据sysfs文件系统相关的设备文件,创建设备节点,即i2c-1的设备节点
    726.     i2c_dev->dev = device_create(i2c_dev_class, &adap->dev,MKDEV(I2C_MAJOR, adap->nr), NULL,"i2c-%d", adap->nr);
    727.     if (IS_ERR(i2c_dev->dev)) {
    728.         res = PTR_ERR(i2c_dev->dev);
    729.         goto error;
    730.     }
    731.     //为sysfs文件系统创建相应的属性文件
    732.     res = device_create_file(i2c_dev->dev, &dev_attr_name);
    733.     if (res)
    734.         goto error_destroy;

    735.     pr_debug("i2c-dev: adapter [%s] registered as minor %dn",adap->name, adap->nr);
    736.     return 0;
    737. error_destroy:
    738.     device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));
    739. error:
    740.     return_i2c_dev(i2c_dev);
    741.     return res;
    742. }


    743. 六、i2c的打开、读、写
    744. 6.1 i2c设备的打开
    745. static int i2cdev_open(struct inode *inode, struct file *file)
    746. {
    747.     unsigned int minor = iminor(inode);
    748.     struct i2c_client *client;
    749.     struct i2c_adapter *adap;
    750.     struct i2c_dev *i2c_dev;
    751.     
    752.     //遍历i2c_dev_list链表,根据i2c_dev对应的adapter的索引值找到对应的i2c_dev结构
    753.     i2c_dev = i2c_dev_get_by_minor(minor);
    754.     if (!i2c_dev)
    755.         return -ENODEV;

    756.     //根据i2c_dev结构找到adapter
    757.     adap = i2c_get_adapter(i2c_dev->adap->nr);
    758.     if (!adap)
    759.         return -ENODEV;

    760.     //分配i2c_client结构空间
    761.     client = kzalloc(sizeof(*client), GFP_KERNEL);
    762.     if (!client) {
    763.         i2c_put_adapter(adap);
    764.         return -ENOMEM;
    765.     }
    766.     snprintf(client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr);
    767.     client->driver = &i2cdev_driver;//设备驱动(adapter 也是这个设备驱动,共用)

    768.     client->adapter = adap;//依附的adapter
    769.     file->private_data = client;//保存到文件的private_data字段中

    770.     return 0;
    771. }

    772. 6.2 i2c的读数据
    773. static ssize_t i2cdev_read(struct file *file, char __user *buf, size_t count,loff_t *offset)
    774. {
    775.     char *tmp;
    776.     int ret;
    777.     //找到相应的i2c_client
    778.     struct i2c_client *client = file->private_data;

    779.     if (count > 8192)
    780.         count = 8192;

    781.     tmp = kmalloc(count, GFP_KERNEL);
    782.     if (tmp == NULL)
    783.         return -ENOMEM;

    784.     pr_debug("i2c-dev: i2c-%d reading %zu bytes.n",iminor(file->f_path.dentry->d_inode), count);

    785.     ret = i2c_master_recv(client, tmp, count);//读数据
    786.     if (ret >= 0)
    787.         ret = copy_to_user(buf, tmp, count) ? -EFAULT : ret;//读出数据拷贝到用户空间
    788.     kfree(tmp);
    789.     return ret;
    790. }

    791. int i2c_master_recv(struct i2c_client *client, char *buf, int count)
    792. {
    793.     struct i2c_adapter *adap = client->adapter;
    794.     struct i2c_msg msg;
    795.     int ret;

    796.     msg.addr = client->addr;//应用程序会通过ioctl(i2c_fd,I2C_SLAVE,slaveaddr)来设置client的地址
    797.     msg.flags = client->flags & I2C_M_TEN;//是否设置过10位地址
    798.     msg.flags |= I2C_M_RD;//读数据标志
    799.     msg.len = count;//读数据长度
    800.     msg.buf = buf;//数据存储空间

    801.     ret = i2c_transfer(adap, &msg, 1);//传输1个msg

    802.     return (ret == 1) ? count : ret;
    803. }


    804. int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
    805. {
    806.     unsigned long orig_jiffies;
    807.     int ret, try;
    808.     
    809.     if (adap->algo->master_xfer) {//存在通信方法
    810.         if (in_atomic() || irqs_disabled()) {
    811.             ret = i2c_trylock_adapter(adap);
    812.             if (!ret)/* I2C activity is ongoing. */
    813.                 return -EAGAIN;
    814.         } else {
    815.             i2c_lock_adapter(adap);//给adapter上锁
    816.         }

    817.         orig_jiffies = jiffies;
    818.         for (ret = 0, try = 0; try <= adap->retries; try++) {
    819.             ret = adap->algo->master_xfer(adap, msgs, num);//最终转换为i2c_algorithm中的master_xfer传输,调用i2c_davinci_xfer()
    820.             if (ret != -EAGAIN)
    821.                 break;
    822.             if (time_after(jiffies, orig_jiffies + adap->timeout))//retry间隔时间
    823.                 break;
    824.         }
    825.         i2c_unlock_adapter(adap);//给adapter解锁

    826.         return ret;
    827.     } else {
    828.         dev_dbg(&adap->dev, "I2C level transfers not supportedn");
    829.         return -EOPNOTSUPP;
    830.     }
    831. }

    832. static int i2c_davinci_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
    833. {
    834.     struct davinci_i2c_dev *dev = i2c_get_adapdata(adap);
    835.     int i;
    836.     int ret;

    837.     dev_dbg(dev->dev, "%s: msgs: %dn", __func__, num);

    838.     ret = i2c_davinci_wait_bus_not_busy(dev, 1);//读ICSTR寄存器查看i2c是否忙,忙则等待到timeout
    839.     if (ret < 0) {
    840.         dev_warn(dev->dev, "timeout waiting for bus readyn");
    841.         return ret;
    842.     }

    843.     for (i = 0; i < num; i++) {
    844.         ret = i2c_davinci_xfer_msg(adap, &msgs[i], (i == (num - 1)));//发送一个msg
    845.         dev_dbg(dev->dev, "%s [%d/%d] ret: %dn", __func__, i + 1, num,ret);
    846.         if (ret < 0)
    847.             return ret;
    848.     }

    849. #ifdef CONFIG_CPU_FREQ //cpu变频支持
    850.     complete(&dev->xfr_complete);
    851. #endif

    852.     return num;
    853. }

    854. static int i2c_davinci_xfer_msg(struct i2c_adapter *adap, struct i2c_msg *msg, int stop)
    855. {
    856.     struct davinci_i2c_dev *dev = i2c_get_adapdata(adap);
    857.     struct davinci_i2c_platform_data *pdata = dev->dev->platform_data;
    858.     u32 flag;
    859.     u16 w;
    860.     int r;

    861.     if (!pdata)
    862.         pdata = &davinci_i2c_platform_data_default;
    863.     /* Introduce a delay, required for some boards (e.g Davinci EVM) */
    864.     if (pdata->bus_delay)//i2c等待时间为100us
    865.         udelay(pdata->bus_delay);

    866.     //设置从地址
    867.     davinci_i2c_write_reg(dev, DAVINCI_I2C_SAR_REG, msg->addr);

    868.     dev->buf = msg->buf;
    869.     dev->buf_len = msg->len;
    870.     dev->stop = stop;

    871.     //写入数据计数寄存器,即把要读多少个数据写入寄存器ICCNT
    872.     davinci_i2c_write_reg(dev, DAVINCI_I2C_CNT_REG, dev->buf_len);

    873.     INIT_COMPLETION(dev->cmd_complete);
    874.     dev->cmd_err = 0;

    875.     //设置使能I2C和设置I2C为主设备
    876.     flag = DAVINCI_I2C_MDR_IRS | DAVINCI_I2C_MDR_MST;

    877.     /* if the slave address is ten bit address, enable XA bit */
    878.     if (msg->flags & I2C_M_TEN)//如果从设备是10位地址模式
    879.         flag |= DAVINCI_I2C_MDR_XA;//设置主设备也为10位地址模式
    880.     if (!(msg->flags & I2C_M_RD))
    881.         flag |= DAVINCI_I2C_MDR_TRX;//设置主设备为接收模式
    882.     if (msg->len == 0)
    883.         flag |= DAVINCI_I2C_MDR_RM;//repeat模式

    884.     //使能I2C的接收和发送中断
    885.     w = davinci_i2c_read_reg(dev, DAVINCI_I2C_IMR_REG);
    886.     if (msg->flags & I2C_M_RD)
    887.         w |= DAVINCI_I2C_IMR_RRDY;
    888.     else
    889.         w |= DAVINCI_I2C_IMR_XRDY;
    890.     davinci_i2c_write_reg(dev, DAVINCI_I2C_IMR_REG, w);

    891.     dev->terminate = 0;

    892.     //写入配置模式寄存器I2C Mode Register (ICMDR)
    893.     davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);

    894.     /*
    895.      * First byte should be set here, not after interrupt,
    896.      * because transmit-data-ready interrupt can come before
    897.      * NACK-interrupt during sending of previous message and
    898.      * ICDXR may have wrong data
    899.      * It also saves us one interrupt, slightly faster
    900.      */
    901.     if ((!(msg->flags & I2C_M_RD)) && dev->buf_len) {//如果不是读模式,则向发送寄存器写出一个数据,后续数据会通过发送中断自动发送完成,直到dev->buf_len为0
    902.         davinci_i2c_write_reg(dev, DAVINCI_I2C_DXR_REG, *dev->buf++);
    903.         dev->buf_len--;
    904.     }

    905.     /* Set STT to begin transmit now DXR is loaded */
    906.     flag |= DAVINCI_I2C_MDR_STT;//产生起始位
    907.     if (stop && msg->len != 0)//stop=0,不需设置停止位
    908.         flag |= DAVINCI_I2C_MDR_STP;
    909.     davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);//产生起始位,准备读数据
    910.     
    911.     //等待读指令完成,这是在I2C中断中i2c_davinci_isr()完成读数据后,会complete(&dev->cmd_complete);
    912.     r = wait_for_completion_interruptible_timeout(&dev->cmd_complete,dev->adapter.timeout);
    913.     if (r == 0) {//返回0表示timeout,返回错误
    914.         dev_err(dev->dev, "controller timed outn");
    915.         i2c_recover_bus(dev);
    916.         i2c_davinci_init(dev);
    917.         dev->buf_len = 0;
    918.         return -ETIMEDOUT;
    919.     }
    920.     
    921.     if (dev->buf_len) {//读取到足够数据或者写完数据,dev->buf_len应该为0
    922.         /* This should be 0 if all bytes were transferred or dev->cmd_err denotes an error.A signal may have aborted the transfer.*/
    923.         if (r >= 0) {
    924.             dev_err(dev->dev, "abnormal termination buf_len=%in",dev->buf_len);
    925.             r = -EREMOTEIO;
    926.         }
    927.         dev->terminate = 1;
    928.         wmb();
    929.         dev->buf_len = 0;
    930.     }
    931.     if (r < 0)
    932.         return r;

    933.     //没有错误,则返回读到的数据个数
    934.     if (likely(!dev->cmd_err))
    935.         return msg->len;

    936.     /* We have an error */
    937.     if (dev->cmd_err & DAVINCI_I2C_STR_AL) {
    938.         i2c_davinci_init(dev);
    939.         return -EIO;
    940.     }

    941.     if (dev->cmd_err & DAVINCI_I2C_STR_NACK) {
    942.         if (msg->flags & I2C_M_IGNORE_NAK)
    943.             return msg->len;
    944.         if (stop) {
    945.             w = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
    946.             w |= DAVINCI_I2C_MDR_STP;
    947.             davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, w);
    948.         }
    949.         return -EREMOTEIO;
    950.     }
    951.     return -EIO;
    952. }

    953. static irqreturn_t i2c_davinci_isr(int this_irq, void *dev_id)
    954. {
    955.     struct davinci_i2c_dev *dev = dev_id;
    956.     u32 stat;
    957.     int count = 0;
    958.     u16 w;

    959.     while ((stat = davinci_i2c_read_reg(dev, DAVINCI_I2C_IVR_REG))) {//读I2C Interrupt Vector Register (ICIVR)判断中断类型
    960.         dev_dbg(dev->dev, "%s: stat=0x%xn", __func__, stat);
    961.         if (count++ == 100) {
    962.             dev_warn(dev->dev, "Too much work in one IRQn");
    963.             break;
    964.         }

    965.         switch (stat) {
    966.         case DAVINCI_I2C_IVR_AL://Arbitration-lost interrupt
    967.             /* Arbitration lost, must retry */
    968.             dev->cmd_err |= DAVINCI_I2C_STR_AL;
    969.             dev->buf_len = 0;
    970.             complete(&dev->cmd_complete);
    971.             break;

    972.         case DAVINCI_I2C_IVR_NACK://No-acknowledgment interrupt
    973.             dev->cmd_err |= DAVINCI_I2C_STR_NACK;
    974.             dev->buf_len = 0;
    975.             complete(&dev->cmd_complete);
    976.             break;

    977.         case DAVINCI_I2C_IVR_ARDY://Register-access-ready interrupt
    978.             davinci_i2c_write_reg(dev,DAVINCI_I2C_STR_REG, DAVINCI_I2C_STR_ARDY);
    979.             if (((dev->buf_len == 0) && (dev->stop != 0)) ||(dev->cmd_err & DAVINCI_I2C_STR_NACK)) {
    980.                 w = davinci_i2c_read_reg(dev,DAVINCI_I2C_MDR_REG);
    981.                 w |= DAVINCI_I2C_MDR_STP;
    982.                 davinci_i2c_write_reg(dev,DAVINCI_I2C_MDR_REG, w);
    983.             }
    984.             complete(&dev->cmd_complete);
    985.             break;

    986.         case DAVINCI_I2C_IVR_RDR://接受数据中断
    987.             if (dev->buf_len) {
    988.                 *dev->buf++ =davinci_i2c_read_reg(dev,DAVINCI_I2C_DRR_REG);//从接受寄存器ICDRR中读取数据
    989.                 dev->buf_len--;
    990.                 if (dev->buf_len)
    991.                     continue;

    992.                 davinci_i2c_write_reg(dev,DAVINCI_I2C_STR_REG,DAVINCI_I2C_IMR_RRDY);//表明接受寄存器ICDRR中的数据已经拷贝完毕
    993.             } else {
    994.                 /* signal can terminate transfer */
    995.                 terminate_read(dev);
    996.             }
    997.             break;

    998.         case DAVINCI_I2C_IVR_XRDY://发送数据中断interrupt
    999.             if (dev->buf_len) {
    1000.                 davinci_i2c_write_reg(dev, DAVINCI_I2C_DXR_REG,*dev->buf++);//要发送的数据写入到发送寄存器中
    1001.                 dev->buf_len--;
    1002.                 if (dev->buf_len)
    1003.                     continue;

    1004.                 w = davinci_i2c_read_reg(dev,DAVINCI_I2C_IMR_REG);
    1005.                 w &= ~DAVINCI_I2C_IMR_XRDY;
    1006.                 davinci_i2c_write_reg(dev,DAVINCI_I2C_IMR_REG,w);//禁止发送中断,在i2c_davinci_xfer()函数中,当数据要再次发送时,会再使能发送中断的
    1007.             } else {
    1008.                 /* signal can terminate transfer */
    1009.                 terminate_write(dev);
    1010.             }
    1011.             break;

    1012.         case DAVINCI_I2C_IVR_SCD://Stop condition detected interrupt
    1013.             davinci_i2c_write_reg(dev,DAVINCI_I2C_STR_REG, DAVINCI_I2C_STR_SCD);
    1014.             complete(&dev->cmd_complete);
    1015.             break;

    1016.         case DAVINCI_I2C_IVR_AAS://Address-as-slave interrupt
    1017.             dev_dbg(dev->dev, "Address as slave interruptn");
    1018.             break;

    1019.         default:
    1020.             dev_warn(dev->dev, "Unrecognized irq stat %dn", stat);
    1021.             break;
    1022.         }
    1023.     }
    1024.     return count ? IRQ_HANDLED : IRQ_NONE;
    1025. }

    1026. 6.3 i2c的写数据
    1027. static ssize_t i2cdev_write(struct file *file, const char __user *buf,size_t count, loff_t *offset)
    1028. {
    1029.     int ret;
    1030.     char *tmp;
    1031.     struct i2c_client *client = file->private_data;

    1032.     if (count > 8192)
    1033.         count = 8192;

    1034.     tmp = memdup_user(buf, count);
    1035.     if (IS_ERR(tmp))
    1036.         return PTR_ERR(tmp);

    1037.     pr_debug("i2c-dev: i2c-%d writing %zu bytes.n",iminor(file->f_path.dentry->d_inode), count);

    1038.     ret = i2c_master_send(client, tmp, count);
    1039.     kfree(tmp);
    1040.     return ret;
    1041. }

    1042. int i2c_master_send(struct i2c_client *client, const char *buf, int count)
    1043. {
    1044.     int ret;
    1045.     struct i2c_adapter *adap = client->adapter;
    1046.     struct i2c_msg msg;

    1047.     msg.addr = client->addr;
    1048.     msg.flags = client->flags & I2C_M_TEN;
    1049.     msg.len = count;
    1050.     msg.buf = (char *)buf;

    1051.     ret = i2c_transfer(adap, &msg, 1);//同上

    1052.     return (ret == 1) ? count : ret;
    1053. }

疑问点:
static int i2c_davinci_cpufreq_transition(struct notifier_block *nb,unsigned long val, void *data)
{
  struct davinci_i2c_dev *dev;

  dev = container_of(nb, struct davinci_i2c_dev, freq_transition);
  if (val == CPUFREQ_PRECHANGE) {
    //wait_for_completion(&dev->xfr_complete);//也要注销掉,否则程序一直等在这里
    davinci_i2c_reset_ctrl(dev, 0);
  } else if (val == CPUFREQ_POSTCHANGE) {
    i2c_davinci_calc_clk_dividers(dev);
    davinci_i2c_reset_ctrl(dev, 1);
  }
 return 0;
}
如果不把这一行wait_for_completion(&dev->xfr_complete);注销掉,linux启动时程序会一直在这里等待。

发现唤醒它的地方在:
static int i2c_davinci_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
{
struct davinci_i2c_dev *dev = i2c_get_adapdata(adap);
int i;
int ret;


dev_dbg(dev->dev, "%s: msgs: %d\n", __func__, num);


ret = i2c_davinci_wait_bus_not_busy(dev, 1);
if (ret < 0) {
dev_warn(dev->dev, "timeout waiting for bus ready\n");
return ret;
}


for (i = 0; i < num; i++) {
ret = i2c_davinci_xfer_msg(adap, &msgs[i], (i == (num - 1)));
dev_dbg(dev->dev, "%s [%d/%d] ret: %d\n", __func__, i + 1, num,
ret);
if (ret < 0)
return ret;
}


#ifdef CONFIG_CPU_FREQ
complete(&dev->xfr_complete);//只有在这里唤醒
#endif


return num;
}

但是当cpu实现变频时,就会触发i2c_davinci_cpufreq_transition(),但是此时一定要等i2c发送或接受一次数据,才能唤醒吗?实在不能理解。
请高手们能不能帮忙解答一下,thanks!!!

你可能感兴趣的:(davinci平台的I2C驱动(非GPIO口模拟i2c))