&i2c1 {
    clock-frequency = <100000>;
    pinctrl-names = "default";
    pinctrl-0 = <&pinctrl_i2c1>;
    status = "okay";
    ...
    mag3110@e {
        compatible = "fsl,mag3110";
        reg = <0xe>;
        position = <2>;
    };

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

&i2c1 {    
    clock-frequency = <100000>; 
    pinctrl-names = "default"; 
    pinctrl-0 = <&pinctrl_i2c1>;   
    status = "okay"; 
    #address-cells = <1>;
    #size-cells = <0>;    
   /* 设备树修改查看是否修改成功，查看内核目录/sys/bus/i2c/devices/看是否存在0x1E地址的设备 */

    mpu6050@68 {
        compatible = "xgj,mpu6050";
        status = "okay"; 
        reg = <0x68>;
        interrupt-parent = <&gpio5>;
        interrupts = <0 IRQ_TYPE_LEVEL_LOW>;
    };          
};

因为mpu6050芯片是挂载在i2c1，将其设备节点追加在i2c节点下

• compatible ，驱动根据该值和设备树进行匹配
• reg， i2c设备地址
• interrupt-parent，芯片中断脚在哪个中断控制器下
• interrupts ,中断引脚号0和IRQ_TYPE_LEVEL_LOW低电平触发

设备树编译：

ares@ubuntu:~/work/ebf_linux_kernel-ebf_4.19.35_imx6ul$ cat make_dtb.sh
#!/bin/sh

make ARCH=arm -j4 CROSS_COMPILE=arm-linux-gnueabihf- dtbs

将设备树拷贝系统目录：

debian@npi:~/nfs_root/driver$ cat cp_dtb_to_linux.sh
#!/bin/sh

sudo cp imx6ull-mmc-npi.dtb /usr/lib/linux-image-4.19.35-carp-imx6/

• /usr/lib/linux-image-4.19.35-carp-imx6/  ，系统存放设备树的目录

重启系统设备树生效：

sudo reboot

通过查看系统目录 /sys/firmware/devicetree/base/ 看是否存在mpu6050的设备树节点判定设备树是否生效

驱动编写

1、MPU6050硬件操作

这部分内容和单片机程序差不多。

mpu6050_def.h ：

#ifndef _MPU6050_DEF_H_
#define _MPU6050_DEF_H_

typedefunsignedcharuint8_t;

/* register define */
#define MPU6050_SMPLRT_DIV                                  0x19     /* */
#define MPU6050_CONFIG                                      0x1A    
#define MPU6050_GYRO_CONFIG                                 0x1B
#define MPU6050_ACCEL_CONFIG                                0x1C
#define MPU6050_ACCEL_XOUT_H                                0x3B
#define MPU6050_ACCEL_XOUT_L                                0x3C
#define MPU6050_ACCEL_YOUT_H                                0x3D
#define MPU6050_ACCEL_YOUT_L                                0x3E
#define MPU6050_ACCEL_ZOUT_H                                0x3F
#define MPU6050_ACCEL_ZOUT_L                                0x40
#define MPU6050_TEMP_OUT_H                                  0x41
#define MPU6050_TEMP_OUT_L                                  0x42
#define MPU6050_GYRO_XOUT_H                                 0x43
#define MPU6050_GYRO_XOUT_L                                 0x44
#define MPU6050_GYRO_YOUT_H                                 0x45
#define MPU6050_GYRO_YOUT_L                                 0x46
#define MPU6050_GYRO_ZOUT_H                                 0x47
#define MPU6050_GYRO_ZOUT_L                                 0x48
#define MPU6050_PWR_MGMT_1                                  0x6B       /* power managemnt register */
#define MPU6050_WHO_AM_I                                    0x75       /* default value :  IIC addr 0x68 */

/* interrupt status register */
#define MPU6050_INT_STATUS                                  0x3A
#define MPU6050_INT_ENABLE                                  0x38
#define MPU6050_INT_PIN_CFG                                 0x37

// #define I2C_RETRIES                                 0x0701
// #define I2C_TIMEOUT                                 0x0702
// #define I2C_SLAVE                                   0x0703             //IIC从器件的地址设置
// #define I2C_BUS_MODE                                0x0780

// #define MPU6050_SlaveAddress                                  0xD0
// #define MPU6050_IIC_ADDR                                      0x68                  //MPU6050 IIC Address

structmpu6050_accel {
short x;
short y;
short z;
};

structmpu6050_gyro {
short x;
short y;
short z;
};

structmpu6050_data {
structmpu6050_accelaccel;
structmpu6050_gyrogyro;
};

#endif/* _MPU6050_DEF_H_ */

staticintmpu6050_i2c_write_reg(struct i2c_client *client, uint8_t reg_addr, uint8_t data)
{
int ret = 0;
uint8_t w_buf[2];

structi2c_msgmsg;

    w_buf[0] = reg_addr;
    w_buf[1] = data;

    msg.addr = client->addr;
    msg.buf = w_buf;
    msg.flags = 0; /* I2C direction ： write */
    msg.len = sizeof(w_buf);

    ret = i2c_transfer(client->adapter, &msg, 1);
if (ret < 0)
return ret;
elseif (ret != 1)
return -EIO;

return0;
}

staticintmpu6050_i2c_read_reg(struct i2c_client *client, uint8_t reg_addr, uint8_t *data)
{
int ret = 0;
structi2c_msgmsgs[2];

    msgs[0].addr = client->addr;
    msgs[0].buf = ®_addr; /* send regsiter */
    msgs[0].flags = 0;       /* I2C direction ： write */
    msgs[0].len = 1;

    msgs[1].addr = client->addr;
    msgs[1].buf = data;       /* 读取寄存器数据 */
    msgs[1].flags = I2C_M_RD; /* I2C direction ： read */
    msgs[1].len = 1;

    ret = i2c_transfer(client->adapter, msgs, 2); /* */
if (ret < 0)
return ret;
elseif (ret != 2)
return -EIO;

return0;
}

staticintmpu6050_init(void)
{
uint8_t reg_val = 0;
int ret = 0;

/* 解除休眠状态 */
    ret = mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_PWR_MGMT_1, 0x00); /*  */

/*  陀螺仪采样频率输出设置 */
    ret = mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_SMPLRT_DIV, 0x07);

    ret = mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_CONFIG, 0x06);

