Linux 内核Ｉ２Ｃ总线架构

总线是将设备与驱动联系在一起的纽带。
如果一个设备与驱动彼此绑在了一起，通过ｓｙｓ目录下的文件信息能看出其绑定的驱动／设备对象。
如：

~# ls /sys/bus/i2c/drivers/ad-7441/ -l
lrwxrwxrwx    1 root     root             0 Jan  1 00:07 2-0070 -> ../../../../devices/platform/hisi_i2c.2/i2c-2/2-0070
--w-------    1 root     root          4096 Jan  1 00:07 bind
--w-------    1 root     root          4096 Jan  1 00:07 uevent
--w-------    1 root     root          4096 Jan  1 00:07 unbind

可以看出ｉ２ｃ总线上的名字为ａｄ－７４４１的ｉ２ｃ＿ｄｒｉｖｅｒ找到了其绑定的设备。
同样有：

/sys/devices/platform/hisi_i2c.2/i2c-2# ls 2-0070/ -l
lrwxrwxrwx    1 root     root             0 Jan  1 00:06 driver -> ../../../../../bus/i2c/drivers/ad-7441
-r--r--r--    1 root     root          4096 Jan  1 00:06 modalias
-r--r--r--    1 root     root          4096 Jan  1 00:06 name
drwxr-xr-x    2 root     root             0 Jan  1 00:06 power
lrwxrwxrwx    1 root     root             0 Jan  1 00:06 subsystem -> ../../../../../bus/i2c
-rw-r--r--    1 root     root          4096 Jan  1 00:06 uevent
/sys/devices/platform/hisi_i2c.2/i2c-2# cat  2-0082/name 
adv8200

由于系统中没有i2c_add_driver 成员 id_table的name为adv8200的i2c_driver，所以，这里的2-0082是找不到自己的另一半的。
相反，系统中定义了：

const static struct i2c_device_id slaveid[]={
            {.name="adv7441"},
            {.name="GS2970"},

};
static struct i2c_driver adv7441_driver={
    .probe=adv7441_probe,
    .id_table=slaveid,
    .driver = {
            .name   = "ad-7441",
            .owner  = THIS_MODULE,
    },
};
ret=i2c_add_driver(&adv7441_driver);

就因为这样，ad-7441找到了driver，而8200却找不到driver。
通常情况下，在一个已经配置了i2c_adpter设备的系统中，如果要在内核中添加一个i2c从设备的驱动。最常用的做法是：
1. 定义 i2c_board_info,并执行i2c_register_board_info(int busnum,
struct i2c_board_info const *info, unsigned len)。该函数会申请分配i2c_board_info
并添加到__i2c_board_list为头的链表中。

struct i2c_board_info {
    char        type[I2C_NAME_SIZE];
    unsigned short  flags;
    unsigned short  addr;
    void        *platform_data;
    struct dev_archdata *archdata;
    struct device_node *of_node;
    int     irq;
};
/*  
 * I2C  slave devices 
 */
static struct i2c_board_info __initdata i2c_devs[] = {
        { I2C_BOARD_INFO("testA8", 0xA8), },
        { I2C_BOARD_INFO("adv7441", 0x70), },
        { I2C_BOARD_INFO("adv8200", 0x82), },
};
i2c_register_board_info(2, i2c_devs, ARRAY_SIZE(i2c_devs))

2.定义i2c_driver结构体，由于i2c_bus_type的match函数是根据id_table来判断是否存在另一半的，因此i2c_driver中要定义合适的id_table字段。并执行i2c_add_driver把driver添加到i2c总线上，还可以定义probe函数，在probe函数中对i2c设备进行配置。。如：

static struct i2c_driver ds1307_driver = {
    .driver = {
        .name   = "rtc-ds1307",
        .owner  = THIS_MODULE,
    },
    .probe      = ds1307_probe,
    .remove     = __devexit_p(ds1307_remove),
    .id_table   = ds1307_id,
};
static const struct i2c_device_id ds1307_id[] = {
    { "ds1307", ds_1307 },
    { "ds1337", ds_1337 },
    { "ds1338", ds_1338 },
    { "ds1339", ds_1339 },
    { "ds1388", ds_1388 },
    { "ds1340", ds_1340 },
    { "ds3231", ds_3231 },
    { "m41t00", m41t00 },
    { "rx8025", rx_8025 },
    { }
};
const static struct i2c_device_id slaveid[]={
            {.name="adv7441"},
            {.name="GS2970"},

};
static struct i2c_driver adv7441_driver={
    .probe=adv7441_probe,
    .id_table=slaveid,
    .driver = {
            .name   = "ad-7441",
            .owner  = THIS_MODULE,
    },
};

那么i2c_register_driver都做了哪些操作呢？
i2c_register_driver中的i2c_driver参数，如果i2c_driver参数定义了address_list且地址探测成功，则会自动调用i2c_new_device来创建设备。
如：

/* This is the driver that will be inserted */
static struct i2c_driver ads7828_driver = {
    .class = I2C_CLASS_HWMON,
    .driver = {
        .name = "ads7828",
    },
    .probe = ads7828_probe,
    .remove = ads7828_remove,
    .id_table = ads7828_id,
    .detect = ads7828_detect,
    .address_list = normal_i2c,
};
/* Addresses to scan */
static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b,I2C_CLIENT_END };
    #define I2C_CLIENT_END      0xfffeU

跟踪内核源码，看i2c_register_driver的执行流程：

