i2c驱动程序全面分析，从adapter驱动程序到设备驱动程序

落日映苍穹つ 2022-06-02 02:26 677阅读 0赞

开发板    ：mini2440  
内核版本：linux2.6.32.2  
驱动程序参考：韦东山老师毕业班i2c

内容概括：

**1、adapter client 简介  
   2、adapter 驱动框架  
      2.1 设备侧  
      2.2 驱动侧  
         2.2.1 probe 函数  
         2.2.1.1 注册adapter  
            new\_device del\_device  
            board\_info  
            i2c\_detect  
            i2c\_new\_device  
   3、i2c 设备驱动框架  
      3.1 i2c\_bus\_type  
      3.2 i2c\_driver  
      3.3 i2c\_device  
    4、写设备驱动程序**

5、写adapter驱动程序

1、adapter client 简介  
  在内核里，i2c 驱动框架大概分为两层，adapter 驱动 和 设备驱动，adapter 英文翻译过来为 “适配器”，适配器并不恰当，根据我的理解，adapter 指的是我们 mcu 里的 i2c 控制模块，就是那堆寄存器，因为一个 mcu 里的i2c控制模块是固定的（寄存器参数、以及收发数据的方法），因此大多数情况下，它们都有芯片厂商写好了，然而我们学习的过程中自己动手写一写也并不困难。对于s3c2440仅仅有一个i2c\_adapter，但是别的Mcu可能有多个。至于Client，它对应于muc外围的I2c设备，每一个i2c设备都由一个唯一的client来描述。

![SouthEast][]

\[cpp\]  [view plain][]  [copy][view plain]

1.  struct i2c\_adapter \{  
2.      struct module \*owner;  
3.      unsigned int id;  
4.      unsigned int class;       /\* classes to allow probing for \*/  
5.      const struct i2c\_algorithm \*algo; /\* the algorithm to access the bus \*/  
6.      void \*algo\_data;  
7.    
8.      /\* data fields that are valid for all devices   \*/  
9.      u8 level;           /\* nesting level for lockdep \*/  
10.     struct mutex bus\_lock;  
11.   
12.     int timeout;            /\* in jiffies \*/  
13.     int retries;  
14.     struct device dev;      /\* the adapter device \*/  
15.   
16.     int nr;  
17.     char name\[48\];  
18.     struct completion dev\_released;  
19. \};

简单扫一眼，i2c\_adapter 封装了 struct device ，因此它是作为一个设备注册到内核中去的（稍后我们会知道，它是注册到i2c\_bus\_type里），此外非常重要的一个成员struct i2c\_algorithm \*algo ，这就是我们上边提到的 i2c 控制器收发数据的方法。

\[cpp\]  [view plain][]  [copy][view plain]

1.  struct i2c\_algorithm \{  
2.    
3.      int (\*master\_xfer)(struct i2c\_adapter \*adap, struct i2c\_msg \*msgs,  
4.                 int num);  
5.      int (\*smbus\_xfer) (struct i2c\_adapter \*adap, u16 addr,  
6.                 unsigned short flags, char read\_write,  
7.                 u8 command, int size, union i2c\_smbus\_data \*data);  
8.    
9.      /\* To determine what the adapter supports \*/  
10.     u32 (\*functionality) (struct i2c\_adapter \*);  
11. \};

master\_xfer 对应于i2c协议子集 smbus ，有些设备只支持这个协议

smbus\_xfer 对应于普通的 i2c 传输协议

functionality 用来描述，adapter 所具有的功能，比如是否支持 smbus

\[cpp\]  [view plain][]  [copy][view plain]

1.  struct i2c\_client \{  
2.      unsigned short flags;       /\* div., see below      \*/  
3.      unsigned short addr;        /\* chip address - NOTE: 7bit    \*/  
4.                      /\* addresses are stored in the  \*/  
5.                      /\* \_LOWER\_ 7 bits       \*/  
6.      char name\[I2C\_NAME\_SIZE\];  
7.      struct i2c\_adapter \*adapter;    /\* the adapter we sit on    \*/  
8.      struct i2c\_driver \*driver;  /\* and our access routines  \*/  
9.      struct device dev;      /\* the device structure     \*/  
10.     int irq;            /\* irq issued by device     \*/  
11.     struct list\_head detected;  
12. \};

i2c\_client 本质上是一个 i2c\_"dev", 它包含了与它配对的 driver ，以及它所在的 adapter（i2c设备在物理连接上，连接到了哪个adapter），后面分析时会看到，它也是作为设备注册到i2c\_bus\_type

2、adapter 驱动框架  
    在我所使用的这个内核里，2440的i2c\_adapter框架是基于 platform\_bus\_type 的，关于 platform\_bus\_type 别的文章已经分析过了，这里不做赘述，只简单提一下，当设备或驱动注册到 platform\_bus\_type 时，首先会查找驱动是否有id\_table，如果有根据id\_table进行匹配（就是看id\_table里有无设备的名字），否则匹配设备名字和驱动名字。匹配成功则调用驱动里的probe函数。  
    2.1 设备侧  
        根据设备总线驱动模型的分层思想，将一个驱动程序分为 device 和 driver 两层，那么 device 里提供底层的硬件资源，在 driver 中取出这些资源进行使用。那么我们就可以猜测到 i2c\_adapter 驱动的设备侧 至少应该含有哪些资源？

1、存器地址必须有吧，因为我们要使用这些寄存器，不然怎么传输。  
        2、中断必须有吧，i2c传输过程中可是离不开中断的。  
        下面，我们就开详细的看一看，i2c\_adapter 驱动的设备侧提供了哪些设备资源。  
        mach-smdk2410.c (arch\\arm\\mach-s3c2410) 中定义了个指针数组，这里面有我们想要的 s3c\_device\_i2c0

\[cpp\]  [view plain][]  [copy][view plain]

1.  static struct platform\_device \*smdk2410\_devices\[\] \_\_initdata = \{  
2.      &s3c\_device\_usb,  
3.      &s3c\_device\_lcd,  
4.      &s3c\_device\_wdt,  
5.      &s3c\_device\_i2c0,  
6.      &s3c\_device\_iis,  
7.  \};  
8.  dev-i2c0.c (arch\\arm\\plat-s3c)  
9.  struct platform\_device s3c\_device\_i2c0 = \{  
10.     .name         = "s3c2410-i2c",  
11. \#ifdef CONFIG\_S3C\_DEV\_I2C1  
12.     .id       = 0,  
13. \#else  
14.     .id       = -1,  
15. \#endif  
16.     .num\_resources    = ARRAY\_SIZE(s3c\_i2c\_resource),  
17.     .resource     = s3c\_i2c\_resource,  
18. \};  
19. static struct resource s3c\_i2c\_resource\[\] = \{  
20.     \[0\] = \{  
21.         .start = S3C\_PA\_IIC1,  
22.         .end   = S3C\_PA\_IIC1 + SZ\_4K - 1,  
23.         .flags = IORESOURCE\_MEM,  
24.     \},  
25.     \[1\] = \{  
26.         .start = IRQ\_IIC1,  
27.         .end   = IRQ\_IIC1,  
28.         .flags = IORESOURCE\_IRQ,  
29.     \},  
30. \};

