Linux 设备驱动篇之-------I2c设备驱动（待续）

Linux 设备驱动篇之-------I2c设备驱动

 

虽然I2C硬件体系结构和协议都很容易理解，但是Linux I2C驱动体系结构却有相当的复杂度，它主要由3部分组成，即I2C设备驱动、I2C总线驱动和I2C核心。I2C核心是I2c总线和I2c设备驱动的中间枢纽，它以通用的、与平台无关的接口实现了I2C中设备与适配器的沟通。I2c总线驱动填充I2c_adapter和I2c_algorithm结构体，I2c设备驱动填充I2c_driver结构体并实现其本身所对应设备类型的驱动。

另外，系统中i2c-dev.c文件定义的主设备号为89的设备可以方便地给应用程序提供读写I2c设备寄存器的能力，使得工程师大多数时候并不需要为具体的I2c设备驱动定义文件操作接口。

如何理解adapter、I2c适配器和client呢？他在s3c2440中对应的是什么？Adapter、I2c适配器和client都是linux驱动软件抽象出来的东西，Linux I2C框架搞那么复杂是为了通用性及为了符合Linux内核驱动模式而制定的。简单的说，你的开发板上有几个I2C接口，就有几个adapter , 也就是有几条I2C bus ， I2C client对应的就是你的外围I2C 设备，有几个就有几个client , 把这些设备插入开发板， 对应其中的一条bus, 那么相应的就对应了其中的一个adapter , 接下来的就是I2c核心部分使client与 adapter匹配成对。

在linux内核中，所有的I2C设备都在sysfs文件系统中显示，存在于/sys/bus/i2c/目录下，适配器地址和芯片地址的形式列出，例如：

[fulinux@ubuntu linux-3.0]$ tree /sys/bus/i2c/       

/sys/bus/i2c/

|-- devices

|   |-- i2c-0 -> ../../../devices/pci0000:00/0000:00:02.0/i2c-0

|   |-- i2c-1 -> ../../../devices/pci0000:00/0000:00:02.0/i2c-1

|   |-- i2c-2 -> ../../../devices/pci0000:00/0000:00:02.0/i2c-2

|   |-- i2c-3 -> ../../../devices/pci0000:00/0000:00:02.0/i2c-3

|   |-- i2c-4 -> ../../../devices/pci0000:00/0000:00:02.0/i2c-4

|   |-- i2c-5 -> ../../../devices/pci0000:00/0000:00:02.0/i2c-5

|   |-- i2c-6 -> ../../../devices/pci0000:00/0000:00:02.0/drm/card0/card0-DP-1/i2c-6

|   `-- i2c-7 -> ../../../devices/pci0000:00/0000:00:02.0/drm/card0/card0-DP-2/i2c-7

|-- drivers

|   |-- 88PM860x

|   |   |-- bind

|   |   |-- uevent

|   |   `-- unbind

|   |-- aat2870

|   |   |-- bind

|   |   |-- uevent

|   |   `-- unbind

|   |-- ab3100

|   |   |-- bind

|   |   |-- uevent

|   |   `-- unbind

|   |-- adp5520

下面我以s3c2440开发板及其之上的EEPROM芯片AT24C02和linux-3.0内核平台讲解I2c的三个部分。

S3c2440芯片上的I2c模块特性

请看s3c2440.pdf

芯片AT24C02的电气特性：

• Low-voltage and Standard-voltage Operation

– 2.7 (VCC= 2.7V to 5.5V)

– 1.8 (VCC= 1.8V to 5.5V)

• Internally Organized 128 x 8 (1K), 256 x 8 (2K), 512 x 8 (4K),

1024 x 8 (8K) or 2048 x 8 (16K)

• Two-wire Serial Interface

• Schmitt Trigger, Filtered Inputs for Noise Suppression

• Bidirectional Data Transfer Protocol

• 100 kHz (1.8V) and 400 kHz (2.7V, 5V) Compatibility

• Write Protect Pin for Hardware Data Protection

• 8-byte Page (1K, 2K), 16-byte Page (4K, 8K, 16K) Write Modes

• Partial Page Writes Allowed

• Self-timed Write Cycle (5 ms max)

• High-reliability

– Endurance: 1 Million Write Cycles

– Data Retention: 100 Years

• Automotive Grade and Lead-free/Halogen-free Devices Available

• 8-lead PDIP, 8-lead JEDEC SOIC, 8-lead MAP, 5-lead SOT23,

8-lead TSSOP and 8-ball dBGA2 Packages

• Die Sales: Wafer Form, Waffle Pack and Bumped Wafers

主要是看AT24C02.pdf

S3c244开发板核心板电路图：

AT24C02电路图：

i2c.h头文件

内核中i2c.h这个头文件对i2c_driver、i2c_client、i2c_adapter和i2c_algorithm着4个数据结构进行了定义。理解这4个结构的作用十分关键，代码清单1、2、3、4分别给出了它们的定义。

代码清单1 i2c_adapter结构体

1. /*

2.  * i2c_adapter is the structure used to identify a physical i2c bus along

3.  * with the access algorithms necessary to access it.

4.  */

5. struct i2c_adapter {

6.     struct module *owner;

7.     unsigned int class;       /* classes to allow probing for */

8.     const struct i2c_algorithm *algo; /* the algorithm to access the bus */

9.     void *algo_data;

10.     /* data fields that are valid for all devices   */

11.     struct rt_mutex bus_lock;

12.     int timeout;            /* in jiffies */

13.     int retries;

14.     struct device dev;      /* the adapter device */

15.     int nr;

16.     char name[48];

17.     struct completion dev_released;

18.     struct mutex userspace_clients_lock;

19.     struct list_head userspace_clients;

20. };

代码清单2 i2c_algorithm结构体

