总线驱动---IIC驱动

总线驱动—IIC驱动

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 = &reg               /* 读取的首地址      */
     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 驱动。

ap3216c实例

1、 IO 修改或添加

首先肯定是要修改 IO，AP3216C 用到了 I2C1 接口，I.MX6U-ALPHA 开发板上的 I2C1 接口使用到了UART4_TXD 和 UART4_RXD，因此肯定要在设备树里面设置这两个 IO。如果要用到 AP3216C 的中断功能的话还需要初始化 AP_INT 对应的 GIO1_IO01 这个 IO，本章实验我们不使用中断功能。因此只需要设置UART4_TXD 和UART4_RXD 这两个 IO，NXP 其实已经将他这两个 IO 设置好了，打开 imx6ull-alientek-emmc.dts，然后找到如下内容：

pinctrl_i2c1: i2c1grp {
    fsl,pins = <
       MX6UL_PAD_UART4_TX_DATA  I2C1_SCL 0x4001b8b0
       MX6UL_PAD_UART4_RX_DATA  I2C1_SDA 0x4001b8b0
    >;
 };

pinctrl_i2c1 就是 I2C1 的 IO 节点，这里将 UART4_TXD 和 UART4_RXD 这两个 IO 分别复用为 I2C1_SCL 和 I2C1_SDA，电气属性都设置为 0x4001b8b0。

2、在 i2c1 节点追加 ap3216c 子节点

AP3216C 是连接到 I2C1 上的，因此需要在 i2c1 节点下添加 ap3216c 的设备子节点，在imx6ull-alientek-emmc.dts 文件中找到 i2c1 节点，此节点默认内容如下：

&i2c1 {
   clock-frequency = <100000>;
   pinctrl-names = "default";
   pinctrl-0 = <&pinctrl_i2c1>;
   status = "okay";


mag3110@0e {
     compatible = "fsl,mag3110";
      reg = <0x0e>;
      position = <2>;
    };

  fxls8471@1e {
      compatible = "fsl,fxls8471";
       reg = <0x1e>;
       position = <0>;
      interrupt-parent = <&gpio5>;
      interrupts = <0 8>;
   };
};

• 第 2 行， clock-frequency 属性为 I2C 频率，这里设置为 100KHz。第 4 行， pinctrl-0 属性指定 I2C 所使用的 IO 为示例代码 中的 pinctrl_i2c1 子节点。
• 第 7~11 行， mag3110 是个磁力计， NXP 官方的 EVK 开发板上接了 mag3110，因此 NXP在 i2c1 节点下添加了 mag3110 这个子节点。正点原子的 I.MX6U-ALPHA 开发板上没有用到mag3110，因此需要将此节点删除掉。第 13~19 行， NXP 官方 EVK 开发板也接了一个 fxls8471，正点原子的 I.MX6U-ALPHA开发板同样没有此器件，所以也要将其删除掉。将 i2c1 节点里面原有的 mag3110 和 fxls8471 这两个 I2C 子节点删除，然后添加 ap3216c子节点信息，完成以后的 i2c1 节点内容如下所示：

 &i2c1 {
     clock-frequency = <100000>;
     pinctrl-names = "default";
    pinctrl-0 = <&pinctrl_i2c1>;
    status = "okay";

ap3216c@1e {
       compatible = "alientek,ap3216c";
       reg = <0x1e>;
    };

};

• 第 7 行，ap3216c 子节点，@后面的“1e”是 ap3216c 的器件地址。
• 第 8 行，设置 compatible 值为“alientek,ap3216c”。
• 第 9 行，reg 属性也是设置 ap3216c 器件地址的，因此 reg 设置为 0x1e。
  设备树修改完成以后使用“make dtbs”重新编译一下，然后使用新的设备树启动Linux 内
  核。/sys/bus/i2c/devices 目录下存放着所有 I2C 设备， 如果设备树修改正确的话， 会在/sys/bus/i2c/devices 目录下看到一个名为“0-001e”的子目录

3.驱动

ap3216creg.h

#ifndef AP3216C_H
#define AP3216C_H