是不是正如我们所料，在资源文件中提供了 物理寄存器 以及 中断资源。  
    Mach-smdk2410.c (arch\\arm\\mach-s3c2410)，将 s3c\_device\_i2c0 注册到 平台设备总线上去

\[cpp\]  [view plain][]  [copy][view plain]

1.  static void \_\_init smdk2410\_init(void)  
2.  \{  
3.      s3c\_i2c0\_set\_platdata(NULL);  
4.      platform\_add\_devices(smdk2410\_devices, ARRAY\_SIZE(smdk2410\_devices));  
5.      smdk\_machine\_init();  
6.  \}  
7.  dev-i2c0.c (arch\\arm\\plat-s3c)  
8.  static struct s3c2410\_platform\_i2c default\_i2c\_data0 \_\_initdata = \{  
9.      .flags      = 0,  
10.     .slave\_addr = 0x10,  
11.     .frequency  = 100\*1000,  
12.     .sda\_delay  = 100,  
13. \};        
14. void \_\_init s3c\_i2c0\_set\_platdata(struct s3c2410\_platform\_i2c \*pd)  
15. \{  
16.     struct s3c2410\_platform\_i2c \*npd;  
17.   
18.     if (!pd)  
19.         pd = &default\_i2c\_data0;  
20.   
21.     npd = kmemdup(pd, sizeof(struct s3c2410\_platform\_i2c), GFP\_KERNEL);  
22.     if (!npd)  
23.         printk(KERN\_ERR "%s: no memory for platform data\\n", \_\_func\_\_);  
24.     else if (!npd->cfg\_gpio)  
25.         npd->cfg\_gpio = s3c\_i2c0\_cfg\_gpio;  
26.   
27.     s3c\_device\_i2c0.dev.platform\_data = npd;  
28. \}  
29. setup-i2c.c (arch\\arm\\plat-s3c24xx)  
30. void s3c\_i2c0\_cfg\_gpio(struct platform\_device \*dev)  
31. \{  
32.     s3c2410\_gpio\_cfgpin(S3C2410\_GPE(15), S3C2410\_GPE15\_IICSDA);  
33.     s3c2410\_gpio\_cfgpin(S3C2410\_GPE(14), S3C2410\_GPE14\_IICSCL);  
34. \}  
35. S3c244x.c (arch\\arm\\plat-s3c24xx)  
36. void \_\_init s3c244x\_map\_io(void)  
37. \{  
38.     /\* register our io-tables \*/  
39.   
40.     iotable\_init(s3c244x\_iodesc, ARRAY\_SIZE(s3c244x\_iodesc));  
41.   
42.     /\* rename any peripherals used differing from the s3c2410 \*/  
43.   
44.     s3c\_device\_sdi.name  = "s3c2440-sdi";  
45.     s3c\_device\_i2c0.name  = "s3c2440-i2c";  
46.     s3c\_device\_nand.name = "s3c2440-nand";  
47.     s3c\_device\_usbgadget.name = "s3c2440-usbgadget";  
48. \}

在将 s3c\_device\_i2c0 注册到 平台设备总线上去之前，还提供了以上的其它信息，包括i2c控制器作为从机的默认slave\_addr等，以及引脚的配置函数。注意，s3c\_device\_i2c0.name  = "s3c2440-i2c";

2.2 驱动侧  
        驱动侧的工作大概是取出设备侧的资源进行利用，比如Ioremap，配置寄存器，注册中断等等

\[cpp\]  [view plain][]  [copy][view plain]

1.  i2c-s3c2410.c (drivers\\i2c\\busses)  
2.  static struct platform\_driver s3c24xx\_i2c\_driver = \{  
3.      .probe      = s3c24xx\_i2c\_probe,  
4.      .remove     = s3c24xx\_i2c\_remove,  
5.      .id\_table   = s3c24xx\_driver\_ids,  
6.      .driver     = \{  
7.          .owner  = THIS\_MODULE,  
8.          .name   = "s3c-i2c",  
9.          .pm = S3C24XX\_DEV\_PM\_OPS,  
10.     \},  
11. \};  
12. static struct platform\_device\_id s3c24xx\_driver\_ids\[\] = \{  
13.     \{  
14.         .name       = "s3c2410-i2c",  
15.         .driver\_data    = TYPE\_S3C2410,  
16.     \}, \{  
17.         .name       = "s3c2440-i2c",  
18.         .driver\_data    = TYPE\_S3C2440,  
19.     \}, \{ \},  
20. \};  
21. static int \_\_init i2c\_adap\_s3c\_init(void)  
22. \{  
23.     return platform\_driver\_register(&s3c24xx\_i2c\_driver);  
24. \}  
25. subsys\_initcall(i2c\_adap\_s3c\_init);

我们在分析platform总线模型的时候，我们知道platform\_bus\_type->match函数是首先根据 driver->id\_table 来进行匹配device的，前面讲了s3c\_device\_i2c0.name  = "s3c2440-i2c"，因此，匹配成功会调用 s3c24xx\_i2c\_driver->probe 函数，也就是 s3c24xx\_i2c\_probe ，它是个重点。

2.3 probe 函数分析

\[cpp\]  [view plain][]  [copy][view plain]

