linux设备模型之i2c子系统

      I2c子系统将i2c控制器(i2c寄存器所在的那块电路)抽象出来，用adapter（适配器）这个结构来描述，可以说一个适配器就代表一条i2c总线，而挂接在i2c总线上的设备是用client这个结构体来表述，另外i2c_bus上的设备链表挂接的不单单是连接的这条i2c上的client，同样adapter也作为一个设备挂在其所在的i2c_bus，也就是说控制器和设备都作为i2c_bus上的设备连接在设备链表，他们用内嵌的device的type这个成员来区分，适配器的类型为i2c_adapter_type，client的类型为i2c_client_type。

一、i2c相关的描述结构

     首先看一下i2c子系统给adapter定义的描述结构：

 1  struct i2c_adapter {
 2     struct module *owner;
 3     unsigned int id;
 4     unsigned int class；                     // 适配器支持的类型，如传感器，eeprom等        
 5     const struct i2c_algorithm *algo;        //该适配器的通信函数    
 6     void *algo_data;
 7     /* data fields that are valid for all devices    */
 8     struct rt_mutex bus_lock;
 9     int timeout;                             //超时时间限定
10     int retries;                             //通信重复次数限定
11     /* 
12      * 内嵌的标准device，其中dev->type标识该设备
13      * 是个adapter，其值为i2c_adapter_type
14 */
15     struct device dev;        
16     
17     int nr;                                  //适配器编号也是bus编号，第几条i2c总线
18     char name[48];                           //名字
19     struct completion dev_released;
20     struct mutex userspace_clients_lock;
21     struct list_head userspace_clients;
22 };

 

   再来看一下client的描述结构：

 1  struct i2c_client {
 2     unsigned short flags;                   //设备的标志，如唤醒标志等等
 3     
 4     /* chip address - NOTE: 7bit    */
 5     /* addresses are stored in the    */
 6     /* _LOWER_ 7 bits        */
 7     unsigned short addr;                    //设备的地址
 8     char name[I2C_NAME_SIZE];               //设备的名字
 9     struct i2c_adapter *adapter;            //设备所属的适配器
10     struct i2c_driver *driver;              //设备的driver
11     
12     /* 
13      * 内嵌的标准device模型，其中dev->type标识该设备
14      * 是个client，其值为i2c_client_type
15 */
16     struct device dev;        /* the device structure    */
17     int irq;                               //中断号
18     struct list_head detected;             //挂接点，挂接在adapter
19 };

 

    下面是driver的表述结构i2c_driver：

 1   struct i2c_driver {
 2     unsigned int class;                                   //支持的类型，与adapter的class相对
 3     /* Notifies the driver that a new bus has appeared or is about to be
 4      * removed. You should avoid using this if you can, it will probably
 5      * be removed in a near future.
 6 */
 7      
 8     int (*attach_adapter)(struct i2c_adapter *);          //旧式探测函数
 9     int (*detach_adapter)(struct i2c_adapter *);
10     /* Standard driver model interfaces */
11     int (*probe)(struct i2c_client *, const struct i2c_device_id *);
12     int (*remove)(struct i2c_client *);
13     /* driver model interfaces that don't relate to enumeration  */
14     void (*shutdown)(struct i2c_client *);
15     int (*suspend)(struct i2c_client *, pm_message_t mesg);
16     int (*resume)(struct i2c_client *);
17     /* Alert callback, for example for the SMBus alert protocol.
18      * The format and meaning of the data value depends on the protocol.
19      * For the SMBus alert protocol, there is a single bit of data passed
20      * as the alert response's low bit ("event flag").
21 */
22     void (*alert)(struct i2c_client *, unsigned int data);
23     /* a ioctl like command that can be used to perform specific functions
24      * with the device.
25 */
26     int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
27   /*
28      * 内嵌的标准driver，driver的of_match_table成员也用于标识其支持
29      * 的设备，并且优先级高于id_table
30 */
31     struct device_driver driver;
32     
33     const struct i2c_device_id *id_table;                            //支持的client信息表
34     /* Device detection callback for automatic device creation */
35     
36     int (*detect)(struct i2c_client *, struct i2c_board_info *);     //探测函数
37     const unsigned short *address_list;                              //driver支持的client地址
38     struct list_head clients;                                        //挂接其探测到的支持的设备
39 };

 

      另外client端有一条全局链表，用于串联所有i2c的client设备，为__i2c_board_list，也就是说client可以静态注册亦可动态
被探测，静态注册挂接在该链表上的结构为：

 1 struct i2c_devinfo {
 2     struct list_head    list;                     //连接指针指向前后设备
 3     int            busnum;                           //所在bus的编号
 4     struct i2c_board_info    board_info;           //板级平台信息相关的结构体
 5 };
 6 //其中 i2c_board_info结构的源码为： 
 7 struct i2c_board_info {
 8     char        type[I2C_NAME_SIZE];             //名字
 9     unsigned short    flags;                       //标志
10     unsigned short    addr;                        //地址
11     void        *platform_data;                  //私有特殊数据
12     struct dev_archdata    *archdata;
13 #ifdef CONFIG_OF
14     struct device_node *of_node;                 //节点
15 #endi
16     int        irq;                                 //中断号
17 };

 

    i2c_devinfo结构静态注册的信息最后都会被整合集成到client中，形成一个标准的i2c_client设备并注册。

