如何编写多个从设备I2C客户端驱动程序？

Question

我正在开发一款嵌入式板的驱动程序。该驱动程序应该为 v4l2 开放接口，并使用 i2c 与2个设备通信。驱动程序将充当主机。

我似乎无法理解 i2c_device_id 数组和 i2c_add_driver 函数的工作原理。我在内核源代码中阅读了文档，但对于多个从设备客户端无法帮助我。

• 我需要有两个单独的探测函数吗？
• 我需要两次调用i2c_add_driver 吗？
• 如果不是这样，我如何能够保存两个不同的客户端以便能够向不同的地址发送不同的字节。

我在此粘贴了我的代码。我尝试实例化两个 i2c_drivers，两次调用 i2c_driver_add，并分别实现了 i2c 探测。但代码不起作用，告诉我当第二次调用 i2c_add_driver 时，foo1 已经注册。

我在 dts 文件中定义了两个块在 i2c1 下面：

&i2c1 {

...
    foo0: foo0@00 {
        compatible = "bar,foo0";
        reg = <0x00>;
        pinctrl-names = "default";
        pinctrl-0 = <&pinctrl_ipu1_2>;
        clocks = <&clks IMX6QDL_CLK_CKO>;
        clock-names = "csi_mclk";
        DOVDD-supply = <&vgen4_reg>; /* 1.8v */
        AVDD-supply = <&vgen3_reg>;  /* 2.8v, on rev C board is VGEN3,
                        on rev B board is VGEN5 */
        DVDD-supply = <&vgen2_reg>;  /* 1.5v*/
        pwn-gpios = <&gpio1 16 1>;   /* active low: SD1_DAT0 */
        rst-gpios = <&gpio1 17 0>;   /* active high: SD1_DAT1 */
        csi_id = <0>;
        mclk = <24000000>;
        mclk_source = <0>;
    };

    foo1: foo1@02 {
        compatible = "bar, foo1";
        reg = <0x02>;
        pinctrl-names = "default";
        pinctrl-0 = <&pinctrl_ipu1_2>;
        clocks = <&clks IMX6QDL_CLK_CKO>;
        clock-names = "csi_mclk";
        DOVDD-supply = <&vgen4_reg>; /* 1.8v */
        AVDD-supply = <&vgen3_reg>;  /* 2.8v, on rev C board is VGEN3,
                        on rev B board is VGEN5 */
        DVDD-supply = <&vgen2_reg>;  /* 1.5v*/
        pwn-gpios = <&gpio1 16 1>;   /* active low: SD1_DAT0 */
        rst-gpios = <&gpio1 17 0>;   /* active high: SD1_DAT1 */
        csi_id = <0>;
        mclk = <24000000>;
        mclk_source = <0>;
    };

...

两个块除了名称以外完全相同。

在驱动文件中，我实例化了以下结构体：

static const struct i2c_device_id foo_id[] = {
    {"foo0", 0},
    {"foo1", 1},
    {},
};

static struct i2c_driver foo0_i2c_driver = {
    .driver = {
        .owner = THIS_MODULE,
        .name = "foo0",
    },
    .probe = foo0_probe,
    .remove = foo0_remove,
    .id_table = foo_id,
};

static struct i2c_driver foo1_i2c_driver = {
    .driver = {
        .owner = THIS_MODULE,
        .name = "foo1",
    },
    .probe = foo1_probe,
    .remove = foo1_remove,
    .id_table = foo_id,
};

以下是我的init和exit函数：

MODULE_DEVICE_TABLE(i2c, foo_id);

static __init int foo_init(void)
{
    u8 err;

    err = i2c_add_driver(&foo0_i2c_driver);
    if (err != 0)
        pr_err("%s:driver registration failed i2c-slave0, error=%d\n",
            __func__, err);

    err = i2c_add_driver(&foo1_i2c_driver);
    if (err != 0)
        pr_err("%s:driver registration failed i2c-slave1, error=%d\n",
            __func__, err);

    return err;
}
static void __exit foo_clean(void)
{
    if((&foo0_i2c_driver) != NULL && i2c0initialized)
    {
        i2c_del_driver(&foo0_i2c_driver);
        i2c0initialized = 0;
    }
    if((&foo1_i2c_driver) != NULL && i2c1initialized)
    {
        i2c_del_driver(&foo1_i2c_driver);
        i2c1initialized = 0;
    }
}

module_init(foo_init);
module_exit(foo_clean);

以下是我的probe函数。 我为两个从机都准备了副本。

static int foo_probe(struct i2c_client *client,
                          const struct i2c_device_id *device_id)
{
    struct pinctrl *pinctrls;
    struct device *dev = &client->dev;

    int ret = 0;

    pinctrls = devm_pinctrl_get_select_default(dev);
    if(IS_ERR(pinctrls))
    {
        dev_err(dev, "pinctrl setup failed\n");
        return PTR_ERR(pinctrls);
    }

    memset(&foo_data, 0, sizeof(foo_data));
    foo_data.sensor_clk = devm_clk_get(dev, "csi_mclk");
    if(IS_ERR(foo_data.sensor_clk))
    {
        dev_err(dev, "get mclk failed\n");
        return PTR_ERR(foo_data.sensor_clk);
    }

    ret = of_property_read_u32(dev->of_node, "mclk", &(foo_data.mclk));
    if(ret < 0)
    {
        dev_err(dev, "mclk frequency is invalid\n");
        return ret;
    }

    ret = of_property_read_u32(dev->of_node, "mclk_source",
                               (u32 *)&(foo_data.mclk_source));
    if(ret < 0)
    {
        dev_err(dev, "mclk source is invalid\n");
        return ret;
    }

    ret = of_property_read_u32(dev->of_node, "csi_id", &(foo_data.csi));
    if(ret < 0)
    {
        dev_err(dev, "csi_id invalid\n");
        return ret;
    }

    clk_prepare_enable(foo_data.sensor_clk);
    i2c_client0 = client;

    /* custom data structures are set here */   

    foo_reset();

    ret = foo_get_id();

    if(ret < 0 /* || ret != foo_ID */)
    {
        clk_disable_unprepare(foo_data.sensor_clk);
        pr_warning("foo is not found\n");
        return -ENODEV;
    }

    clk_disable_unprepare(foo_data.sensor_clk);
    foo_int_device.priv = &foo_data;
    ret = v4l2_int_device_register(&foo_int_device);

    pr_info("foo is found\n");
    i2c0initialized = 1;
    return ret;
}

- Mert Can Ergün

---

我认为你混淆了“驱动程序”和“设备”。您可以注册一个驱动程序（每种设备类型一个），它将处理多个设备，具体取决于它们的I2C从地址。当然，驱动程序必须被编写为支持>1个设备，但是任何合理的驱动程序都应该支持。 - domen

@domen 是的，我能理解，但是寄存器已经硬编码到设备树中了。因此，只实例化一个从设备中读/写的从设备。 - Mert Can Ergün

我认为你不需要。你只需要一个带有一个探测函数的驱动程序。设备驱动程序系统将为每个匹配的DT定义调用该探测函数。很抱歉我没有方便的好参考资料，你查看了ldd3吗？https://www.kernel.org/doc/Documentation/driver-model/platform.txt也包含一些信息。 - domen

您可以在设备树中将一个I2C设备作为“主设备”，以实例化驱动程序，然后将第二个设备的信息（i2c总线、从地址、引脚）作为子节点放入主设备的节点中，并在主设备的探测函数中读取这些信息。基本上，您将次要设备的i2c信息作为附加信息添加到主设备的设备树节点中。 - user3528438

@user3528438，我正在与一台供应1个输出数据的相机进行接口交互，但需要向系统中的2个单独的i2c从设备发送不同的消息。顺便说一句，我不太明白您在主节点和子节点方面的评论。 - Mert Can Ergün

Answer 1

这个回答晚了5个月，但希望能帮助到有同样问题的人（就像我一样），并且找不到合适答案的人。

简而言之，解决方案是使用一个小号来表示每个从设备。您的驱动程序将在存储的客户端列表中查找该小号，以获取正确的i2c_client。

长篇版本：

您的I2C驱动程序最终可能会成为这种独特设备的字符设备驱动程序。否则，可能已经实现了一个框架（如hwmon），并且该框架已经处理了多个从设备，因此您不必担心。请参见http：//lxr.free-electrons.com/source/drivers/hwmon/ 以获取示例。

现在假设它是一个字符设备驱动程序，在驱动程序__init中，您需要分配与从设备相同数量的小号：

alloc_chrdev_region(&dev, *MINOR_START*, *NUM_DEVICES*, name)    
/* for each minor or slave device, do cdev_init and cdev_add */

现在我们来看看MODULE_DEVICE_TABLE。输入每个从设备的条目，记住字符串必须与设备树兼容的条目匹配。第二个字段是一个数字，我们将使用它作为唯一标识符和次要编号（这是技巧）：

struct i2c_device_id foo_idtable[] = {
    { "foo_1", 0 },
    { "foo_2", 1 },
    { },
};
MODULE_DEVICE_TABLE(i2c, foo_idtable);

在这样的情况下，每个匹配的设备树条目都将调用您的.probe函数。当调用.probe函数时，Linux会传递它为您实例化的i2c_client指针。这是诀窍的另一部分，拥有一个全局表来存储这些单独的i2c_client指针。全局表的索引是小编号。小编号是id-> driver_data，也是传递的数字，这是您之前在foo_idtable中分配的编号。

static int foo_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    /* Store the i2c_client pointer in a global table using minor number as index 
     * make sure to allocate the global table dynamically */
    that_table[id->driver_data] = client;
    /* The id->driver_data is the minor number! */
}