1.  i2c-s3c2410.c (drivers\\i2c\\busses)  
2.  static int s3c24xx\_i2c\_probe(struct platform\_device \*pdev)  
3.  \{  
4.      struct s3c24xx\_i2c \*i2c;  
5.      struct s3c2410\_platform\_i2c \*pdata;  
6.      struct resource \*res;  
7.      int ret;  
8.      // 还记得，我们在 device 里放的platform\_data么，是时候取出来使用了  
9.      pdata = pdev->dev.platform\_data;  
10.   
11.     i2c = kzalloc(sizeof(struct s3c24xx\_i2c), GFP\_KERNEL);  
12.   
13.     /\* 1、使能 i2c 时钟 \*/  
14.     i2c->dev = &pdev->dev;  
15.     i2c->clk = clk\_get(&pdev->dev, "i2c");  
16.     clk\_enable(i2c->clk);  
17.   
18.     /\* 2、io内存映射 \*/  
19.     res = platform\_get\_resource(pdev, IORESOURCE\_MEM, 0);  
20.     i2c->ioarea = request\_mem\_region(res->start, resource\_size(res),  
21.                      pdev->name);  
22.     i2c->regs = ioremap(res->start, resource\_size(res));  
23.       
24.     /\* 3、设置adap的相关信息 \*/  
25.     strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));  
26.     i2c->adap.owner   = THIS\_MODULE;  
27.     i2c->adap.algo    = &s3c24xx\_i2c\_algorithm;  // i2c控制器的收发函数  
28.     i2c->adap.retries = 2;  
29.     i2c->adap.class   = I2C\_CLASS\_HWMON | I2C\_CLASS\_SPD;  
30.     i2c->tx\_setup     = 50;  
31.     i2c->adap.algo\_data = i2c;  
32.     i2c->adap.dev.parent = &pdev->dev;  
33.   
34.     /\* 4、初始化 i2c controller \*/  
35.     ret = s3c24xx\_i2c\_init(i2c);  
36.     i2c->irq = ret = platform\_get\_irq(pdev, 0);  
37.     /\* 5、注册中断 \*/  
38.     ret = request\_irq(i2c->irq, s3c24xx\_i2c\_irq, IRQF\_DISABLED,  
39.               dev\_name(&pdev->dev), i2c);  
40.   
41.     ret = s3c24xx\_i2c\_register\_cpufreq(i2c);  
42.   
43.     /\* Note, previous versions of the driver used i2c\_add\_adapter() 
44.      \* to add the bus at any number. We now pass the bus number via 
45.      \* the platform data, so if unset it will now default to always 
46.      \* being bus 0. 
47.      \*/  
48.     /\* 6、适配器编号 \*/  
49.     i2c->adap.nr = pdata->bus\_num; //阅读上面的英文，大概意思就是device侧pdata中没设置bus\_num，那么就默认为0，显然这里是0  
50.       
51.     /\* 7、注册 adapter \*/  
52.     ret = i2c\_add\_numbered\_adapter(&i2c->adap);  // i2c\_register\_adapter（&i2c->adap）;  
53.   
54.     platform\_set\_drvdata(pdev, i2c);  
55.   
56.     return 0;  
57.   
58. \}  
59. i2c-core.c (drivers\\i2c)  
60. static int i2c\_register\_adapter(struct i2c\_adapter \*adap)  
61. \{  
62.     int res = 0, dummy;  
63.   
64.     mutex\_init(&adap->bus\_lock);  
65.   
66.     /\* Set default timeout to 1 second if not already set \*/  
67.     if (adap->timeout == 0)  
68.         adap->timeout = HZ;  
69.       
70.     /\* 设置 adap->dev.kobj.name 为 i2c-0 ，它将出现在 sysfs 中 \*/  
71.     dev\_set\_name(&adap->dev, "i2c-%d", adap->nr);  
72.       
73.     /\* 设置它所属的总线 i2c\_bus\_type \*/  
74.     adap->dev.bus = &i2c\_bus\_type;  
75.       
76.     /\* 重点: 设置属性，用户空间创建 device 就靠它了 \*/  
77.     adap->dev.type = &i2c\_adapter\_type;  
78.       
79.     /\* 将 adap->dev注册到 i2c\_bus\_type \*/  
80.     res = device\_register(&adap->dev);  
81. /\* 大概是创建 devices 目录 到class 目录的符号连接 \*/  
82. \#ifdef CONFIG\_I2C\_COMPAT  
83.     res = class\_compat\_create\_link(i2c\_adapter\_compat\_class, &adap->dev,  
84.                        adap->dev.parent);  
85.     if (res)  
86.         dev\_warn(&adap->dev,  
87.              "Failed to create compatibility class link\\n");  
88. \#endif  
89.   
90.     /\* 重点: 扫描 \_\_i2c\_board\_list 链表里的设备信息，自动创建 client ,并注册到 i2c\_bus\_type \*/  
91.     if (adap->nr < \_\_i2c\_first\_dynamic\_bus\_num)  
92.         i2c\_scan\_static\_board\_info(adap);  
93.   
94.     /\* 重点: 遍历 i2c\_bus\_type的driver 链表，取出每一个driver 调用 i2c\_do\_add\_adapter \*/  
95.     mutex\_lock(&core\_lock);  
96.     dummy = bus\_for\_each\_drv(&i2c\_bus\_type, NULL, adap,  
97.                  i2c\_do\_add\_adapter);  
98.     mutex\_unlock(&core\_lock);  
99.   
100.     return 0;  
101.   
102. \}

这一个 probe 函数的内容是在是太多了，慢慢来吧，至于 ioremap 申请中断啥的就不讲了,上个图

![SouthEast 1][]

在内核帮助文档 instantiating-devices 中说，有4种方法可以创建 i2c\_device ，其中第四种是在用户空间创建的：  
         Example:  
                \# echo eeprom 0x50 > /sys/bus/i2c/devices/i2c-0/new\_device  
                分析过设备模型的都知道，i2c-0 是我们上面设置的 dev\_set\_name(&adap->dev, "i2c-%d", adap->nr)，new\_device 就是它的一个属性了，这个属性在哪里？在i2c\_adapter\_type 中

\[cpp\]  [view plain][]  [copy][view plain]

1.  static struct device\_type i2c\_adapter\_type = \{  
2.      .groups     = i2c\_adapter\_attr\_groups,  
3.      .release    = i2c\_adapter\_dev\_release,  
4.  \};  
5.  static const struct attribute\_group \*i2c\_adapter\_attr\_groups\[\] = \{  
6.      &i2c\_adapter\_attr\_group,  
7.      NULL  
8.  \};  
9.  static struct attribute\_group i2c\_adapter\_attr\_group = \{  
10.     .attrs      = i2c\_adapter\_attrs,  
11. \};  
12.   
13. static DEVICE\_ATTR(new\_device, S\_IWUSR, NULL, i2c\_sysfs\_new\_device);  
14. static DEVICE\_ATTR(delete\_device, S\_IWUSR, NULL, i2c\_sysfs\_delete\_device);  
15. static struct attribute \*i2c\_adapter\_attrs\[\] = \{  
16.     &dev\_attr\_name.attr,  
17.     &dev\_attr\_new\_device.attr,  
18.     &dev\_attr\_delete\_device.attr,  
19.     NULL  
20. \};