/* 配置加速度传感器工作在 16G 模式, 不自检 */
    ret = mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_ACCEL_CONFIG, 0x18);

/* 陀螺仪自检及测量范围，典型值：0x18(不自检，2000deg/s) */
    ret = mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_GYRO_CONFIG, 0x18);
#if MPU6050_USE_INT 
/* 配置中断产生时中断引脚为低电平 */
    ret = mpu6050_i2c_read_reg(mpu6050_dev->client, MPU6050_INT_PIN_CFG, ®_val);
    reg_val |= 0xC0;
    mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_INT_PIN_CFG, reg_val);

/* 开启数据就绪中断 */
    ret = mpu6050_i2c_read_reg(mpu6050_dev->client, MPU6050_INT_ENABLE, ®_val);
    reg_val |= 0x01;
    mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_INT_ENABLE, reg_val);
#endif
return ret;
}

staticintmpu6050_deinit(void)
{
int ret = 0;
/* mpu6050复位, 寄存器恢复默认值 */
    ret = mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_PWR_MGMT_1, 0x80);
return ret;
}

staticintmpu6050_read_id(uint8_t *id)
{
uint8_t data;
int ret = 0;

    ret = mpu6050_i2c_read_reg(mpu6050_dev->client, MPU6050_WHO_AM_I, &data);

if (id != NULL)
        *id = data;

if (data != MPU6050_IIC_ADDR)
        ret = -1;

return ret;
}

staticintmpu6050_read_accel(struct mpu6050_accel *acc)
{
int i = 0;
int ret = 0;
uint8_t data[6] = {0};

for (i = 0; i < 6; i++)
    {
        ret = mpu6050_i2c_read_reg(mpu6050_dev->client, MPU6050_ACCEL_XOUT_H+i, &data[i]);
    }
    acc->x = (data[0] << 8) + data[1];
    acc->y = (data[2] << 8) + data[3];
    acc->z = (data[4] << 8) + data[5];
return ret;
}