#define AP3216C_ADDR        0X1E    /* AP3216C器件地址  */

/* AP3316C寄存器 */
#define AP3216C_SYSTEMCONG  0x00    /* 配置寄存器       */
#define AP3216C_INTSTATUS   0X01    /* 中断状态寄存器   */
#define AP3216C_INTCLEAR    0X02    /* 中断清除寄存器   */
#define AP3216C_IRDATALOW   0x0A    /* IR数据低字节     */
#define AP3216C_IRDATAHIGH  0x0B    /* IR数据高字节     */
#define AP3216C_ALSDATALOW  0x0C    /* ALS数据低字节    */
#define AP3216C_ALSDATAHIGH 0X0D    /* ALS数据高字节    */
#define AP3216C_PSDATALOW   0X0E    /* PS数据低字节     */
#define AP3216C_PSDATAHIGH  0X0F    /* PS数据高字节     */


#endif

ap3216c.c

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/i2c.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include "ap3216creg.h"

#define AP3216C_CNT 1
#define AP3216C_NAME    "ap3216c"

struct ap3216c_dev {
    dev_t devid;            /* 设备号   */
    struct cdev cdev;       /* cdev     */
    struct class *class;    /* 类        */
    struct device *device;  /* 设备    */
    struct device_node  *nd; /* 设备节点 */
    int major;          /* 主设备号 */
    void *private_data; /* 私有数据 */
    unsigned short ir, als, ps;     /* 三个光传感器数据 */
};

static struct ap3216c_dev ap3216cdev;

/*
 * @description : 从ap3216c读取多个寄存器数据
 * @param - dev:  ap3216c设备
 * @param - reg:  要读取的寄存器首地址
 * @param - val:  读取到的数据
 * @param - len:  要读取的数据长度
 * @return      : 操作结果
 */
static int ap3216c_read_regs(struct ap3216c_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;         /* ap3216c地址 */
    msg[0].flags = 0;                   /* 标记为发送数据 */
    msg[0].buf = &reg;                  /* 读取的首地址 */
    msg[0].len = 1;                     /* reg长度*/

    /* msg[1]读取数据 */
    msg[1].addr = client->addr;         /* ap3216c地址 */
    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 {
        printk("i2c rd failed=%d reg=%06x len=%d\n",ret, reg, len);
        ret = -EREMOTEIO;
    }
    return ret;
}

/*
 * @description : 向ap3216c多个寄存器写入数据
 * @param - dev:  ap3216c设备
 * @param - reg:  要写入的寄存器首地址
 * @param - val:  要写入的数据缓冲区
 * @param - len:  要写入的数据长度
 * @return    :   操作结果
 */
static s32 ap3216c_write_regs(struct ap3216c_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;    /* ap3216c地址 */
    msg.flags = 0;              /* 标记为写数据 */

    msg.buf = b;                /* 要写入的数据缓冲区 */
    msg.len = len + 1;          /* 要写入的数据长度 */

    return i2c_transfer(client->adapter, &msg, 1);
}

/*
 * @description : 读取ap3216c指定寄存器值，读取一个寄存器
 * @param - dev:  ap3216c设备
 * @param - reg:  要读取的寄存器
 * @return    :   读取到的寄存器值
 */
static unsigned char ap3216c_read_reg(struct ap3216c_dev *dev, u8 reg)
{
    u8 data = 0;

    ap3216c_read_regs(dev, reg, &data, 1);
    return data;

#if 0
    struct i2c_client *client = (struct i2c_client *)dev->private_data;
    return i2c_smbus_read_byte_data(client, reg);
#endif
}

/*
 * @description : 向ap3216c指定寄存器写入指定的值，写一个寄存器
 * @param - dev:  ap3216c设备
 * @param - reg:  要写的寄存器
 * @param - data: 要写入的值
 * @return   :    无
 */
static void ap3216c_write_reg(struct ap3216c_dev *dev, u8 reg, u8 data)
{
    u8 buf = 0;
    buf = data;
    ap3216c_write_regs(dev, reg, &buf, 1);
}