这里，我就不将宏展开了，大概说一下，当 device\_register 注册 device 时，会设置dev.kobj.ktype = device\_ktype, device\_ktype 提供通用的属性show 与 store函数，当用户空间访问属性文件时，通用的 show 与 store 就会 调用具体的show 与 store。  
         DEVICE\_ATTR(new\_device, S\_IWUSR, NULL, i2c\_sysfs\_new\_device)，就会创建一个device\_attribute结构体，  
                 name = “new\_device”，.mode = S\_IWUSR , show = NULL ,store = i2c\_sysfs\_new\_device   
         显然上面 echo eeprom 0x50 > /sys/bus/i2c/devices/i2c-0/new\_device ，就会调用 i2c\_sysfs\_new\_device 函数了。

\[cpp\]  [view plain][]  [copy][view plain]

1.  static ssize\_t  
2.  i2c\_sysfs\_new\_device(struct device \*dev, struct device\_attribute \*attr,  
3.               const char \*buf, size\_t count)  
4.  \{  
5.      struct i2c\_adapter \*adap = to\_i2c\_adapter(dev);  
6.      struct i2c\_board\_info info;  
7.      struct i2c\_client \*client;  
8.      char \*blank, end;  
9.      int res;  
10.   
11.     memset(&info, 0, sizeof(struct i2c\_board\_info));  
12.   
13.     blank = strchr(buf, ' ');  
14.   
15.     memcpy(info.type, buf, blank - buf);  
16.   
17.     /\* Parse remaining parameters, reject extra parameters \*/  
18.     res = sscanf(++blank, "%hi%c", &info.addr, &end);  
19.   
20.     client = i2c\_new\_device(adap, &info);  
21.   
22.     return count;  
23. \}  
24. struct i2c\_client \* i2c\_new\_device(struct i2c\_adapter \*adap, struct i2c\_board\_info const \*info)  
25. \{  
26.     struct i2c\_client   \*client;  
27.     int         status;  
28.   
29.     client = kzalloc(sizeof \*client, GFP\_KERNEL);  
30.   
31.     client->adapter = adap;  
32.   
33.     client->dev.platform\_data = info->platform\_data;  
34.   
35.     if (info->archdata)  
36.         client->dev.archdata = \*info->archdata;  
37.   
38.     client->flags = info->flags;  
39.     client->addr = info->addr;    // 设备地址   
40.     client->irq = info->irq;  
41.   
42.     strlcpy(client->name, info->type, sizeof(client->name)); // 名字很重要  
43.   
44.     /\* Check for address business \*/  
45.     status = i2c\_check\_addr(adap, client->addr);  
46.   
47.     client->dev.parent = &client->adapter->dev;  
48.     client->dev.bus = &i2c\_bus\_type;  
49.     client->dev.type = &i2c\_client\_type;  
50.   
51.     dev\_set\_name(&client->dev, "%d-%04x", i2c\_adapter\_id(adap),  
52.              client->addr);  
53.     status = device\_register(&client->dev);  
54.   
55.     return client;  
56. \}

i2c\_sysfs\_new\_device 函数，将用户空间传递进来的命令进行解析 生成info结构体(addr ,type)，然后调用 i2c\_new\_device, 在 i2c\_new\_device 中构造client ，设置它的属性并将它注册到 i2c\_bus\_type，其中两个必须提的属性 client->name = info->type ,为什么说名字重要，如果看i2c\_bus\_type的match函数就可以知道，driver是根据client的名字是否在其idtable中判断是否支持这个client的。另外一个就是addr了，不用多说，每一个i2c设备必须都有个地址。空说无凭，看代码。

\[cpp\]  [view plain][]  [copy][view plain]

1.  static int i2c\_device\_match(struct device \*dev, struct device\_driver \*drv)  
2.  \{  
3.      struct i2c\_client   \*client = i2c\_verify\_client(dev);  
4.      struct i2c\_driver   \*driver;  
5.    
6.      if (!client)  
7.          return 0;  
8.    
9.      driver = to\_i2c\_driver(drv);  
10.     /\* match on an id table if there is one \*/  
11.     if (driver->id\_table)  
12.         return i2c\_match\_id(driver->id\_table, client) != NULL;  
13.   
14.     return 0;  
15. \}  
16. static const struct i2c\_device\_id \*i2c\_match\_id(const struct i2c\_device\_id \*id,  
17.         const struct i2c\_client \*client)  
18. \{  
19.     while (id->name\[0\]) \{  
20.         if (strcmp(client->name, id->name) == 0)  
21.             return id;  
22.         id++;  
23.     \}  
24.     return NULL;  
25. \}

分析一下 i2c\_scan\_static\_board\_info 第二种创建 device 的方式

\[cpp\]  [view plain][]  [copy][view plain]

1.  static void i2c\_scan\_static\_board\_info(struct i2c\_adapter \*adapter)  
2.  \{  
3.      struct i2c\_devinfo  \*devinfo;  
4.    
5.      down\_read(&\_\_i2c\_board\_lock);  
6.      /\* 遍历\_\_i2c\_board\_list链表 取出每一个 devinfo \*/  
7.      list\_for\_each\_entry(devinfo, &\_\_i2c\_board\_list, list) \{  
8.          /\* adapter->nr == 0 devinfo->busnum 还不知道，如果相等 
9.             取出 devinfo->board\_info 调用 i2c\_new\_device ，前面分析过了哦 \*/  
10.         if (devinfo->busnum == adapter->nr && !i2c\_new\_device(adapter, &devinfo->board\_info))  
11.             dev\_err(&adapter->dev,  
12.                 "Can't create device at 0x%02x\\n",  
13.                 devinfo->board\_info.addr);  
14.     \}  
15.     up\_read(&\_\_i2c\_board\_lock);  
16. \}

来看一下 \_\_i2c\_board\_list 这个链表是哪里填充的。

\[cpp\]  [view plain][]  [copy][view plain]

1.  mach-mini2440.c (arch\\arm\\mach-s3c2440)  
2.  static struct i2c\_board\_info i2c\_devs\[\] \_\_initdata = \{  
3.      \{ I2C\_BOARD\_INFO("eeprom", 0x50), \},  
4.  \};  
5.  \#define I2C\_BOARD\_INFO(dev\_type, dev\_addr) \\  
6.      .type = dev\_type, .addr = (dev\_addr)  
7.  static void \_\_init mini2440\_machine\_init(void)  
8.  \{  
9.      i2c\_register\_board\_info(0, i2c\_devs, ARRAY\_SIZE(i2c\_devs));  
10.     ....  
11. \}  
12. int \_\_init i2c\_register\_board\_info(int busnum,  
13.     struct i2c\_board\_info const \*info, unsigned len)  
14. \{  
15.     int status;  
16.   
17.     down\_write(&\_\_i2c\_board\_lock);  
18.   
19.     if (busnum >= \_\_i2c\_first\_dynamic\_bus\_num)  
20.         \_\_i2c\_first\_dynamic\_bus\_num = busnum + 1;  
21.   
22.     for (status = 0; len; len--, info++) \{  
23.         struct i2c\_devinfo  \*devinfo;  
24.   
25.         devinfo = kzalloc(sizeof(\*devinfo), GFP\_KERNEL);  
26.   
27.         devinfo->busnum = busnum;    // busnum == 0  
28.         devinfo->board\_info = \*info;  
29.         list\_add\_tail(&devinfo->list, &\_\_i2c\_board\_list); // 添加到 \_\_i2c\_board\_list 链表中  
30.     \}  
31.   
32.     up\_write(&\_\_i2c\_board\_lock);  
33.   
34.     return status;  
35. \}

