RK3568驱动指南｜第十五篇 I2C-第178章 i2c_client结构体分析

瑞芯微RK3568芯片是一款定位中高端的通用型SOC，采用22nm制程工艺，搭载一颗四核Cortex-A55处理器和Mali G52 2EE 图形处理器。RK3568 支持4K 解码和 1080P 编码，支持SATA/PCIE/USB3.0 外围接口。RK3568内置独立NPU，可用于轻量级人工智能应用。RK3568 支持安卓 11 和 linux 系统，主要面向物联网网关、NVR 存储、工控平板、工业检测、工控盒、卡拉 OK、云终端、车载中控等行业。

​
【公众号】迅为电子

【粉丝群】258811263（加群获取驱动文档+例程）

【视频观看】嵌入式学习之Linux驱动（第十五篇 I2C_全新升级）_基于RK3568

【购买链接】迅为RK3568开发板瑞芯微Linux安卓鸿蒙ARM核心板人工智能AI主板

---

第178章 i2c_client结构体分析

在编写FT5X06触摸芯片驱动时，是通过i2c_client结构体来获取到I2C外设地址，而在i2c_client结构体中还包括中断号、I2C控制器等信息，该结构体定义在“include/linux/i2c.h”文件中，具体内容如下所示：

struct i2c_client {
	unsigned short flags;		/* 标志位, 用于各种配置和标识 */
	unsigned short addr;		/* 芯片地址 - 注意: 地址是 7 位的,存储在低 7 位中 */
	char name[I2C_NAME_SIZE];	/* 设备名称 */
	struct i2c_adapter *adapter;	/* 所在的 I2C 适配器 */
	struct device dev;		/* 设备结构体 */
	int init_irq;			/* 初始化时设置的中断号 */
	int irq;			/* 设备产生的中断号 */
	struct list_head detected;	/* 检测到的设备列表 */
#if IS_ENABLED(CONFIG_I2C_SLAVE)
	i2c_slave_cb_t slave_cb;	/* 从模式下的回调函数 */
#endif
};

在编写I2C client代码时提到了两种方法，第一种是在设备树中的I2C节点中追加对应的设备节点，可以回顾第170章内容，第二种方法是编写platform device C程序，可以回顾第172章内容，但是在C程序中并不是直接创建的i2c_client结构体，而是创建了i2c_board_info结构体，i2c_board_info和i2c_client两个结构体内容是相似的，最大的区别在于i2c_board_info没有I2C设备具体挂载到哪一个I2C 适配器的结构体i2c_adapter，那Linux在没有使用设备树的前提下是怎样解决i2c_board_info无法描述挂载的哪一个I2C 适配器这一问题的呢？

在本章的第一小节中将会对非设备树源码的I2C client进行分析，而在第二小节中将会对RK3568源码的I2C client进行分析。

178.1 非设备树I2C client分析

由于RK3568的源码已经不再使用平台文件对设备进行描述，而是使用设备树进行了取代，所以要想对非设备树的I2C client进行分析，需要使用较早一些的内核源码，这里使用的是4412开发板3.0版本的内核源码，具体存放路径为“iTOP-3568开发板\03_【iTOP-RK3568开发板】指南教程\02_Linux驱动配套资料\04_Linux驱动程序\107_i2c_client”

首先找到itop-4412开发板的平台文件，具体路径为“arch/arm/mach-exynos/mach-itop4412.c”，在该平台文件中使用了i2c_register_board_info函数，注册了board_info，具体内容如下所示：

	s3c_i2c0_set_platdata(NULL);
	i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));

	s3c_i2c1_set_platdata(NULL);
	i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));

	s3c_i2c2_set_platdata(NULL);
	i2c_register_board_info(2, i2c_devs2, ARRAY_SIZE(i2c_devs2));

	init_lcd_type();
	get_lcd_type();
	setup_ft5x_width_height();
		
	s3c_i2c3_set_platdata(NULL);
	i2c_register_board_info(3, i2c_devs3, ARRAY_SIZE(i2c_devs3));

	s3c_i2c4_set_platdata(NULL);
	i2c_register_board_info(4, i2c_devs4, ARRAY_SIZE(i2c_devs4));

#ifdef CONFIG_MPU_SENSORS_MPU6050B1
	sensor_hw_init();
#endif

	s3c_i2c5_set_platdata(NULL);
	i2c_register_board_info(5, i2c_devs5, ARRAY_SIZE(i2c_devs5));

	//For S5K4EC (using i2c6)
//#ifndef CONFIG_CAN_MCP251X
#if !defined(CONFIG_CAN_MCP251X) && !defined(CONFIG_SPI_RC522)
	s3c_i2c6_set_platdata(NULL);
	i2c_register_board_info(6, i2c_devs6, ARRAY_SIZE(i2c_devs6));
#endif


	s3c_i2c7_set_platdata(NULL);
	i2c_register_board_info(7, i2c_devs7, ARRAY_SIZE(i2c_devs7));

i2c_register_board_info函数定义在“drivers/i2c/i2c-boardinfo.c”文件中，具体内容如下所示：