1. /*

2.  * The following structs are for those who like to implement new bus drivers:

3.  * i2c_algorithm is the interface to a class of hardware solutions which can

4.  * be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584

5.  * to name two of the most common.

6.  */

7. struct i2c_algorithm {

8.     /* If an adapter algorithm can't do I2C-level access, set master_xfer

9.        to NULL. If an adapter algorithm can do SMBus access, set

10.        smbus_xfer. If set to NULL, the SMBus protocol is simulated

11.        using common I2C messages */

12.     /* master_xfer should return the number of messages successfully

13.        processed, or a negative value on error */

14.     int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,

15.                int num);

16.     int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,

17.                unsigned short flags, char read_write,

18.                u8 command, int size, union i2c_smbus_data *data);

19.     /* To determine what the adapter supports */

20.     u32 (*functionality) (struct i2c_adapter *);

21. };

上述代码第4行对应为SMBus传输函数指针，SMBus大部分基于I2C总线规范，SMBus不需要增加额外引脚。与I2C总线相比，SMBus增加了一些新的功能特性，在访问时序也有一定的差异。

代码清单3 i2c_driver结构体

1. /*

2.  * struct i2c_driver - represent an I2C device driver

3.  * @class: What kind of i2c device we instantiate (for detect)

4.  * @attach_adapter: Callback for bus addition (deprecated)

5.  * @detach_adapter: Callback for bus removal (deprecated)

6.  * @probe: Callback for device binding

7.  * @remove: Callback for device unbinding

8.  * @shutdown: Callback for device shutdown

9.  * @suspend: Callback for device suspend

10.  * @resume: Callback for device resume

11.  * @alert: Alert callback, for example for the SMBus alert protocol

12.  * @command: Callback for bus-wide signaling (optional)

13.  * @driver: Device driver model driver

14.  * @id_table: List of I2C devices supported by this driver

15.  * @detect: Callback for device detection

16.  * @address_list: The I2C addresses to probe (for detect)

17.  * @clients: List of detected clients we created (for i2c-core use only)

18.  *

19.  * The driver.owner field should be set to the module owner of this driver.

20.  * The driver.name field should be set to the name of this driver.

21.  *

22.  * For automatic device detection, both @detect and @address_data must

23.  * be defined. @class should also be set, otherwise only devices forced

24.  * with module parameters will be created. The detect function must

25.  * fill at least the name field of the i2c_board_info structure it is

26.  * handed upon successful detection, and possibly also the flags field.

27.  *

28.  * If @detect is missing, the driver will still work fine for enumerated

29.  * devices. Detected devices simply won't be supported. This is expected

30.  * for the many I2C/SMBus devices which can't be detected reliably, and

31.  * the ones which can always be enumerated in practice.

32.  *

33.  * The i2c_client structure which is handed to the @detect callback is

34.  * not a real i2c_client. It is initialized just enough so that you can

35.  * call i2c_smbus_read_byte_data and friends on it. Don't do anything

36.  * else with it. In particular, calling dev_dbg and friends on it is

37.  * not allowed.

38.  */

39. struct i2c_driver {

40.     unsigned int class;

41.     /* Notifies the driver that a new bus has appeared or is about to be

42.      * removed. You should avoid using this, it will be removed in a

43.      * near future.

44.      */

45.     int (*attach_adapter)(struct i2c_adapter *) __deprecated;

46.     int (*detach_adapter)(struct i2c_adapter *) __deprecated;

47.     /* Standard driver model interfaces */

48.     int (*probe)(struct i2c_client *, const struct i2c_device_id *);

49.     int (*remove)(struct i2c_client *);

50.     /* driver model interfaces that don't relate to enumeration  */

51.     void (*shutdown)(struct i2c_client *);

52.     int (*suspend)(struct i2c_client *, pm_message_t mesg);

53.     int (*resume)(struct i2c_client *);

54.     /* Alert callback, for example for the SMBus alert protocol.

55.      * The format and meaning of the data value depends on the protocol.

56.      * For the SMBus alert protocol, there is a single bit of data passed

57.      * as the alert response's low bit ("event flag").

58.      */

59.     void (*alert)(struct i2c_client *, unsigned int data);

60.     /* a ioctl like command that can be used to perform specific functions

61.      * with the device.

62.      */

63.     int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);

64.     struct device_driver driver;

65.     const struct i2c_device_id *id_table;

66.     /* Device detection callback for automatic device creation */

67.     int (*detect)(struct i2c_client *, struct i2c_board_info *);

68.     const unsigned short *address_list;

69.     struct list_head clients;

70. };

代码清单4 i2c_client结构体

1. /**

2.  * struct i2c_client - represent an I2C slave device

3.  * @flags: I2C_CLIENT_TEN indicates the device uses a ten bit chip address;

4.  *  I2C_CLIENT_PEC indicates it uses SMBus Packet Error Checking

5.  * @addr: Address used on the I2C bus connected to the parent adapter.

6.  * @name: Indicates the type of the device, usually a chip name that's

7.  *  generic enough to hide second-sourcing and compatible revisions.

8.  * @adapter: manages the bus segment hosting this I2C device

9.  * @driver: device's driver, hence pointer to access routines

10.  * @dev: Driver model device node for the slave.

11.  * @irq: indicates the IRQ generated by this device (if any)

12.  * @detected: member of an i2c_driver.clients list or i2c-core's

13.  *  userspace_devices list

14.  *

15.  * An i2c_client identifies a single device (i.e. chip) connected to an

16.  * i2c bus. The behaviour exposed to Linux is defined by the driver

17.  * managing the device.

18.  */