这种方法与第一种用户空间创建device的方法相类似，都是提供一个addr 和 名字,只不过这种方法还有一个限制，前面看代码的时候我们知道，在注册adapter的时候，它会去访问\_\_i2c\_board\_list链表，那么如果想成功创建，你必须在注册adater之前i2c\_register\_board\_info

第二种创建 device 的方式

\[cpp\]  [view plain][]  [copy][view plain]

1.  bus\_for\_each\_drv(&i2c\_bus\_type, NULL, adap, i2c\_do\_add\_adapter) 分析  
2.      取出 i2c\_bus\_type 每一个driver 调用 i2c\_do\_add\_adapter  
3.  static int i2c\_do\_add\_adapter(struct device\_driver \*d, void \*data)  
4.  \{  
5.      struct i2c\_driver \*driver = to\_i2c\_driver(d);  
6.      struct i2c\_adapter \*adap = data;  
7.    
8.      /\* Detect supported devices on that bus, and instantiate them \*/  
9.      i2c\_detect(adap, driver);  
10.   
11.     /\* Let legacy drivers scan this bus for matching devices \*/  
12.     if (driver->attach\_adapter) \{  
13.         /\* We ignore the return code; if it fails, too bad \*/  
14.         driver->attach\_adapter(adap);  
15.     \}  
16.     return 0;  
17. \}  
18. static int i2c\_detect(struct i2c\_adapter \*adapter, struct i2c\_driver \*driver)  
19. \{  
20.     const struct i2c\_client\_address\_data \*address\_data;  
21.     struct i2c\_client \*temp\_client;  
22.     int i, err = 0;  
23.     int adap\_id = i2c\_adapter\_id(adapter);  
24.     // driver中 设置了 address\_data 是创建device的前提，因为 address\_data 中保存了设备的addr 与 名字，看设备驱动的时候会知道  
25.     address\_data = driver->address\_data;  
26.     if (!driver->detect || !address\_data)  
27.         return 0;  
28.   
29.     /\* Set up a temporary client to help detect callback \*/  
30.     temp\_client = kzalloc(sizeof(struct i2c\_client), GFP\_KERNEL);  
31.     if (!temp\_client)  
32.         return -ENOMEM;  
33.     temp\_client->adapter = adapter;  
34.   
35.     /\* Force entries are done first, and are not affected by ignore 
36.        entries \*/  
37.     if (address\_data->forces) \{  
38.         .....  
39.     \}  
40.   
41.     /\* Stop here if the classes do not match \*/  
42.     if (!(adapter->class & driver->class))  
43.         goto exit\_free;  
44.   
45.     /\* Stop here if we can't use SMBUS\_QUICK \*/  
46.     if (!i2c\_check\_functionality(adapter, I2C\_FUNC\_SMBUS\_QUICK)) \{  
47.         ......  
48.     \}  
49.   
50.     /\* Probe entries are done second, and are not affected by ignore 
51.        entries either \*/  
52.     for (i = 0; address\_data->probe\[i\] != I2C\_CLIENT\_END; i += 2) \{  
53.         ......  
54.     \}  
55.   
56.     /\* Normal entries are done last, unless shadowed by an ignore entry \*/  
57.     for (i = 0; address\_data->normal\_i2c\[i\] != I2C\_CLIENT\_END; i += 1) \{  
58.         int j, ignore;  
59.   
60.         ignore = 0;  
61.         ......  
62.         temp\_client->addr = address\_data->normal\_i2c\[i\];  
63.         err = i2c\_detect\_address(temp\_client, -1, driver);  
64.     \}  
65. \}  
66. static int i2c\_detect\_address(struct i2c\_client \*temp\_client, int kind,  
67.   struct i2c\_driver \*driver)  
68. \{  
69.     struct i2c\_board\_info info;  
70.     struct i2c\_adapter \*adapter = temp\_client->adapter;  
71.     int addr = temp\_client->addr;  
72.     int err;  
73.   
74.     /\* 发送 start 信号 以及 i2c设备地址，看是否能收到 ack 信号，判断设备是否存在，不存在返回 \*/  
75.     if (kind < 0) \{  
76.         if (i2c\_smbus\_xfer(adapter, addr, 0, 0, 0,  
77.                    I2C\_SMBUS\_QUICK, NULL) < 0)   // 最终就会调用到adapter驱动中我们设置的 i2c\_algorithm  
78.             return 0;  
79.     \}  
80.   
81.     /\* Finally call the custom detection function \*/  
82.     memset(&info, 0, sizeof(struct i2c\_board\_info));  
83.     info.addr = addr;  
84.     // 要在 driver->detect 设置 info->type   
85.     err = driver->detect(temp\_client, kind, &info);  
86.   
87.     /\* 如果设置了 info.type，创建 client 调用 i2c\_new\_device \*/  
88.     if (info.type\[0\] == '\\0') \{  
89.         ......  
90.     \} else \{  
91.         struct i2c\_client \*client;  
92.   
93.         /\* Detection succeeded, instantiate the device \*/                         
94.         client = i2c\_new\_device(adapter, &info);  
95.         if (client)  
96.             list\_add\_tail(&client->detected, &driver->clients);  
97.     \}  
98.     return 0;  
99. \}

我们在 向i2c\_bus\_type 注册driver时，与上面的方法是一样的，因此，我们可以动态加载driver时，创建对应的device，但是并不推荐这样做。  
         i2c\_add\_driver-》i2c\_register\_driver-》bus\_for\_each\_dev(&i2c\_bus\_type, NULL, driver, \_\_attach\_adapter);  
         \_\_attach\_adapter 和 i2c\_do\_add\_adapter 内容是同理的。