/*
 * 注册 I2C 设备到内核的 I2C 子系统中。
 *
 * @busnum: I2C 总线号
 * @info: I2C 设备信息数组
 * @len: 设备信息数组的长度
 *
 * 返回值:
 * 成功时返回 0,失败时返回负值错误码。
*/
int __init
i2c_register_board_info(int busnum,
	struct i2c_board_info const *info, unsigned len)
{
	int status;

	// 获取写锁以保护全局 I2C 设备列表
	down_write(&__i2c_board_lock);

	// 如果总线号大于等于第一个动态分配的总线号,更新第一个动态分配的总线号
	if (busnum >= __i2c_first_dynamic_bus_num)
		__i2c_first_dynamic_bus_num = busnum + 1;

	// 遍历设备信息数组
	for (status = 0; len; len--, info++) {
		// 为每个设备分配 i2c_devinfo 结构体
		struct i2c_devinfo	*devinfo;
		devinfo = kzalloc(sizeof(*devinfo), GFP_KERNEL);
		if (!devinfo) {
			// 内存分配失败,打印调试信息并退出
			pr_debug("i2c-core: can't register boardinfo!\n");
			status = -ENOMEM;
			break;
		}

		// 填充 i2c_devinfo 结构体
		devinfo->busnum = busnum;
		devinfo->board_info = *info;
		list_add_tail(&devinfo->list, &__i2c_board_list);
	}

	// 释放写锁
	up_write(&__i2c_board_lock);

	return status;
}

该函数有三个参数其中busnum表示I2C的总线编号，例如I2C0、I2C1中的0和1就属于总线编号，第二个参数info表示I2C设备信息数组，第三个参数len:表示设备信息数组的长度，这个函数用于在内核的 I2C 子系统中注册 I2C 设备信息。函数分析如下:

第18行：获取全局 I2C 设备列表的写锁,以保护并发访问。

第21-22行：如果指定的总线号大于等于第一个动态分配的总线号,则更新第一个动态分配的总线号。

第25-34行：遍历传入的 i2c_board_info 数组，为每个设备分配一个 i2c_devinfo 结构体，填充 i2c_devinfo 结构体的成员,包括总线号和设备信息，将新分配的 i2c_devinfo 添加到全局 I2C 设备列表的末尾。

对该函数进行分析之后发现并没有寻找i2c_adapter以及创建i2c_client相关的操作，那上面创建的 i2c_devinfo是如何挂到i2c_adapter上的呢？这就需要找到4412的I2C控制器驱动了，也就是“drivers/i2c/busses/i2c-s3c2410.c”文件，在I2C控制器驱动的probe函数中调用了i2c_add_numbered_adapter函数来注册一个I2C适配器,并分配指定的总线号，该函数定义在“drivers/i2c/i2c-core.c”文件中，具体内容如下所示：

/*
 * 向 I2C 核心子系统注册一个 I2C 适配器,并分配一个指定的总线号。
 *
 * @adap: 要注册的 I2C 适配器
 *
 * 返回值:
 * 成功时返回 0,失败时返回负值错误码。
 */
int i2c_add_numbered_adapter(struct i2c_adapter *adap)
{
	int	id;
	int	status;

	// 检查总线号是否超出了允许的范围
	if (adap->nr & ~MAX_ID_MASK)
		return -EINVAL;

retry:
	// 尝试获取 i2c_adapter_idr IDR 的预分配资源
	if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
		return -ENOMEM;

	// 获取写锁,保护对全局 i2c_adapter_idr IDR 的访问
	mutex_lock(&core_lock);

	// 从 i2c_adapter_idr IDR 中获取一个新 ID,此 ID 应该大于或等于指定的总线号
	status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
	if (status == 0 && id != adap->nr) {
		// 如果获取的 ID 不等于指定的总线号,说明该总线号已被占用
		status = -EBUSY;
		// 从 i2c_adapter_idr IDR 中移除该 ID
		idr_remove(&i2c_adapter_idr, id);
	}

	// 释放写锁
	mutex_unlock(&core_lock);

	if (status == -EAGAIN)
		// 如果获取 IDR 资源失败,则重试
		goto retry;

	if (status == 0)
		// 如果获取 ID 成功,则注册 I2C 适配器
		status = i2c_register_adapter(adap);

	return status;
}

这个函数的具体的工作流程如下:

第15-16行：检查传入的 i2c_adapter 结构体的总线号是否超出了允许的范围。

第18-21行：尝试获取 i2c_adapter_idr IDR 的预分配资源,如果失败则返回 -ENOMEM 错误。

第24行：获取写锁 core_lock,保护对全局 i2c_adapter_idr IDR 的访问。

第27行：从 i2c_adapter_idr IDR 中获取一个新的 ID,此 ID 应该大于或等于指定的总线号。

第28-33行：如果获取的 ID 不等于指定的总线号,说明该总线号已被占用,此时返回 -EBUSY 错误,并从 IDR 中移除该 ID。

第36行：释放写锁 core_lock。

第38-40行：如果在获取 IDR 资源时出现 -EAGAIN 错误,则重试。