staticintmpu6050_read_gyro(struct mpu6050_gyro *gyro)
{
int i = 0;
int ret = 0;
uint8_t data[6] = {0};

for (i = 0; i < 6; i++)
    {
        ret = mpu6050_i2c_read_reg(mpu6050_dev->client, MPU6050_GYRO_XOUT_H+i, &data[i]);
    }
    gyro->x = (data[0] << 8) + data[1];
    gyro->y = (data[2] << 8) + data[3];
    gyro->z = (data[4] << 8) + data[5];
return ret;
}

staticintmpu6050_read_temp(short *temp)
{
int i = 0;
int ret = 0;
uint8_t data[2] = {0};

for (i = 0; i < 2; i++)
    {
        ret = mpu6050_i2c_read_reg(mpu6050_dev->client, MPU6050_TEMP_OUT_H+i, &data[i]);
    }
    *temp = (data[0] << 8) + data[1];
return ret;
}

2、linux I2C 驱动框架

在测试使用中断实现，发现中断触发太快和直接读取也没啥区别。

structmpu6050_device
{
int irq; /* 中断号 */
int gpio;
dev_t dev_no; /* 设备号 */
structcdevchrdev;
structclass *class;
structmutexm_lock;
wait_queue_head_t wq; /* 等待队列 */
structmpu6050_datadata;
structi2c_client *client;
};

staticstructmpu6050_device *mpu6050_dev;

staticint _drv_open(struct inode *node, struct file *file)
{
uint8_t id;
int ret = 0;

    file->private_data = mpu6050_dev;

    ret = mpu6050_init();
if (ret != 0)
    {
        printk("%d-%s init failed %d\r\n", __LINE__, __FUNCTION__, ret);
return -ENXIO;
    }

if (mpu6050_read_id(&id) != 0)
    {
        printk("don't find %s %d\r\n", DEV_NAME, id);
return -ENXIO;
    }

    gpio_direction_input(mpu6050_dev->gpio);

    printk("%s open %d\r\n", DEV_NAME, __LINE__);
return0;
}

staticssize_t _drv_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
{
int ret;
int data_size;
structmpu6050_device *tmp_mpu6050 = filp->private_data;
structmpu6050_datadata;

    data_size = sizeof(data);
if (size != data_size)
return -EINVAL;
#if MPU6050_USE_INT == 0
    ret = mpu6050_read_accel(&data.accel);

    ret = mpu6050_read_gyro(&data.gyro);
#else

#endif
if (copy_to_user(buf, &data, sizeof(data)))
    {
        ret = -EFAULT;
    }
else
    {
        ret = data_size;
    }
return ret;
}

/* 使驱动支持多路复用IO */
static__poll_t _drv_poll(struct file *filp, struct poll_table_struct *wait)
{
__poll_t mask = 0;

// mutex_lock(&mpu6050_dev->m_lock);

// poll_wait(filp, &mpu6050_dev->wq, wait);

// mutex_unlock(&sr501.m_lock);

return mask;
}

staticlong _drv_ioctl(struct file *filp, unsignedint cmd, unsignedlong arg)
{
int ret = 0;
uint8_t result = 0;
short buf[3];
void __user *user_space = (void __user *)arg;

switch (cmd)
    {
case MPU6050_CMD_GET_ID:
            ret = mpu6050_read_id(&result);
            ret = copy_to_user(user_space, &result, sizeof(result));
break;
case MPU6050_CMD_GET_ACCEL:
            ret = mpu6050_read_accel((struct mpu6050_accel *)&buf);
            ret = copy_to_user(user_space, &buf, sizeof(buf));
break;
case MPU6050_CMD_GET_GYRO:
            ret = mpu6050_read_gyro((struct mpu6050_gyro *)&buf);
            ret = copy_to_user(user_space, &buf, sizeof(buf));
break;
case MPU6050_CMD_GET_TEMP:
            ret = mpu6050_read_temp(&buf[0]);
            ret = copy_to_user(user_space, &buf[0], 2);
break;
    }

return ret;
}