3、i2c 设备驱动框架  
  3.1 i2c\_bus\_type  
            前面已经分析过了它的 match 函数，稍后我们会注意一下它的probe函数。  
  3.2 i2c\_driver  
            注册driver的过程，创建 device 前面也分析过了  
  3.3 i2c\_device  
            device 就更不用提了，前面讲了3中创建它的方法，还有第四种 直接 i2c\_new\_device ，岂不是更来得痛快。  
            关于以上3点，就不再分析了，后面直接看 代码更直接，这里再记录一下 我分析这里时遇到的一个小问题。

\[cpp\]  [view plain][]  [copy][view plain]

1.  static struct i2c\_driver eeprom\_driver = \{  
2.      .driver = \{  
3.          .name   = "eeprom",  
4.      \},  
5.      .probe      = eeprom\_probe,  
6.      .remove     = eeprom\_remove,  
7.      .id\_table   = eeprom\_id,  
8.    
9.      .class      = I2C\_CLASS\_DDC | I2C\_CLASS\_SPD,  
10.     .detect     = eeprom\_detect,  
11.     .address\_data   = &addr\_data,   // 由I2C\_CLIENT\_INSMOD\_1(eeprom)宏定义  
12. \};

我们在写i2c\_driver时，在 .driver 中没有指定 probe函数，那么配对成功后是如何调用到 eeprom\_probe 的，对于platform平台，它是在注册platform\_driver时，给.driver设置了通用的probe接口，platform\_probe，使用它跳转到 上层的 probe 也就类似于这里的 eeprom\_probe。但是搜遍代码 i2c\_bus\_type 并没有这样做呀，奇怪奇怪。回想在分析设备总线驱动模型，设备与驱动的配对过程，在调用probe函数时，首先会看bus->probe有没有，有就调用，没有才会调用driver->probe，platform\_bus\_type 是没有Probe函数的，但是i2c\_bus\_type有！！！所以，来看看 i2c\_bus\_type->probe吧。

\[cpp\]  [view plain][]  [copy][view plain]

1.  static int i2c\_device\_probe(struct device \*dev)  
2.  \{  
3.      struct i2c\_client   \*client = i2c\_verify\_client(dev);  
4.      struct i2c\_driver   \*driver;  
5.      int status;  
6.    
7.      if (!client)  
8.          return 0;  
9.    
10.     driver = to\_i2c\_driver(dev->driver);  
11.     if (!driver->probe || !driver->id\_table)  
12.         return -ENODEV;  
13.     client->driver = driver;  
14.     if (!device\_can\_wakeup(&client->dev))  
15.         device\_init\_wakeup(&client->dev,  
16.                     client->flags & I2C\_CLIENT\_WAKE);  
17.     dev\_dbg(dev, "probe\\n");  
18.   
19.     status = driver->probe(client, i2c\_match\_id(driver->id\_table, client));  
20.     if (status)  
21.         client->driver = NULL;  
22.     return status;  
23. \}

不难分析，原来是通过 Bus->probe 函数进行了跳转，以后分析别的总线模型又涨知识了。

4、写设备驱动程序

我们使用最简单粗暴的方法，直接在设备侧使用 i2c\_new\_device 创建一个设备注册到 i2c\_bus\_type里，再写个驱动与它配对。

\[cpp\]  [view plain][]  [copy][view plain]

1.  \#include <linux/kernel.h>  
2.  \#include <linux/module.h>  
3.  \#include <linux/platform\_device.h>  
4.  \#include <linux/i2c.h>  
5.  \#include <linux/err.h>  
6.  \#include <linux/regmap.h>  
7.  \#include <linux/slab.h>  
8.    
9.    
10. static struct i2c\_board\_info at24cxx\_info = \{     
11.     I2C\_BOARD\_INFO("at24c08", 0x50),  
12. \};  
13.   
14. static struct i2c\_client \*at24cxx\_client;  
15.   
16. static int at24cxx\_dev\_init(void)  
17. \{  
18.     struct i2c\_adapter \*i2c\_adap;  
19.     // 获取设备号为 0 的adpter ，也就是adapter->nr == 0  
20.     i2c\_adap = i2c\_get\_adapter(0);  
21.     // 直接使用 i2c\_new\_device 创建 client 自动注册到i2c\_bus\_type 中去，client->name == "at24c08" ,client->addr = 0x50  
22.     at24cxx\_client = i2c\_new\_device(i2c\_adap, &at24cxx\_info);  
23.     // 释放掉 adapter  
24.     i2c\_put\_adapter(i2c\_adap);    
25.     return 0;  
26. \}  
27.   
28. static void at24cxx\_dev\_exit(void)  
29. \{  
30.     i2c\_unregister\_device(at24cxx\_client);  
31. \}  
32.   
33. module\_init(at24cxx\_dev\_init);  
34. module\_exit(at24cxx\_dev\_exit);  
35. MODULE\_LICENSE("GPL");

设备侧的程序相对简单，我们只需要构造一个board\_info结构体，设置名字Info->type 以及 地址 info->addr，然后使用 i2c\_new\_device 将其注册到I2c\_bus\_type 即可。

\[cpp\]  [view plain][]  [copy][view plain]