第42行：如果获取 ID 成功,则调用 i2c_register_adapter() 函数注册I2C适配器。

该函数的重点为第42行调用的 i2c_register_adapter() 函数，通过 i2c_register_adapter() 函数注册了I2C适配器，该函数的具体内容如下所示：

/*
 * 将一个 I2C 适配器注册到 I2C 核心子系统中。
 *
 * @adap: 要注册的 I2C 适配器
 *
 * 返回值:
 * 成功时返回 0,失败时返回负值错误码。
 */
static int i2c_register_adapter(struct i2c_adapter *adap)
{
	int res = 0;

	// 检查 I2C 总线类型是否已初始化完成
	if (unlikely(WARN_ON(!i2c_bus_type.p))) {
		res = -EAGAIN;
		goto out_list;
	}

	// 检查适配器名称是否为空
	if (unlikely(adap->name[0] == '\0')) {
		pr_err("i2c-core: Attempt to register an adapter with "
		       "no name!\n");
		return -EINVAL;
	}
	// 检查适配器是否有算法
	if (unlikely(!adap->algo)) {
		pr_err("i2c-core: Attempt to register adapter '%s' with "
		       "no algo!\n", adap->name);
		return -EINVAL;
	}

	// 初始化适配器的总线锁和用户空间客户端锁
	rt_mutex_init(&adap->bus_lock);
	mutex_init(&adap->userspace_clients_lock);
	INIT_LIST_HEAD(&adap->userspace_clients);

	// 如果未设置超时时间,则默认为 1 秒
	if (adap->timeout == 0)
		adap->timeout = HZ;

	// 设置适配器的设备名称
	dev_set_name(&adap->dev, "i2c-%d", adap->nr);
	adap->dev.bus = &i2c_bus_type;
	adap->dev.type = &i2c_adapter_type;

	// 注册适配器设备
	res = device_register(&adap->dev);
	if (res)
		goto out_list;

	dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);

#ifdef CONFIG_I2C_COMPAT
	// 创建兼容性类链接
	res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
				       adap->dev.parent);
	if (res)
		dev_warn(&adap->dev,
			 "Failed to create compatibility class link\n");
#endif

	// 扫描静态的 I2C 设备信息
	if (adap->nr < __i2c_first_dynamic_bus_num)
		i2c_scan_static_board_info(adap);

	// 通知所有的 I2C 驱动程序有新的适配器注册
	mutex_lock(&core_lock);
	bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
	mutex_unlock(&core_lock);

	return 0;

out_list:
	// 如果注册失败,则从 i2c_adapter_idr 中移除该适配器
	mutex_lock(&core_lock);
	idr_remove(&i2c_adapter_idr, adap->nr);
	mutex_unlock(&core_lock);
	return res;
}

第13-17行：检查 i2c_bus_type 是否已经初始化完成,如果未初始化则返回 -EAGAIN 错误。

第20-24行：检查适配器的名称是否为空,如果为空则返回 -EINVAL 错误。

第26-30行：检查适配器是否有算法,如果没有则返回 -EINVAL 错误。

第33-35行：初始化适配器的总线锁和用户空间客户端锁。

第38-39行：如果未设置超时时间,则默认为 1 秒。

第42-49行：设置适配器的设备名称,并注册设备。

第63-64行：如果适配器的总线号小于 __i2c_first_dynamic_bus_num,则扫描静态的 I2C 设备信息。

第66-69行：通知所有的 I2C 驱动程序有新的适配器注册。

第73-78行：如果注册失败,则从 i2c_adapter_idr 中移除该适配器。

该函数的重点为第64行调用的i2c_scan_static_board_info函数，该函数的主要作用是扫描当前i2c适配器上的静态板载设备信息，函数的具体内容如下所示：

static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
{
    // 定义一个i2c_devinfo结构体指针
    struct i2c_devinfo *devinfo;

    // 获取__i2c_board_lock读锁
    down_read(&__i2c_board_lock);

    // 遍历__i2c_board_list链表
    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);
    }

    // 释放__i2c_board_lock读锁
    up_read(&__i2c_board_lock);
}

该函数的重点在10-19行，通过遍历__i2c_board_list链表最后调用第13行的i2c_new_device函数用于创建一个新的i2c client设备客户端，该函数的具体内容为：

struct i2c_client *
i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
{
    // 定义一个i2c_client结构体指针
    struct i2c_client *client;
    // 定义一个状态变量
    int status;

    // 为i2c_client分配内存
    client = kzalloc(sizeof *client, GFP_KERNEL);
    if (!client)
        // 如果内存分配失败,返回NULL
        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));

    // 检查客户端地址的有效性
    status = i2c_check_client_addr_validity(client);
    if (status) {
        // 如果地址无效,打印错误信息并返回NULL
        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;
    }

    // 检查地址是否正在被使用
    status = i2c_check_addr_busy(adap, client->addr);
    if (status)
        // 如果地址正在被使用,打印错误信息并返回NULL
        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;

    // 设置客户端的设备名称
    dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
                 client->addr);
    // 注册设备
    status = device_register(&client->dev);
    if (status)
        // 如果注册失败,打印错误信息并返回NULL
        goto out_err;

    // 打印设备注册信息
    dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
        client->name, dev_name(&client->dev));

    // 返回新创建的i2c_client
    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 client就分析完成了，当然现在的源码已经不再使用平台文件了，而是使用设备树对设备进行描述，本小节的知识只是为了更好的理解I2C框架，在下个小节中将对设备树中的i2c client进行分析。