staticint _drv_release(struct inode *node, struct file *filp)
{
int ret = 0;
structmpu6050_device *tmp_mpu6050 = filp->private_data;

    ret = mpu6050_deinit();  
return ret;
}

staticstructfile_operationsmpu6050_drv_ops = {
    .owner = THIS_MODULE,
    .open = _drv_open,
    .read = _drv_read,
    .poll = _drv_poll,
    .release = _drv_release,
};

staticirqreturn_tmpu6050_isr(int irq, void *dev)
{
uint8_t reg_val;
// printk("%s %d %s\n", __FILE__, __LINE__, __FUNCTION__);
    mpu6050_i2c_read_reg(mpu6050_dev->client, MPU6050_INT_STATUS, ®_val);
if (reg_val & 0x01)     
    {
/* 唤醒进程去读取数据 */

        printk("data ready\n");
    }
return IRQ_RETVAL(IRQ_HANDLED);
}

probe和remove函数实现：

staticint _driver_probe(struct i2c_client *client, conststruct i2c_device_id *id)
{
int err = 0;
// int ret = 0;
structdevice *_dev;
structdevice_node *_dts_node;

    mpu6050_dev = (struct mpu6050_device *)kzalloc(sizeof(struct mpu6050_device), GFP_KERNEL);
if (!mpu6050_dev)
    {
        printk("can't kzalloc mpu6050 dev\n");
return -ENOMEM;
    }

    _dts_node = client->dev.of_node;
if (!_dts_node)
    {
        printk("mpu6050 dts node can not found!\r\n");
        err = -EINVAL;
goto out_free_dev;
    }

    mpu6050_dev->client = client;

    printk("mpu6050 dtsirq %d !\r\n", client->irq);
#if 1
// mpu6050_dev->gpio = of_get_named_gpio(_dts_node, AP3216C_READY_GPIO_NAME, 0);   /* 获取gpio */
// if (!gpio_is_valid( mpu6050_dev->gpio)) {
//     printk("don't get mpu6050 ready gpio!\n");
//     err = -EINVAL;
//     goto out_free_dev;
// }

// mpu6050_dev->irq = gpio_to_irq( mpu6050_dev->gpio);                              /* 通过gpio得到irq */

// gpiod_direction_input(mpu6050_dev->gpio);          /* 设置gpio为输入 */
    mpu6050_dev->irq = client->irq;
// mpu6050_dev->gpio = irq_to_gpio(mpu6050_dev->irq);
    err = request_irq(mpu6050_dev->irq, mpu6050_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, DEV_NAME, NULL); /* 申请中断 */
if (err)
    {
        printk(KERN_INFO "failed to request irq %d\r\n", mpu6050_dev->irq);
goto out_free_dev;
    }
/* 内核自动分配设备号 */
    err = alloc_chrdev_region(&mpu6050_dev->dev_no, 0, 1, DEV_NAME);
if (err < 0)
    {
        pr_err("Error: failed to register mbochs_dev, err: %d\n", err);

goto out_free_irq;
    }

    cdev_init(&mpu6050_dev->chrdev, &mpu6050_drv_ops);
    err = cdev_add(&mpu6050_dev->chrdev, mpu6050_dev->dev_no, 1);
if (err)
    {
goto out_unregister;
    }

    mpu6050_dev->class = class_create(THIS_MODULE, DEV_NAME);
if (IS_ERR(mpu6050_dev->class))
    {
        err = PTR_ERR(mpu6050_dev->class);
goto out_cdev_del;
    }

/* 创建设备节点 */
    _dev = device_create(mpu6050_dev->class, NULL, mpu6050_dev->dev_no, NULL, DEV_NAME);
if (IS_ERR(_dev))
    { /* 判断指针是否合法 */
        err = PTR_ERR(_dev);
goto out_class_del;
    }

// mutex_init(&mpu6050_dev->m_lock);                 /* 初始化互斥锁  */

    printk("%s probe success\r\n", DEV_NAME);

goto out;

out_class_del:
    class_destroy(mpu6050_dev->class);
out_cdev_del:
    cdev_del(&mpu6050_dev->chrdev);
out_unregister:
    unregister_chrdev_region(mpu6050_dev->dev_no, 1); /* 注销设备 */
out_free_irq:
    free_irq(mpu6050_dev->irq, NULL);
out_free_dev:
    kfree(mpu6050_dev);
    mpu6050_dev = NULL;
out:
#endif
return err;
}