1.  \#include <linux/kernel.h>  
2.  \#include <linux/module.h>  
3.  \#include <linux/platform\_device.h>  
4.  \#include <linux/i2c.h>  
5.  \#include <linux/err.h>  
6.  \#include <linux/regmap.h>  
7.  \#include <linux/slab.h>  
8.  \#include <linux/fs.h>  
9.  \#include <asm/uaccess.h>  
10.   
11.   
12. static int major;  
13. static struct class \*class;  
14. static struct i2c\_client \*at24cxx\_client;  
15.   
16. /\* 传入: buf\[0\] : addr 
17.  \* 输出: buf\[0\] : data 
18.  \*/  
19. static ssize\_t at24cxx\_read(struct file \* file, char \_\_user \*buf, size\_t count, loff\_t \*off)  
20. \{  
21.     unsigned char addr, data;  
22.       
23.     copy\_from\_user(&addr, buf, 1);  
24.     data = i2c\_smbus\_read\_byte\_data(at24cxx\_client, addr);  
25.     copy\_to\_user(buf, &data, 1);  
26.     return 1;  
27. \}  
28.   
29. /\* buf\[0\] : addr 
30.  \* buf\[1\] : data 
31.  \*/  
32. static ssize\_t at24cxx\_write(struct file \*file, const char \_\_user \*buf, size\_t count, loff\_t \*off)  
33. \{  
34.     unsigned char ker\_buf\[2\];  
35.     unsigned char addr, data;  
36.   
37.     copy\_from\_user(ker\_buf, buf, 2);  
38.     addr = ker\_buf\[0\];  
39.     data = ker\_buf\[1\];  
40.   
41.     printk("addr = 0x%02x, data = 0x%02x\\n", addr, data);  
42.   
43.     if (!i2c\_smbus\_write\_byte\_data(at24cxx\_client, addr, data))  
44.         return 2;  
45.     else  
46.         return -EIO;      
47. \}  
48.   
49. static struct file\_operations at24cxx\_fops = \{  
50.     .owner = THIS\_MODULE,  
51.     .read  = at24cxx\_read,  
52.     .write = at24cxx\_write,  
53. \};  
54.   
55. static int \_\_devinit at24cxx\_probe(struct i2c\_client \*client,  
56.                   const struct i2c\_device\_id \*id)  
57. \{  
58.     at24cxx\_client = client;  
59.           
60.     //printk("%s %s %d\\n", \_\_FILE\_\_, \_\_FUNCTION\_\_, \_\_LINE\_\_);  
61.     major = register\_chrdev(0, "at24cxx", &at24cxx\_fops);  
62.     class = class\_create(THIS\_MODULE, "at24cxx");  
63.     device\_create(class, NULL, MKDEV(major, 0), NULL, "at24cxx"); /\* /dev/at24cxx \*/  
64.       
65.     return 0;  
66. \}  
67.   
68. static int \_\_devexit at24cxx\_remove(struct i2c\_client \*client)  
69. \{  
70.     //printk("%s %s %d\\n", \_\_FILE\_\_, \_\_FUNCTION\_\_, \_\_LINE\_\_);  
71.     device\_destroy(class, MKDEV(major, 0));  
72.     class\_destroy(class);  
73.     unregister\_chrdev(major, "at24cxx");  
74.           
75.     return 0;  
76. \}  
77.   
78. static const struct i2c\_device\_id at24cxx\_id\_table\[\] = \{  
79.     \{ "at24c08", 0 \},  
80.     \{\}  
81. \};  
82.   
83.   
84. /\* 1. 分配/设置i2c\_driver \*/  
85. static struct i2c\_driver at24cxx\_driver = \{  
86.     .driver = \{  
87.         .name   = "100ask",  
88.         .owner  = THIS\_MODULE,  
89.     \},  
90.     .probe      = at24cxx\_probe,  
91.     .remove     = \_\_devexit\_p(at24cxx\_remove),  
92.     .id\_table   = at24cxx\_id\_table,  
93. \};  
94.   
95. static int at24cxx\_drv\_init(void)  
96. \{  
97.     /\* 2. 注册i2c\_driver \*/  
98.     i2c\_add\_driver(&at24cxx\_driver);  
99.       
100.     return 0;  
101. \}  
102.   
103. static void at24cxx\_drv\_exit(void)  
104. \{  
105.     i2c\_del\_driver(&at24cxx\_driver);  
106. \}  
107.   
108.   
109. module\_init(at24cxx\_drv\_init);  
110. module\_exit(at24cxx\_drv\_exit);  
111. MODULE\_LICENSE("GPL");

驱动侧的程序，思路：

1、分配一个 i2c\_driver 结构体

2、设置它的名字，仅仅是出现在 sysfs 的目录名

3、设置 id\_table ，根据 id\_table 与 client 的名字进行匹配

4、设置 probe 函数，配对成功后调用它，我们往往在这里面创建类，在类下面创建设备，让Mdev自动帮我们创建设备节点。

5、设备 remove 函数  ，与 i2c\_add\_driver 相反，我们在remove函数里 将driver删除掉，使用 i2c\_del\_driver 。

还有需要注意的是，我们在Probe函数里，注册了一个字符设备驱动，在它的 read 和 write 函数里，用到了两个简单的函数，i2c\_smbus\_read\_byte\_data 与 i2c\_smbus\_write\_byte\_data，这两个函数是什么东西，我们之前用过 i2c\_transfer 使用 mesg 结构体进行传输过，i2c\_transfer 最终会调用到 adapter 里我们设置的传输函数。这里就不再分析代码了，根据我个人的理解，我们现在使用的 i2c\_smbus\_read\_byte\_data 等函数，是对 i2c\_transfer 与 meag 进行了更深层次的封装，我们以前向读数据时，需要用两个mesg 结构体，因为要先发送地址，再读取数据，i2c\_smbus\_read\_byte\_data 函数我们只需要提供一个要读取的地址，它就会帮我们去构造那两个Mesg 结构体，总而言之，我们写程序更方便了。那么，i2c\_smbus\_read\_byte\_data 等函数对应的时序是怎样的，是否符合我们的要求，如何选取？看帮助文档 smbus-protocol

\---------------------------------------------------------------------------------------------------------------------------------

SMBus Protocol Summary

======================  
  
The following is a summary of the SMBus protocol. It applies to  
all revisions of the protocol (1.0, 1.1, and 2.0).  
Certain protocol features which are not supported by  
this package are briefly described at the end of this document.  
  
Some adapters understand only the SMBus (System Management Bus) protocol,  
which is a subset from the I2C protocol. Fortunately, many devices use  
only the same subset, which makes it possible to put them on an SMBus.  
  
If you write a driver for some I2C device, please try to use the SMBus  
commands if at all possible (if the device uses only that subset of the  
I2C protocol). This makes it possible to use the device driver on both  
SMBus adapters and I2C adapters (the SMBus command set is automatically  
translated to I2C on I2C adapters, but plain I2C commands can not be  
handled at all on most pure SMBus adapters).  
  
Below is a list of SMBus protocol operations, and the functions executing  
them.  Note that the names used in the SMBus protocol specifications usually  
don't match these function names.  For some of the operations which pass a  
single data byte, the functions using SMBus protocol operation names execute  
a different protocol operation entirely.  
  
Key to symbols  
==============  
  
S     (1 bit) : Start bit  
P     (1 bit) : Stop bit  
Rd/Wr (1 bit) : Read/Write bit. Rd equals 1, Wr equals 0.  
A, NA (1 bit) : Accept and reverse accept bit.   
Addr  (7 bits): I2C 7 bit address. Note that this can be expanded as usual to   
                get a 10 bit I2C address.  
Comm  (8 bits): Command byte, a data byte which often selects a register on  
                the device.  
Data  (8 bits): A plain data byte. Sometimes, I write DataLow, DataHigh  
                for 16 bit data.  
Count (8 bits): A data byte containing the length of a block operation.  
  
\[..\]: Data sent by I2C device, as opposed to data sent by the host adapter.  
  
SMBus Quick Command  
===================  
  
This sends a single bit to the device, at the place of the Rd/Wr bit.  
  
A Addr Rd/Wr \[A\] P  
  
