linux下I2C驱动分析1

linux下I2C驱动分析1 分类： LINUX

       这几篇文章来分析下linux2.6下I2C驱动的写法，对个人也是一个学习的过程。

       在linux系统下，i2c驱动架构分为三个部分：I2C核心、I2C总线驱动、I2C设备驱动，下面首先从设备驱动怎么写开始，主要是分析内核中的代码。本文中分析的内核代码是基于LINUX2.6.19版本。

       首先看一个以前做过的I2C驱动。下面是一个设备驱动的模块加载和卸载函数。

static struct i2c_driver tw_i2c_driver = {

       .driver = {

                 .owner = THIS_MODULE,

                 .name = "TW Client",

                 },

       .attach_adapter = tw_attach,

       .detach_client = tw_detach,

};

static __init int tw_init(void)

{

       u8 err;

       err = i2c_add_driver(&tw_i2c_driver);

       return err;

}

static void __exit tw_clean(void)

{

       i2c_del_driver(&tw_i2c_driver);

}

 

module_init(tw_init);

module_exit(tw_clean);

       从上面模块加载函数中可以看到，调用了I2C核心函数i2c_add_driver，我们看看这个函数做了些什么。

static inline int i2c_add_driver(struct i2c_driver *driver)

{

       return i2c_register_driver(THIS_MODULE, driver);

}

i2c_register_driver的作用是向系统注册该驱动，下面我们看这个函数的具体实现。

int i2c_register_driver(struct module *owner, struct i2c_driver *driver)

{

       struct list_head   *item;

       struct i2c_adapter *adapter;

       int res;

//将该设备插入到设备链表中，这部分属于设备管理模型中的内容。

       /* add the driver to the list of i2c drivers in the driver core */

       driver->driver.owner = owner;

       driver->driver.bus = &i2c_bus_type;

 

       res = driver_register(&driver->driver);

       if (res)

              return res;

      

       mutex_lock(&core_lists);

 

       list_add_tail(&driver->list,&drivers);

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

//下面将要找到该设备所接的适配器，调用i2c_driver结构体的attach_adapter

//函数。

       /* now look for instances of driver on our adapters */

       if (driver->attach_adapter) {

//注意下面是一个循环体，系统总所有的适配器,都放在链表adapters里了，这个

//工作是在I2C总线驱动里做的。

              list_for_each(item,&adapters) {

                     adapter = list_entry(item, struct i2c_adapter, list);

//对于每一个适配器都要调用attach_adapter函数，这个attach_adpter函数是用

//户编写的，需要要在这个函数调用i2c_probe函数来探测该设备是否接在该适配器上面。

                     driver->attach_adapter(adapter);

              }

       }

 

       mutex_unlock(&core_lists);

       return 0;

}

下面我们看看driver->attach_adapter函数的实现：

static unsigned short normal_i2c[] = { TW_I2C_ADDRESS, I2C_CLIENT_END };

static int tw_attach(struct i2c_adapter *adap)

{

//调用了i2c_probe函数，注意参数addr_data已经在i2c.h中给出了模板定义的，这里只需要给出addr_data.normal_i2c即可，就是给出需要探测的设备从地址。

    err = i2c_probe(adap, &addr_data, &tw_detect_client);

    clk_disable(clk);

    clk_put(clk);

    return err;

}

我们在来跟踪i2c_probe函数的实现：

 

int i2c_probe(struct i2c_adapter *adapter,

             struct i2c_client_address_data *address_data,

             int (*found_proc) (struct i2c_adapter *, int, int))

