简述

I2c是一个应用很广的总线。通讯协议简单，而且一条总线上可以挂载多个设备，在这里讲一下I2c在linux中的架构。首先借一下网络上的一张图：

I2c的框架主要分为以上这么几个部分。下面根据代码，相机讲述一下，各个部分的实现。

软件版本：linux 4.14.98
硬件型号：imx7

1. I2C core 初始化

文件位置：drivers/i2c/i2c-core-base.c
首先来看i2c_init()函数。

static int __init i2c_init(void)
{int retval;retval = of_alias_get_highest_id("i2c");down_write(&__i2c_board_lock);if (retval >= __i2c_first_dynamic_bus_num)__i2c_first_dynamic_bus_num = retval + 1;up_write(&__i2c_board_lock);retval = bus_register(&i2c_bus_type);if (retval)return retval;is_registered = true;#ifdef CONFIG_I2C_COMPATi2c_adapter_compat_class = class_compat_register("i2c-adapter");if (!i2c_adapter_compat_class) {retval = -ENOMEM;goto bus_err;}
#endifretval = i2c_add_driver(&dummy_driver);if (retval)goto class_err;if (IS_ENABLED(CONFIG_OF_DYNAMIC))WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));if (IS_ENABLED(CONFIG_ACPI))WARN_ON(acpi_reconfig_notifier_register(&i2c_acpi_notifier));return 0;class_err:
#ifdef CONFIG_I2C_COMPATclass_compat_unregister(i2c_adapter_compat_class);
bus_err:
#endifis_registered = false;bus_unregister(&i2c_bus_type);return retval;
}

在该函数中利用 bus_register(&i2c_bus_type)向系统注册I2c总线。
其中i2c_bus_type定义如下：

struct bus_type i2c_bus_type = {.name           = "i2c",.match          = i2c_device_match,.probe          = i2c_device_probe,.remove         = i2c_device_remove,.shutdown       = i2c_device_shutdown,
};
EXPORT_SYMBOL_GPL(i2c_bus_type);

在这里我们看一下i2c_device_probe（）函数：

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 (!client->irq && !driver->disable_i2c_core_irq_mapping) {int irq = -ENOENT;if (client->flags & I2C_CLIENT_HOST_NOTIFY) {dev_dbg(dev, "Using Host Notify IRQ\n");irq = i2c_smbus_host_notify_to_irq(client);} 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);} else if (ACPI_COMPANION(dev)) {irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);}if (irq == -EPROBE_DEFER)return irq;if (irq < 0)irq = 0;client->irq = irq;}/** An I2C ID table is not mandatory, if and only if, a suitable OF* or ACPI ID table is supplied for the probing device.*/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;if (client->flags & I2C_CLIENT_WAKE) {int wakeirq = -ENOENT;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);elsestatus = 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;status = dev_pm_domain_attach(&client->dev, true);if (status == -EPROBE_DEFER)goto err_clear_wakeup_irq;/** When there are no more users of probe(),* rename probe_new to 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));elsestatus = -EINVAL;if (status)goto err_detach_pm_domain;return 0;err_detach_pm_domain:dev_pm_domain_detach(&client->dev, true);
err_clear_wakeup_irq:dev_pm_clear_wake_irq(&client->dev);device_init_wakeup(&client->dev, false);return status;
}

如果在driver中初始化了probe,那么就使用driver中定义的probe.那么这个是在那里定义的呢？看下节分析

2. I2C-imx 分析

文件：drivers/i2c/busses/i2c-imx.c

static const struct dev_pm_ops i2c_imx_pm_ops = {SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(i2c_imx_suspend, i2c_imx_resume)SET_RUNTIME_PM_OPS(i2c_imx_runtime_suspend,i2c_imx_runtime_resume, NULL)
};
#define I2C_IMX_PM_OPS (&i2c_imx_pm_ops)
#else
#define I2C_IMX_PM_OPS NULL
#endif /* CONFIG_PM */static struct platform_driver i2c_imx_driver = {.probe = i2c_imx_probe,.remove = i2c_imx_remove,.driver = {.name = DRIVER_NAME,.pm = I2C_IMX_PM_OPS,.of_match_table = i2c_imx_dt_ids,},.id_table = imx_i2c_devtype,
};static int __init i2c_adap_imx_init(void)
{return platform_driver_register(&i2c_imx_driver);
}
subsys_initcall(i2c_adap_imx_init);static void __exit i2c_adap_imx_exit(void)
{platform_driver_unregister(&i2c_imx_driver);
}
module_exit(i2c_adap_imx_exit);