19. struct i2c_client {

20.     unsigned short flags;       /* div., see below      */

21.     unsigned short addr;        /* chip address - NOTE: 7bit    */

22.                     /* addresses are stored in the  */

23.                     /* _LOWER_ 7 bits       */

24.     char name[I2C_NAME_SIZE];

25.     struct i2c_adapter *adapter;    /* the adapter we sit on    */

26.     struct i2c_driver *driver;  /* and our access routines  */

27.     struct device dev;      /* the device structure     */

28.     int irq;            /* irq issued by device     */

29.     struct list_head detected;

30. };

下面分析i2c_driver、i2c_client、i2c_adapter和i2c_algorithm这4个数据结构的作用及盘根错节的关系。

（1）i2c_adapter与i2c_algorithm.

i2c_adapter对应于物理上的一个适配器，而i2c_algorithm对应一套通信方法。一个I2C适配器需要i2c_algorithm中提供的通信函数来控制适配器上产生特定的访问周期。缺少i2c_algorithm的i2c_adapter什么也做不了，因此i2c_adapter中包含其使用的i2c_algorithm的指针。

I2c_algorithm中关键函数master_xfer用于产生I2C访问周期需要的信号，以i2c_msg（即I2C消息）为单位。I2c_msg结构体非常关键，代码清单5给出了它的定义。

代码清单5 i2c_msg结构体

1. /**

2.  * struct i2c_msg - an I2C transaction segment beginning with START

3.  * @addr: Slave address, either seven or ten bits.  When this is a ten

4.  *  bit address, I2C_M_TEN must be set in @flags and the adapter

5.  *  must support I2C_FUNC_10BIT_ADDR.

6.  * @flags: I2C_M_RD is handled by all adapters.  No other flags may be

7.  *  provided unless the adapter exported the relevant I2C_FUNC_*

8.  *  flags through i2c_check_functionality().

9.  * @len: Number of data bytes in @buf being read from or written to the

10.  *  I2C slave address.  For read transactions where I2C_M_RECV_LEN

11.  *  is set, the caller guarantees that this buffer can hold up to

12.  *  32 bytes in addition to the initial length byte sent by the

13.  *  slave (plus, if used, the SMBus PEC); and this value will be

14.  *  incremented by the number of block data bytes received.

15.  * @buf: The buffer into which data is read, or from which it's written.

16.  *

17.  * An i2c_msg is the low level representation of one segment of an I2C

18.  * transaction.  It is visible to drivers in the @i2c_transfer() procedure,

19.  * to userspace from i2c-dev, and to I2C adapter drivers through the

20.  * @i2c_adapter.@master_xfer() method.

21.  *

22.  * Except when I2C "protocol mangling" is used, all I2C adapters implement

23.  * the standard rules for I2C transactions.  Each transaction begins with a

24.  * START.  That is followed by the slave address, and a bit encoding read

25.  * versus write.  Then follow all the data bytes, possibly including a byte

26.  * with SMBus PEC.  The transfer terminates with a NAK, or when all those

27.  * bytes have been transferred and ACKed.  If this is the last message in a

28.  * group, it is followed by a STOP.  Otherwise it is followed by the next

29.  * @i2c_msg transaction segment, beginning with a (repeated) START.

30.  *

31.  * Alternatively, when the adapter supports I2C_FUNC_PROTOCOL_MANGLING then

32.  * passing certain @flags may have changed those standard protocol behaviors.

33.  * Those flags are only for use with broken/nonconforming slaves, and with

34.  * adapters which are known to support the specific mangling options they

35.  * need (one or more of IGNORE_NAK, NO_RD_ACK, NOSTART, and REV_DIR_ADDR).

36.  */

37. struct i2c_msg {

38.     __u16 addr; /* slave address            */

39.     __u16 flags;

40. #define I2C_M_TEN       0x0010  /* this is a ten bit chip address */

41. #define I2C_M_RD        0x0001  /* read data, from slave to master */

42. #define I2C_M_NOSTART       0x4000  /* if I2C_FUNC_PROTOCOL_MANGLING */

43. #define I2C_M_REV_DIR_ADDR  0x2000  /* if I2C_FUNC_PROTOCOL_MANGLING */

44. #define I2C_M_IGNORE_NAK    0x1000  /* if I2C_FUNC_PROTOCOL_MANGLING */

45. #define I2C_M_NO_RD_ACK     0x0800  /* if I2C_FUNC_PROTOCOL_MANGLING */

46. #define I2C_M_RECV_LEN      0x0400  /* length will be first received byte */

47.     __u16 len;      /* msg length               */

48.     __u8 *buf;      /* pointer to msg data          */

49. };

(2)i2c_driver与i2c_client。

i2c_driver对应一套驱动方法，其主要成员函数是probe（）、remove（）、suspend()、resume（）等，另外id_table是该驱动所支持的I2C设备的ID表。i2c_client对应于真实的物理设备，每个I2C设备都需要一个i2c_client来描述。I2c_driver和i2c_client的关系是一对多，一个i2c_driver上可以支持多个同类型的i2c_client。

I2c_client信息通常在BSP的板文件中通过i2c_board_info填充，如下面代码就定义了一个I2C设备ID为“24c02”、地址为0x50的i2c_client:

代码清单6 i2c_board_info结构体定义

1. static struct i2c_board_info __initdata smdk2440_i2c_devs[] = {

2.     {

3.         I2C_BOARD_INFO("24c02", 0x50),

4.         .platform_data = &at24c02,

5.     },

6.     /*  more devices can be added using expansion connectors */

7. };

在I2C总线驱动i2c_bus_type的match()函数i2c_device_match()中，会调用i2c_match_id()函数匹配板文件中定义的ID和i2c_driver所支持的ID表。

代码清单7 i2c_device_match函数在linux-3.0/drivers/i2c/i2c-core.c

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.     if (!client)

6.         return 0;

