Linux I2C体系结构
Linux的I2C体系结构分为3个组成部分。
（1）I2C核心
I2C核心提供了I2C总线驱动和设备驱动的注册、注销方法，I2C通信方法（即Algorithm）上层的与具体适配器无关的代码以及探测设备、检测设备地址的上层代码等，如图15.1所示。
（2）I2C总线驱动
I2C总线驱动是对I2C硬件体系结构中适配器端的实现，适配器可由CPU控制，甚至可以直接集成在CPU内部。
I2C总线驱动主要包含I2C适配器数据结构i2c_adapter、I2C适配器的Algorithm数据结构i2c_algorithm和控制I2C适配器产生通信信号的函数。
经由I2C总线驱动的代码，我们可以控制I2C适配器以主控方式产生开始位、停止位、读写周期，以及以从设备方式被读写、产生ACK等。
（3）I2C设备驱动
I2C设备驱动（也称为客户驱动）是对I2C硬件体系结构中设备端的实现，设备一般挂接在受CPU控制的I2C适配器上，通过I2C适配器与CPU交换数据。
I2C设备驱动主要包含数据结构i2c_driver和i2c_client，我们需要根据具体设备实现其中的成员函数。
IIC-core(协议层）
I2C核心向内核注册了I2C总线，同时创建了一个适配器类（/sys/class/i2c-adapter），以便于后面向I2C总线注册适配器时在该适配器类下创建适配器设备。在I2C核心中，提供了I2C适配器和I2C设备驱动的注册、注销方法。
1） 增加/删除i2c_adapter
通过 i2c_add_adapter 接口将I2C适配器注册到I2C总线中。
通过 i2c_add_driver 接口将I2C设备驱动注册到I2C总线中。
int i2c_add_adapter(struct i2c_adapter *adap); void i2c_del_adapter(struct i2c_adapter *adap);
2） 增加/删除i2c_driver
int i2c_register_driver(struct module *owner, struct i2c_driver *driver); void i2c_del_driver(struct i2c_driver *driver); #define i2c_add_driver(driver) \ i2c_register_driver(THIS_MODULE, driver)
3） I2C传输、 发送和接收
int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num); int i2c_master_send(struct i2c_client *client,const char *buf ,int count); int i2c_master_recv(struct i2c_client *client, char *buf ,int count);
i2c_transfer（） 函数用于进行I2C适配器和I2C设备之间的一组消息交互， 其中第2个参数是一个指向i2c_msg数组的指针， 所以i2c_transfer（） 一次可以传输多个i2c_msg（考虑到很多外设的读写波形比较复杂， 比如读寄存器可能要先写， 所以需要两个以上的消息） 。 而对于时序比较简单的外设，i2c_master_send（） 函数和i2c_master_recv（） 函数内部会调用i2c_transfer（） 函数分别完成一条写消息和一条读消息。
struct bus_type i2c_bus_type = { .name = "i2c", .match = i2c_device_match,//match方法用来进行 device 和driver 的匹配，在向总线注册设备或是驱动的的时候会调用此方法 .probe = i2c_device_probe,//probe方法在完成设备和驱动的配对之后调用执行 .remove = i2c_device_remove, .shutdown = i2c_device_shutdown, };
static struct attribute *i2c_adapter_attrs[] = { &dev_attr_name.attr, &dev_attr_new_device.attr, &dev_attr_delete_device.attr, NULL }; ATTRIBUTE_GROUPS(i2c_adapter);
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);//注册IIC总线 if (retval) return retval; #ifdef CONFIG_I2C_COMPAT i2c_adapter_compat_class = class_compat_register("i2c-adapter"); if (!i2c_adapter_compat_class) { retval = -ENOMEM; goto bus_err; } #endif retval = 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)); return 0; class_err: #ifdef CONFIG_I2C_COMPAT class_compat_unregister(i2c_adapter_compat_class); bus_err: #endif bus_unregister(&i2c_bus_type); return retval; } static void __exit i2c_exit(void) { if (IS_ENABLED(CONFIG_OF_DYNAMIC)) WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier)); i2c_del_driver(&dummy_driver); #ifdef CONFIG_I2C_COMPAT class_compat_unregister(i2c_adapter_compat_class); #endif bus_unregister(&i2c_bus_type); tracepoint_synchronize_unregister(); } /* We must initialize early, because some subsystems register i2c drivers * in subsys_initcall() code, but are linked (and initialized) before i2c. */ postcore_initcall(i2c_init); module_exit(i2c_exit);
IIC总线驱动
首先来看一下 I2C 总线，在讲 platform 的时候就说过，platform 是虚拟出来的一条总线，
目的是为了实现总线、设备、驱动框架。对于 I2C 而言，不需要虚拟出一条总线，直接使用 I2C
总线即可。I2C 总线驱动重点是 I2C 适配器(也就是 SOC 的 I2C 接口控制器)驱动，这里要用到
两个重要的数据结构：i2c_adapter (IIc适配器） 和 i2c_algorithm (IIc算法），Linux 内核将 SOC 的 I2C 适配器(控制器)抽象成 i2c_adapter，i2c_adapter结构体定义在 include/linux/i2c.h 文件中，结构体内容如下
struct i2c_adapter {//描述一个i2c控制器 struct module *owner;//模块计数 unsigned int class; //允许探测的驱动类型 /* classes to allow probing for */ const struct i2c_algorithm *algo;//算法,指向适配器的驱动程序 /* the algorithm to access the bus */ void *algo_data; //指向适配器的私有数据，根据不同的情况使用方法不同 /* data fields that are valid for all devices */ struct rt_mutex bus_lock;//对总线进行操作时，将获得总线锁 int timeout; /* in jiffies */ int retries; struct device dev; //继承父类，也会加入到i2c bus /* the adapter device */ int nr;//标号 char name[48];//适配器名称 struct completion dev_released; //用于同步的完成量 struct mutex userspace_clients_lock; struct list_head userspace_clients; //连接总线上的设备的链表 struct i2c_bus_recovery_info *bus_recovery_info; const struct i2c_adapter_quirks *quirks; };
i2c_algorithm 类型的指针变量 algo，对于一个 I2C 适配器，肯定要对外提供读写 API 函数，设备驱动程序可以使用这些 API 函数来完成读写操作。i2c_algorithm 就是 I2C 适配器与 IIC 设备进行通信的方法。
i2c_algorithm 结构体定义在 include/linux/i2c.h 文件中，内容如下:
struct i2c_algorithm { /* If an adapter algorithm can't do I2C-level access, set master_xfer to NULL. If an adapter algorithm can do SMBus access, set smbus_xfer. If set to NULL, the SMBus protocol is simulated using common I2C messages */ /* master_xfer should return the number of messages successfully processed, or a negative value on error */ int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs, int num); /*传输函数指针，指向实现IIC总线通信协议的函数，用来确定适配器支持那些传输类型 */ int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr, unsigned short flags, char read_write, u8 command, int size, union i2c_smbus_data *data); /*smbus方式传输函数指针，指向实现SMBus总线通信协议的函数。SMBus和IIC之间可以通过软件方式兼容，所以这里提供了一个函数，但是一般都赋值为NULL*/ /* To determine what the adapter supports */ u32 (*functionality) (struct i2c_adapter *);/*返回适配器支持的功能*/ #if IS_ENABLED(CONFIG_I2C_SLAVE) int (*reg_slave)(struct i2c_client *client); int (*unreg_slave)(struct i2c_client *client); #endif };
master_xfer 就是 I2C 适配器的传输函数，可以通过此函数来完成与 IIC 设备之间的通信。
smbus_xfer 就是 SMBUS 总线的传输函数。
综上所述，I2C 总线驱动，或者说 I2C 适配器驱动的主要工作就是初始化 i2c_adapter 结构体变量，然后设置 i2c_algorithm 中的 master_xfer 函数。完成以后通过 i2c_add_numbered_adapter或 i2c_add_adapter 这两个函数向系统注册设置好的 i2c_adapter，这两个函数的原型如下：
int i2c_add_adapter(struct i2c_adapter *adapter) int i2c_add_numbered_adapter(struct i2c_adapter *adap)
这两个函数的区别在于 i2c_add_adapter 使用动态的总线号，而 i2c_add_numbered_adapter使用静态总线号。函数参数和返回值含义如下：
adapter 或 adap：要添加到 Linux 内核中的 i2c_adapter，也就是 I2C 适配器。
返回值：0，成功；负值，失败。
如果要删除 I2C 适配器的话使用 i2c_del_adapter 函数即可，函数原型如下：
void i2c_del_adapter(struct i2c_adapter * adap)
函数参数和返回值含义如下：
adap：要删除的 I2C 适配器。
返回值：无。
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 (id < 0) return id; adapter->nr = id; return i2c_register_adapter(adapter); }
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); } void i2c_del_adapter(struct i2c_adapter *adap) { struct i2c_adapter *found; struct i2c_client *client, *next; /* First make sure that this adapter was ever added */ mutex_lock(&core_lock); found = idr_find(&i2c_adapter_idr, adap->nr); mutex_unlock(&core_lock); if (found != adap) { pr_debug("i2c-core: attempting to delete unregistered " "adapter [%s]\n", adap->name); return; } acpi_i2c_remove_space_handler(adap); /* Tell drivers about this removal */ mutex_lock(&core_lock); bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_removed_adapter); mutex_unlock(&core_lock); /* Remove devices instantiated from sysfs */ mutex_lock_nested(&adap->userspace_clients_lock, i2c_adapter_depth(adap)); list_for_each_entry_safe(client, next, &adap->userspace_clients, detected) { dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name, client->addr); list_del(&client->detected); i2c_unregister_device(client); } mutex_unlock(&adap->userspace_clients_lock); /* Detach any active clients. This can't fail, thus we do not * check the returned value. This is a two-pass process, because * we can't remove the dummy devices during the first pass: they * could have been instantiated by real devices wishing to clean * them up properly, so we give them a chance to do that first. */ device_for_each_child(&adap->dev, NULL, __unregister_client); device_for_each_child(&adap->dev, NULL, __unregister_dummy); #ifdef CONFIG_I2C_COMPAT class_compat_remove_link(i2c_adapter_compat_class, &adap->dev, adap->dev.parent); #endif /* device name is gone after device_unregister */ dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name); /* wait until all references to the device are gone * * FIXME: This is old code and should ideally be replaced by an * alternative which results in decoupling the lifetime of the struct * device from the i2c_adapter, like spi or netdev do. Any solution * should be throughly tested with DEBUG_KOBJECT_RELEASE enabled! */ init_completion(&adap->dev_released); device_unregister(&adap->dev); wait_for_completion(&adap->dev_released); /* free bus id */ mutex_lock(&core_lock); idr_remove(&i2c_adapter_idr, adap->nr); mutex_unlock(&core_lock); /* Clear the device structure in case this adapter is ever going to be added again */ memset(&adap->dev, 0, sizeof(adap->dev)); }
IIC设备驱动
I2C 设备驱动重点关注两个数据结构： i2c_client 和 i2c_driver，根据总线、设备和驱动模型，I2C 总线上一小节已经讲了。还剩下设备和驱动， i2c_client 就是描述设备信息的， i2c_driver 描述驱动内容，类似于 platform_driver。
struct i2c_driver {//表示一个从设备的驱动对象 unsigned int class; //驱动的类型 /* Notifies the driver that a new bus has appeared. You should avoid * using this, it will be removed in a near future. */ int (*attach_adapter)(struct i2c_adapter *) __deprecated;//当检测到适配器时调用的函数 /* Standard driver model interfaces */ int (*probe)(struct i2c_client *, const struct i2c_device_id *);//新类型设备探测函数 int (*remove)(struct i2c_client *);//新类型设备的移除函数 /* driver model interfaces that don't relate to enumeration */ void (*shutdown)(struct i2c_client *);//新类型设备的移除函数 /* Alert callback, for example for the SMBus alert protocol. * The format and meaning of the data value depends on the protocol. * For the SMBus alert protocol, there is a single bit of data passed * as the alert response's low bit ("event flag"). */ void (*alert)(struct i2c_client *, unsigned int data); /* a ioctl like command that can be used to perform specific functions * with the device. */ int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);//使用命令使设备完成特殊的功能。类似ioctl（）函数 struct device_driver driver;//继承了父类,设备驱动结构体 const struct i2c_device_id *id_table;//用于做比对，非设备树的情况,//设备ID表 /* Device detection callback for automatic device creation */ int (*detect)(struct i2c_client *, struct i2c_board_info *);//设备所在的地址范围 const unsigned short *address_list;//设备所在的地址范围 struct list_head clients;//指向驱动支持的设备 };
i2c_client 结构体
i2c_client 结构体定义在 include/linux/i2c.h 文件中，内容如下：
struct i2c_client {//描述一个从设备的信息，不需要在代码中创建，i2c adapter帮我们创建 unsigned short flags; /* div., see below */ unsigned short addr;//从设备地址，来自于设备树中<reg> /* chip address - NOTE: 7bit */ /* addresses are stored in the */ /* _LOWER_ 7 bits */ char name[I2C_NAME_SIZE];//用于i2c driver进行匹配，来自于设备树中compatible struct i2c_adapter *adapter;//指向当前从设备所存在的i2c_adapter /* the adapter we sit on */ struct device dev; //继承了父类 /* the device structure */ int irq; //设备申请的中断号 /* irq issued by device */ struct list_head detected;//设备申请的中断号 #if IS_ENABLED(CONFIG_I2C_SLAVE) i2c_slave_cb_t slave_cb; /* callback for slave mode */ #endif
};
I.MX6U 的 I2C 适配器驱动分析
I2C 适配器驱动就是 SOC 的 I2C 控制器驱动。 I2C 设备驱动是需要用户根据不同的 I2C 设备去编写，而 I2C 适配器驱动一般都是 SOC 厂商去编写的，比如 NXP 就编写好了 I.MX6U 的I2C 适配器驱动。在 imx6ull.dtsi 文件中找到 I.MX6U 的 I2C1 控制器节点，节点内容如下所示：
i2c1: i2c@021a0000 { #address-cells = <1>; #size-cells = <0>; compatible = "fsl,imx6ul-i2c", "fsl,imx21-i2c"; reg = <0x021a0000 0x4000>; interrupts = <GIC_SPI 36 IRQ_TYPE_LEVEL_HIGH>; clocks = <&clks IMX6UL_CLK_I2C1>; status = "disabled"; }; i2c2: i2c@021a4000 { #address-cells = <1>; #size-cells = <0>; compatible = "fsl,imx6ul-i2c", "fsl,imx21-i2c"; reg = <0x021a4000 0x4000>; interrupts = <GIC_SPI 37 IRQ_TYPE_LEVEL_HIGH>; clocks = <&clks IMX6UL_CLK_I2C2>; status = "disabled"; }; i2c3: i2c@021a8000 { #address-cells = <1>; #size-cells = <0>; compatible = "fsl,imx6ul-i2c", "fsl,imx21-i2c"; reg = <0x021a8000 0x4000>; interrupts = <GIC_SPI 38 IRQ_TYPE_LEVEL_HIGH>; clocks = <&clks IMX6UL_CLK_I2C3>; status = "disabled"; }; i2c4: i2c@021f8000 { #address-cells = <1>; #size-cells = <0>; compatible = "fsl,imx6ul-i2c", "fsl,imx21-i2c"; reg = <0x021f8000 0x4000>; interrupts = <GIC_SPI 35 IRQ_TYPE_LEVEL_HIGH>; clocks = <&clks IMX6UL_CLK_I2C4>; status = "disabled"; };
重点关注 i2c1 节点的 compatible 属性值，因为通过 compatible 属性值可以在 Linux 源码里面找到对应的驱动文件。这里i2c1节点的compatible属性值有两个：“fsl,imx6ul-i2c”和“fsl,imx21-i2c”，在 Linux 源码中搜索这两个字符串即可找到对应的驱动文件。 I.MX6U 的 I2C 适配器驱动驱动文件为 drivers/i2c/busses/i2c-imx.c，在此文件中有如下内容：
/* 定义i2c硬件数据结构体 */ struct imx_i2c_hwdata { enum imx_i2c_type devtype; // i2c类型 unsigned regshift; // 寄存器偏移量 struct imx_i2c_clk_pair *clk_div; // 时钟分频器 unsigned ndivs; // 分频器数量 unsigned i2sr_clr_opcode; // I2SR清除操作码 unsigned i2cr_ien_opcode; // I2CR使能操作码 }; /* 定义i2c硬件数据结构体 */ struct imx_i2c_dma { struct dma_chan *chan_tx; // DMA发送通道 struct dma_chan *chan_rx; // DMA接收通道 struct dma_chan *chan_using; // DMA使用通道 struct completion cmd_complete; // DMA完成标志 dma_addr_t dma_buf; // DMA缓存地址 unsigned int dma_len; // DMA缓存长度 enum dma_transfer_direction dma_transfer_dir; // DMA传输方向 enum dma_data_direction dma_data_dir; // DMA数据方向 }; /* 定义i2c硬件数据结构体 */ struct imx_i2c_struct { struct i2c_adapter adapter; // i2c适配器 struct clk *clk; // 时钟 void __iomem *base; // 基地址 wait_queue_head_t queue; // 等待队列 unsigned long i2csr; // i2c状态寄存器 unsigned int disable_delay; // 延迟时间 int stopped; // 是否停止 unsigned int ifdr; /* IMX_I2C_IFDR */ // i2c频率分频器 unsigned int cur_clk; // 当前时钟 unsigned int bitrate; // 位率 const struct imx_i2c_hwdata *hwdata; // i2c硬件数据结构体 struct imx_i2c_dma *dma; // DMA结构体 };
static struct platform_device_id imx_i2c_devtype[] = { { .name = "imx1-i2c", .driver_data = (kernel_ulong_t)&imx1_i2c_hwdata, }, { .name = "imx21-i2c", .driver_data = (kernel_ulong_t)&imx21_i2c_hwdata, }, { /* sentinel */ } }; MODULE_DEVICE_TABLE(platform, imx_i2c_devtype); 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, }, { /* sentinel */ } };
static struct platform_driver i2c_imx_driver = { .probe = i2c_imx_probe, .remove = i2c_imx_remove, .driver = { .name = DRIVER_NAME, .owner = THIS_MODULE, .of_match_table = i2c_imx_dt_ids, .pm = IMX_I2C_PM, }, .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);
I.MX6U 的 I2C 适配器驱动是个标准的 platform 驱动，由此可以看出，虽然 I2C 总线为别的设备提供了一种总线驱动框架，但是 I2C 适配器却是 platform驱动。就像你的部门老大是你的领导，你是他的下属，但是放到整个公司，你的部门老大却也是老板的下属。
“fsl,imx21-i2c”属性值，设备树中 i2c1 节点的 compatible 属性值就是与此匹配上的。因此i2c-imx.c 文件就是 I.MX6U 的 I2C 适配器驱动文件。
当设备和驱动匹配成功以后 i2c_imx_probe 函数就会执行i2c_imx_probe 函数就会完成 I2C 适配器初始化工作。
i2c_imx_probe 函数内容如下所示：
static int i2c_imx_probe(struct platform_device *pdev) { /* 获取设备树中的设备ID */ const struct of_device_id *of_id = of_match_device(i2c_imx_dt_ids, &pdev->dev); /* 定义i2c_imx结构体 */ 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地址 */ 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结构体 */ i2c_imx = devm_kzalloc(&pdev->dev, sizeof(*i2c_imx), GFP_KERNEL); if (!i2c_imx) return -ENOMEM; if (of_id) /* 获取设备树中的设备ID */ i2c_imx->hwdata = of_id->data; else /* 获取平台数据 */ i2c_imx->hwdata = (struct imx_i2c_hwdata *) platform_get_device_id(pdev)->driver_data; /* 设置i2c_imx驱动结构体 */ 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; /* 获取I2C时钟 */ 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"); /* 获取I2C时钟失败 */ if (ret) { dev_err(&pdev->dev, "can't enable I2C clock\n"); /* 使能I2C时钟失败 */ IRQF_NO_SUSPEND, pdev->name, i2c_imx); if (ret) { dev_err(&pdev->dev, "can't claim irq %d\n", irq); goto clk_disable; } /* 设置适配器数据 */ i2c_set_adapdata(&i2c_imx->adapter, i2c_imx); /* 设置时钟分频 */ 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; /* 读取时钟频率失败 */ /* 设置芯片寄存器为默认值 */ 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); /* 添加I2C适配器 */ ret = i2c_add_numbered_adapter(&i2c_imx->adapter); if (ret < 0) { dev_err(&pdev->dev, "registration failed\n"); goto clk_disable; } /* 设置平台驱动数据 */ platform_set_drvdata(pdev, i2c_imx); clk_disable_unprepare(i2c_imx->clk); 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"); /* 如果支持DMA，则初始化DMA配置 */ i2c_imx_dma_request(i2c_imx, phy_addr); return 0; /* 返回OK */ clk_disable: clk_disable_unprepare(i2c_imx->clk); return ret; }
- 调用 platform_get_irq 函数获取中断号。
- 调用 platform_get_resource 函数从设备树中获取 I2C1 控制器寄存器物理基地址，也就是 0X021A0000。获取到寄存器基地址以后使用 devm_ioremap_resource 函数对其进行内存映射，得到可以在Linux 内核中使用的虚拟地址。
- NXP 使用 imx_i2c_struct 结构体来表示 I.MX 系列 SOC 的 I2C 控制器，这里使用 devm_kzalloc 函数来申请内存。
- imx_i2c_struct 结构体要有个叫做 adapter 的成员变量，adapter 就是i2c_adapter，这里初始化i2c_adapter。第1009 行设置i2c_adapter 的algo 成员变量为i2c_imx_algo，也就是设置i2c_algorithm。
- 注册 I2C 控制器中断，中断服务函数为 i2c_imx_isr。
设置 I2C 频率默认为 IMX_I2C_BIT_RATE=100KHz，如果设备树节点设置了“clock-frequency”属性的话 I2C 频率就使用 clock-frequency 属性值。 - 设置 I2C1 控制的 I2CR 和 I2SR 寄存器。
- 调用 i2c_add_numbered_adapter 函数向 Linux 内核注册 i2c_adapter。
- 申请 DMA，看来 I.MX 的 I2C 适配器驱动采用了DMA 方式。
i2c_imx_probe 函数主要的工作就是一下两点：
①、初始化 i2c_adapter，设置 i2c_algorithm 为 i2c_imx_algo，最后向 Linux 内核注册i2c_adapter。
②、初始化 I2C1 控制器的相关寄存器。
i2c_imx_algo 包含 I2C1 适配器与 I2C 设备的通信函数 master_xfer，i2c_imx_algo 结构体定义如下：
static struct i2c_algorithm i2c_imx_algo = {
.master_xfer = i2c_imx_xfer,
.functionality = i2c_imx_func,
};
. functionality， functionality用于返回此I2C适配器支持什么样的通信协议，在这里 functionality 就是 i2c_imx_func 函数， i2c_imx_func 函数内容如下：
static u32 i2c_imx_func(struct i2c_adapter *adapter) { return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_SMBUS_READ_BLOCK_DATA; }
重点来看一下 i2c_imx_xfer 函数，因为最终就是通过此函数来完成与 I2C 设备通信的， 此函数内容如下：
static int i2c_imx_xfer(struct i2c_adapter *adapter, struct i2c_msg *msgs, int num) { unsigned int i, temp; int result; bool is_lastmsg = false; struct imx_i2c_struct *i2c_imx = i2c_get_adapdata(adapter); /* 开始I2C传输 */ result = i2c_imx_start(i2c_imx); if (result) goto fail0; /* 读写数据 */ for (i = 0; i < num; i++) { if (i == num - 1) is_lastmsg = true; if (i) { /* 重复开始 */ dev_dbg(&i2c_imx->adapter.dev, "<%s> repeated start\n", __func__); temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR); temp |= I2CR_RSTA; imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR); result = i2c_imx_bus_busy(i2c_imx, 1); if (result) goto fail0; } /* 调试信息 */ dev_dbg(&i2c_imx->adapter.dev, "<%s> transfer message: %d\n", __func__, i); /* 写/读数据 */ #ifdef CONFIG_I2C_DEBUG_BUS /* 读取I2C控制寄存器 */ temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR); dev_dbg(&i2c_imx->adapter.dev, "<%s> CONTROL: IEN=%d, IIEN=%d, MSTA=%d, MTX=%d, TXAK=%d, RSTA=%d\n", __func__, (temp & I2CR_IEN ? 1 : 0), (temp & I2CR_IIEN ? 1 : 0), (temp & I2CR_MSTA ? 1 : 0), (temp & I2CR_MTX ? 1 : 0), (temp & I2CR_TXAK ? 1 : 0), (temp & I2CR_RSTA ? 1 : 0)); temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2SR); dev_dbg(&i2c_imx->adapter.dev, "<%s> STATUS: ICF=%d, IAAS=%d, IBB=%d, IAL=%d, SRW=%d, IIF=%d, RXAK=%d\n", __func__, (temp & I2SR_ICF ? 1 : 0), (temp & I2SR_IAAS ? 1 : 0), (temp & I2SR_IBB ? 1 : 0), (temp & I2SR_IAL ? 1 : 0), (temp & I2SR_SRW ? 1 : 0), (temp & I2SR_IIF ? 1 : 0), (temp & I2SR_RXAK ? 1 : 0)); #endif if (msgs[i].flags & I2C_M_RD) result = i2c_imx_read(i2c_imx, &msgs[i], is_lastmsg); // 读数据 else { if (i2c_imx->dma && msgs[i].len >= DMA_THRESHOLD) result = i2c_imx_dma_write(i2c_imx, &msgs[i]); // DMA写数据 else result = i2c_imx_write(i2c_imx, &msgs[i]); // 写数据 } if (result) goto fail0; } fail0: /* 停止I2C传输 */ i2c_imx_stop(i2c_imx); dev_dbg(&i2c_imx->adapter.dev, "<%s> exit with: %s: %d\n", __func__, (result < 0) ? "error" : "success msg", (result < 0) ? result : num); return (result < 0) ? result : num; }
- 调用 i2c_imx_start 函数开启 I2C 通信。
- 如果是从 I2C 设备读数据的话就调用 i2c_imx_read 函数。
- 向 I2C 设备写数据，如果要用 DMA 的话就使用 i2c_imx_dma_write 函数来完成写数据。如果不使用DMA 的话就使用i2c_imx_write 函数完成写数据。
- I2C 通信完成以后调用 i2c_imx_stop 函数停止 I2C 通信。
- i2c_imx_start、i2c_imx_read、i2c_imx_write 和 i2c_imx_stop 这些函数就是 I2C 寄存器的具体操作函数
I2C 设备驱动编写流程
1、未使用设备树的时候
首先肯定要描述 I2C 设备节点信息，先来看一下没有使用设备树的时候是如何在 BSP 里面描述 I2C 设备信息的，在未使用设备树的时候需要在 BSP 里面使用 i2c_board_info 结构体来描述一个具体的I2C 设备。i2c_board_info 结构体如下：
示例代码 i2c_board_info 结构体
295 struct i2c_board_info { 296 char type[I2C_NAME_SIZE]; /* I2C 设备名字 /297 unsigned short flags; / 标志 /298 unsigned short addr; / I2C 器件地址 */ 299 void *platform_data; 300 struct dev_archdata *archdata; 301 struct device_node *of_node; 302 struct fwnode_handle *fwnode; 303 int irq; 304 };
type 和 addr 这两个成员变量是必须要设置的，一个是 I2C 设备的名字，一个是 I2C 设备的器件地址。打开 arch/arm/mach-imx/mach-mx27_3ds.c 文件，此文件中关于 OV2640 的 I2C 设备信息描述如下：
示例代码 OV2640 的 I2C 设备信息
392 static struct i2c_board_info mx27_3ds_i2c_camera = { 393 I2C_BOARD_INFO("ov2640", 0x30), 394 };
示例代码 中使用 I2C_BOARD_INFO 来完成mx27_3ds_i2c_camera 的初始化工作，I2C_BOARD_INFO 是一个宏，定义如下：
示例代码 I2C_BOARD_INFO 宏
316 #define I2C_BOARD_INFO(dev_type, dev_addr) 317 .type = dev_type, .addr = (dev_addr)
可以看出，I2C_BOARD_INFO 宏其实就是设置 i2c_board_info 的 type 和 addr 这两个成员变量，因此示例代码 61.3.1.2 的主要工作就是设置 I2C 设备名字为ov2640，ov2640 的器件地址为 0X30。
大家可以在 Linux 源码里面全局搜索i2c_board_info，会找到大量以i2c_board_info 定义的I2C 设备信息，这些就是未使用设备树的时候 I2C 设备的描述方式，当采用了设备树以后就不会再使用 i2c_board_info 来描述 I2C 设备了。
2、使用设备树的时候
使用设备树的时候 I2C 设备信息通过创建相应的节点就行了，比如NXP 官方的 EVK 开发板在 I2C1 上接了 mag3110 这个磁力计芯片，因此必须在 i2c1 节点下创建 mag3110 子节点，然后在这个子节点内描述 mag3110 这个芯片的相关信息。打开 imx6ull-14x14-evk.dts 这个设备树文件，然后找到如下内容：
示例代码 mag3110 子节点
1 &i2c1 { 2 clock-frequency = <100000>; 3 pinctrl-names = "default"; 4 pinctrl-0 = <&pinctrl_i2c1>; 5 status = "okay"; 6 7 mag3110@0e { 8 compatible = "fsl,mag3110"; 9 reg = <0x0e>; 10 position = <2>; 11 }; ...... 20 };
第 7~11 行，向 i2c1 添加 mag3110 子节点，第 7 行“mag3110@0e”是子节点名字，“@”后面的“0e”就是 mag3110 的 I2C 器件地址。第 8 行设置 compatible 属性值为“fsl,mag3110”。第 9 行的 reg 属性也是设置 mag3110 的器件地址的，因此值为 0x0e。I2C 设备节点的创建重点是 compatible 属性和 reg 属性的设置，一个用于匹配驱动，一个用于设置器件地址。
I2C 设备数据收发处理流程
I2C 设备驱动首先要做的就是初始化 i2c_driver 并向 Linux 内核注册。当设备和驱动匹配以后 i2c_driver 里面的 probe 函数就会执行，probe 函数里面所做的就是字符设备驱动那一套了。一般需要在 probe 函数里面初始化 I2C 设备，要初始化 I2C 设备就必须能够对I2C 设备寄存器进行读写操作，这里就要用到 i2c_transfer 函数了。i2c_transfer 函数最终会调用 I2C 适配器中 i2c_algorithm 里面的 master_xfer 函数，对于 I.MX6U 而言就是i2c_imx_xfer 这个函数。i2c_transfer 函数原型如下：
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num) { int ret; /* 该处的错误报告模型存在问题： * * - 当我们在从从设备接收N个字节后出现错误时，没有办法报告“N”。 * * - 当我们在向从设备传输N个字节后收到NAK时，没有办法报告“N”……或者让主设备继续执行此组合消息的其余部分，如果这是适当的响应。 * * - 当例如“num”为2时，我们成功完成第一个消息，但在第二个消息的部分中出现错误时，不清楚是应报告为一个（丢弃第二个消息的状态）还是errno（丢弃第一个消息的状态）。 */ 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活动正在进行中。 */ return -EAGAIN; } else { i2c_lock_adapter(adap); } ret = __i2c_transfer(adap, msgs, num); i2c_unlock_adapter(adap); return ret; } else { dev_dbg(&adap->dev, "I2C level transfers not supported\n"); return -EOPNOTSUPP; } }
函数参数和返回值含义如下：
adap：所使用的 I2C 适配器，i2c_client 会保存其对应的 i2c_adapter。
msgs：I2C 要发送的一个或多个消息。
num：消息数量，也就是msgs 的数量。
返回值：负值，失败，其他非负值，发送的 msgs 数量。
我们重点来看一下 msgs 这个参数，这是一个 i2c_msg 类型的指针参数，I2C 进行数据收发说白了就是消息的传递，Linux 内核使用 i2c_msg 结构体来描述一个消息。i2c_msg 结构体定义在 include/uapi/linux/i2c.h 文件中，结构体内容如下：
示例代码 i2c_msg 结构体
68 struct i2c_msg { 69 u16 addr; /* 从机地址 */ 70 u16 flags; /* 标志 */ 71 #define I2C_M_TEN 0x0010 72 #define I2C_M_RD 0x0001 73 #define I2C_M_STOP 0x8000 74 #define I2C_M_NOSTART 0x4000 75 #define I2C_M_REV_DIR_ADDR 0x2000 76 #define I2C_M_IGNORE_NAK 0x1000 77 #define I2C_M_NO_RD_ACK 0x0800 78 #define I2C_M_RECV_LEN 0x0400 79 u16 len; /* 消息(本 msg)长度 */ 80 u8 buf; / 消息数据 */ 81 };
使用 i2c_transfer 函数发送数据之前要先构建好 i2c_msg，使用 i2c_transfer 进行 I2C 数据收发的示例代码如下：
示例代码I2C 设备多寄存器数据读写
/* 设备结构体 */ struct xxx_dev { ...... void private_data; /* 私有数据，一般会设置为 i2c_client */ }; /* * @description : 读取 I2C 设备多个寄存器数据 * @param – dev : I2C 设备 * @param – reg : 要读取的寄存器首地址 * @param – val : 读取到的数据 * @param – len : 要读取的数据长度 * @return : 操作结果 */ static int xxx_read_regs(struct xxx_dev *dev, u8 reg, void *val,int len) { int ret; struct i2c_msg msg[2]; struct i2c_client *client = (struct i2c_client *)dev->private_data; /* msg[0]，第一条写消息，发送要读取的寄存器首地址 */ msg[0].addr = client->addr; /* I2C 器件地址 */ msg[0].flags = 0; /*标记为发送数据 * / msg[0].buf = ® /* 读取的首地址 */ msg[0].len = 1; /* reg 长度 */ /* msg[1]，第二条读消息，读取寄存器数据 */ msg[1].addr = client->addr; /* I2C 器件地址 * / msg[1].flags = I2C_M_RD; /* 标记为读取数据 */ msg[1].buf = val; /* 读取数据缓冲区 */ msg[1].len = len; /* 要读取的数据长度 */ ret = i2c_transfer(client->adapter, msg, 2); if(ret == 2) { ret = 0; } else { ret = -EREMOTEIO; } return ret; } /* * @description : 向 I2C 设备多个寄存器写入数据 * @param – dev : 要写入的设备结构体 * @param – reg : 要写入的寄存器首地址 * @param – buf : 要写入的数据缓冲区 * @param – len : 要写入的数据长度 * @return : 操作结果 */ static s32 xxx_write_regs(struct xxx_dev *dev, u8 reg, u8 *buf, u8 len) { u8 b[256]; struct i2c_msg msg; struct i2c_client *client = (struct i2c_client *) dev->private_data; b[0] = reg; /* 寄存器首地址 */ memcpy(&b[1],buf,len); /* 将要发送的数据拷贝到数组 b 里面*/ msg.addr = client->addr; /* I2C 器件地址 */ msg.flags = 0; /* 标记为写数据 */ msg.buf = b; /* 要发送的数据缓冲区 */ msg.len = len + 1; /* 要发送的数据长度 */ return i2c_transfer(client->adapter, &msg, 1); }
- 第2~5 行，设备结构体，在设备结构体里面添加一个执行void 的指针成员变量private_data，此成员变量用于保存设备的私有数据。在 I2C 设备驱动中我们一般将其指向 I2C 设备对应的i2c_client。
- 第 15~40 行，xxx_read_regs 函数用于读取 I2C 设备多个寄存器数据。第 18 行定义了一个i2c_msg 数组，2 个数组元素，因为 I2C 读取数据的时候要先发送要读取的寄存器地址，然后再读取数据，所以需要准备两个 i2c_msg。一个用于发送寄存器地址，一个用于读取寄存器值。对于 msg[0]，将 flags 设置为 0，表示写数据。msg[0]的 addr 是 I2C 设备的器件地址，msg[0]的 buf
成员变量就是要读取的寄存器地址。对于 msg[1]，将 flags 设置为 I2C_M_RD，表示读取数据。msg[1]的 buf 成员变量用于保存读取到的数据，len 成员变量就是要读取的数据长度。调用i2c_transfer 函数完成 I2C 数据读操作。 - 第 50~66 行，xxx_write_regs 函数用于向 I2C 设备多个寄存器写数据，I2C 写操作要比读操作简单一点，因此一个 i2c_msg 即可。数组 b 用于存放寄存器首地址和要发送的数据，第 59 行设置 msg 的 addr 为 I2C 器件地址。第 60 行设置 msg 的 flags 为 0，也就是写数据。第 62 行设置要发送的数据，也就是数组 b。第 63 行设置 msg 的 len 为 len+1，因为要加上一个字节的寄存器地址。最后通过 i2c_transfer 函数完成向 I2C 设备的写操作。
另外还有两个API函数分别用于I2C 数据的收发操作，这两个函数最终都会调用i2c_transfer。首先来看一下I2C 数据发送函数 i2c_master_send，函数原型如下：
//写从设备 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; msg.flags = client->flags & I2C_M_TEN; 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; }
函数参数和返回值含义如下：
client：I2C 设备对应的 i2c_client。
buf：要发送的数据。
count：要发送的数据字节数，要小于 64KB，以为 i2c_msg 的 len 成员变量是一个 u16(无
符号 16 位)类型的数据。
返回值：负值，失败，其他非负值，发送的字节数。
I2C 数据接收函数为 i2c_master_recv，函数原型如下：
/
/读从设备 int i2c_master_recv(const struct i2c_client *client, char *buf, int count) { struct i2c_adapter *adap = client->adapter; struct i2c_msg msg; int ret; msg.addr = client->addr; msg.flags = client->flags & I2C_M_TEN; msg.flags |= I2C_M_RD; msg.len = count; msg.buf = buf; ret = i2c_transfer(adap, &msg, 1); /* * If everything went ok (i.e. 1 msg received), return #bytes received, * else error code. */ return (ret == 1) ? count : ret;
}
函数参数和返回值含义如下：
client：I2C 设备对应的 i2c_client。 buf：要接收的数据。
count：要接收的数据字节数，要小于 64KB，以为 i2c_msg 的 len 成员变量是一个 u16(无
符号 16 位)类型的数据。
返回值：负值，失败，其他非负值，发送的字节数。
关于 Linux 下 I2C 设备驱动的编写流程就讲解到这里，重点就是 i2c_msg 的构建和i2c_transfer 函数的调用，接下来我们就编写AP3216C 这个 I2C 设备的Linux 驱动。