178.2 设备树I2C client分析

FT5X06触摸芯片完整的设备树如下所示：

i2c1: i2c@fe5a0000 {
	compatible = "rockchip,rk3399-i2c";
	reg = <0x0 0xfe5a0000 0x0 0x1000>;
	clocks = <&cru CLK_I2C1>, <&cru PCLK_I2C1>;
	clock-names = "i2c", "pclk";
	interrupts = ;
	pinctrl-names = "default";
	pinctrl-0 = <&i2c1_xfer>;
	#address-cells = <1>;
	#size-cells = <0>;
	status = "disabled";

	myft5x06: my-ft5x06@38 {
		compatible = "my-ft5x06";
		reg = <0x38>;
		reset-gpios = <&gpio0 RK_PB6 GPIO_ACTIVE_LOW>;
		interrupt-parent = <&gpio3>;
		interrupts-gpio = <&gpio3 RK_PA5 GPIO_ACTIVE_LOW>;
		interrupts = ;
		pinctrl-names = "default";
		pinctrl-0 = <&myft5x06_pins>;
	};
};

根据设备树讲解的相关知识，i2c1节点会转换成为platform device，但由于在该节点中并没有特殊的属性值，所以它的子节点myft5x06并不会被转换成platform device，这时候就出现问题了，既然触摸节点myft5x06不会被转换成platform device，那最后是如何解析的呢？

在上一小节关于平台文件中的I2C client的分析中，需要先让I2C 控制器工作起来，然后再添加具体的I2C设备信息，这里的设备树文件也同样如此，先让I2C 控制器工作起来，再解析对应的设备树节点。所以先打开RK3568对应的I2C控制器驱动文件“drivers/i2c/busses/i2c-rk3x.c”找到probe初始化函数，具体内容如下所示：

static int rk3x_i2c_probe(struct platform_device *pdev)
{
    // 从设备树中获取设备节点和匹配信息
    struct device_node *np = pdev->dev.of_node;
    const struct of_device_id *match;
    struct rk3x_i2c *i2c;
    struct resource *mem;
    int ret = 0;
    u32 value;
    int irq;
    unsigned long clk_rate;

    // 分配 rk3x_i2c 结构体
    i2c = devm_kzalloc(&pdev->dev, sizeof(struct rk3x_i2c), GFP_KERNEL);
    if (!i2c)
        return -ENOMEM;

    // 获取匹配的 SoC 数据
    match = of_match_node(rk3x_i2c_match, np);
    i2c->soc_data = match->data;

    // 解析 I2C 时序属性
    i2c_parse_fw_timings(&pdev->dev, &i2c->t, true);

    // 初始化 I2C 适配器
    strlcpy(i2c->adap.name, "rk3x-i2c", sizeof(i2c->adap.name));
    i2c->adap.owner = THIS_MODULE;
    i2c->adap.algo = &rk3x_i2c_algorithm;
    i2c->adap.retries = 3;
    i2c->adap.dev.of_node = np;
    i2c->adap.algo_data = i2c;
    i2c->adap.dev.parent = &pdev->dev;

    i2c->dev = &pdev->dev;

    // 初始化自旋锁和等待队列
    spin_lock_init(&i2c->lock);
    init_waitqueue_head(&i2c->wait);

    // 注册 I2C 重启处理程序
    i2c->i2c_restart_nb.notifier_call = rk3x_i2c_restart_notify;
    i2c->i2c_restart_nb.priority = 128;
    ret = register_pre_restart_handler(&i2c->i2c_restart_nb);
    if (ret) {
        dev_err(&pdev->dev, "failed to setup i2c restart handler.\n");
        return ret;
    }

    // 映射 I2C 寄存器
    mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    i2c->regs = devm_ioremap_resource(&pdev->dev, mem);
    if (IS_ERR(i2c->regs))
        return PTR_ERR(i2c->regs);

    // 切换到新的 I2C 接口
    if (i2c->soc_data->grf_offset >= 0) {
        struct regmap *grf;
        grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf");
        if (!IS_ERR(grf)) {
            int bus_nr;
            bus_nr = of_alias_get_id(np, "i2c");
            if (bus_nr < 0) {
                dev_err(&pdev->dev, "rk3x-i2c needs i2cX alias");
                return -EINVAL;
            }
            // 配置 GRF 寄存器以切换到新的 I2C 接口
            if (i2c->soc_data == &rv1108_soc_data && bus_nr == 2)
                value = BIT(26) | BIT(10);
            else if (i2c->soc_data == &rv1126_soc_data && bus_nr == 2)
                value = BIT(20) | BIT(4);
            else
                value = BIT(27 + bus_nr) | BIT(11 + bus_nr);
            ret = regmap_write(grf, i2c->soc_data->grf_offset, value);
            if (ret != 0) {
                dev_err(i2c->dev, "Could not write to GRF: %d\n", ret);
                return ret;
            }
        }
    }

    // 请求 I2C 中断
    irq = platform_get_irq(pdev, 0);
    if (irq < 0) {
        dev_err(&pdev->dev, "cannot find rk3x IRQ\n");
        return irq;
    }
    ret = devm_request_irq(&pdev->dev, irq, rk3x_i2c_irq, 0, dev_name(&pdev->dev), i2c);
    if (ret < 0) {
        dev_err(&pdev->dev, "cannot request IRQ\n");
        return ret;
    }

    // 获取 I2C 时钟
    if (i2c->soc_data->calc_timings == rk3x_i2c_v0_calc_timings) {
        // 只有一个时钟用于总线时钟和外设时钟
        i2c->clk = devm_clk_get(&pdev->dev, NULL);
        i2c->pclk = i2c->clk;
    } else {
        i2c->clk = devm_clk_get(&pdev->dev, "i2c");
        i2c->pclk = devm_clk_get(&pdev->dev, "pclk");
    }

    // 准备 I2C 时钟
    ret = clk_prepare(i2c->clk);
    if (ret < 0) {
        dev_err(&pdev->dev, "Can't prepare bus clk: %d\n", ret);
        return ret;
    }
    ret = clk_prepare(i2c->pclk);
    if (ret < 0) {
        dev_err(&pdev->dev, "Can't prepare periph clock: %d\n", ret);
        goto err_clk;
    }

    // 注册时钟变化通知函数
    i2c->clk_rate_nb.notifier_call = rk3x_i2c_clk_notifier_cb;
    ret = clk_notifier_register(i2c->clk, &i2c->clk_rate_nb);
    if (ret != 0) {
        dev_err(&pdev->dev, "Unable to register clock notifier\n");
        goto err_pclk;
    }

    // 计算 I2C 时钟分频
    clk_rate = clk_get_rate(i2c->clk);
    rk3x_i2c_adapt_div(i2c, clk_rate);

    // 注册 I2C 适配器
    ret = i2c_add_adapter(&i2c->adap);
    if (ret < 0)
        goto err_clk_notifier;

    return 0;

err_clk_notifier:
    clk_notifier_unregister(i2c->clk, &i2c->clk_rate_nb);
err_pclk:
    clk_unprepare(i2c->pclk);
err_clk:
    clk_unprepare(i2c->clk);
    return ret;
}