7.     /* Attempt an OF style match */

8.     if (of_driver_match_device(dev, drv))

9.         return 1;

10.     driver = to_i2c_driver(drv);

11.     /* match on an id table if there is one */

12.     if (driver->id_table)

13.         return i2c_match_id(driver->id_table, client) != NULL;

14.     return 0;

15. }

（3）i2c_adpater与i2c_client。

i2c_adapter与i2c_client的关系与I2C硬件体系中适配器和设备的关系一致，即i2c_client依附于i2c_adapter。由于一个适配器上可以连接多个I2C设备，所以一个i2c_adapter也可以被多个i2c_client依附，i2c_adapter中包含依附于它的i2c_client的链表。

代码清单8 i2c_client的链表

1. struct list_head userspace_clients;

假设I2C总线适配器xxx上有两个使用相同驱动程序的yyyI2C设备，在打开盖I2C总线的设备节点后相关数据结构之间的逻辑组织关系将如下图所示：

从上面的分析可知，虽然I2C硬件体系结构简单，但是I2C体系结构在linux中的实现却相当复杂。当工程师拿到实际的电路板，面对复杂的linux I2C子系统，应该如何下手写驱动呢？究竟要哪些是需要亲自做的，哪些是内核已经提供的呢？理清这个问题非常有意义，可以使我们面对具体问题时迅速地抓住重点。

一方面，适配器驱动可能是linux内核本身还不包含的；另一方面，挂接在适配器上的就提设备可能也是linux内核还不包含的。因此，工程师要实现的主要工作如下。

l 提供I2C适配器的硬件驱动，探测、初始化I2C适配器（如申请I2C的I/O地址和中断号）、驱动CPU控制的I2C适配器从硬件上产生各种信号以及处理I2C中断等。

l 提供I2C适配器的algorithm，具体适配器的xxx_xfer（）函数填充i2c_algorithm的master_xfer指针，并把i2c_algorithm指针赋值给i2c_adapter的algo指针。

l 实现I2C设备驱动中的i2c_driver接口，具体设备yyy_probe()、yyy_remove()、yyy_suspend()、yyy_resume()函数指针和i2c_device_id设备ID表赋值给i2c_driver的probe、remove、suspend、resume和id_table指针。

l 实现I2C设备所对应类型的具体驱动，i2c_driver只是实现设备与总线的挂接，而挂接在总线上的设备则是千差万别的。例如，如果字符设备，就实现文件操作接口，即实现具体yyy的yyy_read()、yyy_write()和yyy_ioctl()函数等；如果是声卡，就实现ALSA驱动。

I2c的第一部分----I2C设备驱动

上述工作中前两个属于I2C总线驱动，后两个属于I2C设备驱动，做完这些工作，系统会增加两个内核模块。在详细分析这些工作的实施方法给出设计模板之前，先看下linux I2C核心部分。

Linux I2C核心

I2C核心（driver/i2c/i2c-core.c）文件中提供了一组不依赖与硬件平台的接口函数，这个文件一般不需要被工程师修改，但是理解其中的主要函数非常关键，因为I2C总线驱动和设备驱动之间依赖于I2C核心作为纽带I2C核心中的主要函数如下。

（1）增加/删除i2c_adapter。

代码清单9 i2c_add_adapter函数：

1. /**

2.  * i2c_add_adapter - declare i2c adapter, use dynamic bus number

3.  * @adapter: the adapter to add

4.  * Context: can sleep

5.  *

6.  * This routine is used to declare an I2C adapter when its bus number

7.  * doesn't matter.  Examples: for I2C adapters dynamically added by

8.  * USB links or PCI plugin cards.

9.  *

10.  * When this returns zero, a new bus number was allocated and stored

11.  * in adap->nr, and the specified adapter became available for clients.

12.  * Otherwise, a negative errno value is returned.

13.  */

14. int i2c_add_adapter(struct i2c_adapter *adapter)

15. {

16.     int id, res = 0;

17. retry:

18.     if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)

19.         return -ENOMEM;

20.     mutex_lock(&core_lock);

21.     /* "above" here means "above or equal to", sigh */

22.     res = idr_get_new_above(&i2c_adapter_idr, adapter,

23.                 __i2c_first_dynamic_bus_num, &id);

24.     mutex_unlock(&core_lock);

25.     if (res < 0) {

26.         if (res == -EAGAIN)

27.             goto retry;

28.         return res;

29.     }

30.     adapter->nr = id;

31.     return i2c_register_adapter(adapter);

32. }

33. EXPORT_SYMBOL(i2c_add_adapter);

代码清单10 I2c_del_adapter函数：

1. /**

2.  * i2c_del_adapter - unregister I2C adapter

3.  * @adap: the adapter being unregistered

4.  * Context: can sleep

5.  *

6.  * This unregisters an I2C adapter which was previously registered

7.  * by @i2c_add_adapter or @i2c_add_numbered_adapter.

8.  */

9. int i2c_del_adapter(struct i2c_adapter *adap)

10. {

11.     int res = 0;

12.     struct i2c_adapter *found;

13.     struct i2c_client *client, *next;

14.     /* First make sure that this adapter was ever added */

15.     mutex_lock(&core_lock);

16.     found = idr_find(&i2c_adapter_idr, adap->nr);

17.     mutex_unlock(&core_lock);

18.     if (found != adap) {

19.         pr_debug("i2c-core: attempting to delete unregistered "

20.              "adapter [%s]\n", adap->name);

21.         return -EINVAL;

22.     }

23.     /* Tell drivers about this removal */

24.     mutex_lock(&core_lock);

25.     res = bus_for_each_drv(&i2c_bus_type, NULL, adap,

26.                    __process_removed_adapter);

27.     mutex_unlock(&core_lock);

28.     if (res)

29.         return res;

30.     /* Remove devices instantiated from sysfs */

31.     mutex_lock(&adap->userspace_clients_lock);

32.     list_for_each_entry_safe(client, next, &adap->userspace_clients,

33.                  detected) {

34.         dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,

35.             client->addr);

36.         list_del(&client->detected);

37.         i2c_unregister_device(client);

38.     }