其中i2c_imx_dt_ids定义如下：

static const struct of_device_id i2c_imx_dt_ids[] = {{ .compatible = "fsl,imx1-i2c", .data = &imx1_i2c_hwdata, },{ .compatible = "fsl,imx21-i2c", .data = &imx21_i2c_hwdata, },{ .compatible = "fsl,vf610-i2c", .data = &vf610_i2c_hwdata, },{ .compatible = "fsl,imx7d-i2c", .data = &imx7d_i2c_hwdata, },{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, i2c_imx_dt_ids);

下面看下probe函数

static int i2c_imx_probe(struct platform_device *pdev)
{const struct of_device_id *of_id = of_match_device(i2c_imx_dt_ids,&pdev->dev);struct imx_i2c_struct *i2c_imx;struct resource *res;struct imxi2c_platform_data *pdata = dev_get_platdata(&pdev->dev);void __iomem *base;int irq, ret;dma_addr_t phy_addr;dev_dbg(&pdev->dev, "<%s>\n", __func__);irq = platform_get_irq(pdev, 0);if (irq < 0) {dev_err(&pdev->dev, "can't get irq number\n");return irq;}res = platform_get_resource(pdev, IORESOURCE_MEM, 0);base = devm_ioremap_resource(&pdev->dev, res);if (IS_ERR(base))return PTR_ERR(base);phy_addr = (dma_addr_t)res->start;i2c_imx = devm_kzalloc(&pdev->dev, sizeof(*i2c_imx), GFP_KERNEL);if (!i2c_imx)return -ENOMEM;if (of_id)i2c_imx->hwdata = of_id->data;elsei2c_imx->hwdata = (struct imx_i2c_hwdata *)platform_get_device_id(pdev)->driver_data;/* Setup i2c_imx driver structure */strlcpy(i2c_imx->adapter.name, pdev->name, sizeof(i2c_imx->adapter.name));i2c_imx->adapter.owner          = THIS_MODULE;i2c_imx->adapter.algo           = &i2c_imx_algo;i2c_imx->adapter.dev.parent     = &pdev->dev;i2c_imx->adapter.nr             = pdev->id;i2c_imx->adapter.dev.of_node    = pdev->dev.of_node;i2c_imx->base                   = base;/* Get I2C clock */i2c_imx->clk = devm_clk_get(&pdev->dev, NULL);if (IS_ERR(i2c_imx->clk)) {dev_err(&pdev->dev, "can't get I2C clock\n");return PTR_ERR(i2c_imx->clk);}ret = clk_prepare_enable(i2c_imx->clk);if (ret) {dev_err(&pdev->dev, "can't enable I2C clock, ret=%d\n", ret);return ret;}/* Request IRQ */ret = devm_request_irq(&pdev->dev, irq, i2c_imx_isr,IRQF_SHARED | IRQF_NO_SUSPEND,pdev->name, i2c_imx);if (ret) {dev_err(&pdev->dev, "can't claim irq %d\n", irq);goto clk_disable;}/* Init queue */init_waitqueue_head(&i2c_imx->queue);/* Set up adapter data */i2c_set_adapdata(&i2c_imx->adapter, i2c_imx);/* Set up platform driver data */platform_set_drvdata(pdev, i2c_imx);pm_runtime_set_autosuspend_delay(&pdev->dev, I2C_PM_TIMEOUT);pm_runtime_use_autosuspend(&pdev->dev);pm_runtime_set_active(&pdev->dev);pm_runtime_enable(&pdev->dev);ret = pm_runtime_get_sync(&pdev->dev);if (ret < 0)goto rpm_disable;/* Set up clock divider */i2c_imx->bitrate = IMX_I2C_BIT_RATE;ret = of_property_read_u32(pdev->dev.of_node,"clock-frequency", &i2c_imx->bitrate);if (ret < 0 && pdata && pdata->bitrate)i2c_imx->bitrate = pdata->bitrate;/** This limit caused by an i.MX7D hardware issue(e7805 in Errata).* If there is no limit, when the bitrate set up to 400KHz, it will* cause the SCK low level period less than 1.3us.*/if (is_imx7d_i2c(i2c_imx) && i2c_imx->bitrate > IMX_I2C_MAX_E_BIT_RATE)i2c_imx->bitrate = IMX_I2C_MAX_E_BIT_RATE;/* Set up chip registers to defaults */imx_i2c_write_reg(i2c_imx->hwdata->i2cr_ien_opcode ^ I2CR_IEN,i2c_imx, IMX_I2C_I2CR);imx_i2c_write_reg(i2c_imx->hwdata->i2sr_clr_opcode, i2c_imx, IMX_I2C_I2SR);/* Init optional bus recovery function */ret = i2c_imx_init_recovery_info(i2c_imx, pdev);/* Give it another chance if pinctrl used is not ready yet */if (ret == -EPROBE_DEFER)goto rpm_disable;/* Add I2C adapter */ret = i2c_add_numbered_adapter(&i2c_imx->adapter);if (ret < 0)goto rpm_disable;pm_runtime_mark_last_busy(&pdev->dev);pm_runtime_put_autosuspend(&pdev->dev);dev_dbg(&i2c_imx->adapter.dev, "claimed irq %d\n", irq);dev_dbg(&i2c_imx->adapter.dev, "device resources: %pR\n", res);dev_dbg(&i2c_imx->adapter.dev, "adapter name: \"%s\"\n",i2c_imx->adapter.name);dev_info(&i2c_imx->adapter.dev, "IMX I2C adapter registered\n");/* Init DMA config if supported */i2c_imx_dma_request(i2c_imx, phy_addr);return 0;   /* Return OK */rpm_disable:pm_runtime_put_noidle(&pdev->dev);pm_runtime_disable(&pdev->dev);pm_runtime_set_suspended(&pdev->dev);pm_runtime_dont_use_autosuspend(&pdev->dev);clk_disable:clk_disable_unprepare(i2c_imx->clk);return ret;
}

在这个函数里面重点是 ret = i2c_add_numbered_adapter(&i2c_imx->adapter)，注册I2C适配器和I2C设备都在里面实现。
下面我们看一下这个函数实现：

/*** i2c_add_numbered_adapter - declare i2c adapter, use static bus number* @adap: the adapter to register (with adap->nr initialized)* Context: can sleep** This routine is used to declare an I2C adapter when its bus number* matters.  For example, use it for I2C adapters from system-on-chip CPUs,* or otherwise built in to the system's mainboard, and where i2c_board_info* is used to properly configure I2C devices.** If the requested bus number is set to -1, then this function will behave* identically to i2c_add_adapter, and will dynamically assign a bus number.** If no devices have pre-been declared for this bus, then be sure to* register the adapter before any dynamically allocated ones.  Otherwise* the required bus ID may not be available.** When this returns zero, the specified adapter became available for* clients using the bus number provided in adap->nr.  Also, the table* of I2C devices pre-declared using i2c_register_board_info() is scanned,* and the appropriate driver model device nodes are created.  Otherwise, a* negative errno value is returned.*/
int i2c_add_numbered_adapter(struct i2c_adapter *adap)
{if (adap->nr == -1) /* -1 means dynamically assign bus id */return i2c_add_adapter(adap);return __i2c_add_numbered_adapter(adap);
}
EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);......................................
/*** __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1* @adap: the adapter to register (with adap->nr initialized)* Context: can sleep** See i2c_add_numbered_adapter() for details.*/
static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
{int id;mutex_lock(&core_lock);id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);mutex_unlock(&core_lock);if (WARN(id < 0, "couldn't get idr"))return id == -ENOSPC ? -EBUSY : id;return i2c_register_adapter(adap);
}
..............................................
/*** i2c_add_adapter - declare i2c adapter, use dynamic bus number* @adapter: the adapter to add* Context: can sleep** This routine is used to declare an I2C adapter when its bus number* doesn't matter or when its bus number is specified by an dt alias.* Examples of bases when the bus number doesn't matter: I2C adapters* dynamically added by USB links or PCI plugin cards.** When this returns zero, a new bus number was allocated and stored* in adap->nr, and the specified adapter became available for clients.* Otherwise, a negative errno value is returned.*/
int i2c_add_adapter(struct i2c_adapter *adapter)
{struct device *dev = &adapter->dev;int id;if (dev->of_node) {id = of_alias_get_id(dev->of_node, "i2c");if (id >= 0) {adapter->nr = id;return __i2c_add_numbered_adapter(adapter);}}mutex_lock(&core_lock);id = idr_alloc(&i2c_adapter_idr, adapter,__i2c_first_dynamic_bus_num, 0, GFP_KERNEL);mutex_unlock(&core_lock);if (WARN(id < 0, "couldn't get idr"))return id;adapter->nr = id;return i2c_register_adapter(adapter);
}
EXPORT_SYMBOL(i2c_add_adapter);