SMBus Receive Byte:  i2c\_smbus\_read\_byte()  
==========================================  
  
This reads a single byte from a device, without specifying a device  
register. Some devices are so simple that this interface is enough; for  
others, it is a shorthand if you want to read the same register as in  
the previous SMBus command.  
  
S Addr Rd \[A\] \[Data\] NA P  
  
SMBus Send Byte:  i2c\_smbus\_write\_byte()  
========================================  
  
This operation is the reverse of Receive Byte: it sends a single byte  
to a device.  See Receive Byte for more information.  
  
S Addr Wr \[A\] Data \[A\] P  
  
SMBus Read Byte:  i2c\_smbus\_read\_byte\_data()  
============================================  
  
This reads a single byte from a device, from a designated register.  
The register is specified through the Comm byte.  
  
  
S Addr Wr \[A\] Comm \[A\] S Addr Rd \[A\] \[Data\] NA P  
  
SMBus Read Word:  i2c\_smbus\_read\_word\_data()  
============================================  
  
This operation is very like Read Byte; again, data is read from a  
device, from a designated register that is specified through the Comm  
byte. But this time, the data is a complete word (16 bits).  
  
S Addr Wr \[A\] Comm \[A\] S Addr Rd \[A\] \[DataLow\] A \[DataHigh\] NA P  
  
SMBus Write Byte:  i2c\_smbus\_write\_byte\_data()  
==============================================  
  
This writes a single byte to a device, to a designated register. The  
register is specified through the Comm byte. This is the opposite of  
the Read Byte operation.  
  
S Addr Wr \[A\] Comm \[A\] Data \[A\] P  
  
SMBus Write Word:  i2c\_smbus\_write\_word\_data()  
==============================================  
  
This is the opposite of the Read Word operation. 16 bits  
of data is written to a device, to the designated register that is  
specified through the Comm byte.   
  
S Addr Wr \[A\] Comm \[A\] DataLow \[A\] DataHigh \[A\] P  
  
SMBus Process Call:  i2c\_smbus\_process\_call()  
=============================================  
  
This command selects a device register (through the Comm byte), sends  
16 bits of data to it, and reads 16 bits of data in return.  
  
S Addr Wr \[A\] Comm \[A\] DataLow \[A\] DataHigh \[A\]   
                             S Addr Rd \[A\] \[DataLow\] A \[DataHigh\] NA P  
  
SMBus Block Read:  i2c\_smbus\_read\_block\_data()  
==============================================  
  
This command reads a block of up to 32 bytes from a device, from a   
designated register that is specified through the Comm byte. The amount  
of data is specified by the device in the Count byte.  
  
S Addr Wr \[A\] Comm \[A\]   
           S Addr Rd \[A\] \[Count\] A \[Data\] A \[Data\] A ... A \[Data\] NA P  
  
SMBus Block Write:  i2c\_smbus\_write\_block\_data()  
================================================  
  
The opposite of the Block Read command, this writes up to 32 bytes to   
a device, to a designated register that is specified through the  
Comm byte. The amount of data is specified in the Count byte.  
  
S Addr Wr \[A\] Comm \[A\] Count \[A\] Data \[A\] Data \[A\] ... \[A\] Data \[A\] P  
  
SMBus Block Write - Block Read Process Call  
===========================================  
  
SMBus Block Write - Block Read Process Call was introduced in  
Revision 2.0 of the specification.  
  
This command selects a device register (through the Comm byte), sends  
1 to 31 bytes of data to it, and reads 1 to 31 bytes of data in return.  
  
S Addr Wr \[A\] Comm \[A\] Count \[A\] Data \[A\] ...  
                             S Addr Rd \[A\] \[Count\] A \[Data\] ... A P  
  
SMBus Host Notify  
=================  
  
This command is sent from a SMBus device acting as a master to the  
SMBus host acting as a slave.  
It is the same form as Write Word, with the command code replaced by the  
alerting device's address.  
  
\[S\] \[HostAddr\] \[Wr\] A \[DevAddr\] A \[DataLow\] A \[DataHigh\] A \[P\]  
  
Packet Error Checking (PEC)  
===========================  
  
Packet Error Checking was introduced in Revision 1.1 of the specification.  
  
PEC adds a CRC-8 error-checking byte to transfers using it, immediately  
before the terminating STOP.  
  
Address Resolution Protocol (ARP)  
=================================  
  
The Address Resolution Protocol was introduced in Revision 2.0 of  
the specification. It is a higher-layer protocol which uses the  
messages above.  
  
ARP adds device enumeration and dynamic address assignment to  
the protocol. All ARP communications use slave address 0x61 and  
require PEC checksums.  
  
I2C Block Transactions  
======================  
  
The following I2C block transactions are supported by the  
SMBus layer and are described here for completeness.  
They are \*NOT\* defined by the SMBus specification.  
  
I2C block transactions do not limit the number of bytes transferred  
but the SMBus layer places a limit of 32 bytes.  
  
I2C Block Read:  i2c\_smbus\_read\_i2c\_block\_data()  
================================================  
  
This command reads a block of bytes from a device, from a   
designated register that is specified through the Comm byte.  
  
  
S Addr Wr \[A\] Comm \[A\]   
           S Addr Rd \[A\] \[Data\] A \[Data\] A ... A \[Data\] NA P  
  
  
  
  
I2C Block Read (2 Comm bytes)  
=============================  
  
  
This command reads a block of bytes from a device, from a   
designated register that is specified through the two Comm bytes.  
  
  
S Addr Wr \[A\] Comm1 \[A\] Comm2 \[A\]   
           S Addr Rd \[A\] \[Data\] A \[Data\] A ... A \[Data\] NA P  
  
  
  
  
I2C Block Write:  i2c\_smbus\_write\_i2c\_block\_data()  
==================================================  
  
  
The opposite of the Block Read command, this writes bytes to   
a device, to a designated register that is specified through the  
Comm byte. Note that command lengths of 0, 2, or more bytes are  
supported as they are indistinguishable from data.  
  
  
S Addr Wr \[A\] Comm \[A\] Data \[A\] Data \[A\] ... \[A\] Data \[A\] P

5、写adapter驱动程序

i2c协议的简单介绍，以及手写 adapter驱动程序 放到下一篇文章里吧~  
  
  
  
转自：http://blog.csdn.net/lizuobin2/article/details/51694574

[SouthEast]: /images/20220602/6b56c3e68eb740cfa7398a73dd9669a2.png
[view plain]: http://blog.csdn.net/lizuobin2/article/details/51694574#
[SouthEast 1]: /images/20220602/24c6006fd53e42748fa08bc3a59614a2.png