i2c_register_driver--》  i2c_for_each_dev(driver, __process_new_driver);---》i2c_do_add_adapter(data, to_i2c_adapter(dev));---》i2c_detect(adap, driver);---》  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]);
        temp_client->addr = address_list[i];
        err = i2c_detect_address(temp_client, driver);
        if (unlikely(err))
            break;
    }

static int i2c_detect_address(struct i2c_client *temp_client,
                  struct i2c_driver *driver){

    if (info.type[0] == '\0') {//i2c_board_info的type字段不为空
        dev_err(&adapter->dev, "%s detection function provided "
            "no name for 0x%x\n", driver->driver.name,
            addr);
    } else {
        struct i2c_client *client;

        /* Detection succeeded, instantiate the device */
        dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
            info.type, info.addr);
        client = i2c_new_device(adapter, &info);
        if (client)
            list_add_tail(&client->detected, &driver->clients);
        else
            dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
                info.type, info.addr);
    }

}
另外在i2c_register_adapter中执行的是
    bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);

    一个是__process_new_driver，一个是__process_new_adapter，两个都执行了i2c_detect--》i2c_detect_address---》i2c_new_device。i2c_new_device中会给i2c_client的adpter成员赋值，然后会执行device_register，如果match函数返回真，则会执行i2c_device_probe。
    不同的地方是__process_new_adapter执行的是 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);遍历i2c_bus上的所有driver。
    而i2c_register_driver用的是 i2c_for_each_dev(driver, __process_new_driver);---》bus_for_each_dev，遍历的是i2c_bus上的所有device的时候，可以根据device得到adpter，因为i2c_adapter中有device dev成员。通过#define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
可以找到对应的adapter，然后adapter就可以作为i2c_detect的参数传进去。


    struct bus_type i2c_bus_type = {
    .name       = "i2c",
    .match      = i2c_device_match,
    .probe      = i2c_device_probe,
    .remove     = i2c_device_remove,
    .shutdown   = i2c_device_shutdown,
    .pm     = &i2c_device_pm_ops,
};
    static int i2c_device_probe(struct device *dev)
{
    struct i2c_client   *client = i2c_verify_client(dev);
    struct i2c_driver   *driver;
    int status;

    if (!client)
        return 0;

    driver = to_i2c_driver(dev->driver);
    if (!driver->probe || !driver->id_table)
        return -ENODEV;
    client->driver = driver;
    }
    由此可见，在i2c_new_device的过程中，首选给client赋adapter，如果批评成功，调用了i2c_bus_type的probe函数后，又会给i2c_client赋i2c_driver。i2c_client的driver和adapter成员都会得到正确的赋值。

这说明在注册i2c_driver的时候，也可以自动的创建设备。
但不是必须这样自动创建设备的，有的i2c_driver中没有定义address_list也没有自定义attach函数，那么就不会自动创建i2c_device.

如果不在内核里做的话，可以实现i2c-dev.c的fops，在应用层调用read、write、ioctl、open系统调用来配置i2c设备。
看了上面的内容，你会觉得太表面化了，或者是心里没底，为什么这样做就可以呢。下面就来解释一下！

i2c总线结构可以分为3层：
1. i2c 核心层，主要是i2c-core.c，提供了i2c设备、驱动的注册、注销函数。I2C 通信方法（即“ algorithm”）上层的、与具体适配器无关的代码以及探测设备、检测设备地址的上层代码等。
2. i2c设备层。这里说的设备包括“主设备从设备”，主设备是指i2c适配器，一般是集成到CPU的i2c模块，也可以是GPIO模拟的i2c模块。从设备是指我们的板子上用的支持i2c总线的芯片，如RTC、AD、E2PROM等。
3. I2C设备驱动层，驱动是指从设备的设备。主要工作是填充I2c_driver。
我觉得上面的分层比较好理解。有的书上分三层是： 核心层、总线层、设备驱动层。其中总线层是适配器端完成的，而设备驱动层是I2C硬件体系结构中设备端的实现的，主要是填充i2c_client和driver。
这样理解也行。可能是我对系统认识的不够深，仍然觉得我自己的理解比较通俗。

一个常识性的知识，就是当device_add或者driver_add的时候，都会把device或者driver添加到bus的 struct subsys_private *p;成员指向的对应链表头中，然后根据总线注册的时候是否允许drivers_autoprobe，来进行探测。探测的时候会根据总线的match函数返回结果来决定是否要绑定dev和driver。那么我们来看一下i2c_bus_type的注册后是否允许drivers_autoprobe.

struct subsys_private {
    struct kset subsys;
    struct kset *devices_kset;
    struct list_head interfaces;
    struct mutex mutex;

    struct kset *drivers_kset;
    struct klist klist_devices;//添加到总线上的设备链表
    struct klist klist_drivers;//添加到总线上的驱动链表
    struct blocking_notifier_head bus_notifier;
    unsigned int drivers_autoprobe:1;
    struct bus_type *bus;

    struct kset glue_dirs;
    struct class *class;
};
static int __init i2c_init(void)
{
    int retval;

    retval = bus_register(&i2c_bus_type);
    if (retval)
        return retval;
}
int __bus_register(struct bus_type *bus, struct lock_class_key *key)
{
    priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);
    if (!priv)
        return -ENOMEM;

    priv->bus = bus;
    bus->p = priv;

    BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);

    retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
    if (retval)
        goto out;

    priv->subsys.kobj.kset = bus_kset;
    priv->subsys.kobj.ktype = &bus_ktype;
    **priv->drivers_autoprobe = 1;**

    retval = kset_register(&priv->subsys);
}