/*
 * @description : 读取AP3216C的数据，读取原始数据，包括ALS,PS和IR, 注意！
 *              : 如果同时打开ALS,IR+PS的话两次数据读取的时间间隔要大于112.5ms
 * @param - ir  : ir数据
 * @param - ps  : ps数据
 * @param - ps  : als数据 
 * @return      : 无。
 */
void ap3216c_readdata(struct ap3216c_dev *dev)
{
    unsigned char i =0;
    unsigned char buf[6];
    
    /* 循环读取所有传感器数据 */
    for(i = 0; i < 6; i++)  
    {
        buf[i] = ap3216c_read_reg(dev, AP3216C_IRDATALOW + i);  
    }

    if(buf[0] & 0X80)   /* IR_OF位为1,则数据无效 */
        dev->ir = 0;                    
    else                /* 读取IR传感器的数据           */
        dev->ir = ((unsigned short)buf[1] << 2) | (buf[0] & 0X03);          
    
    dev->als = ((unsigned short)buf[3] << 8) | buf[2];  /* 读取ALS传感器的数据           */  
    
    if(buf[4] & 0x40)   /* IR_OF位为1,则数据无效           */
        dev->ps = 0;                                                        
    else                /* 读取PS传感器的数据    */
        dev->ps = ((unsigned short)(buf[5] & 0X3F) << 4) | (buf[4] & 0X0F); 
}

/*
 * @description     : 打开设备
 * @param - inode   : 传递给驱动的inode
 * @param - filp    : 设备文件，file结构体有个叫做private_data的成员变量
 *                    一般在open的时候将private_data指向设备结构体。
 * @return          : 0 成功;其他 失败
 */
static int ap3216c_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &ap3216cdev;

    /* 初始化AP3216C */
    ap3216c_write_reg(&ap3216cdev, AP3216C_SYSTEMCONG, 0x04);       /* 复位AP3216C            */
    mdelay(50);                                                     /* AP3216C复位最少10ms  */
    ap3216c_write_reg(&ap3216cdev, AP3216C_SYSTEMCONG, 0X03);       /* 开启ALS、PS+IR      */
    return 0;
}

/*
 * @description     : 从设备读取数据 
 * @param - filp    : 要打开的设备文件(文件描述符)
 * @param - buf     : 返回给用户空间的数据缓冲区
 * @param - cnt     : 要读取的数据长度
 * @param - offt    : 相对于文件首地址的偏移
 * @return          : 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t ap3216c_read(struct file *filp, char __user *buf, size_t cnt, loff_t *off)
{
    short data[3];
    long err = 0;

    struct ap3216c_dev *dev = (struct ap3216c_dev *)filp->private_data;
    
    ap3216c_readdata(dev);

    data[0] = dev->ir;
    data[1] = dev->als;
    data[2] = dev->ps;
    err = copy_to_user(buf, data, sizeof(data));
    return 0;
}

/*
 * @description     : 关闭/释放设备
 * @param - filp    : 要关闭的设备文件(文件描述符)
 * @return          : 0 成功;其他 失败
 */
static int ap3216c_release(struct inode *inode, struct file *filp)
{
    return 0;
}

/* AP3216C操作函数 */
static const struct file_operations ap3216c_ops = {
    .owner = THIS_MODULE,
    .open = ap3216c_open,
    .read = ap3216c_read,
    .release = ap3216c_release,
};

 /*
  * @description     : i2c驱动的probe函数，当驱动与
  *                    设备匹配以后此函数就会执行
  * @param - client  : i2c设备
  * @param - id      : i2c设备ID
  * @return          : 0，成功;其他负值,失败
  */
