前言：

因为工作是音频驱动，所以经常涉及到I2C、I2S等常用的总线，想将I2C相关的东西总结一下，让自己更加了解I2C。

方式一：

使用arch/arm/mach-s3c24xx/mach-mini2440.c举例：

            
                static
                struct i2c_board_info mini2440_i2c_devs[] __initdata = {
    {
/* 遇到与”24c08一样的名称”的驱动就会与之绑定，0x50是I2C设备的地址 */
        I2C_BOARD_INFO("24c08", 0x50),
        .platform_data = &at24c08,
    },
};

/* 这里的0代表：i2c-0总线 */
    i2c_register_board_info(0, mini2440_i2c_devs,
                ARRAY_SIZE(mini2440_i2c_devs));
        

到这里我们可以说就完成了第一种方式的实例化。

使用i2c_register_board_info去实例化必须知道我们使用的I2C设备是挂载到哪个总线上，并知道设备的地址。

在Linux启动的时候会将信息进行收集，i2c适配器会扫描已经静态注册的i2c_board_info，通过调用i2c_register_board_info函数将包含所有I2C设备的i2c_board_info信息的i2c_devinfo变量加入到__i2c_board_list链表中，并调用i2c_new_device为其实例化一个i2c_client。在驱动加载的时候遇到同名的i2c_board_info就会将i2c_client和driver绑定，并且执行driver的probe函数。

这种方式一般放在平台的代码中。

struct i2c_board_info :

            /**
 * struct i2c_board_info - template for device creation
 * @type: chip type, to initialize i2c_client.name
 * @flags: to initialize i2c_client.flags
 * @addr: stored in i2c_client.addr
 * @platform_data: stored in i2c_client.dev.platform_data
 * @archdata: copied into i2c_client.dev.archdata
 * @of_node: pointer to OpenFirmware device node
 * @acpi_node: ACPI device node
 * @irq: stored in i2c_client.irq
 *
 * I2C doesn‘t actually support hardware probing, although controllers and
 * devices may be able to use I2C_SMBUS_QUICK totell whether ornot there‘s
 * a device at a given address.  Drivers commonly need more information than
 * that, such as chip type, configuration, associated IRQ, and so on.
 *
 * i2c_board_info is used to build tables of information listing I2C devices
 * that are present.  This information is used to grow the driver model tree.
 * For mainboards this is done statically using i2c_register_board_info();
 * bus numbers identify adapters that aren‘t yet available.  For add-on boards,
 * i2c_new_device() does this dynamically withthe adapter already known.
 */
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;
    struct acpi_dev_node acpi_node;
    int     irq;
};
        

i2c_register_board_info:

            /**
 * i2c_register_board_info - statically declare I2C devices
 * @busnum: identifies the bus to which these devices belong
 * @info: vector of i2c device descriptors
 * @len: how many descriptors inthe vector; may be zero to reserve
 *  the specified bus number.
 *
 * Systems using the Linux I2C driver stack can declare tables of board info
 * while they initialize.  This should be done in board-specific init code
 * near arch_initcall() time, or equivalent, before any I2C adapter driver is
 * registered.  For example, mainboard init code could define several devices,
 * as could the init code for each daughtercard in a board stack.
 *
 * The I2C devices will be created later, afterthe adapter forthe relevant
 * bus has been registered.  After that moment, standard driver model tools
 * are used to bind "new style" I2C drivers tothe devices.  The bus number
 * for any device declared using this routine isnot available for dynamic
 * allocation.
 *
 * The board info passed can safely be __initdata, but be careful of embedded
 * pointers (for platform_data, functions, etc) sincethat won‘t be copied.
 */
int
i2c_register_board_info(int busnum,
    struct i2c_board_info const *info, unsigned len)
{
    int status;

    down_write(&__i2c_board_lock);

    /* dynamic bus numbers will be assigned afterthelast static one */
    if (busnum >= __i2c_first_dynamic_bus_num)
        __i2c_first_dynamic_bus_num = busnum + 1;