该probe函数最重要的部分就是第128行，调用i2c_add_adapter函数注册I2C适配器，该

函数定义在“drivers/i2c/i2c-core-base.c”文件中，具体内容如下所示：

// 添加I2C适配器的函数
int i2c_add_adapter(struct i2c_adapter *adapter)
{
    // 获取适配器的设备
    struct device *dev = &adapter->dev;
    // 声明一个ID变量
    int id;

    // 如果设备节点存在
    if (dev->of_node) {
        // 从设备树别名中获取I2C总线号
        id = of_alias_get_id(dev->of_node, "i2c");
        // 如果总线号有效
        if (id >= 0) {
            // 设置适配器编号为获取的总线号
            adapter->nr = id;
            // 添加编号的I2C适配器
            return __i2c_add_numbered_adapter(adapter);
        }
    }

    // 加锁,防止并发访问
    mutex_lock(&core_lock);
    // 在i2c_adapter_idr动态ID池中分配一个ID
    id = idr_alloc(&i2c_adapter_idr, adapter,
                   __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
    // 解锁
    mutex_unlock(&core_lock);
    // 如果分配ID失败
    if (WARN(id < 0, "couldn't get idr"))
        // 返回错误码
        return id;

    // 设置适配器编号为分配的ID
    adapter->nr = id;

    // 注册I2C适配器
    return i2c_register_adapter(adapter);
}

第10-20行：首先尝试从设备树别名中获取I2C总线号,如果获取成功,则直接使用这个总线号并使用__i2c_add_numbered_adapter函数添加编号的I2C适配器。

第25-26行：如果没有在设备树中找到总线号,则从动态ID池中分配一个ID作为适配器编号。

第38行：最后调用i2c_register_adapter函数注册I2C适配器。

I2C总线号就是I2C0、I2C1的0和1，获取到总线号之后会调用__i2c_add_numbered_adapter函数来添加对应的I2C适配器，该函数的具体内容如下所示：

// 添加编号的I2C适配器的内部函数
static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
{
    // 声明一个ID变量
    int id;

    // 加锁,防止并发访问
    mutex_lock(&core_lock);
    // 在i2c_adapter_idr动态ID池中分配一个从adap->nr开始的ID
    id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
    // 解锁
    mutex_unlock(&core_lock);
    // 如果分配ID失败
    if (WARN(id < 0, "couldn't get idr"))
        // 如果是因为空间不足,-ENOSPC,返回-EBUSY表示设备忙;否则返回错误码
        return id == -ENOSPC ? -EBUSY : id;

    // 注册I2C适配器
    return i2c_register_adapter(adap);
}

在该函数的最后会使用i2c_register_adapter函数注册I2C适配器,i2c_register_adapter函数的具体内容如下所示：

// I2C适配器注册函数
static int i2c_register_adapter(struct i2c_adapter *adap)
{
    // 初始化返回值为无效
    int res = -EINVAL;

    // 如果驱动模型还没有初始化完成,返回-EAGAIN表示再次尝试
    if (WARN_ON(!is_registered)) {
        res = -EAGAIN;
        goto out_list;
    }

    // 进行一些基本检查
    // 如果适配器名称为空,返回错误
    if (WARN(!adap->name[0], "i2c adapter has no name"))
        goto out_list;
    // 如果没有提供算法,返回错误
    if (!adap->algo) {
        pr_err("adapter '%s': no algo supplied!\n", adap->name);
        goto out_list;
    }

    // 如果没有提供锁操作,使用默认的i2c_adapter_lock_ops
    if (!adap->lock_ops)
        adap->lock_ops = &i2c_adapter_lock_ops;

    // 初始化适配器总线锁和复用锁
    rt_mutex_init(&adap->bus_lock);
    rt_mutex_init(&adap->mux_lock);
    mutex_init(&adap->userspace_clients_lock);
    INIT_LIST_HEAD(&adap->userspace_clients);

    // 如果没有设置超时时间,设置为1秒
    if (adap->timeout == 0)
        adap->timeout = HZ;

    // 设置Host Notify中断域
    res = i2c_setup_host_notify_irq_domain(adap);
    if (res) {
        pr_err("adapter '%s': can't create Host Notify IRQs (%d)\n",
               adap->name, res);
        goto out_list;
    }

    // 设置设备名称和总线类型
    dev_set_name(&adap->dev, "i2c-%d", adap->nr);
    adap->dev.bus = &i2c_bus_type;
    adap->dev.type = &i2c_adapter_type;
    // 注册设备
    res = device_register(&adap->dev);
    if (res) {
        pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
        goto out_list;
    }

    // 设置SMBUS警报
    res = of_i2c_setup_smbus_alert(adap);
    if (res)
        goto out_reg;

    // 输出调试信息
    dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);

    // 设置电源管理相关属性
    pm_runtime_no_callbacks(&adap->dev);
    pm_suspend_ignore_children(&adap->dev, true);
    pm_runtime_enable(&adap->dev);

    // 创建兼容性类链接
#ifdef CONFIG_I2C_COMPAT
    res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
                                   adap->dev.parent);
    if (res)
        dev_warn(&adap->dev,
                 "Failed to create compatibility class link\n");