39.     mutex_unlock(&adap->userspace_clients_lock);

40.     /* Detach any active clients. This can't fail, thus we do not

41.      * check the returned value. This is a two-pass process, because

42.      * we can't remove the dummy devices during the first pass: they

43.      * could have been instantiated by real devices wishing to clean

44.      * them up properly, so we give them a chance to do that first. */

45.     res = device_for_each_child(&adap->dev, NULL, __unregister_client);

46.     res = device_for_each_child(&adap->dev, NULL, __unregister_dummy);

47. #ifdef CONFIG_I2C_COMPAT

48.     class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,

49.                  adap->dev.parent);

50. #endif

51.     /* device name is gone after device_unregister */

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

53.     /* clean up the sysfs representation */

54.     init_completion(&adap->dev_released);

55.     device_unregister(&adap->dev);

56.     /* wait for sysfs to drop all references */

57.     wait_for_completion(&adap->dev_released);

58.     /* free bus id */

59.     mutex_lock(&core_lock);

60.     idr_remove(&i2c_adapter_idr, adap->nr);

61.     mutex_unlock(&core_lock);

62.     /* Clear the device structure in case this adapter is ever going to be

63.        added again */

64.     memset(&adap->dev, 0, sizeof(adap->dev));

65.     return 0;

66. }

67. EXPORT_SYMBOL(i2c_del_adapter);

(2)增加/删除i2c_driver。

代码清单11 I2c_register_driver函数：

1. static int i2c_register_adapter(struct i2c_adapter *adap)

2. {

3.     int res = 0;

4.     /* Can't register until after driver model init */

5.     if (unlikely(WARN_ON(!i2c_bus_type.p))) {

6.         res = -EAGAIN;

7.         goto out_list;

8.     }  

9.     /* Sanity checks */

10.     if (unlikely(adap->name[0] == '\0')) {   

11.         pr_err("i2c-core: Attempt to register an adapter with "

12.                "no name!\n");

13.         return -EINVAL;

14.     }  

15.     if (unlikely(!adap->algo)) {        

16.         pr_err("i2c-core: Attempt to register adapter '%s' with "

17.                "no algo!\n", adap->name);        

18.         return -EINVAL;

19.     }  

20.     rt_mutex_init(&adap->bus_lock);     

21.     mutex_init(&adap->userspace_clients_lock);

22.     INIT_LIST_HEAD(&adap->userspace_clients);

23.     /* Set default timeout to 1 second if not already set */

24.     if (adap->timeout == 0)

25.         adap->timeout = HZ;             

26.     dev_set_name(&adap->dev, "i2c-%d", adap->nr);

27.     adap->dev.bus = &i2c_bus_type;

28.     adap->dev.type = &i2c_adapter_type;

29.     res = device_register(&adap->dev);

30.     if (res)

31.         goto out_list;

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

33. #ifdef CONFIG_I2C_COMPAT

34.     res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,

35.                        adap->dev.parent);

36.     if (res)

37.         dev_warn(&adap->dev,

38.              "Failed to create compatibility class link\n");

39. #endif

40.     /* create pre-declared device nodes */

41.     if (adap->nr < __i2c_first_dynamic_bus_num)

42.         i2c_scan_static_board_info(adap);

43.     /* Notify drivers */

44.     mutex_lock(&core_lock);

45.     bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);

46.     mutex_unlock(&core_lock);

47.     return 0;

48. out_list:

49.     mutex_lock(&core_lock);

50.     idr_remove(&i2c_adapter_idr, adap->nr);

51.     mutex_unlock(&core_lock);

52.     return res;

53. }

代码清单12 i2c_del_driver函数：

1. /**

2.  * i2c_del_driver - unregister I2C driver

3.  * @driver: the driver being unregistered

4.  * Context: can sleep

5.  */

6. void i2c_del_driver(struct i2c_driver *driver)

7. {

8.     i2c_for_each_dev(driver, __process_removed_driver);

9.     driver_unregister(&driver->driver);

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

11. }

12. EXPORT_SYMBOL(i2c_del_driver);

（3）i2c_client依附/脱离。

当一个具体的client被侦测到并被关联的时候，设备和使用爽肤水文件件被注册。相反地，在client杯取消关联的时候，sysfs文件和设备也被注销。如下代码清单。

代码清单13 i2c_new_device函数：

1. /**

2.  * i2c_new_device - instantiate an i2c device

3.  * @adap: the adapter managing the device

4.  * @info: describes one I2C device; bus_num is ignored

5.  * Context: can sleep

6.  *

7.  * Create an i2c device. Binding is handled through driver model

8.  * probe()/remove() methods.  A driver may be bound to this device when we

9.  * return from this function, or any later moment (e.g. maybe hotplugging will

10.  * load the driver module).  This call is not appropriate for use by mainboard

11.  * initialization logic, which usually runs during an arch_initcall() long

12.  * before any i2c_adapter could exist.

13.  *

14.  * This returns the new i2c client, which may be saved for later use with

15.  * i2c_unregister_device(); or NULL to indicate an error.

16.  */

17. struct i2c_client *

18. i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)