很明显i2c_bus_type.p->drivers_autoprobe 是为1的。因此在添加i2c设备和i2c驱动的时候，会自动匹配另一半。而总线匹配条件一般是总线的match成员函数返回的。那么需要分析一下i2c总线的match函数：

static int i2c_device_match(struct device *dev, struct device_driver *drv)
{
    struct i2c_client   *client = i2c_verify_client(dev);
    struct i2c_driver   *driver;

    if (!client)
        return 0;

    /* Attempt an OF style match */
    if (of_driver_match_device(dev, drv))
        return 1;

    driver = to_i2c_driver(drv);
    /* match on an id table if there is one */
    if (driver->id_table)
        return i2c_match_id(driver->id_table, client) != NULL;

    return 0;
}
static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
                        const struct i2c_client *client)
{
    while (id->name[0]) {
        if (strcmp(client->name, id->name) == 0)
            return id;
        id++;
    }
    return NULL;
}
struct bus_type i2c_bus_type = {
    .name       = "i2c",
    .match      = i2c_device_match,
    .probe      = i2c_device_probe,
    .remove     = i2c_device_remove,
    .shutdown   = i2c_device_shutdown,
    .pm     = &i2c_device_pm_ops,
};
EXPORT_SYMBOL_GPL(i2c_bus_type);

i2c_driver的id_table里的name字段与client字段相同则返回真进行匹配。而clientd的name是从哪里来的呢？是在i2c_new_devie(adpter)的时候给赋值的。而i2c_new_device。如果执行了i2c_register_board_info，那么就会调用到i2c_scan_static_board_info。i2c_scan_static_board_info在扫描过程中，会尝试执行i2c_new_device进行匹配。匹配成功了设备与驱动就会绑定在一起。

在static int i2c_register_adapter(struct i2c_adapter *adap)中有

static int i2c_register_adapter(struct i2c_adapter *adap){
    dev_set_name(&adap->dev, "i2c-%d", adap->nr);//i2c-012
    adap->dev.bus = &i2c_bus_type;
    adap->dev.type = &i2c_adapter_type;
    res = device_register(&adap->dev);
    if (adap->nr < __i2c_first_dynamic_bus_num)
        i2c_scan_static_board_info(adap);

    /* Notify drivers */
    mutex_lock(&core_lock);
    bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
    mutex_unlock(&core_lock);

    }
static int __process_new_adapter(struct device_driver *d, void *data)
{
    return i2c_do_add_adapter(to_i2c_driver(d), data);
}
static int i2c_do_add_adapter(struct i2c_driver *driver,
                  struct i2c_adapter *adap)
{
    /* Detect supported devices on that bus, and instantiate them */
    i2c_detect(adap, driver);

    /* Let legacy drivers scan this bus for matching devices */
    if (driver->attach_adapter) {
        dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
             driver->driver.name);
        dev_warn(&adap->dev, "Please use another way to instantiate "
             "your i2c_client\n");
        /* We ignore the return code; if it fails, too bad */
        driver->attach_adapter(adap);
    }
    return 0;
}
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);

    address_list = driver->address_list;
    if (!driver->detect || !address_list)
        return 0;

    /* Stop here if the classes do not match */
    if (!(adapter->class & driver->class))
        return 0;

    /* Set up a temporary client to help detect callback */
    temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
    if (!temp_client)
        return -ENOMEM;
    temp_client->adapter = adapter;

    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]);
        temp_client->addr = address_list[i];
        err = i2c_detect_address(temp_client, driver);
        if (unlikely(err))
            break;
    }

    kfree(temp_client);
    return err;
}
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 err;

    /* Make sure the address is valid */
    err = i2c_check_addr_validity(addr);
    if (err) {
        dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
             addr);
        return err;
    }

    /* Skip if already in use */
    if (i2c_check_addr_busy(adapter, addr))
        return 0;

    /* Make sure there is something at this address */
    if (!i2c_default_probe(adapter, addr))
        return 0;

    /* Finally call the custom detection function */
    memset(&info, 0, sizeof(struct i2c_board_info));
    info.addr = addr;
    err = driver->detect(temp_client, &info);
    if (err) {
        /* -ENODEV is returned if the detection fails. We catch it
           here as this isn't an error. */
        return err == -ENODEV ? 0 : err;
    }

    /* Consistency check */
    if (info.type[0] == '\0') {
        dev_err(&adapter->dev, "%s detection function provided "
            "no name for 0x%x\n", driver->driver.name,
            addr);
    } else {
        struct i2c_client *client;

        /* Detection succeeded, instantiate the device */
        dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
            info.type, info.addr);
        client = i2c_new_device(adapter, &info);
        if (client)
            list_add_tail(&client->detected, &driver->clients);
        else
            dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
                info.type, info.addr);
    }
    return 0;
}

