linux GPIO-i2c驱动

430阅读　0评论2014-11-14　644924073
分类：LINUX


点击(此处)折叠或打开

  1. 一、I2C概述
  2. 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，我们需要根据具体设备实现其中的成员函数。

  13. 二、下面介绍i2c各核心数据结构的定义和它们之间的连接关系。
  14. 1. 一个i2c设备的驱动程序由i2c_driver数据结构描述，i2c_driver代表I2C从设备驱动,定义于include/linux/i2c.h：
  15. struct i2c_driver {
  16.     unsigned int class;
  17.     /* 这两个接口已经被probe和remove取代 */
  18.     int (*attach_adapter)(struct i2c_adapter *);//attach_adapter回调函数在安装i2c设备驱动程序模块时、或者在安装i2c适配器驱动程序模块时被调用，
  19.                                                                                             //用于检测、认领设备并为设备分配i2c_client数据结构。
  20.     int (*detach_adapter)(struct i2c_adapter *);//detach_client方法在卸载适配器或设备驱动程序模块时被调用，用于从总线上注销设备、并释放i2c_client及相应的私有数据结构。
  21.     
  22.     int (*probe)(struct i2c_client *, const struct i2c_device_id *);
  23.     int (*remove)(struct i2c_client *);
  24.     
  25.     void (*shutdown)(struct i2c_client *);
  26.     int (*suspend)(struct i2c_client *, pm_message_t mesg);
  27.     int (*resume)(struct i2c_client *);
  28.     void (*alert)(struct i2c_client *, unsigned int data);
  29.     int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
  30.     struct device_driver driver;/*设备驱动结构体*/
  31.     const struct i2c_device_id *id_table;//该驱动所支持的设备ID表
  32.     int (*detect)(struct i2c_client *, struct i2c_board_info *);
  33.     const unsigned short *address_list;
  34.     struct list_head clients;
  35. };

  37. 2. 一个i2c适配器由i2c_adapter数据结构描述
  38. /*
  39. i2c adapter是软件上抽象出来的i2c总线控制器接口
  40. 物理上一条i2c总线可以挂接多个硬件设备(slave)，一个CPU可以挂接多条i2c总线(想象一下PCI总线)
  41. i2c总线控制器就是CPU访问I2C总线的硬件接口，也就是你说的那几个寄存器 .

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

  69. 3.具体i2c适配器的通信方法由i2c_algorithm数据结构进行描述：
  70. struct i2c_algorithm {
  71.     int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,int num);//I2C传输函数指针
  72.     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传输函数指针
  73.     u32 (*functionality) (struct i2c_adapter *);//返回适配器支持的功能
  74. };

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

  93. 5.下面分析一下i2c_driver、i2c_client、i2c_adapter和i2c_algorithm这4个数据结构的作用及其盘根错节的关系。
  94. 5.1 i2c_adapter与i2c_algorithm
  95. i2c_adapter 对应于物理上的一个适配器，而i2c_algorithm对应一套通信方法。一个I2C适配器需要i2c_algorithm中提供的通信函数来控制适配器上产生特定的访问周期。缺少i2c_algorithm的i2c_adapter什么也做不了，因此i2c_adapter中包含其使用的 i2c_algorithm的指针。
  96. i2c_algorithm中的关键函数master_xfer()用于产生I2C访问周期需要的信号，以i2c_msg（即I2C消息）为单位。i2c_msg结构体也非常关键。
  97. //i2c_msg结构体:
  98. struct i2c_msg {
  99.     __u16 addr; /* 设备地址*/
  100.     __u16 flags; /* 标志 */
  101.     __u16 len; /* 消息长度*/
  102.     __u8 *buf; /* 消息数据*/
  103. };
  104. 5.2 i2c_driver与i2c_client
  105. i2c_driver对应一套驱动方法，是纯粹的用于辅助作用的数据结构，它不对应于任何的物理实体。i2c_client对应于真实的物理设备，每个I2C设备都需要一个i2c_client来描述。i2c_client一般被包含在i2c字符设备的私有信息结构体中。
  106. 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()函数被调用的时候。
  107. 5.3 i2c_adpater与i2c_client
  108. i2c_adpater 与i2c_client的关系与I2C硬件体系中适配器和设备的关系一致，即i2c_client依附于i2c_adpater。由于一个适配器上可以连 接多个I2C设备，所以一个i2c_adpater也可以被多个i2c_client依附，i2c_adpater中包括依附于它的i2c_client 的链表。

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

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

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

  168. 3.driver/i2c/buses/i2c-gpio.c中的函数：i2c_gpio_init()---------->subsys_initcall级别

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


  173. 1.在linux内核启动的时候最先执行的和I2C子系统相关的函数应该是driver/i2c/i2c-core.c文件中的i2c_init()函数。
  174. static int __init i2c_init(void)
  175. {
  176.     int retval;
  177.     //设备模型中，关心总线，设备，驱动这三个实体，总线将设备和驱动绑定，在系统每注册一个设备的时候，会寻找与之匹配的驱动。
  178.     //相反，在系统每注册一个驱动的时候，寻找与之匹配的设备，匹配是由总线来完成的。 你还可以看一看链表的信息。它们都是关联的。
  179.     retval = bus_register(&i2c_bus_type);//可以发现i2c_inti的函数主要功能就是注册i2c总线
  180.     if (retval)
  181.         return retval;

  183.     retval = i2c_add_driver(&dummy_driver);
  184.     if (retval)
  185.         goto class_err;
  186.     return 0;

  188. class_err:
  189.     bus_unregister(&i2c_bus_type);
  190.     return retval;
  191. }
  192. /*
  193. struct bus_type i2c_bus_type = {
  194.     .name = "i2c",
  195.     .match = i2c_device_match,
  196.     .probe = i2c_device_probe,
  197.     .remove = i2c_device_remove,
  198.     .shutdown = i2c_device_shutdown,
  199.     .pm = &i2c_device_pm_ops,
  200. };
  201. match方法的用来进行client device和client driver的配对。在向总线i2c_bus_type注册设备或者驱动时会调用此方法。
  202. probe方法在完成设备和驱动的配对后调用执行，i2c_bus_type的probe方法是通过传递进来的drv找到包含此drv的i2c_driver驱动，然后再去调用i2c_driver的probe方法，此处就是at24_probe。
  203. 为什么要这样呢？因为driver_register后，注册的是i2_driver->drv，而drv中的probe未初始化，我们需要调用的是i2c-driver的probe方法。
  204. */
  205. 2.设置i2c的复用管脚配置，以及注册platform设备
  206. 调用完函数i2c_init后，系统将成功创建i2c总线。初始化完毕总线后还需要接着初始化i2c设备和i2c驱动(一般是先初始化device)，
  207. linux内核中的device初始化一般是通过platform device来初始化的，platform device的初始化在da850_evm_init().
  208. static __init void da850_evm_init(void)
  209. {
  210.     int ret;
  211.     char mask = 0;
  212.     //在\arch\arm\mach-davinci\include\mach\common.h中定义davinci_soc_info结构。
  213.     //而\arch\arm\mach-davinci\common.c中davinci_common_init（）对其初始化。
  214.     //davinci_soc_info真正的定义在\arch\arm\mach-davinci\da850.c中，定义达芬奇架构的各类资源的地址等
  215.     struct davinci_soc_info *soc_info = &davinci_soc_info;

  217.     //......
  218.     /*const short da850_i2c0_pins[] __initdata = {
  219.             DA850_GPIO1_4, DA850_GPIO1_5,
  220.             -1
  221.         };
  222.     */
  223.     ret = davinci_cfg_reg_list(da850_i2c0_pins);//i2c的复用管脚配置
  224.     if (ret)
  225.         pr_warning("da850_evm_init: i2c0 mux setup failed: %d\n",ret);

  227.     /*
  228.         static struct i2c_gpio_platform_data da850_gpio_i2c_pdata = {
  229.             .sda_pin    = GPIO_TO_PIN(1, 4),//20 #define GPIO_TO_PIN(bank, gpio)    (16 * (bank) + (gpio))
  230.             .scl_pin    = GPIO_TO_PIN(1, 5),//21
  231.             .udelay        = 2,//250 KHz
  232.             //.sda_is_open_drain =1, //未设置
  233.             //.scl_is_open_drain =1, //未设置
  234.             //.scl_is_output_only =1, //未设置
  235.         };
  236.         
  237.         static struct platform_device da850_gpio_i2c = {
  238.             .name        = "i2c-gpio",
  239.             .id        = 1,
  240.             .dev        = {
  241.                 .platform_data    = &da850_gpio_i2c_pdata,
  242.             },
  243.         };
  244.     */
  245.     platform_device_register(&da850_gpio_i2c);//注册i2c对应的platform设备
  246.     
  247.     //......
  248. }

  250. 3.在完成platform_device的添加之后，i2c子系统将进行platform_driver的注册过程。platform_driver的注册通过调用初始化函数i2c_gpio_init()函数来完成。
  251. static int __init i2c_gpio_init(void)
  252. {
  253.     int ret;
  254.     /*
  255.         static struct platform_driver i2c_gpio_driver = {
  256.             .driver        = {
  257.                 .name    = "i2c-gpio",
  258.                 .owner    = THIS_MODULE,
  259.             },
  260.             .probe        = i2c_gpio_probe,
  261.             .remove        = __devexit_p(i2c_gpio_remove),
  262.         };
  263.     */
  264.     //注册i2c设备对应的platform驱动,会调用i2c_gpio_probe
  265.     ret = platform_driver_register(&i2c_gpio_driver);
  266.     if (ret)
  267.         printk(KERN_ERR "i2c-gpio: probe failed: %d\n", ret);

  269.     return ret;
  270. }

  272. //3.1 platform_driver在注册到platform_bus总线的过程中会尝试将已注册的platform_driver与已注册到platform_bus上的所有platform_device进行配对。
  273. //配对过程通过调用总线的match方法实现，即platform_match函数.就是根据platfor_device和platform_driver的名字来实现配对。
  274. //但是platform_driver有好几个名字可以选择，通过id_table来实现配对。
  275. //执行到此处，之前已注册到platform_bus的platform_device型设备da850_gpio_i2c和现在刚注册到platform_bus总线的platfor_drver型驱动i2c_gpio_driver将实现配对成功。
  276. //因为他们的名字都是“i2c-gpio”。
  277. //3.2 成功配对之后将尝试进行probe。成功配对后首先调用的是总线的probe，假如总线未初始化probe方法才会去 调用驱动中的probe，即platform_driver.drv->probe，
  278. //而platform_bus本身未初始化probe方法，所以此处调用驱动的probe方法，驱动的probe在注册过程中已被初始化。即i2c_gpio_probe（）。

  280. static int __devinit i2c_gpio_probe(struct platform_device *pdev)
  281. {
  282.     //传入的platform_device就是前边已经注册过的da850_gpio_i2c
  283.     struct i2c_gpio_platform_data *pdata;
  284.     struct i2c_algo_bit_data *bit_data;
  285.     struct i2c_adapter *adap;
  286.     int ret;

  288.     /*这个结构体主要描述gpio模拟i2c总线，sda_pin和scl_pin表示使用哪两个IO管脚来模拟I2C总线，
  289.     udelay和timeout分别为它的时钟频率和超时时间，sda_is_open_drain和scl_is_open_drain表示sda、scl这两个管脚是否是开漏(opendrain)电路，
  290.     如果是设置为1，scl_is_output_only表示scl这个管脚是否只是作为输出，如果是设置为1。
  291.     static struct i2c_gpio_platform_data da850_gpio_i2c_pdata = {
  292.             .sda_pin    = GPIO_TO_PIN(1, 4),//20
  293.             .scl_pin    = GPIO_TO_PIN(1, 5),//21
  294.             .udelay        = 2,//250 KHz         
  295.         };
  296.     */
  297.     pdata = pdev->dev.platform_data;//得到设备的i2c_gpio_platform_data结构
  298.     if (!pdata)
  299.         return -ENXIO;

  301.     ret = -ENOMEM;
  302.     adap = kzalloc(sizeof(struct i2c_adapter), GFP_KERNEL);//分配适配器i2c_adapter结构空间
  303.     if (!adap)
  304.         goto err_alloc_adap;
  305.         
  306.     bit_data = kzalloc(sizeof(struct i2c_algo_bit_data), GFP_KERNEL);//申请空间，这个结构主要用来定义对GPIO管脚的一些操作
  307.     if (!bit_data)
  308.         goto err_alloc_bit_data;

  310.     //使用gpio_request去申请这个两个GPIO管脚，申请的目的是为了防止重复使用管脚。
  311.     //然后是根据struct i2c_gpio_platform_data结构中定义的后面三个数据对struct i2c_algo_bit_data结构中的函数指针做一些赋值操作
  312.     ret = gpio_request(pdata->sda_pin, "sda");//向全局数组gpio_desc[]申请一个gpio，并设置对应的标志FLAG_REQUESTED表示申请。并取名为sda
  313.     if (ret)
  314.         goto err_request_sda;
  315.     ret = gpio_request(pdata->scl_pin, "scl");//同上
  316.     if (ret)
  317.         goto err_request_scl;
  318.     
  319.     //然后是根据struct i2c_gpio_platform_data结构中定义的后面三个数据对struct i2c_algo_bit_data结构中的函数指针做一些赋值操作
  320.     if (pdata->sda_is_open_drain) {//未设置
  321.         gpio_direction_output(pdata->sda_pin, 1);
  322.         bit_data->setsda = i2c_gpio_setsda_val;
  323.     } else {
  324.         gpio_direction_input(pdata->sda_pin);//设置为输入
  325.         bit_data->setsda = i2c_gpio_setsda_dir;//设置sda管脚的方向函数
  326.     }

  328.     if (pdata->scl_is_open_drain || pdata->scl_is_output_only) {//未设置
  329.         gpio_direction_output(pdata->scl_pin, 1);
  330.         bit_data->setscl = i2c_gpio_setscl_val;
  331.     } else {
  332.         gpio_direction_input(pdata->scl_pin);//设置为输入
  333.         bit_data->setscl = i2c_gpio_setscl_dir;//设置scl管脚的方向
  334.     }

  336.     if (!pdata->scl_is_output_only)//未设置
  337.         bit_data->getscl = i2c_gpio_getscl;
  338.     
  339.     bit_data->getsda = i2c_gpio_getsda;//读sda管脚数据的函数

  341.     //I2C时钟频率设置
  342.     if (pdata->udelay)//2,即250 KHz
  343.         bit_data->udelay = pdata->udelay;
  344.     else if (pdata->scl_is_output_only)
  345.         bit_data->udelay = 50;//10 kHz
  346.     else
  347.         bit_data->udelay = 5;//100 kHz
  348.     
  349.     //I2C超时设置
  350.     if (pdata->timeout)
  351.         bit_data->timeout = pdata->timeout;
  352.     else
  353.         bit_data->timeout = HZ / 10;//100 ms

  355.     bit_data->data = pdata;//i2c_gpio_platform_data结构
  356.     
  357.     //初始化i2c_adapter结构
  358.     adap->owner = THIS_MODULE;
  359.     snprintf(adap->name, sizeof(adap->name), "i2c-gpio%d", pdev->id);//设置adapter的名称：i2c-gpio1
  360.     adap->algo_data = bit_data;//通信算法的数据
  361.     adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
  362.     adap->dev.parent = &pdev->dev;//父设备指向platform_device

  364.     //pdev->id = 1,表示总线号
  365.     adap->nr = (pdev->id != -1) ? pdev->id : 0;
  366.     
  367.     //继续初始化i2c_adapter结构，设置通信方法,然后在i2c-core中注册适配器。
  368.     ret = i2c_bit_add_numbered_bus(adap);
  369.     if (ret)
  370.         goto err_add_bus;
  371.     
  372.     //保存i2c_adapter结构到pdev？？？
  373.     platform_set_drvdata(pdev, adap);

  375.     dev_info(&pdev->dev, "using pins %u (SDA) and %u (SCL%s)\n",pdata->sda_pin, pdata->scl_pin,pdata->scl_is_output_only? ", no clock stretching" : "");

  377.     return 0;

  379. err_add_bus:
  380.     gpio_free(pdata->scl_pin);
  381. err_request_scl:
  382.     gpio_free(pdata->sda_pin);
  383. err_request_sda:
  384.     kfree(bit_data);
  385. err_alloc_bit_data:
  386.     kfree(adap);
  387. err_alloc_adap:
  388.     return ret;
  389. }

  391. int i2c_bit_add_numbered_bus(struct i2c_adapter *adap)
  392. {
  393.     int err;
  394.     
  395.     //初始化i2c_adapter的通信方法
  396.     err = i2c_bit_prepare_bus(adap);
  397.     if (err)
  398.         return err;
  399.         
  400.     return i2c_add_numbered_adapter(adap);//注册adapter
  401. }

  403. static int i2c_bit_prepare_bus(struct i2c_adapter *adap)
  404. {
  405.     struct i2c_algo_bit_data *bit_adap = adap->algo_data;

  407.     if (bit_test) {//bit_test =0
  408.         int ret = test_bus(bit_adap, adap->name);
  409.         if (ret < 0)
  410.             return -ENODEV;
  411.     }

  413.     /* static const struct i2c_algorithm i2c_bit_algo = {
  414.             .master_xfer    = bit_xfer,//数据传输函数
  415.             .functionality    = bit_func,
  416.         };
  417.  */
  418.  //设置i2c_adapter的通信方法
  419.     adap->algo = &i2c_bit_algo;
  420.     adap->retries = 3;

  422.     return 0;
  423. }

  425. int i2c_add_numbered_adapter(struct i2c_adapter *adap)
  426. {
  427.     int    id;
  428.     int    status;

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

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

  440.     mutex_lock(&core_lock);//上锁
  441.     
  442.     //它是将adapter结构插入到i2c_adapter_idr中，存放位置的id必须要大于或者等于adap->nr,然后将对应的id号存放在adapter->nr中
  443.     status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
  444.     if (status == 0 && id != adap->nr) {
  445.         status = -EBUSY;
  446.         idr_remove(&i2c_adapter_idr, id);
  447.     }
  448.     mutex_unlock(&core_lock);//解锁
  449.     if (status == -EAGAIN)
  450.         goto retry;

  452.     if (status == 0)
  453.         status = i2c_register_adapter(adap);//对这个adapter进行进一步注册。
  454.     return status;
  455. }

  457. static int i2c_register_adapter(struct i2c_adapter *adap)
  458. {
  459.     int res = 0;

  461.     if (unlikely(WARN_ON(!i2c_bus_type.p))) {
  462.         res = -EAGAIN;
  463.         goto out_list;
  464.     }

  466.     /* Sanity checks */
  467.     if (unlikely(adap->name[0] == '\0')) {//adapter的name不为空
  468.         pr_err("i2c-core: Attempt to register an adapter with ""no name!\n");
  469.         return -EINVAL;
  470.     }
  471.     if (unlikely(!adap->algo)) {//adapter的通信算法不能为空
  472.         pr_err("i2c-core: Attempt to register adapter '%s' with ""no algo!\n", adap->name);
  473.         return -EINVAL;
  474.     }

  476.     rt_mutex_init(&adap->bus_lock);
  477.     mutex_init(&adap->userspace_clients_lock);
  478.     INIT_LIST_HEAD(&adap->userspace_clients);

  480.     //若没设置超时时间，则缺省为HZ。实际已经设置
  481.     if (adap->timeout == 0)
  482.         adap->timeout = HZ;
  483.     
  484.     //adapter中内嵌的struct device结构进行必须的初始化
  485.     dev_set_name(&adap->dev, "i2c-%d", adap->nr);//设置adapter->dev的设备名：i2c-1
  486.     adap->dev.bus = &i2c_bus_type;//adapter中内嵌的struct device所在总线为i2c_bus_type
  487.     adap->dev.type = &i2c_adapter_type;
  488.     
  489.     //adapter内嵌的struct device注册
  490.     res = device_register(&adap->dev);
  491.     if (res)
  492.         goto out_list;

  494.     dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);

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

  509.     return 0;

  511. out_list:
  512.     mutex_lock(&core_lock);
  513.     idr_remove(&i2c_adapter_idr, adap->nr);
  514.     mutex_unlock(&core_lock);
  515.     return res;
  516. }

  518. static int __process_new_adapter(struct device_driver *d, void *data)
  519. {
  520.     return i2c_do_add_adapter(to_i2c_driver(d), data);
  521. }

  523. static int i2c_do_add_adapter(struct i2c_driver *driver,struct i2c_adapter *adap)
  524. {
  525.     i2c_detect(adap, driver);

  527.     if (driver->attach_adapter) {//这里还没有设置attach_adapter字段，所以下边的函数不会执行
  528.         driver->attach_adapter(adap);
  529.     }
  530.     return 0;
  531. }

  533. //这个函数比较简单， struct i2c_board_info用来表示I2C设备的一些情况，比如所在的总线。名称，地址，中断号等。最后，这些信息会被存放到__i2c_board_list链表。
  534. /*
  535. static struct i2c_board_info __initdata da850_evm_i2c_devices[] = {
  536.     {
  537.         I2C_BOARD_INFO("24c256", 0x50),
  538.         .platform_data = &da850_evm_i2c_eeprom_info,
  539.     },
  540.     {
  541.         I2C_BOARD_INFO("tlv320aic3x", 0x18),
  542.     },

  544.     {
  545.         I2C_BOARD_INFO("tca6416", 0x20),
  546.         .platform_data = &da850_evm_ui_expander_info,
  547.     },
  548.     {
  549.         I2C_BOARD_INFO("tca6416", 0x21),
  550.         .platform_data = &da850_evm_bb_expander_info,
  551.     },
  552.     
  553.     {
  554.         I2C_BOARD_INFO("tps6507x", 0x48),
  555.         .platform_data = &tps_board,
  556.     },
  557.     {
  558.         I2C_BOARD_INFO("cdce913", 0x65),
  559.     },
  560.     {
  561.         I2C_BOARD_INFO("PCA9543A", 0x73),
  562.     },
  563. };
  564. */
  565. int __init i2c_register_board_info(int busnum,struct i2c_board_info const *info, unsigned len)
  566. {
  567.     int status;
  568.     mutex_lock(&__i2c_board_lock);

  570.     if (busnum >= __i2c_first_dynamic_bus_num)
  571.         __i2c_first_dynamic_bus_num = busnum + 1;
  572.         
  573.     for (status = 0; len; len--, info++) {
  574.         struct i2c_devinfo *devinfo;
  575.         devinfo = kzalloc(sizeof(*devinfo)， GFP_KERNEL);
  576.         if (!devinfo) {
  577.             pr_debug("i2c-core: can't register boardinfo!\n");
  578.             status = -ENOMEM;
  579.             break;
  580.         }
  581.         devinfo->busnum = busnum;
  582.         devinfo->board_info = *info;
  583.         list_add_tail(&devinfo->list, &__i2c_board_list);
  584.     }
  585.     mutex_unlock(&__i2c_board_lock);
  586.     return status;
  587. }

  589. static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
  590. {
  591.     struct i2c_devinfo    *devinfo;

  593.     down_read(&__i2c_board_lock);
  594.     list_for_each_entry(devinfo, &__i2c_board_list, list) {//遍历__i2c_board_list链表中挂载的i2c_devinfo结构
  595.         //如果指定设备是位于adapter所在的I2C总线上，那么，就调用i2c_new_device()。
  596.         if (devinfo->busnum == adapter->nr && !i2c_new_device(adapter,&devinfo->board_info))//adapter->nr = 1
  597.             dev_err(&adapter->dev,"Can't create device at 0x%02x\n",devinfo->board_info.addr);
  598.     }
  599.     up_read(&__i2c_board_lock);
  600. }

  602. struct i2c_client *i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
  603. {
  604.     struct i2c_client    *client;
  605.     int            status;

  607.     //i2c_client表示一个具体的I2C设备，就是一个嵌入struct device的I2C设备的封装
  608.     client = kzalloc(sizeof *client, GFP_KERNEL);//分配空间
  609.     if (!client)
  610.         return NULL;
  611.     //client->adapter指向了它所在的adapter
  612.     client->adapter = adap;
  613.     //
  614.     client->dev.platform_data = info->platform_data;

  616.     if (info->archdata)
  617.         client->dev.archdata = *info->archdata;
  618.     
  619.     //设置标志，地址以及中断号
  620.     client->flags = info->flags;
  621.     client->addr = info->addr;
  622.     client->irq = info->irq;

  624.     //设置i2c设备名
  625.     strlcpy(client->name, info->type, sizeof(client->name));

  627.     //检查设备地址的有效性
  628.     status = i2c_check_client_addr_validity(client);
  629.     if (status) {
  630.         dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
  631.         goto out_err_silent;
  632.     }

  634.     /* Check for address business */
  635.     status = i2c_check_addr_busy(adap, client->addr);
  636.     if (status)
  637.         goto out_err;

  639.     client->dev.parent = &client->adapter->dev;
  640.     client->dev.bus = &i2c_bus_type;
  641.     client->dev.type = &i2c_client_type;
  642. #ifdef CONFIG_OF
  643.     client->dev.of_node = info->of_node;
  644. #endif
  645.     //设置i2c设备的名称
  646.     dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),client->addr);
  647.     //将i2c设备内嵌的dev注册
  648.     status = device_register(&client->dev);
  649.     if (status)
  650.         goto out_err;

  652.     dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",client->name, dev_name(&client->dev));
  653.     return client;

  655. out_err:
  656.     dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x ""(%d)\n", client->name, client->addr, status);
  657. out_err_silent:
  658.     kfree(client);
  659.     return NULL;
  660. }

  662. 4.运行i2c_dev_init函数，注册设备，注册设备驱动，以_init为头的函数，在运行过后系统将回收其内存
  663. //前边已经注册了adapter设备device_register(&adap->dev);下边要注册设备的驱动i2c_add_driver(&i2cdev_driver);
  664. //驱动注册成功会和前边才注册的adapter设备相匹配i2cdev_attach_adapter()，匹配成功则创建设备文件。
  665. static int __init i2c_dev_init(void)
  666. {
  667.     int res;

  669.     printk(KERN_INFO "i2c /dev entries driver\n");
  670.     
  671.     //register_chrdev函数最终会向系统注册主设备为I2C_MAJOR，此设备号为0~255的设备。这表示系统最多可以容纳256个i2c adapter,其中注册的结构体&i2cdev_fops，给用户空间提供了调用接口，就是个字符型驱动
  672.     /*当read()、write()、open()、close()、ioctl()等系统调用发生时就会调用到这些函数。
  673.     static const struct file_operations i2cdev_fops = {
  674.         .owner        = THIS_MODULE,
  675.         .llseek        = no_llseek,
  676.         .read        = i2cdev_read,
  677.         .write        = i2cdev_write,
  678.         .unlocked_ioctl    = i2cdev_ioctl,
  679.         .open        = i2cdev_open,
  680.         .release    = i2cdev_release,
  681.     };
  682.     */
  683.     res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);
  684.     if (res)
  685.         goto out;

  687.      //创建设备类,字符设备注册完毕后通过class_create()函数初始化一个类i2c_dev_class，这个类稍后需要使用，用于在/dev/i2c-0下自动创建设备.
  688.      //注册一个类，使i2c可以在"/dev/"目录下 面建立设备节点
  689.     i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");
  690.     if (IS_ERR(i2c_dev_class)) {
  691.         res = PTR_ERR(i2c_dev_class);
  692.         goto out_unreg_chrdev;
  693.     }
  694.     
  695.     //调用函数i2c_add_driver函数注册i2c driver。这里所说的i2c其实对应的是系统中所有的i2c类设备(包括i2c_client and adapter)。
  696.     /*
  697.         static struct i2c_driver i2cdev_driver = {
  698.          .driver = {
  699.          .name = "dev_driver",
  700.          },
  701.          .attach_adapter = i2cdev_attach_adapter,
  702.          .detach_adapter = i2cdev_detach_adapter,
  703.         };

  705.     */
  706.     //其作用在于为系统中所有已安装的i2c适配器调用i2cdev_driver的attach_adpter方法，
  707.     //即i2cdev_attach_adapter函数，为所有已安装的适配器创建相应的/dev/i2c-%d字符设备结点并注册设备访问方法。
  708.     res = i2c_add_driver(&i2cdev_driver);
  709.     if (res)
  710.         goto out_unreg_class;

  712.     return 0;

  714. out_unreg_class:
  715.     class_destroy(i2c_dev_class);
  716. out_unreg_chrdev:
  717.     unregister_chrdev(I2C_MAJOR, "i2c");
  718. out:
  719.     printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
  720.     return res;
  721. }

  723. static inline int i2c_add_driver(struct i2c_driver *driver)
  724. {
  725.     return i2c_register_driver(THIS_MODULE, driver);
  726. }

  728. int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
  729. {
  730.     int res;

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

  736.     //关联到i2c_bus_types
  737.     driver->driver.owner = owner;
  738.     driver->driver.bus = &i2c_bus_type;

  740.     //注册i2c_driver结构中内嵌的device_driver
  741.     res = driver_register(&driver->driver);
  742.     if (res)
  743.         return res;

  745.     pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);

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

  753.     return 0;
  754. }

  756. static int __process_new_driver(struct device *dev, void *data)
  757. {
  758.     if (dev->type != &i2c_adapter_type)
  759.         return 0;
  760.     //前边adapter的dev已经注册，这里会找到注册的i2c_adapter设备
  761.     return i2c_do_add_adapter(data, to_i2c_adapter(dev));
  762. }

  764. static int i2c_do_add_adapter(struct i2c_driver *driver,struct i2c_adapter *adap)
  765. {
  766.     i2c_detect(adap, driver);//空函数

  768.     if (driver->attach_adapter) {
  769.         driver->attach_adapter(adap);//调用i2cdev_attach_adapter()
  770.     }
  771.     return 0;
  772. }

  774. static int i2cdev_attach_adapter(struct i2c_adapter *adap)
  775. {
  776.     struct i2c_dev *i2c_dev;
  777.     int res;

  779.     i2c_dev = get_free_i2c_dev(adap);//创建一个i2c_dev结构，并且指向adap( i2c_dev->adap = adap;)
  780.     if (IS_ERR(i2c_dev))
  781.         return PTR_ERR(i2c_dev);

  783.     /* 可见attach_adapter函数的作用就是调用device_create()函数 通过之前class_create的类信息在/dev下自动创建设备文件。
  784.     并且此设备的设备号是由固定的主设备号I2C_MAJOR 和 从设备号组成的，从设备号取的就是adapter的nr，此处为0。
  785.     并且可以推断出系统最多可以容纳0~255 总共256个i2c adapter。
  786.  */
  787.      //创建一个设备节点，节点名为"i2c-1"
  788.     i2c_dev->dev = device_create(i2c_dev_class, &adap->dev,MKDEV(I2C_MAJOR, adap->nr), NULL,"i2c-%d", adap->nr);
  789.     if (IS_ERR(i2c_dev->dev)) {
  790.         res = PTR_ERR(i2c_dev->dev);
  791.         goto error;
  792.     }
  793.     res = device_create_file(i2c_dev->dev, &dev_attr_name);
  794.     if (res)
  795.         goto error_destroy;

  797.     pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",adap->name, adap->nr);
  798.     return 0;
  799. error_destroy:
  800.     device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));
  801. error:
  802.     return_i2c_dev(i2c_dev);
  803.     return res;
  804. }
  805. 六、i2c的打开、读、写
  806. 初始化过后就可以通过用户空间对i2c进行读写。
  807. 6.1 i2c的打开
  808. static int i2cdev_open(struct inode *inode, struct file *file)
  809. {
  810.     unsigned int minor = iminor(inode);
  811.     struct i2c_client *client;
  812.     struct i2c_adapter *adap;
  813.     struct i2c_dev *i2c_dev;

  815.     i2c_dev = i2c_dev_get_by_minor(minor);
  816.     if (!i2c_dev)
  817.         return -ENODEV;

  819.     adap = i2c_get_adapter(i2c_dev->adap->nr);
  820.     if (!adap)
  821.         return -ENODEV;

  823.     client = kzalloc(sizeof(*client), GFP_KERNEL);
  824.     if (!client) {
  825.         i2c_put_adapter(adap);
  826.         return -ENOMEM;
  827.     }
  828.     snprintf(client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr);
  829.     client->driver = &i2cdev_driver;//设备驱动(adapter 也是这个设备驱动，共用)

  831.     client->adapter = adap;
  832.     file->private_data = client;//保存到文件的private_data字段中

  834.     return 0;
  835. }

  837. 6.2 i2c的读数据
  838. static ssize_t i2cdev_read(struct file *file, char __user *buf, size_t count,loff_t *offset)
  839. {
  840.     char *tmp;
  841.     int ret;

  843.     struct i2c_client *client = file->private_data;

  845.     if (count > 8192)
  846.         count = 8192;

  848.     tmp = kmalloc(count, GFP_KERNEL);
  849.     if (tmp == NULL)
  850.         return -ENOMEM;

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

  854.     ret = i2c_master_recv(client, tmp, count);
  855.     if (ret >= 0)
  856.         ret = copy_to_user(buf, tmp, count) ? -EFAULT : ret;
  857.     kfree(tmp);
  858.     return ret;
  859. }

  861. int i2c_master_recv(struct i2c_client *client, char *buf, int count)
  862. {
  863.     struct i2c_adapter *adap = client->adapter;
  864.     struct i2c_msg msg;
  865.     int ret;

  867.     msg.addr = client->addr;//应用程序会通过ioctl(i2c_fd,I2C_SLAVE,slaveaddr)来设置client的地址
  868.     msg.flags = client->flags & I2C_M_TEN;
  869.     msg.flags |= I2C_M_RD;
  870.     msg.len = count;
  871.     msg.buf = buf;

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

  875.     return (ret == 1) ? count : ret;
  876. }

  878. int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
  879. {
  880.     unsigned long orig_jiffies;
  881.     int ret, try;
  882.     
  883.     if (adap->algo->master_xfer) {//存在通信方法
  884.         if (in_atomic() || irqs_disabled()) {
  885.             ret = i2c_trylock_adapter(adap);
  886.             if (!ret)/* I2C activity is ongoing. */
  887.                 return -EAGAIN;
  888.         } else {
  889.             i2c_lock_adapter(adap);//给adapter上锁
  890.         }

  892.         orig_jiffies = jiffies;
  893.         for (ret = 0, try = 0; try <= adap->retries; try++) {
  894.             ret = adap->algo->master_xfer(adap, msgs, num);//最终转换为i2c_algorithm中的master_xfer传输，调用bit_xfer()
  895.             if (ret != -EAGAIN)
  896.                 break;
  897.             if (time_after(jiffies, orig_jiffies + adap->timeout))//retry间隔时间
  898.                 break;
  899.         }
  900.         i2c_unlock_adapter(adap);//给adapter解锁

  902.         return ret;
  903.     } else {
  904.         dev_dbg(&adap->dev, "I2C level transfers not supported\n");
  905.         return -EOPNOTSUPP;
  906.     }
  907. }

  909. static int bit_xfer(struct i2c_adapter *i2c_adap,struct i2c_msg msgs[], int num)
  910. {
  911.     struct i2c_msg *pmsg;
  912.     struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
  913.     int i, ret;
  914.     unsigned short nak_ok;

  916.     if (adap->pre_xfer) {//这个字段没有设置
  917.         ret = adap->pre_xfer(i2c_adap);
  918.         if (ret < 0)
  919.             return ret;
  920.     }

  922.     bit_dbg(3, &i2c_adap->dev, "emitting start condition\n");
  923.     
  924.     /*发送起始信号*/
  925.     i2c_start(adap);
  926.     for (i = 0; i < num; i++) {//这里的num代表有几个struct i2c_msg
  927.         pmsg = &msgs[i];
  928.         nak_ok = pmsg->flags & I2C_M_IGNORE_NAK;
  929.         /*
  930.         I2C_M_NOSTART标志，这个标志主要用于写操作时，不必重新发送起始信号和设备地址，但是对于读操作就不同了，
  931.         要调用i2c_repstart这个函数去重新发送起始信号，调用bit_doAddress函数去重新构造设备地址字节
  932.         */
  933.         if (!(pmsg->flags & I2C_M_NOSTART)) {
  934.             if (i) {
  935.                 bit_dbg(3, &i2c_adap->dev, "emitting ""repeated start condition\n");
  936.                 i2c_repstart(adap);
  937.             }
  938.             ret = bit_doAddress(i2c_adap, pmsg);//重新构造设备地址字节
  939.             if ((ret != 0) && !nak_ok) {
  940.                 bit_dbg(1, &i2c_adap->dev, "NAK from ""device addr 0x%02x msg #%d\n",msgs[i].addr, i);
  941.                 goto bailout;
  942.             }
  943.         }
  944.         
  945.         if (pmsg->flags & I2C_M_RD) {//读数据
  946.             ret = readbytes(i2c_adap, pmsg);
  947.             if (ret >= 1)
  948.                 bit_dbg(2, &i2c_adap->dev, "read %d byte%s\n",ret, ret == 1 ? "" : "s");
  949.             if (ret < pmsg->len) {
  950.                 if (ret >= 0)
  951.                     ret = -EREMOTEIO;
  952.                 goto bailout;
  953.             }
  954.         } else {//写数据
  955.             ret = sendbytes(i2c_adap, pmsg);
  956.             if (ret >= 1)
  957.                 bit_dbg(2, &i2c_adap->dev, "wrote %d byte%s\n",ret, ret == 1 ? "" : "s");
  958.             if (ret < pmsg->len) {
  959.                 if (ret >= 0)
  960.                     ret = -EREMOTEIO;
  961.                 goto bailout;
  962.             }
  963.         }
  964.     }
  965.     ret = i;

  967. bailout:
  968.     bit_dbg(3, &i2c_adap->dev, "emitting stop condition\n");
  969.     i2c_stop(adap);

  971.     if (adap->post_xfer)
  972.         adap->post_xfer(i2c_adap);
  973.     return ret;
  974. }

  976. 这里先做了一个判断，10位设备地址和7位设备地址分别做不同的处理，通常一条I2C总线上不会挂那么多I2C设备，所以10位地址不常用，直接看对7位地址的处理。struct i2c_msg中addr中是真正的设备地址，而这里发送的addr高7位才是设备地址，最低位为读写位，如果为读，最低位为1，如果为写，最低位为0。所以要将struct i2c_msg中addr向左移1位，如果定义了I2C_M_RD标志，就将addr或上1，前面就说过，这个标志就代表读，如果是写，这里就不用处理，因为最低位本身就是0。最后调用try_address函数将这个地址字节发送出去。
  977. static int bit_doAddress(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
  978. {
  979.     unsigned short flags = msg->flags;
  980.     unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK;
  981.     struct i2c_algo_bit_data *adap = i2c_adap->algo_data;

  983.     unsigned char addr;
  984.     int ret, retries;

  986.     retries = nak_ok ? 0 : i2c_adap->retries;

  988.     if (flags & I2C_M_TEN) {
  989.         /* a ten bit address */
  990.         addr = 0xf0 | ((msg->addr >> 7) & 0x03);
  991.         bit_dbg(2, &i2c_adap->dev, "addr0: %d\n", addr);
  992.         /* try extended address code...*/
  993.         ret = try_address(i2c_adap, addr, retries);
  994.         if ((ret != 1) && !nak_ok) {
  995.             dev_err(&i2c_adap->dev,
  996.                 "died at extended address code\n");
  997.             return -EREMOTEIO;
  998.         }
  999.         /* the remaining 8 bit address */
  1000.         ret = i2c_outb(i2c_adap, msg->addr & 0x7f);
  1001.         if ((ret != 1) && !nak_ok) {
  1002.             /* the chip did not ack / xmission error occurred */
  1003.             dev_err(&i2c_adap->dev, "died at 2nd address code\n");
  1004.             return -EREMOTEIO;
  1005.         }
  1006.         if (flags & I2C_M_RD) {
  1007.             bit_dbg(3, &i2c_adap->dev, "emitting repeated "
  1008.                 "start condition\n");
  1009.             i2c_repstart(adap);
  1010.             /* okay, now switch into reading mode */
  1011.             addr |= 0x01;
  1012.             ret = try_address(i2c_adap, addr, retries);
  1013.             if ((ret != 1) && !nak_ok) {
  1014.                 dev_err(&i2c_adap->dev,
  1015.                     "died at repeated address code\n");
  1016.                 return -EREMOTEIO;
  1017.             }
  1018.         }
  1019.     } else {        /* normal 7bit address    */
  1020.         addr = msg->addr << 1;
  1021.         if (flags & I2C_M_RD)
  1022.             addr |= 1;
  1023.         if (flags & I2C_M_REV_DIR_ADDR)
  1024.             addr ^= 1;
  1025.         ret = try_address(i2c_adap, addr, retries);
  1026.         if ((ret != 1) && !nak_ok)
  1027.             return -ENXIO;
  1028.     }

  1030.     return 0;
  1031. }

  1033. //最主要的就是调用i2c_outb发送一个字节，retries为重复次数，看前面adap->retries= 3;
  1034. //如果发送失败，也就是设备没有给出应答信号，那就发送停止信号，发送起始信号，再发送这个地址字节，这就叫retries。
  1035. static int try_address(struct i2c_adapter *i2c_adap,unsigned char addr, int retries)
  1036. {
  1037.     struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
  1038.     int i, ret = 0;

  1040.     for (i = 0; i <= retries; i++) {
  1041.         ret = i2c_outb(i2c_adap, addr);
  1042.         if (ret == 1 || i == retries)
  1043.             break;
  1044.         bit_dbg(3, &i2c_adap->dev, "emitting stop condition\n");
  1045.         i2c_stop(adap);
  1046.         udelay(adap->udelay);
  1047.         yield();
  1048.         bit_dbg(3, &i2c_adap->dev, "emitting start condition\n");
  1049.         i2c_start(adap);
  1050.     }
  1051.     if (i && ret)
  1052.         bit_dbg(1, &i2c_adap->dev, "Used %d tries to %s client at ""0x%02x: %s\n", i + 1,addr & 1 ? "read from" : "write to", addr >> 1,ret == 1 ? "success" : "failed, timeout?");
  1053.     return ret;
  1054. }
  1055. static int readbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
  1056. {
  1057.     int inval;
  1058.     int rdcount = 0;    /* counts bytes read */
  1059.     unsigned char *temp = msg->buf;
  1060.     int count = msg->len;
  1061.     const unsigned flags = msg->flags;

  1063.     while (count > 0) {
  1064.         inval = i2c_inb(i2c_adap);
  1065.         if (inval >= 0) {
  1066.             *temp = inval;
  1067.             rdcount++;
  1068.         } else { /* read timed out */
  1069.             break;
  1070.         }

  1072.         temp++;
  1073.         count--;

  1075.         /* Some SMBus transactions require that we receive the
  1076.          transaction length as the first read byte. */
  1077.         if (rdcount == 1 && (flags & I2C_M_RECV_LEN)) {
  1078.             if (inval <= 0 || inval > I2C_SMBUS_BLOCK_MAX) {
  1079.                 if (!(flags & I2C_M_NO_RD_ACK))
  1080.                     acknak(i2c_adap, 0);
  1081.                 dev_err(&i2c_adap->dev, "readbytes: invalid ""block length (%d)\n", inval);
  1082.                 return -EREMOTEIO;
  1083.             }

  1085.             count += inval;
  1086.             msg->len += inval;
  1087.         }

  1089.         bit_dbg(2, &i2c_adap->dev, "readbytes: 0x%02x %s\n",inval,(flags & I2C_M_NO_RD_ACK)? "(no ack/nak)": (count ? "A" : "NA"));

  1091.         if (!(flags & I2C_M_NO_RD_ACK)) {
  1092.             inval = acknak(i2c_adap, count);
  1093.             if (inval < 0)
  1094.                 return inval;
  1095.         }
  1096.     }
  1097.     return rdcount;
  1098. }
  1099. 6.3 i2c的写数据

  1101. static ssize_t i2cdev_write(struct file *file, const char __user *buf,size_t count, loff_t *offset)
  1102. {
  1103.     int ret;
  1104.     char *tmp;
  1105.     struct i2c_client *client = file->private_data;

  1107.     if (count > 8192)
  1108.         count = 8192;

  1110.     tmp = memdup_user(buf, count);
  1111.     if (IS_ERR(tmp))
  1112.         return PTR_ERR(tmp);

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

  1116.     ret = i2c_master_send(client, tmp, count);
  1117.     kfree(tmp);
  1118.     return ret;
  1119. }

  1121. int i2c_master_send(struct i2c_client *client, const char *buf, int count)
  1122. {
  1123.     int ret;
  1124.     struct i2c_adapter *adap = client->adapter;
  1125.     struct i2c_msg msg;

  1127.     msg.addr = client->addr;
  1128.     msg.flags = client->flags & I2C_M_TEN;
  1129.     msg.len = count;
  1130.     msg.buf = (char *)buf;

  1132.     ret = i2c_transfer(adap, &msg, 1);

  1134.     return (ret == 1) ? count : ret;
  1135. }

上一篇：davinci平台的I2C驱动（非GPIO口模拟i2c）
下一篇：devtmpfs文件系统创建设备节点