    for (status = 0; len; len--, info++) {
        struct i2c_devinfo  *devinfo;

        devinfo = kzalloc(sizeof(*devinfo), GFP_KERNEL);
        if (!devinfo) {
            pr_debug("i2c-core: can‘t register boardinfo!\n");
            status = -ENOMEM;
            break;
        }

        devinfo->busnum = busnum;
        devinfo->board_info = *info;
        list_add_tail(&devinfo->list, &__i2c_board_list);
    }

    up_write(&__i2c_board_lock);

    return status;
}

        

方式二：

使用arch/arm/mach-ux500/board-mop500-uib.c举例：

            
                void mop500_uib_i2c_add(int busnum, struct i2c_board_info *info,
        unsigned n)
{
    struct i2c_adapter *adap;
    struct i2c_client *client;
    int i;
/* 获得一个总线，当然必须知道我们设备要挂载在哪个总线上，busnum就是总线编号 */
    adap = i2c_get_adapter(busnum);
    if (!adap) {
        pr_err("failed to get adapter i2c%d\n", busnum);
        return;
    }

    for (i = 0; i < n; i++) {
/* 将i2c_board_info所描述的器件与适配器进行关联，并实例化i2c_client */
        client = i2c_new_device(adap, &info[i]);
        if (!client)
            pr_err("failed to register %s to i2c%d\n",
                    info[i].type, busnum);
    }
/* 与 i2c_get_adapter对应，释放资源 */
    i2c_put_adapter(adap);
}
        

别忘了在注销驱动或者出错的情况下调用i2c_unregister_device(struct i2c_client *client)去释放资源。

这种方式与方式一的差别是不需要在编译内核的时候就要知道设备挂载哪个总线上、设备的地址是什么。灵活性变强了。

方式三：

如果连i2c设备的地址不知道，我们可以提供一个地址列表供系统探测。

使用drivers/media/pci/bt8xx/bttv-input.c举例：

            
                /* Instantiate the I2C IR receiver device, if present */
                void init_bttv_i2c_ir(struct bttv *btv)
{
/* 这里就是地址列表 */constunsignedshort addr_list[] = {
        0x1a, 0x18, 0x64, 0x30, 0x71,
        I2C_CLIENT_END
    };
    struct i2c_board_info info;
    struct i2c_client *i2c_dev;

    if (0 != btv->i2c_rc)
        return;
/* 用于存放i2c_board_info信息 */
    memset(&info, 0, sizeof(struct i2c_board_info));
    memset(&btv->init_data, 0, sizeof(btv->init_data));
    strlcpy(info.type, "ir_video", I2C_NAME_SIZE);

    switch (btv->c.type) {
    case BTTV_BOARD_PV951:
        btv->init_data.name = "PV951";
        btv->init_data.get_key = get_key_pv951;
        btv->init_data.ir_codes = RC_MAP_PV951;
        info.addr = 0x4b;
        break;
    }

    if (btv->init_data.name) {
        info.platform_data = &btv->init_data;
        i2c_dev = i2c_new_device(&btv->c.i2c_adap, &info);
    } else {
        /*
         * The external IR receiver is at i2c address 0x34 (0x35 for
         * reads).  Future Hauppauge cards will have an internal
         * receiver at 0x30 (0x31 for reads).  In theory, both can be
         * fitted, and Hauppauge suggest an external overrides an
         * internal.
         * That‘s why we probe 0x1a (~0x34) first. CB
         *//* 这样就会在指定的总线上匹配addr_list中地址，将第一个匹配正确的地址保存到info->addr，然后使用i2c_device_new来实例化i2c_client */
        i2c_dev = i2c_new_probed_device(&btv->c.i2c_adap, &info, addr_list, NULL);
    }
    if (NULL == i2c_dev)
        return;

#if defined(CONFIG_MODULES) && defined(MODULE)
    request_module("ir-kbd-i2c");
#endif
}
        

i2c_new_probed_device：

            
                struct i2c_client *