static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
{
    struct i2c_devinfo  *devinfo;

    down_read(&__i2c_board_lock);
    list_for_each_entry(devinfo, &__i2c_board_list, list) {
        if (devinfo->busnum == adapter->nr
                && !i2c_new_device(adapter,
                        &devinfo->board_info))
            dev_err(&adapter->dev,
                "Can't create device at 0x%02x\n",
                devinfo->board_info.addr);
    }
    up_read(&__i2c_board_lock);
}
struct i2c_client *
i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
{
    struct i2c_client   *client;
    int         status;

    client = kzalloc(sizeof *client, GFP_KERNEL);
    if (!client)
        return NULL;

    client->adapter = adap;

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

    if (info->archdata)
        client->dev.archdata = *info->archdata;

    client->flags = info->flags;
    client->addr = info->addr;
    client->irq = info->irq;

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

    /* Check for address validity */
    status = i2c_check_client_addr_validity(client);
    if (status) {
        dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
            client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
        goto out_err_silent;
    }

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

    client->dev.parent = &client->adapter->dev;
    client->dev.bus = &i2c_bus_type;
    client->dev.type = &i2c_client_type;
    client->dev.of_node = info->of_node;

    /* For 10-bit clients, add an arbitrary offset to avoid collisions */
    dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
             client->addr | ((client->flags & I2C_CLIENT_TEN)
                     ? 0xa000 : 0));
    status = device_register(&client->dev);
    if (status)
        goto out_err;

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

    return client;

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

如果内核启动过程中没有执行i2c_register_board_info，那么__i2c_first_dynamic_bus_num的值就为0，是不会执行i2c_scan_static_board_info的。
但是仍然可以在系统起来后，以模块的形式调用i2c_new_device。如：

static struct i2c_board_info hi_info = {
     I2C_BOARD_INFO("sensor_i2c", 0x6c),
};
static int hi_dev_init(void)
{
    struct i2c_adapter *i2c_adap;

    // use i2c0
    i2c_adap = i2c_get_adapter(0);
    sensor_client = i2c_new_device(i2c_adap, &hi_info);//可以使用这个client进行i2c设置。因为/
    *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_put_adapter(i2c_adap);
    return 0;
}

由此可以知道执行i2c_register_board_info并添加了i2c_boar_info后，在以后执行i2c_register_adapter的时候是会主动扫描__i2c_board_list中的静态devinfo信息。如果没有执行i2c_register_board_info，那么可以通过i2c_new_device以模块的形式被动创建client。在i2c_new_device的时候执行device_add->bus.match?probe:return.
在i2c_register_adapter中有

    if (adap->nr < __i2c_first_dynamic_bus_num)
        i2c_scan_static_board_info(adap);

    /* Notify drivers */
    mutex_lock(&core_lock);
    bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
    mutex_unlock(&core_lock);

即当在i2c总线上注册适配器的时候，会扫描i2c总线上的drv，从i2c_bus_type.p.klist_drivers中查找驱动，遍历到一个有效的驱动后执行__process_new_adapter(drv,adap); —>i2c_do_add_adapter—->i2c_detect(adap, driver)和driver->attach_adapter。顾名思义，其中的i2c_detect就是检测i2c总线上可以使用的驱动是否与当前的适配器匹配。如果定义了i2c_driver的detect和address_list才会匹配{ if (!driver->detect || !address_list)
return 0;}，匹配成功则把制作的client结构体添加到driver->clients的链表中。不过这种方法用的很少，一般在i2c_driver中不处理detect和address信息，因此这种Notify driver的方式很少用。

    下面总结一下：
1.首先执行的是i2c_init-》bus_register(&i2c_bus_type);
postcore_initcall(i2c_init);
系统中有了i2c总线，才能将i2c总线的设备和驱动联系在一起。

2.完成i2c总线驱动即i2c适配器驱动，主要是adpter的algorithm成员。填充好adpter以后，用i2c_add_numbered_adapter--》i2c_register_adapter-->主动扫描__i2c_board_list中的i2c_board_info的i2c设备，如果有会执行i2c_new_device，并且在sys目录下会看到想应name的目录。--->扫描i2c总线上的所有驱动，来尝试匹配该适配器（现在基本不用）。
3.在设备驱动层要完成的是定义i2c_board_info和i2c_driver。
这样看上去，把i2c框架分成三层，i2c核心层、i2c总线层、i2c设备驱动层。这样的划分方式应该是更合理。其中i2c核心层定义了i2c适配器注册注销、i2cdriver注册注销,register_i2c_boardinfo、与具体的硬件无关的发生接收函数，如：i2c_master_send和i2c_master_recv。

加载模块调用内核态 I2C 读写程序示例：
此操作示例在内核态下通过 I2C 读写程序实现对 I2C 外围设备的读写操作。
步骤 1. 调用 I2C 核心层的函数，获得描述一个 I2C 控制器的结构体 i2c_adap：
i2c_adap = i2c_get_adapter(2);
假设我们已经知道新增的器件挂载在 I2C 控制器 2 上，直接设置 i2c_get_adapter 的参数为 2。
步骤 2. 把 I2C 控制器和新增的 I2C 外围设备关联起来，得到描述 I2C 外围设备的客户端结构
体 hi_client：
hi_client = i2c_new_device(i2c_adap, &hi_info);
hi_info 结构体提供了 I2C 外围设备的设备地址
步骤 3. 调用 I2C 核心层提供的标准读写函数对外围器件进行读写：
ret = i2c_master_send(client, buf, count);
ret = i2c_master_recv(client, buf, count);
其中i2c_master_send都是与具体的平台和硬件无关的接口，由i2c-core层定义，其中主要的是client，这个client对应于一个i2c设备，i2c_client里的adpter成员完成了i2c设备和CPU之间的通讯。

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

    msg.addr = client->addr;
#ifdef CONFIG_ARCH_HI3516A
    msg.flags = client->flags;
#else
    msg.flags = client->flags & I2C_M_TEN;