19. {

20.     struct i2c_client   *client;

21.     int         status;

22.     client = kzalloc(sizeof *client, GFP_KERNEL);

23.     if (!client)

24.         return NULL;

25.     client->adapter = adap;

26.     client->dev.platform_data = info->platform_data;

27.     if (info->archdata)

28.         client->dev.archdata = *info->archdata;

29.     client->flags = info->flags;

30.     client->addr = info->addr;

31.     client->irq = info->irq;

32.     strlcpy(client->name, info->type, sizeof(client->name));

33.     /* Check for address validity */

34.     status = i2c_check_client_addr_validity(client);

35.     if (status) {

36.         dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",

37.             client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);

38.         goto out_err_silent;

39.     }

40.     /* Check for address business */

41.     status = i2c_check_addr_busy(adap, client->addr);

42.     if (status)

43.         goto out_err;

44.     client->dev.parent = &client->adapter->dev;

45.     client->dev.bus = &i2c_bus_type;

46.     client->dev.type = &i2c_client_type;

47.     client->dev.of_node = info->of_node;

48.     dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),

49.              client->addr);

50.     status = device_register(&client->dev);

51.     if (status)

52.         goto out_err;

53.     dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",

54.         client->name, dev_name(&client->dev));

55.     return client;

56. out_err:

57.     dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "

58.         "(%d)\n", client->name, client->addr, status);

59. out_err_silent:

60.     kfree(client);

61.     return NULL;

62. }

63. EXPORT_SYMBOL_GPL(i2c_new_device);

代码清单14 i2c_unregister_device函数

1. /**

2.  * i2c_unregister_device - reverse effect of i2c_new_device()

3.  * @client: value returned from i2c_new_device()

4.  * Context: can sleep

5.  */

6. void i2c_unregister_device(struct i2c_client *client)

7. {

8.     device_unregister(&client->dev);

9. }

10. EXPORT_SYMBOL_GPL(i2c_unregister_device);

（4）I2C传输、发送和接收。

I2c_transfer（）函数本身不具备驱动适配器物理硬件完成消息交互的能力，它只是寻找到i2c_adapter对应的i2c_algorithm，并使用i2c_algorithm的master_xfer()函数真正驱动硬件流程。

代码清单15 i2c_transfer函数

1. /* ----------------------------------------------------

2.  * the functional interface to the i2c busses.

3.  * ----------------------------------------------------

4.  */

5. /**

6.  * i2c_transfer - execute a single or combined I2C message

7.  * @adap: Handle to I2C bus

8.  * @msgs: One or more messages to execute before STOP is issued to

9.  *  terminate the operation; each message begins with a START.

10.  * @num: Number of messages to be executed.

11.  *

12.  * Returns negative errno, else the number of messages executed.

13.  *

14.  * Note that there is no requirement that each message be sent to

15.  * the same slave address, although that is the most common model.

16.  */

17. int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)

18. {

19.     unsigned long orig_jiffies;

20.     int ret, try;

21.     /* REVISIT the fault reporting model here is weak:

22.      *

23.      *  - When we get an error after receiving N bytes from a slave,

24.      *    there is no way to report "N".

25.      *

26.      *  - When we get a NAK after transmitting N bytes to a slave,

27.      *    there is no way to report "N" ... or to let the master

28.      *    continue executing the rest of this combined message, if

29.      *    that's the appropriate response.

30.      *

31.      *  - When for example "num" is two and we successfully complete

32.      *    the first message but get an error part way through the

33.      *    second, it's unclear whether that should be reported as

34.      *    one (discarding status on the second message) or errno

35.      *    (discarding status on the first one).

36.      */

37.     if (adap->algo->master_xfer) {

38. #ifdef DEBUG

39.         for (ret = 0; ret < num; ret++) {

40.             dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "

41.                 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)

42.                 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,

43.                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");

44.         }

45. #endif

46.         if (in_atomic() || irqs_disabled()) {

47.             ret = i2c_trylock_adapter(adap);

48.             if (!ret)

49.                 /* I2C activity is ongoing. */

50.                 return -EAGAIN;

51.         } else {

52.             i2c_lock_adapter(adap);

53.         }

54.         /* Retry automatically on arbitration loss */

55.         orig_jiffies = jiffies;

56.         for (ret = 0, try = 0; try <= adap->retries; try++) {

57.             ret = adap->algo->master_xfer(adap, msgs, num);

58.             if (ret != -EAGAIN)

59.                 break;

60.             if (time_after(jiffies, orig_jiffies + adap->timeout))

61.                 break;

62.         }

63.         i2c_unlock_adapter(adap);

64.         return ret;

65.     } else {

66.         dev_dbg(&adap->dev, "I2C level transfers not supported\n");

67.         return -EOPNOTSUPP;

68.     }

69. }

70. EXPORT_SYMBOL(i2c_transfer);

代码清单16 i2c_master_send函数

1. /**

2.  * i2c_master_send - issue a single I2C message in master transmit mode

3.  * @client: Handle to slave device

4.  * @buf: Data that will be written to the slave

5.  * @count: How many bytes to write, must be less than 64k since msg.len is u16

6.  *

7.  * Returns negative errno, or else the number of bytes written.

8.  */

9. int i2c_master_send(const struct i2c_client *client, const char *buf, int count)

10. {

11.     int ret;

12.     struct i2c_adapter *adap = client->adapter;

13.     struct i2c_msg msg;

14.     msg.addr = client->addr;

15.     msg.flags = client->flags & I2C_M_TEN;

16.     msg.len = count;

17.     msg.buf = (char *)buf;

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

19.     /* If everything went ok (i.e. 1 msg transmitted), return #bytes

20.        transmitted, else error code. */

21.     return (ret == 1) ? count : ret;

22. }

23. EXPORT_SYMBOL(i2c_master_send);

代码清单17 i2c_master_recv函数