{

       int i, err;

//获得当前适配器的ID

       int adap_id = i2c_adapter_id(adapter);

 

       /* Force entries are done first, and are not affected by ignore

          entries */

//首先扫描forces中的地址，这个是不受ignore影响的

       if (address_data->forces) {

              unsigned short **forces = address_data->forces;

              int kind;

 

              for (kind = 0; forces[kind]; kind++) {

                     for (i = 0; forces[kind][i] != I2C_CLIENT_END;

                          i += 2) {

                            if (forces[kind][i] == adap_id

                             || forces[kind][i] == ANY_I2C_BUS) {

                                   dev_dbg(&adapter->dev, "found force "

                                          "parameter for adapter %d, "

                                          "addr 0x%02x, kind %d\n",

                                          adap_id, forces[kind][i + 1],

                                          kind);

                                   err = i2c_probe_address(adapter,

                                          forces[kind][i + 1],

                                          kind, found_proc);

                                   if (err)

                                          return err;

                            }

                     }

              }

       }

//下面是有关适配器具体功能支持方面的问题，暂且不管他

       /* Stop here if we can't use SMBUS_QUICK */

       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {

              if (address_data->probe[0] == I2C_CLIENT_END

               && address_data->normal_i2c[0] == I2C_CLIENT_END)

                    return 0;

 

              dev_warn(&adapter->dev, "SMBus Quick command not supported, "

                      "can't probe for chips\n");

              return -1;

       }

 

       /* Probe entries are done second, and are not affected by ignore

          entries either */

//接着会扫描probe项

       for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {

              if (address_data->probe[i] == adap_id

               || address_data->probe[i] == ANY_I2C_BUS) {

                     dev_dbg(&adapter->dev, "found probe parameter for "

                            "adapter %d, addr 0x%02x\n", adap_id,

                            address_data->probe[i + 1]);

                     err = i2c_probe_address(adapter,

                                          address_data->probe[i + 1],

                                          -1, found_proc);

                     if (err)

                            return err;

              }

       }

//最为关键的地方，扫描normal项，一般我们设备的地址就是放在这里的。

       /* Normal entries are done last, unless shadowed by an ignore entry */

       for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {

              int j, ignore;

 

              ignore = 0;

//下面的地方就是确认扫描的地址不在ignore里面

              for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;

                   j += 2) {

                     if ((address_data->ignore[j] == adap_id ||

                          address_data->ignore[j] == ANY_I2C_BUS)

                      && address_data->ignore[j + 1]

                         == address_data->normal_i2c[i]) {

                            dev_dbg(&adapter->dev, "found ignore "

                                   "parameter for adapter %d, "

                                   "addr 0x%02x\n", adap_id,

                                   address_data->ignore[j + 1]);

                            ignore = 1;

                            break;

                     }

              }

              if (ignore)

                     continue;

//当该地址是有效地址后，就调用i2c_probe_address函数来判断该设备是否接在该适配器上面。

              dev_dbg(&adapter->dev, "found normal entry for adapter %d, "

                     "addr 0x%02x\n", adap_id,

                     address_data->normal_i2c[i]);

              err = i2c_probe_address(adapter, address_data->normal_i2c[i],

                                   -1, found_proc);

              if (err)

                     return err;

       }

 

       return 0;

}

下面我们来追踪下i2c_probe_address函数的实现过程：

 

/* ----------------------------------------------------

 * the i2c address scanning function

 * Will not work for 10-bit addresses!

 * ----------------------------------------------------

 */

static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,

                          int (*found_proc) (struct i2c_adapter *, int, int))

{

       int err;

//确定该地址为有效地址

       /* Make sure the address is valid */

       if (addr < 0x03 || addr > 0x77) {

              dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",

                      addr);

              return -EINVAL;

       }

//如果该地址已经被用，则跳过

       /* Skip if already in use */

       if (i2c_check_addr(adapter, addr))

              return 0;

//判断该总线上面是否真的接有这个设备，对于i2c_smbus_xfer在讲总线驱动的时候再详细介绍。

       /* Make sure there is something at this address, unless forced */

       if (kind < 0) {

              if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,

                               I2C_SMBUS_QUICK, NULL) < 0)

                     return 0;

 

              /* prevent 24RF08 corruption */

              if ((addr & ~0x0f) == 0x50)

                     i2c_smbus_xfer(adapter, addr, 0, 0, 0,

                                   I2C_SMBUS_QUICK, NULL);

       }

//如果有该设备就调用回调函数

       /* Finally call the custom detection function */

       err = found_proc(adapter, addr, kind);

       /* -ENODEV can be returned if there is a chip at the given address

          but it isn't supported by this chip driver. We catch it here as

          this isn't an error. */

       if (err == -ENODEV)

              err = 0;

 

       if (err)

              dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",

                      addr, err);

       return err;

}

下面我们在看看回调函数做了什么：

 

/*!

 * tw I2C detect_client function

 *

 * @param adapter            struct i2c_adapter *

 * @param address            int

 * @param kind               int

 *

 * @return  Error code indicating success or failure

 */

static int tw_detect_client(struct i2c_adapter *adapter, int address,

                            int kind)