二、i2c核心初始化代码分析

    首先看一下i2c平台无关的核心初始化，代码位于drivers/i2c/i2c-core.c下：

 1 static int __init i2c_init(void)
 2 {
 3     int retval;
 4    /*
 5     * 注册i2c_bus
 6 */
 7     retval = bus_register(&i2c_bus_type);              
 8     if (retval)
 9         return retval;
10 #ifdef CONFIG_I2C_COMPAT                            
11    /*
12     * 在sys/class下创建适配器目录
13 */
14     i2c_adapter_compat_class = class_compat_register("i2c-adapter");
15     if (!i2c_adapter_compat_class) {
16         retval = -ENOMEM;
17         goto bus_err;
18     }
19     
20 #endif
21    /*
22     * 增加一个虚拟的driver
23 */
24     retval = i2c_add_driver(&dummy_driver);             
25     if (retval)
26         goto class_err;
27     return 0;
28 class_err:
29 #ifdef CONFIG_I2C_COMPAT
30     class_compat_unregister(i2c_adapter_compat_class);  
31 bus_err:
32 #endif
33     bus_unregister(&i2c_bus_type);
34     return retval;
35 }
36 //其中的i2c_bus_type原型为：
37 struct bus_type i2c_bus_type = {
38     .name        = "i2c",
39     .match        = i2c_device_match,
40     .probe        = i2c_device_probe,
41     .remove        = i2c_device_remove,
42     .shutdown    = i2c_device_shutdown,
43     .pm        = &i2c_device_pm_ops,
44 };

 

三、i2c_add_driver分析

    驱动端的统一接口为i2c_add_driver：

 

static  inline  int  i2c_add_driver( struct  i2c_driver *driver)
{
    /*
     *注册i2c driver，可能是adapter的，也可能是client的
     */
    return  i2c_register_driver(THIS_MODULE, driver);
}
int  i2c_register_driver( struct  module *owner, struct  i2c_driver *driver)
{
    int  res;
    /* Can't register until after driver model init*/
    if  (unlikely(WARN_ON(!i2c_bus_type.p)))
        return  -EAGAIN;
    /* add the driver to the list of i2c drivers in the driver core */

    /*
     * i2c_driver内嵌的标准driver赋值，其bus指定为i2c_bus_type
     */
    driver->driver.owner = owner;
    driver->driver.bus = &i2c_bus_type;
    /* When registration returns, the driver core
     * will have called probe() for all matching-but-unbound devices.
     */

    /*注册标准的driver，driver注册后会去i2c_bus_type的设备链表上匹配
     *设备，匹配函数用的是bus端的，也就是i2c_device_match，如果匹配成功
     *将建立标准关联，并且将调用bus端的probe函数初始化这个设备，即
     *函数i2c_device_probe，下面会逐个分析
     */
    res = driver_register(&driver->driver);
    if  (res)
        return  res;
    pr_debug( "i2c-core: driver [%s] registered/n" , driver->driver.name);
  /*
   * 把该driver的clients初始化，该成员连接着这个driver可以操作的具
   * 体设备
   */
    INIT_LIST_HEAD(&driver->clients);
    /* Walk the adapters that are already present */
    mutex_lock(&core_lock);

  /*
   * 遍历挂接在该i2c设备链表上的设备，并对其都调用__process_new_driver
   * 函数
   */
    bus_for_each_dev(&i2c_bus_type, NULL, driver, __process_new_driver);
    mutex_unlock(&core_lock);
    return  0;
}
/****************************
* 匹配函数i2c_device_match *
****************************/
static  int  i2c_device_match( struct  device *dev, struct  device_driver *drv)
{
    /*
     * i2c_verify_client检查匹配的这个设备是否为i2c_client_type
     * 类型，如果不是则返回NULL，此处的匹配只是针对i2c设备的
     * 不是适配器
     */

    struct  i2c_client   *client = i2c_verify_client(dev);
    struct  i2c_driver   *driver;
      /*
     * 如果不是i2c设备类型就返回
     */
    if  (!client)
        return  0;
    /* Attempt an OF style match */

    /*
     * 如果定义了CONFIG_OF_DEVICE，那么就利用
     * drv.of_match_table成员表进行匹配
     */
    if  (of_driver_match_device(dev, drv))
        return  1;
      /*
     * 由内嵌的driver得到外面封装的i2c_driver
     */
    driver = to_i2c_driver(drv);

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

    /*
     * 如果i2c_driver->id_table存在，也就是支持的设备信息表
     * 存在，那么利用这个表进行匹配
     */
    if  (driver->id_table)
        return  i2c_match_id(driver->id_table, client) != NULL;
    return  0;
}
/**********************************
* 初始化设备函数i2c_device_probe *
**********************************/
static  int  i2c_device_probe( struct  device *dev)
{
    /*
     * 检查如果设备类型不是client则返回
     */
    struct  i2c_client   *client = i2c_verify_client(dev);
    struct  i2c_driver   *driver;
    int  status;
    if  (!client)
        return  0;

      /*
     * dev->driver指向匹配完成的driver，根据该标准
     * driver得到其外围封装的i2c_driver
     */
    driver = to_i2c_driver(dev->driver);

    /*
     * 如果该i2c_driver的probe成员或者id_table成员为
     * NULL则退出
     */
    if  (!driver->probe || !driver->id_table)
        return  -ENODEV;

    /*
     * client的driver成员赋值为该i2c_driver
     */
    client->driver = driver;

    /*
     * 唤醒该设备
     */
    if  (!device_can_wakeup(&client->dev))
        device_init_wakeup(&client->dev,
                    client->flags & I2C_CLIENT_WAKE);
    dev_dbg(dev, "probe/n" );

     /*
     * 利用i2c_driver的probe成员初始化该设备，此部分为实际平台相关
     */
    status = driver->probe(client, i2c_match_id(driver->id_table, client));

    /*
     * 失败则清除client指定的driver
     */
    if  (status) {
        client->driver = NULL;
        i2c_set_clientdata(client, NULL);
    }
    return  status;
}
/*************************************************************
* 下面看一下当找到一个dev后调用的__process_new_driver函数 *
*************************************************************/
static  int  __process_new_driver( struct  device *dev, void  *data)
{
    /*
     * 设备的类型如果不是i2c_adapter类型就推出
     * 下面的代码是针对i2c适配器的代码
     */
    if  (dev->type != &i2c_adapter_type)
        return  0;

    /*
     * 如果这个设备代表i2c适配器，则调用i2c_do_add_adapter
     * 此时的data类型为i2c_driver
     */
    return  i2c_do_add_adapter(data, to_i2c_adapter(dev)); //根据设备得到他的适配器
                             //i2c_driver。第一个是i2c_driver
}
/*************************
* i2c_do_add_adapter函数 *
*************************/
static  int  i2c_do_add_adapter( struct  i2c_driver *driver,
                  struct  i2c_adapter *adap)
{
    /* Detect supported devices on that bus, and instantiate them */