#endif
    msg.len = count;
    msg.buf = (char *)buf;

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

    /*
     * If everything went ok (i.e. 1 msg transmitted), return #bytes
     * transmitted, else error code.
     */
    return (ret == 1) ? count : ret;
}
EXPORT_SYMBOL(i2c_master_send);

int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
{
    unsigned long orig_jiffies;
    int ret, try;

    /* REVISIT the fault reporting model here is weak:
     *
     *  - When we get an error after receiving N bytes from a slave,
     *    there is no way to report "N".
     *
     *  - When we get a NAK after transmitting N bytes to a slave,
     *    there is no way to report "N" ... or to let the master
     *    continue executing the rest of this combined message, if
     *    that's the appropriate response.
     *
     *  - When for example "num" is two and we successfully complete
     *    the first message but get an error part way through the
     *    second, it's unclear whether that should be reported as
     *    one (discarding status on the second message) or errno
     *    (discarding status on the first one).
     */

    if (adap->algo->master_xfer) {
#ifdef DEBUG
        for (ret = 0; ret < num; ret++) {
            dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
                "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
                ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
                (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
        }
#endif

        if (in_atomic() || irqs_disabled()) {
            ret = i2c_trylock_adapter(adap);
            if (!ret)
                /* I2C activity is ongoing. */
                return -EAGAIN;
        } else {
            i2c_lock_adapter(adap);
        }
        /* Retry automatically on arbitration loss */
        orig_jiffies = jiffies;
        for (ret = 0, try = 0; try <= adap->retries; try++) {
            ret = adap->algo->master_xfer(adap, msgs, num);
            if (ret != -EAGAIN)
                break;
            if (time_after(jiffies, orig_jiffies + adap->timeout))
                break;
        }
        i2c_unlock_adapter(adap);
        return ret;
    } else {
        dev_dbg(&adap->dev, "I2C level transfers not supported\n");
        return -EOPNOTSUPP;
    }
}
EXPORT_SYMBOL(i2c_transfer);

而adap->algo->master_xfer就是与硬件和适配器有关的了，是驱动工程师要做的。如：
static const struct i2c_algorithm hi_i2c_algo = {
    .master_xfer    = hi_i2c_xfer,
    .functionality  = hi_i2c_func,
};
    adap->algo = &hi_i2c_algo;
    adap->dev.parent = &pdev->dev;
    adap->nr = pdev->id;
    adap->retries = CONFIG_HI_I2C_RETRIES;
    errorcode = i2c_add_numbered_adapter(adap);
static int hi_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
        int num)
{
    struct hi_i2c *pinfo;
    int errorcode;
    pinfo = (struct hi_i2c *)i2c_get_adapdata(adap);
    pinfo->msgs = msgs;
    pinfo->msg_num = num;
    pinfo->msg_index = 0;
    if (msgs->flags & I2C_M_RD)
        errorcode = hi_i2c_read(pinfo);
    else
        errorcode = hi_i2c_write(pinfo);
    return errorcode;
}

以i2c-dev.c提供的接口，通过应用程序读写i2c设备的方法：
用户态 I2C 读写程序示例：
此操作示例在用户态下通过 I2C 读写程序实现对 I2C 外围设备的读写操作。
步骤 1. 打开 I2C 总线对应的设备文件，获取文件描述符：
fd = open(“/dev/i2c-2”, O_RDWR);
步骤 2. 通过 ioctl 设置外围设备地址、外围设备寄存器位宽和数据位宽
ret = ioctl(fd, I2C_SLAVE_FORCE, device_addr);
ioctl(fd, I2C_16BIT_REG, 0);
ioctl(fd, I2C_16BIT_DATA, 0);//ioctl 的第三个参数为 0 表示 8bit 位宽，为 1 表示 16bit 位宽。
步骤 3. 使用 read/wite 进行数据读写：
read(fd, recvbuf, reg_width);
write(fd, buf, (reg_width + data_width));

unsigned int reg_width = 1;
unsigned int data_width = 1;
unsigned int reg_step = 1;
HI_RET i2c_read(int argc, char* argv[])
{
 int fd = -1;
 int ret;
 unsigned int i2c_num, device_addr, reg_addr, reg_addr_end;
 char data;
 char recvbuf[4];
 int cur_addr;
 memset(recvbuf, 0x0, 4);
 fd = open("/dev/i2c-2", O_RDWR);
 if (fd<0)
 {
 printf("Open i2c dev error!\n");
 return -1;
 }
 ret = ioctl(fd, I2C_SLAVE_FORCE, device_addr);
 if (reg_width == 2)
 ret = ioctl(fd, I2C_16BIT_REG, 1);
 else
 ret = ioctl(fd, I2C_16BIT_REG, 0);
 if (ret < 0) {
 printf("CMD_SET_REG_WIDTH error!\n");
 close(fd);
 return -1;
 }
 if (data_width == 2)
 ret = ioctl(fd, I2C_16BIT_DATA, 1);
 else
 ret = ioctl(fd, I2C_16BIT_DATA, 0);
 if (ret < 0) {
 printf("CMD_SET_DATA_WIDTH error!\n");
 close(fd);
 return -1;
 }
 for (cur_addr = reg_addr; cur_addr < reg_addr_end + reg_width;
cur_addr += reg_step)
 {
 if (reg_width == 2) {
 recvbuf[0] = cur_addr & 0xff;
 recvbuf[1] = (cur_addr >> 8) & 0xff;
 } else
 recvbuf[0] = cur_addr & 0xff;
 ret = read(fd, recvbuf, reg_width);
 if (ret < 0) {
 printf("CMD_I2C_READ error!\n");
 close(fd);
 return -1;
 }
 if (data_width == 2) {
 data = recvbuf[0] | (recvbuf[1] << 8);
 } else
 data = recvbuf[0];
 printf("0x%x 0x%x\n", cur_addr, data);
 }
 close(fd);
 return 0;
}