希望你现在已经有所了解了。当你使用insmod加载.ko文件时，需要为每个次设备号创建一个节点：

insmod foo.ko
make_dir /dev/foo
find_major foo
make_node /dev/foo/foo_0 c <major> 0
make_node /dev/foo/foo_1 c <major> 1

现在，当您的用户空间代码尝试使用您的驱动程序时，它会打开与正确次设备号（从设备）相对应的文件。在用户空间中，您可以执行以下操作：

/* Accessing slave #0 */
int fd = open("/dev/foo/foo_0", O_RDWR);

/* Accessing slave #1 */
int fd_1 = open("/dev/foo/foo_1", O_RDWR);

您的 .open 实现将被调用。

static int foo_driver_open(struct inode *inode, struct file *filep)
{
    int minor_num = MINOR(inode->i_rdev);
    /* remember the global table we had before that was indexed using the minor number?
     * Let's get the i2c_client stored there and get filep->private_data
     * to point to that i2c_client. Then subsequent read/write/ioctl can just
     * obtain the i2c_client from filep->private_data */
    filep->private_data = that_table[minor_num];
}

例如，您的用户空间代码调用了驱动程序的ioctl：

ioctl(fd, FOO_IOCTL_DO_READ, &msg);
ioctl(fd_1, FOO_IOCTL_DO_WRITE, &msg);