static int ap3216c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    /* 1、构建设备号 */
    if (ap3216cdev.major) {
        ap3216cdev.devid = MKDEV(ap3216cdev.major, 0);
        register_chrdev_region(ap3216cdev.devid, AP3216C_CNT, AP3216C_NAME);
    } else {
        alloc_chrdev_region(&ap3216cdev.devid, 0, AP3216C_CNT, AP3216C_NAME);
        ap3216cdev.major = MAJOR(ap3216cdev.devid);
    }

    /* 2、注册设备 */
    cdev_init(&ap3216cdev.cdev, &ap3216c_ops);
    cdev_add(&ap3216cdev.cdev, ap3216cdev.devid, AP3216C_CNT);

    /* 3、创建类 */
    ap3216cdev.class = class_create(THIS_MODULE, AP3216C_NAME);
    if (IS_ERR(ap3216cdev.class)) {
        return PTR_ERR(ap3216cdev.class);
    }

    /* 4、创建设备 */
    ap3216cdev.device = device_create(ap3216cdev.class, NULL, ap3216cdev.devid, NULL, AP3216C_NAME);
    if (IS_ERR(ap3216cdev.device)) {
        return PTR_ERR(ap3216cdev.device);
    }

    ap3216cdev.private_data = client;

    return 0;
}

/*
 * @description     : i2c驱动的remove函数，移除i2c驱动的时候此函数会执行
 * @param - client  : i2c设备
 * @return          : 0，成功;其他负值,失败
 */
static int ap3216c_remove(struct i2c_client *client)
{
    /* 删除设备 */
    cdev_del(&ap3216cdev.cdev);
    unregister_chrdev_region(ap3216cdev.devid, AP3216C_CNT);

    /* 注销掉类和设备 */
    device_destroy(ap3216cdev.class, ap3216cdev.devid);
    class_destroy(ap3216cdev.class);
    return 0;
}

/* 传统匹配方式ID列表 */
static const struct i2c_device_id ap3216c_id[] = {
    {"alientek,ap3216c", 0},  
    {}
};

/* 设备树匹配列表 */
static const struct of_device_id ap3216c_of_match[] = {
    { .compatible = "alientek,ap3216c" },
    { /* Sentinel */ }
};

/* i2c驱动结构体 */  
static struct i2c_driver ap3216c_driver = {
    .probe = ap3216c_probe,
    .remove = ap3216c_remove,
    .driver = {
            .owner = THIS_MODULE,
            .name = "ap3216c",
            .of_match_table = ap3216c_of_match, 
           },
    .id_table = ap3216c_id,
};
           
/*
 * @description : 驱动入口函数
 * @param       : 无
 * @return      : 无
 */
static int __init ap3216c_init(void)
{
    int ret = 0;

    ret = i2c_add_driver(&ap3216c_driver);
    return ret;
}

/*
 * @description : 驱动出口函数
 * @param       : 无
 * @return      : 无
 */
static void __exit ap3216c_exit(void)
{
    i2c_del_driver(&ap3216c_driver);
}

/* module_i2c_driver(ap3216c_driver) */

module_init(ap3216c_init);
module_exit(ap3216c_exit);
MODULE_LICENSE("GPL");

test.c文章来源地址https://www.toymoban.com/news/detail-743096.html

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "sys/ioctl.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include <poll.h>
#include <sys/select.h>
#include <sys/time.h>
#include <signal.h>
#include <fcntl.h>
/***************************************************************
使用方法     ：./ap3216cApp /dev/ap3216c
***************************************************************/

/*
 * @description     : main主程序
 * @param - argc    : argv数组元素个数
 * @param - argv    : 具体参数
 * @return          : 0 成功;其他 失败
 */
int main(int argc, char *argv[])
{
    int fd;
    char *filename;
    unsigned short databuf[3];
    unsigned short ir, als, ps;
    int ret = 0;

    if (argc != 2) {
        printf("Error Usage!\r\n");
        return -1;
    }

    filename = argv[1];
    fd = open(filename, O_RDWR);
    if(fd < 0) {
        printf("can't open file %s\r\n", filename);
        return -1;
    }

    while (1) {
        ret = read(fd, databuf, sizeof(databuf));
        if(ret == 0) {          /* 数据读取成功 */
            ir =  databuf[0];   /* ir传感器数据 */
            als = databuf[1];   /* als传感器数据 */
            ps =  databuf[2];   /* ps传感器数据 */
            printf("ir = %d, als = %d, ps = %d\r\n", ir, als, ps);
        }
        usleep(200000); /*100ms */
    }
    close(fd);  /* 关闭文件 */  
    return 0;
}

到了这里，关于总线驱动---IIC驱动的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！