i2c_write(int argc , char* argv[])
{
 int fd = -1;
 int ret =0, index = 0;
 unsigned int i2c_num, device_addr, reg_addr, reg_value;
 char buf[4];
 fd = open("/dev/i2c-2", O_RDWR);
 if(fd < 0)
 {
 printf("Open i2c dev error!\n");
 return -1;
 }
 ret = ioctl(fd, I2C_SLAVE_FORCE, device_addr);
 if (reg_width == 2)
 ret = ioctl(fd, I2C_16BIT_REG, 1);
 else
 ret = ioctl(fd, I2C_16BIT_REG, 0);
 if (data_width == 2)
 ret = ioctl(fd, I2C_16BIT_DATA, 1);
 else
 ret = ioctl(fd, I2C_16BIT_DATA, 0);
 if (reg_width == 2) {
 buf[index] = reg_addr & 0xff;
 index++;
 buf[index] = (reg_addr >> 8) & 0xff;
 index++;
 } else {
 buf[index] = reg_addr & 0xff;
 index++;
 }
 if (data_width == 2) {
 buf[index] = reg_value & 0xff;
 index++;
 buf[index] = (reg_value >> 8) & 0xff;
 index++;
 } else {
 buf[index] = reg_value & 0xff;
 index++;
 }
 write(fd, buf, (reg_width + data_width));
 if(ret < 0)
 {
 printf("I2C_WRITE error!\n");
 return -1;
 }
 close(fd);
 return 0;
}

下面简单分析一下i2c-dev.c