staticint _driver_remove(struct i2c_client *client)
{
    device_destroy(mpu6050_dev->class, mpu6050_dev->dev_no);
    class_destroy(mpu6050_dev->class);
    cdev_del(&mpu6050_dev->chrdev);
    unregister_chrdev_region(mpu6050_dev->dev_no, 1); /* 注销设备 */
    free_irq(mpu6050_dev->irq, NULL); /* 释放中断*/
    kfree(mpu6050_dev);
    printk(KERN_INFO "%s success\n", DEV_NAME);

return0;
}

• remove函数只要做一些清理工作，删除设备、删除class、注销设备以及释放内存等。

出口入口函数实现 ：

/* 设备树的匹配列表 */
staticstructof_device_iddts_match_table[] = {
    {.compatible = MPU6050_DTS_COMPATIBLE}, /* 通过设备树来匹配 */
    {},
};

/* 传统匹配方式 ID 列表 ，即使不使用也要添加，不然probe匹配不成功 */
staticconststructi2c_device_idmpu6050_id[] = {
    {MPU6050_DTS_COMPATIBLE, 0},
    {},
};

staticstructi2c_drivermpu6050_driver = {
    .probe = _driver_probe,
    .remove = _driver_remove,
    .driver = {
        .name = MPU6050_DTS_COMPATIBLE,
        .owner = THIS_MODULE,
        .of_match_table = dts_match_table, /* 通过设备树匹配 */
    },
    .id_table = mpu6050_id,
};

/* 入口函数 */
staticint __init _driver_init(void)
{
int ret = 0;

    ret = i2c_add_driver(&mpu6050_driver); /* 注册I2C驱动 */
    printk("%s %s\n", DEV_NAME, __FUNCTION__);
return ret;
}

/*  出口函数 */
staticvoid __exit _driver_exit(void)
{
    printk("%s driver %s\n", DEV_NAME, __FUNCTION__);
    i2c_del_driver(&mpu6050_driver); /* 注销I2C驱动 */
}

module_init(_driver_init);
module_exit(_driver_exit);

MODULE_AUTHOR("Ares");
MODULE_LICENSE("GPL");

测试的app程序编写

#include"stdio.h"
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdio.h>
#include<string.h>
#include<sys/ioctl.h>
#include<poll.h>
#include<stdint.h>

#define DEV_NAME   "/dev/mpu6050"

structmpu6050_accel {
short x;
short y;
short z;
};

structmpu6050_gyro {
short x;
short y;
short z;
};

structmpu6050_data {
structmpu6050_accelaccel;
structmpu6050_gyrogyro;
};


voidsleep_ms(unsignedint ms)
{
structtimevaldelay;
    delay.tv_sec = 0;
    delay.tv_usec = ms * 1000; 
    select(0, NULL, NULL, NULL, &delay);
}

intmain(int argc, char **argv)
{
int fd;
int ret;

/* 2. 打开文件 */
    fd = open(DEV_NAME, O_RDWR | O_NONBLOCK);   // | O_NONBLOCK

if (fd < 0)
    {
printf("can not open file %s, %d\n", DEV_NAME, fd);
return-1;
    }

structmpu6050_datampu6050_data;
int size = sizeof(struct mpu6050_data);

printf("read size %d\n", size);

while (1)
    {
if (read(fd, &mpu6050_data, size) == size)
        {
printf("accel x %d y %d z %d\r\n", mpu6050_data.accel.x, mpu6050_data.accel.y, mpu6050_data.accel.z);
printf("gyro x %d y %d z %d\r\n", mpu6050_data.gyro.x, mpu6050_data.gyro.y, mpu6050_data.gyro.z);
        }
printf("running\r\n");
        sleep_ms(500);
    }

    close(fd);

return0;
}