    /*
     * 利用该适配器和该i2c_driver探测该适配器所在的这条i2c总线
     * 找到该driver支持的设备并实例化它
     */
    i2c_detect(adap, driver);

    /* Let legacy drivers scan this bus for matching devices */

    /*
     * 老版本的探测利用i2c_driver的attach_adapter函数
     */
    if  (driver->attach_adapter) {
        /* We ignore the return code; if it fails, too bad */
        driver->attach_adapter(adap);
    }
    return  0;
}
/****************************
* 重点看一下i2c_detect函数 *
****************************/
static  int  i2c_detect( struct  i2c_adapter *adapter, struct  i2c_driver *driver)
{
    const  unsigned short  *address_list;
    struct  i2c_client *temp_client;
    int  i, err = 0;
    int  adap_id = i2c_adapter_id(adapter);
  /*
   * 得到该i2c_driver指定的client地址范围
   */
    address_list = driver->address_list;

  /*
   * driver平台相关的detect函数和client地址范围不能为NULL
   */
    if  (!driver->detect || !address_list)
        return  0;
    /* Set up a temporary client to help detect callback */

  /*
   * 申请一块client内存
   */
    temp_client = kzalloc( sizeof ( struct  i2c_client), GFP_KERNEL);
    if  (!temp_client)
        return  -ENOMEM;

  /*
   * 申请的client结构的adapter成员设置为当前的adapter
   */
    temp_client->adapter = adapter;
    /* Stop here if the classes do not match */

    /*
     * 当前adapter的类型如果和driver的类型不一样，则退出
     * 例如：适配器的类型可以为传感器，eeprom，driver类型必须
     * 与其匹配
     */
    if  (!(adapter-> class  & driver-> class ))
        goto  exit_free;
  /*
   * 根据指定的支持的地址范围开始逐一探测
   */
    for  (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
        dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
            "addr 0x%02x/n" , adap_id, address_list[i]);
  /*
   * 临时申请的client的地址设置为这次要探测的地址
   */
        temp_client->addr = address_list[i];
        err = i2c_detect_address(temp_client, driver);
        if  (err)
            goto  exit_free;
    }
 exit_free:
    kfree(temp_client);
    return  err;
}
/**********************************
* 继续跟进i2c_detect_address函数 *
**********************************/
static  int  i2c_detect_address( struct  i2c_client *temp_client,
                  struct  i2c_driver *driver)
{
    struct  i2c_board_info info;
    struct  i2c_adapter *adapter = temp_client->adapter;
    int  addr = temp_client->addr;
    int