static const struct file_operations i2cdev_fops = {
    .owner      = THIS_MODULE,
    .llseek     = no_llseek,
    .read       = i2cdev_read,
    .write      = i2cdev_write,
    .unlocked_ioctl = i2cdev_ioctl,
    .open       = i2cdev_open,
    .release    = i2cdev_release,
};
static int i2cdev_open(struct inode *inode, struct file *file)
{
    unsigned int minor = iminor(inode);
    struct i2c_client *client;
    struct i2c_adapter *adap;
    struct i2c_dev *i2c_dev;

    i2c_dev = i2c_dev_get_by_minor(minor);
    if (!i2c_dev)
        return -ENODEV;

    adap = i2c_get_adapter(i2c_dev->adap->nr);
    if (!adap)
        return -ENODEV;
        .......
}
static ssize_t i2cdev_read(struct file *file, char __user *buf, size_t count,
        loff_t *offset)
{
    char *tmp;
    int ret;

    struct i2c_client *client = file->private_data;

    if (count > 8192)
        count = 8192;

    tmp = kmalloc(count, GFP_KERNEL);
    if (tmp == NULL)
        return -ENOMEM;

#ifdef CONFIG_ARCH_HI3516A
    copy_from_user(tmp, buf, count);
#endif

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

    ret = i2c_master_recv(client, tmp, count);
    if (ret >= 0)
        ret = copy_to_user(buf, tmp, count) ? -EFAULT : ret;
    kfree(tmp);
    return ret;
}

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

    if (count > 8192)
        count = 8192;

    tmp = memdup_user(buf, count);
    if (IS_ERR(tmp))
        return PTR_ERR(tmp);

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

    ret = i2c_master_send(client, tmp, count);
    kfree(tmp);
    return ret;
}
static long i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    struct i2c_client *client = file->private_data;
    unsigned long funcs;

    dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
        cmd, arg);

    switch (cmd) {
    case I2C_SLAVE:
    case I2C_SLAVE_FORCE:
        /* NOTE:  devices set up to work with "new style" drivers
         * can't use I2C_SLAVE, even when the device node is not
         * bound to a driver.  Only I2C_SLAVE_FORCE will work.
         *
         * Setting the PEC flag here won't affect kernel drivers,
         * which will be using the i2c_client node registered with
         * the driver model core.  Likewise, when that client has
         * the PEC flag already set, the i2c-dev driver won't see
         * (or use) this setting.
         */
        if ((arg > 0x3ff) ||
            (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
            return -EINVAL;
        if (cmd == I2C_SLAVE && i2cdev_check_addr(client->adapter, arg))
            return -EBUSY;
        /* REVISIT: address could become busy later */
        client->addr = arg;
        return 0;
    case I2C_TENBIT:
        if (arg)
            client->flags |= I2C_M_TEN;
        else
            client->flags &= ~I2C_M_TEN;
        return 0;
    case I2C_PEC:
        if (arg)
            client->flags |= I2C_CLIENT_PEC;
        else
            client->flags &= ~I2C_CLIENT_PEC;
        return 0;
    case I2C_16BIT_REG:
        if (arg)
            client->flags |= I2C_M_16BIT_REG;
        else
            client->flags &= ~I2C_M_16BIT_REG;
        return 0;
    case I2C_16BIT_DATA:
        if (arg)
            client->flags |= I2C_M_16BIT_DATA;
        else
            client->flags &= ~I2C_M_16BIT_DATA;
        return 0;
    case I2C_FUNCS:
        funcs = i2c_get_functionality(client->adapter);
        return put_user(funcs, (unsigned long __user *)arg);

    case I2C_RDWR:
        return i2cdev_ioctl_rdrw(client, arg);

    case I2C_SMBUS:
        return i2cdev_ioctl_smbus(client, arg);

    case I2C_RETRIES:
        client->adapter->retries = arg;
        break;
    case I2C_TIMEOUT:
        /* For historical reasons, user-space sets the timeout
         * value in units of 10 ms.
         */
        client->adapter->timeout = msecs_to_jiffies(arg * 10);
        break;
    default:
        /* NOTE:  returning a fault code here could cause trouble
         * in buggy userspace code.  Some old kernel bugs returned
         * zero in this case, and userspace code might accidentally
         * have depended on that bug.
         */
        return -ENOTTY;
    }
    return 0;
}   
static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client,
        unsigned long arg)
{
    struct i2c_rdwr_ioctl_data rdwr_arg;
    struct i2c_msg *rdwr_pa;
    u8 __user **data_ptrs;
    int i, res;

    if (copy_from_user(&rdwr_arg,
               (struct i2c_rdwr_ioctl_data __user *)arg,
               sizeof(rdwr_arg)))
        return -EFAULT;

    /* Put an arbitrary limit on the number of messages that can
     * be sent at once */
    if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
        return -EINVAL;

    rdwr_pa = memdup_user(rdwr_arg.msgs,
                  rdwr_arg.nmsgs * sizeof(struct i2c_msg));
    if (IS_ERR(rdwr_pa))
        return PTR_ERR(rdwr_pa);

    data_ptrs = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL);
    if (data_ptrs == NULL) {
        kfree(rdwr_pa);
        return -ENOMEM;
    }

    res = 0;
    for (i = 0; i < rdwr_arg.nmsgs; i++) {
        /* Limit the size of the message to a sane amount;
         * and don't let length change either. */
        if ((rdwr_pa[i].len > 8192) ||
            (rdwr_pa[i].flags & I2C_M_RECV_LEN)) {
            res = -EINVAL;
            break;
        }
        data_ptrs[i] = (u8 __user *)rdwr_pa[i].buf;
        rdwr_pa[i].buf = memdup_user(data_ptrs[i], rdwr_pa[i].len);
        if (IS_ERR(rdwr_pa[i].buf)) {
            res = PTR_ERR(rdwr_pa[i].buf);
            break;
        }
    }
    if (res < 0) {
        int j;
        for (j = 0; j < i; ++j)
            kfree(rdwr_pa[j].buf);
        kfree(data_ptrs);
        kfree(rdwr_pa);
        return res;
    }

    res = i2c_transfer(client->adapter, rdwr_pa, rdwr_arg.nmsgs);
    while (i-- > 0) {
        if (res >= 0 && (rdwr_pa[i].flags & I2C_M_RD)) {
            if (copy_to_user(data_ptrs[i], rdwr_pa[i].buf,
                     rdwr_pa[i].len))
                res = -EFAULT;
        }
        kfree(rdwr_pa[i].buf);
    }
    kfree(data_ptrs);
    kfree(rdwr_pa);
    return res;
}
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
{
    unsigned long orig_jiffies;
    int ret, try;

    /* REVISIT the fault reporting model here is weak:
     *
     *  - When we get an error after receiving N bytes from a slave,
     *    there is no way to report "N".
     *
     *  - When we get a NAK after transmitting N bytes to a slave,
     *    there is no way to report "N" ... or to let the master
     *    continue executing the rest of this combined message, if
     *    that's the appropriate response.
     *
     *  - When for example "num" is two and we successfully complete
     *    the first message but get an error part way through the
     *    second, it's unclear whether that should be reported as
     *    one (discarding status on the second message) or errno
     *    (discarding status on the first one).
     */

    if (adap->algo->master_xfer) {
#ifdef DEBUG
        for (ret = 0; ret < num; ret++) {
            dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
                "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
                ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
                (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
        }
#endif

        if (in_atomic() || irqs_disabled()) {
            ret = i2c_trylock_adapter(adap);
            if (!ret)
                /* I2C activity is ongoing. */
                return -EAGAIN;
        } else {
            i2c_lock_adapter(adap);
        }

        /* Retry automatically on arbitration loss */
        orig_jiffies = jiffies;
        for (ret = 0, try = 0; try <= adap->retries; try++) {
            ret = adap->algo->master_xfer(adap, msgs, num);
            if (ret != -EAGAIN)
                break;
            if (time_after(jiffies, orig_jiffies + adap->timeout))
                break;
        }
        i2c_unlock_adapter(adap);

        return ret;
    } else {
        dev_dbg(&adap->dev, "I2C level transfers not supported\n");
        return -EOPNOTSUPP;
    }
}
EXPORT_SYMBOL(i2c_transfer);

i2c-dev.c创建了字符设备，主设备号都是89.次设备号跟adpter-nr的值一样，实现过程很简单，就不多说了，主要依赖于i2c适配器的algorithm的master_xfer成员函数。当用到具体的应用的时候，需要结合I2c适配器的algorithm的master_xfer成员函数和芯片手册。
如以下几个I2C硬件模块，其使用方法是不一样的。
下面以几个平台的I2C硬件模块为例，介绍一下集成到芯片内部的I2C控制器。
1.如Xarina的I2C模块，其中包含了64字节的RAM。其RAM地址空间分布如下：

在进行i2c写操作的时候，需要在RAM中准备好SLAVE地址和REG、数据，可以是多字节写入。硬件模块中提供了ICRAM寄存器，里面存放的是从RAM中发出或者读入的字节数。当i2C总线上产生起始位后，后续会将RAM中的数据写到总线上。在master端，软件上只需要控制总线的开始、再次开始、NACK、ACK时钟(只需要时钟，不需要判断SDA的电平，可以通过读取状态寄存器来判断是否有应答，这个状态寄存器是I2C硬件单元在通讯过程中自动更新的。发生NACK的时候也是硬件自动去发生的)、停止位。相对来说操作简单，而且用法灵活。

2.再如海思3516、3520D、3521、3535的I2c模块，则比较容易理解。其定义了ICR、TXR、RXR、CTRL、COMM寄存器。COMM寄存器的定义了起始位、停止位、读/写标志位，TXR专门用于发送数据的寄存器。每当写TXR寄存器后，再设置COMMAN寄存器，则会把数据从TXR传送到总线上(如果是起始位则直接写COMM即可)。如写0xa2设备的0x50寄存器为0xAA，则可以执行类似如下操作:
1.COMM.startbit=1 and COMM.writebit=1
2.waitfor_writeend（有专门状态寄存器反馈）
3.TXR=0xa2
4.COMM.writebit=1
5.同2
6.TXR=0x50
7.同4
8.同2
9.TXR=0xAA
10.同4
11.同2
3.再如海思3516A。这个芯片的I2C模块，操作更简单。有一个I2C_MST_SINGLE_CTRL的寄存器，

如果是读操作，就置bit30为1，如果为写操作就置bit30为0。I2C硬件模块会根据这个位的状态来判断是读还是写，还有一个寄存器MSG_CMD。
这个寄存器的bit[0-15]为写入或者读入的数据，bit[16-31]为需要读/写的寄存器地址。当然还有SLAVE_ADDRESS寄存器，这里就不列出了。
因此我们如果要写寄存器a8为0x37话，只需要设置I2C_MST_SIGLE_CMD为0xa837，将CTRL寄存器有0x80000000或上其他位的信息。在写寄存器的之前要等TXFIFO不满，要读数据的之前，要等RX FIFO不为空，当RXFIFO不空的时候，说明I2C硬件模块已经将数据准备好了，并且放到了CMD寄存器的低16位，这个过程是硬件自动完成的。因此软件的配置就显得相当简单，如要读寄存器0xa8。那么可以这样做：
1. 设设置slave的器件地址
2.等待TX_FIFO非满
3.写入CMD【31-16】，0xa8
4.等待RX_FIFO非空
5.从CMD【15-0】中把I2C的数据给取出来。
如果要写寄存器0xa8为0x37。就更简单了。
1. 设设置slave的器件地址
2. 等待TX_FIFO非满
3. 写入CMD【31-0】 为0xa837
对于这个模块，如下面要读取一个I2c的从设备，他的寄存器地址是16bits，寄存器数据是8bits,则下面的例子，可能是达不到你要的效果。 跟踪了一下HI3516A i2c驱动代码。当第一次写地址的时候，由于在写的时候没有准备写入的数据，只是告诉从设备要读取的地址。在驱动中就写0到寄存器了。而第二次执行了读操作，而读的时候没有指定寄存器地址，只是告诉了设备地址，因此是读不正确的。可以尝试只使用一个mgs。
读的过程也可以猜出来了吧。由此可知，在使用应用程序读写i2c设备的时候，同样的应用程序，在一个平台正确，则换个平台就不一定正确了，具体要看I2c模块介绍和Kernel里面的I2C驱动。

{
if((argc>3)&&(!strncmp("-r",argv[1],2))){
                e2prom_data.nmsgs=2;
                (e2prom_data.msgs[0]).len=2; //e2prom 目标数据的地址
                (e2prom_data.msgs[0]).addr=strtoul((const char *)argv[2],0,0); // e2prom 设备地址
                (e2prom_data.msgs[0]).flags&=~I2C_M_RD;//write
                (e2prom_data.msgs[0]).flags|=I2C_M_16BIT_REG;
                (e2prom_data.msgs[0]).flags&=~ I2C_M_16BIT_DATA;
                (e2prom_data.msgs[0]).buf=(unsigned char*)malloc(2);
                unsigned short buf = strtoul((const char *)argv[3],0,0);
                                printf("buf :%x\n", buf);
                (e2prom_data.msgs[0]).buf[1]=((buf>>8)&0xff);   //(unsigned char)atol(argv[3]);//e2prom数据地址(e2prom_data.msgs[0]).buf[0]=(buf>>8);   //(unsigned char)atol(argv[3]);//e2prom数据地址

                (e2prom_data.msgs[0]).buf[0]=(buf&0xff);    //(unsigned char)atol(argv[3]);//e2prom数据地址

                (e2prom_data.msgs[1]).len=1;//读出的数据
                (e2prom_data.msgs[1]).addr=(e2prom_data.msgs[0]).addr;// e2prom 设备地址 
                (e2prom_data.msgs[1]).flags|=I2C_M_RD;//read
                (e2prom_data.msgs[1]).flags|=I2C_M_16BIT_REG;
                (e2prom_data.msgs[1]).flags&=~ I2C_M_16BIT_DATA;
                (e2prom_data.msgs[1]).buf=(unsigned char*)malloc(1);//存放返回值的地址。
                (e2prom_data.msgs[1]).buf[0]=0;//初始化读缓冲


                ret=ioctl(fd,I2C_RDWR,(unsigned long)&e2prom_data);
}