i2c_new_probed_device(struct i2c_adapter *adap,
              struct i2c_board_info *info,
              unsignedshortconst *addr_list,
              int (*probe)(struct i2c_adapter *, unsignedshort addr))
{
    int i;

    if (!probe)
        probe = i2c_default_probe;

    for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
        /* Check address validity */if (i2c_check_addr_validity(addr_list[i]) < 0) {
            dev_warn(&adap->dev, "Invalid 7-bit address ""0x%02x\n", addr_list[i]);
            continue;
        }

        /* Check address availability */if (i2c_check_addr_busy(adap, addr_list[i])) {
            dev_dbg(&adap->dev, "Address 0x%02x already in ""use, not probing\n", addr_list[i]);
            continue;
        }

        /* Test address responsiveness */if (probe(adap, addr_list[i]))
            break;
    }

    if (addr_list[i] == I2C_CLIENT_END) {
        dev_dbg(&adap->dev, "Probing failed, no device found\n");
        returnNULL;
    }

    info->addr = addr_list[i];
    return i2c_new_device(adap, info);
}
        

方式四：

从用户空间着手，在/sys/bus/i2c/devices/i2c-0(i2c总线编号)下存在new_device（建立i2c_client）和delete_device（删除i2c_client）。

            new_device方法：
echo [name] [addr:0x20] > /sys/bus/i2c/devices/i2c-0/new_device
delete_device方法：
echo [addr:0x20] > /sys/bus/i2c/devices/i2c-0/delete_device
        

方式五：

在dtsi中有：

            
                /*@后面是设备的起始地址*/
     &i2c-0@fe {
         compatible = "qcom, hall-i2c";
         reg = <fe>;
         interrupts = <70>;
/* 如果设置成disabled，在初始化的时候就不会被实例化，可以在linux内置文档查看更多 */
         status = "disabled";
     };
        

其中：i2c-0中的0是总线编号，reg是设备地址，interrupts是中断号。

在初始化的时候i2c总线会调用qup_i2c_probe()，接着调用of_i2c_register_devices对dtsi上所描述的设备进行实例化。并创建相应的sys文件：sys/bus/i2c/devices/0-00fe。

驱动部分代码：

            static const struct of_device_id i2c_of_match[] = {
    {
        .compatible = "qcom,hall-i2c",
        .data = &ppdata,
    },
    { },
};

static struct platform_driver omap_i2c_driver = {
    .probe        = ...,
    .remove        = ...,
    .driver        = {
        .name    = "qcom_test",
        .owner    = THIS_MODULE,
        .of_match_table = of_match_ptr(i2c_of_match),
    },
};
        

在驱动加载的时候i2c_of_match与dtsi中的”qcom,hall-i2c”匹配成功就会调用probe函数。并发现/sys/bus/i2c/devices/0-00fe/subsystem/drivers/qcom_test，没错qcom_test就是我们驱动中的name。

of_i2c_register_devices：

            
                void of_i2c_register_devices(struct i2c_adapter *adap)
{
    void*result;
    struct device_node *node;

    /* Only register child devices if the adapter has a node pointer set */if (!adap->dev.of_node)
        return;

    dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");

    for_each_available_child_of_node(adap->dev.of_node, node) {
        struct i2c_board_info info = {};
        struct dev_archdata dev_ad = {};
        const __be32 *addr;
        int len;

        dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);

        if (of_modalias_node(node, info.type, sizeof(info.type)) <0) {
            dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
                node->full_name);
            continue;
        }

        addr = of_get_property(node, "reg", &len);
        if (!addr || (len < sizeof(int))) {
            dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
                node->full_name);
            continue;
        }

        info.addr = be32_to_cpup(addr);
        if (info.addr > (1<<10) -1) {
            dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
                info.addr, node->full_name);
            continue;
        }

        info.irq = irq_of_parse_and_map(node, 0);
        info.of_node = of_node_get(node);
        info.archdata =&dev_ad;

        if (of_get_property(node, "wakeup-source", NULL))
            info.flags |= I2C_CLIENT_WAKE;

        request_module("%s%s", I2C_MODULE_PREFIX, info.type);

        result = i2c_new_device(adap, &info);
        if (result ==NULL) {
            dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
                    node->full_name);
            of_node_put(node);
            irq_dispose_mapping(info.irq);
            continue;
        }
    }
}
        

版权声明：本文为博主原创文章，未经博主允许不得转载。