{

//将i2c_client的adapter变量指向其所接的适配器

       tw_i2c_client.adapter = adapter;

//调用i2c_attach_client函数将i2c_client依附到适配器，就是将该client接到其对应adapter的client链表上面。

       if (i2c_attach_client(&tw_i2c_client)) {

              tw_i2c_client.adapter = NULL;

              printk(KERN_ERR

                     "tw_detect_client: i2c_attach_client failed\n");

              return -1;

       }

}

 

int i2c_attach_client(struct i2c_client *client)

{

       struct i2c_adapter *adapter = client->adapter;

       int res = 0;

 

       mutex_lock(&adapter->clist_lock);

       if (__i2c_check_addr(client->adapter, client->addr)) {

              res = -EBUSY;

              goto out_unlock;

       }

//最关键的地方：将该client插到适配器的clients链表中

       list_add_tail(&client->list,&adapter->clients);

      

       client->usage_count = 0;

//下面的都是设备管理模型实现，以后再详细讨论

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

       client->dev.driver = &client->driver->driver;

       client->dev.bus = &i2c_bus_type;

       client->dev.release = &i2c_client_release;

      

       snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),

              "%d-%04x", i2c_adapter_id(adapter), client->addr);

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

              client->name, client->dev.bus_id);

       res = device_register(&client->dev);

       if (res)

              goto out_list;

       res = device_create_file(&client->dev, &dev_attr_client_name);

       if (res)

              goto out_unregister;

       mutex_unlock(&adapter->clist_lock);

 

       if (adapter->client_register)  {

              if (adapter->client_register(client)) {

                     dev_dbg(&adapter->dev, "client_register "

                            "failed for client [%s] at 0x%02x\n",

                            client->name, client->addr);

              }

       }

 

       return 0;

 

out_unregister:

       init_completion(&client->released); /* Needed? */

       device_unregister(&client->dev);

       wait_for_completion(&client->released);

out_list:

       list_del(&client->list);

       dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "

              "(%d)\n", client->name, client->addr, res);

out_unlock:

       mutex_unlock(&adapter->clist_lock);

       return res;

}

       现在我们已经找到设备所接的适配器，并且将该设备依附到适配器链表中，接下来我们看看用户如何访问设备。看下面的函数：

 

/*

 * Function definitions

 */

static int tw_i2c_client_xfer(unsigned int addr, u8 page, u8 reg,

                              char *buf, int num, int tran_flag)

{

       struct i2c_msg msg[3];

       int ret;

//构造了3条I2C消息，注意这里构造多少条I2C消息，是有芯片决定的。

       msg[0].addr = addr;

       msg[0].len = 1;

       msg[0].buf = &page;

       msg[0].flags = tran_flag;

       msg[0].flags &= ~I2C_M_RD;

 

       msg[1].addr = addr;

       msg[1].len = 1;

       msg[1].buf = &reg;

       msg[1].flags = tran_flag;

       msg[1].flags &= ~I2C_M_RD;

 

       msg[2].addr = addr;

       msg[2].len = num;

       msg[2].buf = buf;

       msg[2].flags = tran_flag;

 

       if (tran_flag & MXC_I2C_FLAG_READ) {

              msg[2].flags |= I2C_M_RD;

       } else {

              msg[2].flags &= ~I2C_M_RD;

       }

//调用i2c_transfer访问设备

       ret = i2c_transfer(tw_i2c_client.adapter, msg, 3);

       if (ret >= 0)

              return 0;

 

       return ret;

}

我们跟踪i2c_transfer函数：

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

{

       int ret;

 

       if (adap->algo->master_xfer) {

 

              mutex_lock(&adap->bus_lock);

//调用了adap->algo->master_xfer函数，这个函数的实现是在i2c总线驱动里做的，在讲总线驱动的时候具体解释。

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

              mutex_unlock(&adap->bus_lock);

 

              return ret;

       } else {

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

              return -ENOSYS;

       }

}

 

总结：我们来看看整个I2C设备驱动的设计流程。

1. i2c_add_driver：添加一个I2C驱动

2.i2c_register_driver：直接被调用，将该驱动向系统注册（设备管理模型）。对系统的每个适配器，都调用i2c_probe函数，直到找到设备所接的适配器。

3.i2c_probe：将合法的设备从地址传递给i2c_probe_address函数

4.i2c_probe_address：调用总线驱动函数探测该总线上面是否接有该设备，如果有则调用i2c_attach_client函数

5.i2c_attach_client：将该设备的 i2c_client结构体依附到对应的适配器