#endif

    // 初始化恢复机制
    i2c_init_recovery(adap);

    // 注册设备节点和ACPI设备
    of_i2c_register_devices(adap);
    i2c_acpi_install_space_handler(adap);
    i2c_acpi_register_devices(adap);

    // 扫描静态板载设备
    if (adap->nr < __i2c_first_dynamic_bus_num)
        i2c_scan_static_board_info(adap);

    // 通知驱动
    mutex_lock(&core_lock);
    bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
    mutex_unlock(&core_lock);

    return 0;

out_reg:
    init_completion(&adap->dev_released);
    device_unregister(&adap->dev);
    wait_for_completion(&adap->dev_released);
out_list:
    mutex_lock(&core_lock);
    idr_remove(&i2c_adapter_idr, adap->nr);
    mutex_unlock(&core_lock);
    return res;
}

在该函数的第82行调用了of_i2c_register_devices函数扫描设备树中定义的I2C从设备并注册他们，该函数的具体内容如下所示

void of_i2c_register_devices(struct i2c_adapter *adap)
{
    // 声明两个设备树节点指针变量,分别用于表示I2C总线节点和I2C从设备节点
    struct device_node *bus, *node;
    // 声明一个I2C从设备客户端指针变量
    struct i2c_client *client;

    // 只有当I2C适配器有关联的设备树节点时,才继续注册从设备
    if (!adap->dev.of_node)
        return;

    // 打印调试信息,表示正在遍历I2C从设备节点
    dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");

    // 尝试从I2C适配器的设备树节点中获取名为"i2c-bus"的子节点
    // 如果没有找到该子节点,则直接使用I2C适配器的设备树节点作为I2C总线节点
    bus = of_get_child_by_name(adap->dev.of_node, "i2c-bus");
    if (!bus)
        bus = of_node_get(adap->dev.of_node);

    // 遍历I2C总线节点的所有可用子节点
    for_each_available_child_of_node(bus, node) {
        // 检查该I2C从设备节点是否已被标记为已注册
        // 如果已被标记,则跳过该节点,避免重复注册
        if (of_node_test_and_set_flag(node, OF_POPULATED))
            continue;

        // 使用of_i2c_register_device函数注册I2C从设备
        // 该函数根据设备树节点的属性创建并注册i2c_client结构体
        client = of_i2c_register_device(adap, node);
        if (IS_ERR(client)) {
            // 如果注册失败,打印错误消息,并清除节点的"已注册"标志,以便下次可以重新尝试注册
            dev_err(&adap->dev,
                "Failed to create I2C device for %pOF\n",
                node);
            of_node_clear_flag(node, OF_POPULATED);
        }
    }

    // 释放对I2C总线节点的引用
    of_node_put(bus);
}