1. /**

2.  * i2c_master_recv - issue a single I2C message in master receive mode

3.  * @client: Handle to slave device

4.  * @buf: Where to store data read from slave

5.  * @count: How many bytes to read, must be less than 64k since msg.len is u16

6.  *

7.  * Returns negative errno, or else the number of bytes read.

8.  */

9. int i2c_master_recv(const struct i2c_client *client, char *buf, int count)

10. {

11.     struct i2c_adapter *adap = client->adapter;

12.     struct i2c_msg msg;

13.     int ret;

14.     msg.addr = client->addr;

15.     msg.flags = client->flags & I2C_M_TEN;

16.     msg.flags |= I2C_M_RD;

17.     msg.len = count;

18.     msg.buf = buf;

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

20.     /* If everything went ok (i.e. 1 msg transmitted), return #bytes

21.        transmitted, else error code. */

22.     return (ret == 1) ? count : ret;

23. }

24. EXPORT_SYMBOL(i2c_master_recv);

i2c_transfer()函数用于进行I2C适配器和I2C设备之间的一组消息交互，i2c_master_send()函数和i2c_master_recv()函数内部会调用i2c_transfer函数分别完成一条写消息和一条读消息。

I2c的第二部分----I2C总线驱动

I2c总线驱动模块的加载函数要完成两个工作。

l 第一个是初始化i2c适配器所使用的硬件资源，如申请I/O地址、中断号等。

l 第二个是通过i2c_add_adapter()添加i2c_adapter的数据结构，当然这个i2c_adapter数据结构的成员已经被适配器的相应的函数指针所初始化。

第一个工作对于s3c2440的i2c模块而言内核中做了这个工作，如下：

S3c2440处理器内部集成了一个I2C控制器，通过4个寄存器就可以方便地对其进行控制，这4个寄存器如下：

l IICCON：I2C控制寄存器。

l IICSTAT:I2C状态寄存器。

l IICDS：I2C收发数据移位寄存器。

l IICADD：I2C地址寄存器。

S3c2440处理器内部集成的I2C控制器可支持主、从两种模式，我们主要使用其主模式。通过对IICCON、IICDS和IICADD寄存器的操作，可

在I2C总线上产生开始位、停止位、数据和地址，而传输的状态则通过IICSTAT寄存器获取。

s3c2440 I2C 总线驱动总体分析

s3c_2440的I2C总线驱动driver/i2c/busses/i2c-s3c2410.c支持s3c24xx、s3c64xx、s5pc1xx和s5p64xx处理器，在我们使用的3.0内核版本中，其名称任然叫2410，显然是历史原因引起的。它主要完成以下工作。

（1）

代码清单18 module_init

1. module_init(i2c_dev_init);

i2c_dev_init函数

代码清单19 i2c_dev_init函数                                                                                                  

1. /* ------------------------------------------------------------------------- */

2. /*

3.  * module load/unload record keeping

4.  */

5. static int __init i2c_dev_init(void)

6. {

7.     int res;

8.     printk(KERN_INFO "i2c /dev entries driver\n");

9.     res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);

10.     if (res)

11.         goto out;

12.     i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");

13.     if (IS_ERR(i2c_dev_class)) {

14.         res = PTR_ERR(i2c_dev_class);

15.         goto out_unreg_chrdev;

16.     }

17.     /* Keep track of adapters which will be added or removed later */

18.     res = bus_register_notifier(&i2c_bus_type, &i2cdev_notifier);

19.     if (res)

20.         goto out_unreg_class;

21.     /* Bind to already existing adapters right away */

22.     i2c_for_each_dev(NULL, i2cdev_attach_adapter);

23.     return 0;

24. out_unreg_class:

25.     class_destroy(i2c_dev_class);

26. out_unreg_chrdev:

27.     unregister_chrdev(I2C_MAJOR, "i2c");

28. out:

29.     printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);

30.     return res;

31. }

函数首先调用register_chardev函数向内核注册主设备号为I2C_MAJOR、操作集为i2cdev_fops的字符设备。然后调用一次调用-->i2c_for_each_dev-->bus_for_each_dev-->fn函数来立即绑定已经存在的适配器adapters。

代码清单20 file_opertions结构体初始化

1. static const struct file_operations i2cdev_fops = {

2.     .owner      = THIS_MODULE,

3.     .llseek     = no_llseek,

4.     .read       = i2cdev_read,

5.     .write      = i2cdev_write,

6.     .unlocked_ioctl = i2cdev_ioctl,

7.     .open       = i2cdev_open,

8.     .release    = i2cdev_release,

9. };

I2c设备驱动（也称为客户驱动）是对I2c硬件体系结构中设备端的实现，我们这里是AT24C02的I2c设备驱动，设备一般挂接在受CPU控制的I2c适配器上，通过I2c适配器与CPU交换数据。