在您的驱动程序的ioctl实现中：

long foo_driver_ioctl(struct file *filep, unsinged int cmd, unsigned long arg)
{
    /* the filep->private_data has the i2c_client pointer! yay! */
    struct i2c_client *client = filep->private_data;

    /* now you can talk to your slave device with the i2c_client knowing
     * it is the correct i2c_client */
}

就是这样 :). 我希望这很有道理。这是一个长的解释，但我希望我既彻底又不会太混乱。最大的问题是我们有一个全局表来存储i2c_client指针，但是我想不到不拥有它的方法，因为.probe和.open之间没有传递参数的方法。如果有更好的解决方案，请让我知道。

- Splaty

---

这看起来比我的解决方案更优雅，我的解决方案注册一个设备但在需要时更改设备可能会令人困惑。 - Mert Can Ergün

Answer 2

这是我目前正在使用的一种解决方法，我不会接受此答案，因为这种方法感觉不太对。

struct i2c_client *foo_i2c_client;

static int foo_probe(struct i2c_client *client,
                          const struct i2c_device_id *device_id)
{
    foo_i2c_client = client;
    // implementation
}

static int foo_remove(struct i2c_client *client)
{
    // implementation
}

static const struct i2c_device_id foo_id[] = {
    {"foo0", 0},
    {},
};

static struct i2c_driver foo0_i2c_driver = {
    .driver = {
        .owner = THIS_MODULE,
        .name = "foo0",
    },
    .probe = foo0_probe,
    .remove = foo0_remove,
    .id_table = foo_id,
};

static int send_cmd(u8 slv_addr, u8 *buffer, u16 size)
{
    foo_i2c_client->address = slv_addr;
    i2c_master_send(foo_i2c_client, buffer, size);
    // rest of implementation
} 

MODULE_DEVICE_TABLE(i2c, foo_id);

module_i2c_driver(foo0_i2c_driver);

- Mert Can Ergün