第9-10行：检查 adap->dev.of_node 是否为空。如果为空,意味着 I2C 适配器没有关联的设备树节点,函数直接返回。

第17-19行：尝试从 I2C 适配器的设备树节点中获取名为 "i2c-bus" 的子节点。如果找不到,则直接使用 I2C 适配器的设备树节点作为 I2C 总线节点。

第22-26行遍历 I2C 总线节点的所有可用子节点。对于每个子节点:

（1）检查该节点是否已被标记为已注册(OF_POPULATED)。如果已被标记,则跳过该节点,避免重复注册。

（2）使用 of_i2c_register_device() 函数注册 I2C 从设备。该函数根据设备树节点的属性创建并注册 i2c_client 结构体。

（3）如果注册失败,打印错误消息,并清除节点的 "已注册" 标志,以便下次可以重新尝试注册。

该函数的关注点在第30行的of_i2c_register_device函数，通过该函数注册所有可用子节点，该函数的具体内容为

static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
						 struct device_node *node)
{
	// 声明i2c_client和i2c_board_info结构体指针变量
	struct i2c_client *client;
	struct i2c_board_info info;
	int ret;

	// 打印调试信息,表示正在注册设备树节点
	dev_dbg(&adap->dev, "of_i2c: register %pOF\n", node);

	// 根据设备树节点信息填充i2c_board_info结构体
	ret = of_i2c_get_board_info(&adap->dev, node, &info);
	if (ret)
		// 如果获取i2c_board_info信息失败,返回错误指针
		return ERR_PTR(ret);

	// 使用i2c_new_device()函数注册i2c_client设备
	client = i2c_new_device(adap, &info);
	if (!client) {
		// 如果注册失败,打印错误信息并返回错误指针
		dev_err(&adap->dev, "of_i2c: Failure registering %pOF\n", node);
		return ERR_PTR(-EINVAL);
	}
	// 返回成功注册的i2c_client指针
	return client;
}

这个函数的主要作用是根据提供的设备树节点信息,自动创建并注册一个I2C从设备。它使用of_i2c_get_board_info()函数从设备树节点中获取必要的信息，of_i2c_get_board_info()函数的具体内容如下所示：

int of_i2c_get_board_info(struct device *dev, struct device_node *node,
			  struct i2c_board_info *info)
{
	// 声明地址和返回值变量
	u32 addr;
	int ret;

	// 清空i2c_board_info结构体
	memset(info, 0, sizeof(*info));

	// 从设备树节点获取modalias字符串
	if (of_modalias_node(node, info->type, sizeof(info->type)) < 0) {
		// 如果获取modalias失败,打印错误信息并返回
		dev_err(dev, "of_i2c: modalias failure on %pOF\n", node);
		return -EINVAL;
	}

	// 从设备树节点获取reg属性(设备地址)
	ret = of_property_read_u32(node, "reg", &addr);
	if (ret) {
		// 如果获取地址失败,打印错误信息并返回
		dev_err(dev, "of_i2c: invalid reg on %pOF\n", node);
		return ret;
	}

	// 检查地址是否为10位地址模式
	if (addr & I2C_TEN_BIT_ADDRESS) {
		// 清除高位标志,并设置i2c_board_info的flags
		addr &= ~I2C_TEN_BIT_ADDRESS;
		info->flags |= I2C_CLIENT_TEN;
	}

	// 检查地址是否为从设备地址模式
	if (addr & I2C_OWN_SLAVE_ADDRESS) {
		// 清除高位标志,并设置i2c_board_info的flags
		addr &= ~I2C_OWN_SLAVE_ADDRESS;
		info->flags |= I2C_CLIENT_SLAVE;
	}

	// 填充i2c_board_info结构体的addr、of_node和fwnode字段
	info->addr = addr;
	info->of_node = node;
	info->fwnode = of_fwnode_handle(node);

	// 检查设备树节点是否有"host-notify"属性
	if (of_property_read_bool(node, "host-notify"))
		// 如果有,设置i2c_board_info的flags
		info->flags |= I2C_CLIENT_HOST_NOTIFY;

	// 检查设备树节点是否有"wakeup-source"属性
	if (of_get_property(node, "wakeup-source", NULL))
		// 如果有,设置i2c_board_info的flags
		info->flags |= I2C_CLIENT_WAKE;

	// 返回0,表示成功获取并填充i2c_board_info结构体
	return 0;
}

这个函数的主要作用是根据提供的设备树节点信息,填充i2c_board_info结构体。它从设备树节点中获取设备的modalias、地址、总线标志等信息,并将其填充到i2c_board_info结构体中。

在of_i2c_register_device函数的最后会调用i2c_new_device()函数进行实际设备的注册，至此对于设备树中的I2C client的分析就结束了。

