当前位置: 首页 > news >正文

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. 二、下面介绍i2c各核心数据结构的定义和它们之间的连接关系。
    29. 1. 一个i2c适配器由i2c_adapter数据结构描述
    30. /*
    31. i2c adapter是软件上抽象出来的i2c总线控制器接口,i2c总线适配器(adapter)就是一条 i2c总线的控制器,i2c_adapter对应于物理上的一个适配器
    32. 物理上一条i2c总线可以挂接多个硬件设备(slave),一个CPU可以挂接多条i2c总线(想象一下PCI总线),i2c总线控制器就是CPU访问I2C总线的硬件接口,也就是你说的那几个寄存器 .

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

    56. 2.具体i2c适配器的通信方法由i2c_algorithm数据结构进行描述:
    57. struct i2c_algorithm {
    58.     int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,int num);//I2C传输函数指针
    59.     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传输函数指针
    60.     u32 (*functionality) (struct i2c_adapter *);//返回适配器支持的功能
    61. };

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

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

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

    107. 5.2 i2c_driver与i2c_client
    108. i2c_driver对应一套驱动方法,是纯粹的用于辅助作用的数据结构,它不对应于任何的物理实体。i2c_client对应于真实的物理设备,每个I2C设备都需要一个i2c_client来描述。i2c_client一般被包含在i2c字符设备的私有信息结构体中。同一类的i2c设备device对应一个驱动driver。driver与device的关系是一对多的关系。
    109. 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()函数被调用的时候。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    411.     return r;
    412. }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    591.     return 0;

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

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

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

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

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

    642.     return 0;

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

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

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

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

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

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

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

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

    674.     return 0;
    675. }

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

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

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

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

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

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

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

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

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


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

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

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

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

    769.     return 0;
    770. }

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

    851.     return num;
    852. }

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

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

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

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

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

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

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

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

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

    890.     dev->terminate = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

疑问点:
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!!!

http://www.taodudu.cc/news/show-8381743.html

相关文章:

  • STM32F429第十九篇之基本定时器实验详解
  • GD32 RT-Thread PWM驱动函数
  • Linux指纹识别程序,安装和配置Fingerprint GUI以在Linux上启用指纹扫描程序支持
  • linux 深度扫描软件,Deepin 15.5 Linux操作系统首次采用HiDPI和Flatpak支持,指纹扫描...
  • Suprema RFID指纹扫描仪增加安卓设备支持
  • android 指纹存储密码,Android-使用指纹扫描仪和密码来加密和解密...
  • 35.CSS指纹扫描器动画效果
  • web指纹扫描器_欺骗手机的指纹扫描器很容易。 这是我们应解决的方法。
  • 小程序手机号注册php,微信小程序授权获取用户手机号码
  • 微信小程序怎么注册?
  • 09C++文件读取
  • 点成案例| BE-Gradient 微流控芯片用于胶质母细胞瘤的研究
  • 数字微流控生物芯片模拟界面
  • 微流控芯片建模分析技术与应用
  • 什么是微流控芯片?它是如何发展起来的?
  • 详述纸基微流控芯片的研究进展
  • 优可测推动微流控技术革新,精准助力生物医学等行业的发展
  • 简化SQL式计算之逆分组
  • PyConChina 2012 - 第二届中国Python开发者大会 上海.北京.西安.杭州.合肥.武汉.珠海 | 抢座网...
  • 高新园区云计算机大厦,合肥超猛!九区900大项目曝光,中央CBD、超算中心来了!滨湖、高新、新站彻底爆发!...
  • 【线下赛游记】2023 ICPC合肥区域赛 游记
  • 近2000万!鸿雁中标杭州地铁 9 号线一期工程公共区 LED 灯具项目
  • 用Python计算合肥地铁乘车最优乘车路线:暴力方式
  • Element UI中全部的图标以及组件
  • 小白必看的那些UI图标设计规范分享!
  • 区块链,会越来越无聊!
  • 小程序如何用data的数据控制页面展示_小程序实战之登录的原理和实现(内含福利)...
  • 边缘计算与物联网精华问答 | 边缘计算和物联网有什么关系?
  • 营养餐搭配小程序开发价值
  • 「安搭Share你问我答」你老了,如何养老?