重点是i2c_register_adapter这个函数：

static int i2c_register_adapter(struct i2c_adapter *adap)
{int res = -EINVAL;/* Can't register until after driver model init */if (WARN_ON(!is_registered)) {res = -EAGAIN;goto out_list;}/* Sanity checks */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;}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);/* Set default timeout to 1 second if not already set */if (adap->timeout == 0)adap->timeout = HZ;/* register soft irqs for 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;}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_COMPATres = 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");
#endifi2c_init_recovery(adap);/* create pre-declared device nodes */of_i2c_register_devices(adap);i2c_acpi_register_devices(adap);i2c_acpi_install_space_handler(adap);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);return 0;out_list:mutex_lock(&core_lock);idr_remove(&i2c_adapter_idr, adap->nr);mutex_unlock(&core_lock);return res;
}

重点来了，查看i2c_scan_static_board_info(adap)函数，这个函数中会注册所有设备树中定义的设备。看代码：

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);
}
..............................
/*** i2c_new_device - instantiate an i2c device* @adap: the adapter managing the device* @info: describes one I2C device; bus_num is ignored* Context: can sleep** Create an i2c device. Binding is handled through driver model* probe()/remove() methods.  A driver may be bound to this device when we* return from this function, or any later moment (e.g. maybe hotplugging will* load the driver module).  This call is not appropriate for use by mainboard* initialization logic, which usually runs during an arch_initcall() long* before any i2c_adapter could exist.** This returns the new i2c client, which may be saved for later use with* i2c_unregister_device(); or NULL to indicate an error.*/
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;if (!client->irq)client->irq = i2c_dev_irq_from_resources(info->resources,info->num_resources);strlcpy(client->name, info->type, sizeof(client->name));status = i2c_check_addr_validity(client->addr, client->flags);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, i2c_encode_flags_to_addr(client));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;client->dev.fwnode = info->fwnode;i2c_dev_set_name(adap, client);if (info->properties) {status = device_add_properties(&client->dev, info->properties);if (status) {dev_err(&adap->dev,"Failed to add properties to client %s: %d\n",client->name, status);goto out_err;}}status = device_register(&client->dev);if (status)goto out_free_props;dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",client->name, dev_name(&client->dev));return client;out_free_props:if (info->properties)device_remove_properties(&client->dev);
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;
}
EXPORT_SYMBOL_GPL(i2c_new_device);

在i2c_register_adapter函数中，bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter)函数会遍历所有注册了的驱动。利用__process_new_adapter（）函数进行处理。

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 __process_new_adapter(struct device_driver *d, void *data)
{return i2c_do_add_adapter(to_i2c_driver(d), data);
}

该函数会检查驱动与适配器上所在总线上的设备是否匹配。

参考文章：
https://www.cnblogs.com/lknlfy/p/3265078.html