但还有一个地方需要注意，在上面的函数分析中并没有涉及到中断相关内容，而前面章节编写的FT5X06驱动中有这样的代码描述，这里的中断号是在哪里进行的赋值呢？

    ret = request_irq(client->irq, ft5x06_handler,
                     IRQ_TYPE_EDGE_FALLING | IRQF_ONESHOT, "ft5x06 irq", NULL);

实际上在执行驱动的probe函数之前，会先执行“drivers/i2c/i2c-core-base.c”文件中的i2c_device_probe函数，该函数的具体内容如下所示：

static int i2c_device_probe(struct device *dev)
{
    // 从 device 结构体中获取 i2c_client 结构体
    struct i2c_client    *client = i2c_verify_client(dev);
    // 从 device 结构体中获取 i2c_driver 结构体
    struct i2c_driver    *driver;
    int status;

    // 如果 client 不存在,则返回 0
    if (!client)
        return 0;

    // 将 dev->driver 转换为 i2c_driver 类型
    driver = to_i2c_driver(dev->driver);

    // 如果 client 没有中断号且 driver 没有禁用 i2c 核心中断映射,则尝试获取中断号
    if (!client->irq && !driver->disable_i2c_core_irq_mapping) {
        int irq = -ENOENT;

        // 如果 client 使用 Host Notify 中断,则使用 i2c_smbus_host_notify_to_irq 获取中断号
        if (client->flags & I2C_CLIENT_HOST_NOTIFY) {
            dev_dbg(dev, "Using Host Notify IRQ\n");
            // 保持适配器处于活动状态,因为需要 Host Notify 中断
            pm_runtime_get_sync(&client->adapter->dev);
            irq = i2c_smbus_host_notify_to_irq(client);
        } 
        // 如果设备有 DT 节点,则尝试从 DT 节点获取中断号
        else if (dev->of_node) {
            irq = of_irq_get_byname(dev->of_node, "irq");
            if (irq == -EINVAL || irq == -ENODATA)
                irq = of_irq_get(dev->of_node, 0);
        } 
        // 如果设备有 ACPI 关联,则尝试从 ACPI 获取中断号
        else if (ACPI_COMPANION(dev)) {
            irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
        }

        // 如果获取中断号失败,则设置为 0
        if (irq == -EPROBE_DEFER)
            return irq;
        if (irq < 0)
            irq = 0;

        // 将获取到的中断号设置到 client 结构体中
        client->irq = irq;
    }

    // 如果 driver 没有 ID 表,且设备也没有匹配的 OF 或 ACPI ID 表,则返回 -ENODEV
    if (!driver->id_table &&
        !i2c_acpi_match_device(dev->driver->acpi_match_table, client) &&
        !i2c_of_match_device(dev->driver->of_match_table, client))
        return -ENODEV;

    // 如果 client 需要唤醒功能,则尝试设置唤醒中断
    if (client->flags & I2C_CLIENT_WAKE) {
        int wakeirq = -ENOENT;

        // 如果设备有 DT 节点,则尝试从 DT 节点获取唤醒中断号
        if (dev->of_node) {
            wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
            if (wakeirq == -EPROBE_DEFER)
                return wakeirq;
        }

        // 启用设备的唤醒功能
        device_init_wakeup(&client->dev, true);

        // 如果获取到了唤醒中断号,且与普通中断号不同,则设置专用唤醒中断
        if (wakeirq > 0 && wakeirq != client->irq)
            status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
        // 否则,使用普通中断作为唤醒中断
        else if (client->irq > 0)
            status = dev_pm_set_wake_irq(dev, client->irq);
        else
            status = 0;

        // 如果设置唤醒中断失败,则输出警告
        if (status)
            dev_warn(&client->dev, "failed to set up wakeup irq\n");
    }

    dev_dbg(dev, "probe\n");

    // 设置设备的时钟默认值
    status = of_clk_set_defaults(dev->of_node, false);
    if (status < 0)
        goto err_clear_wakeup_irq;

    // 附加 PM 域
    status = dev_pm_domain_attach(&client->dev, true);
    if (status)
        goto err_clear_wakeup_irq;

    // 调用 driver 的 probe_new 或 probe 函数
    if (driver->probe_new)
        status = driver->probe_new(client);
    else if (driver->probe)
        status = driver->probe(client,
                               i2c_match_id(driver->id_table, client));
    else
        status = -EINVAL;

    // 如果 probe 函数失败,则清除唤醒中断并分离 PM 域
    if (status) {
        dev_pm_domain_detach(&client->dev, true);
        goto err_clear_wakeup_irq;
    }

    return 0;

err_clear_wakeup_irq:
    dev_pm_clear_wake_irq(&client->dev);
    device_init_wakeup(&client->dev, false);
    return status;
}

第16行-第46行都是关于中断相关的操作，在第45行将获取到的中断号设置到 client 结构体中，所以在FT5X06的驱动中可以直接调用client->irq，至此关于设备树的I2C client的分析就完成了，在下个章节将会对应用程序中使用I2C进行讲解。