首先是要在内核中注册板级信息，因为设备和驱动需要匹配，他们是通过设备名和驱动名进行匹配的。因为AT24C02芯片是由2048bits构成，所以有2048 / 8 = 256byte,并将其分成32页每页有8byte大小，是8bits寻址，如果AT24C02芯片的A0，A1,A2,这三个引脚接地，着AT24C02芯片从地址是01010000b(即0x50），如果AT24C02芯片的A0结高电平，A1，A2两个引脚接地，着AT24C02芯片从地址是01010001b(即0x51），这些都是AT24C02的datasheet上有的，不同芯片不同情况。下面在linux-3.0/arch/arm/mach-s3c2440/mach-smdk2440.c添加AT24C02设备的板级信息如下（其中行首的行号是文件中大致的位置）：

[fulinux@ubuntu linux-3.0]$ vim arch/arm/mach-s3c2440/mach-smdk2440.c 

54 #include <linux/i2c.h>     

55 #include <linux/i2c/at24.h> 

190 static struct at24_platform_data at24c02= {

191     .byte_len   = SZ_2K / 8,

192     .page_size  = 8,

193     .flags      = AT24_FLAG_ADDR8,

194 };

195 

196 static struct i2c_board_info __initdata smdk2440_i2c_devs[] = {

197     {

198         I2C_BOARD_INFO("24c02", 0x50),

199         .platform_data = &at24c02,

200     },

201     /*  more devices can be added using expansion connectors */

202 };

I2c设备驱动主要包含了数据结构i2c_driver和i2c_clien,我们需要根据具体的设备实现其中的成员函数。下面我们紧紧围绕这两个数据结构展开。

i2c_driver

在linux-3.0/include/linux/i2c.h文件中有定义其i2c_driver数据结构，如下：

/*

 * struct i2c_driver - represent an I2C device driver

 * @class: What kind of i2c device we instantiate (for detect)

 * @attach_adapter: Callback for bus addition (deprecated)

 * @detach_adapter: Callback for bus removal (deprecated)

 * @probe: Callback for device binding

 * @remove: Callback for device unbinding

 * @shutdown: Callback for device shutdown

 * @suspend: Callback for device suspend

 * @resume: Callback for device resume

 * @alert: Alert callback, for example for the SMBus alert protocol

 * @command: Callback for bus-wide signaling (optional)

 * @driver: Device driver model driver

 * @id_table: List of I2C devices supported by this driver

 * @detect: Callback for device detection

 * @address_list: The I2C addresses to probe (for detect)

 * @clients: List of detected clients we created (for i2c-core use only)

 *

 * The driver.owner field should be set to the module owner of this driver.

 * The driver.name field should be set to the name of this driver.

 *

 * For automatic device detection, both @detect and @address_data must

 * be defined. @class should also be set, otherwise only devices forced

 * with module parameters will be created. The detect function must

 * fill at least the name field of the i2c_board_info structure it is

 * handed upon successful detection, and possibly also the flags field.

 *

 * If @detect is missing, the driver will still work fine for enumerated

 * devices. Detected devices simply won't be supported. This is expected

 * for the many I2C/SMBus devices which can't be detected reliably, and

 * the ones which can always be enumerated in practice.

 *

 * The i2c_client structure which is handed to the @detect callback is

 * not a real i2c_client. It is initialized just enough so that you can

 * call i2c_smbus_read_byte_data and friends on it. Don't do anything

 * else with it. In particular, calling dev_dbg and friends on it is

 * not allowed.

 */

struct i2c_driver {

    unsigned int class;

    /* Notifies the driver that a new bus has appeared or is about to be

     * removed. You should avoid using this, it will be removed in a

     * near future.

     */

    int (*attach_adapter)(struct i2c_adapter *) __deprecated;

    int (*detach_adapter)(struct i2c_adapter *) __deprecated;

    /* Standard driver model interfaces */

    int (*probe)(struct i2c_client *, const struct i2c_device_id *);

    int (*remove)(struct i2c_client *);

    /* driver model interfaces that don't relate to enumeration  */

    void (*shutdown)(struct i2c_client *);

    int (*suspend)(struct i2c_client *, pm_message_t mesg);

    int (*resume)(struct i2c_client *);

    /* Alert callback, for example for the SMBus alert protocol.

     * The format and meaning of the data value depends on the protocol.

     * For the SMBus alert protocol, there is a single bit of data passed

     * as the alert response's low bit ("event flag").

     */

    void (*alert)(struct i2c_client *, unsigned int data);

    /* a ioctl like command that can be used to perform specific functions

     * with the device.

     */

    int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);

    struct device_driver driver;

    const struct i2c_device_id *id_table;

    /* Device detection callback for automatic device creation */

    int (*detect)(struct i2c_client *, struct i2c_board_info *);

    const unsigned short *address_list;

    struct list_head clients;

};

675/*--------------------------------------------------------------------*/

676 

677 static struct i2c_driver at24_driver = {

678     .driver = {

679         .name = "at24",

680         .owner = THIS_MODULE,

681     },

682     .probe = at24_probe,

683     .remove = __devexit_p(at24_remove),

684     .id_table = at24_ids,

685 };

686 

/**

 * struct i2c_client - represent an I2C slave device

 * @flags: I2C_CLIENT_TEN indicates the device uses a ten bit chip address;

 *  I2C_CLIENT_PEC indicates it uses SMBus Packet Error Checking

 * @addr: Address used on the I2C bus connected to the parent adapter.

 * @name: Indicates the type of the device, usually a chip name that's

 *  generic enough to hide second-sourcing and compatible revisions.

 * @adapter: manages the bus segment hosting this I2C device

 * @driver: device's driver, hence pointer to access routines

 * @dev: Driver model device node for the slave.

 * @irq: indicates the IRQ generated by this device (if any)

 * @detected: member of an i2c_driver.clients list or i2c-core's

 *  userspace_devices list

 *

 * An i2c_client identifies a single device (i.e. chip) connected to an

 * i2c bus. The behaviour exposed to Linux is defined by the driver

 * managing the device.

 */

struct i2c_client {

    unsigned short flags;       /* div., see below      */

    unsigned short addr;        /* chip address - NOTE: 7bit    */

                    /* addresses are stored in the  */

                    /* _LOWER_ 7 bits       */

    char name[I2C_NAME_SIZE];

    struct i2c_adapter *adapter;    /* the adapter we sit on    */

    struct i2c_driver *driver;  /* and our access routines  */

    struct device dev;      /* the device structure     */

    int irq;            /* irq issued by device     */

    struct list_head detected;

};

I2c的第三部分----linux I2c核心：

由于I2c核心（drivers/i2c/i2c-core.c）中提供了一组不依赖与硬件平台的接口函数，这个文件一般不需要修改。I2c核心中的主要函数如下：