Exynos4412 IIC总线驱动开发（二）—— IIC 驱动开发

 

 程

 

         首先看一张代码层次图，有助于我们的理解

 

 

 

 

 

 

       上面这些代码的展示是告诉我们 ​​内核和芯片提供商为我们的的驱动程序提供了 i2c驱动的框架，以及框架底层与硬件相关的代码的实现。

 

　  剩下的就是针对挂载在i2c两线上的i2c设备了device，而编写的即具体设备驱动了，这里的设备就是硬件接口外挂载的设备，而非硬件接口本身（soc硬件接口本身的驱动可以理解为总线驱动）

 

 

 

一、编写驱动需要完成的工作

 

       编写具体的I2C驱动时，工程师需要处理的主要工作如下：

 

1)、提供I2C适配器的硬件驱动，探测，初始化I2C适配器(如申请I2C的I/O地址和中断号)，驱动CPU控制的I2C适配器从硬件上产生。

 

2)、提供I2C控制的algorithm, 用具体适配器的xxx_xfer()函数填充i2c_algorithm的master_xfer指针，并把i2c_algorithm指针赋给i2c_adapter的algo指针。

 

3)、实现I2C设备驱动中的i2c_driver接口，用具体yyy的yyy_probe()，yyy_remove()，yyy_suspend(),yyy_resume()函数指针和i2c_device_id设备ID表赋给i2c_driver的probe,remove,suspend,resume和id_table指针。

 

4)、实现I2C设备所对应类型的具体驱动，i2c_driver只是实现设备与总线的挂接。

 

　　上面的工作中前两个属于I2C总线驱动，后面两个属于I2C设备驱动。

 

 

 

二、开发实例

 

-------------------------------------------------------------------

 

开发板：Exynos4412-fs4412

 

Linux 内核版本：Linux 3.14

 

IIC 从机对象：陀螺仪MPU6050

 

--------------------------------------------------------------------

 

1、查看原理图

 

 

对应核心板pin

 

 

从机地址

 

 

 

 

可以获取的信息：

 

1、MPU6050 对应 IIC 通道5；

 

2、对应中断 EINT27  父节点 GPX3  3

 

3、因为ad0接地，所以从设备地址0x68

 

      base address 0x138B0000

 

 

 

2、创建设备树节点

 

      通过上面获取的信息，可以写出

 

 ​​

2. i2c@138b0000 {  
3.         #address-cells = <1>;  
4.         #size-cells = <0>;  
5.   
6.         samsung,i2c-sda-delay = <100>;  
7.         samsung,i2c-max-bus-freq = <20000>;  
8.         pinctrl-0 = <&i2c5_bus>;  
9.         pinctrl-names = "default";  
10.         status = "okay";  
11.      
12.         pmu6050-3-asix@68 {  
13.                compatible = "invense,mpu6050";  
14.                reg = <0x68>;  
15.               interrupt-parent = <&gpx3>;  
16.               interrupts = <3 2>;  
17.         };  
18. };  

 

 

 

3、MPU6050相应寄存器

 

 

 

  ​​

2. #define SMPLRT_DIV 0x19 //采样率分频，典型值： 0x07(125Hz) */  
3. #define CONFIG 0x1A // 低通滤波频率，典型值： 0x06(5Hz) */  
4. #define GYRO_CONFIG 0x1B // 陀螺仪自检及测量范围，典型值： 0x18(不自检，2000deg/s) */  
5. #define ACCEL_CONFIG 0x1C // 加速计自检、测量范围及高通滤波频率，典型值： 0x01(不自检， 2G， 5Hz) */  
6. #define ACCEL_XOUT_H 0x3B // 存储最近的 X 轴、 Y 轴、 Z 轴加速度感应器的测量值 */  
7. #define ACCEL_XOUT_L 0x3C  
8. #define ACCEL_YOUT_H 0x3D  
9. #define ACCEL_YOUT_L 0x3E  
10. #define ACCEL_ZOUT_H 0x3F  
11. #define ACCEL_ZOUT_L 0x40  
12. #define TEMP_OUT_H 0x41 // 存储的最近温度传感器的测量值 */  
13. #define TEMP_OUT_L 0x42  
14. #define GYRO_XOUT_H 0x43 // 存储最近的 X 轴、 Y 轴、 Z 轴陀螺仪感应器的测量值 */  
15. #define GYRO_XOUT_L 0x44  
16. #define GYRO_YOUT_H 0x45  
17. #define GYRO_YOUT_L 0x46  
18. #define GYRO_ZOUT_H 0x47  
19. #define GYRO_ZOUT_L 0x48  
20. #define PWR_MGMT_1 0x6B // 电源管理，典型值： 0x00(正常启用) */  
21. #define WHO_AM_I 0x75 //IIC 地址寄存器(默认数值 0x68，只读) */  

4、具体程序

 

 

mpu6050.h

 

 ​​

2. #ifndef MPU6050_HHHH  
3. #define MPU6050_HHHH  
4.   
5. #define MPU6050_MAGIC 'K'  
6.   
7. union mpu6050_data  
8. {  
9.     struct {  
10.         unsigned short x;  
11.         unsigned short y;  
12.         unsigned short z;  
13.     }accel;  
14.     struct {  
15.         unsigned short x;  
16.         unsigned short y;  
17.         unsigned short z;  
18.     }gyro;  
19.     unsigned short temp;  
20. };  
21.   
22. #define GET_ACCEL _IOR(MPU6050_MAGIC, 0, union mpu6050_data)  
23. #define GET_GYRO  _IOR(MPU6050_MAGIC, 1, union mpu6050_data)   
24. #define GET_TEMP  _IOR(MPU6050_MAGIC, 2, union mpu6050_data)  
25.   
26. #endif  

 

 

 

i2c_driver

 

 

 

 ​​

2. #include <linux/kernel.h>  
3. #include <linux/module.h>  
4. #include <linux/i2c.h>  
5. #include <linux/cdev.h>  
6. #include <linux/slab.h>  
7. #include <linux/fs.h>  
8. #include <linux/delay.h>  
9.   
10. #include <asm/uaccess.h>  
11.   
12. #include "mpu6050.h"  
13.   
14. MODULE_LICENSE("GPL");  
15.   
16. #define SMPLRT_DIV      0x19  
17. #define CONFIG          0x1A  
18. #define GYRO_CONFIG     0x1B  
19. #define ACCEL_CONFIG    0x1C  
20. #define ACCEL_XOUT_H    0x3B  
21. #define ACCEL_XOUT_L    0x3C  
22. #define ACCEL_YOUT_H    0x3D  
23. #define ACCEL_YOUT_L    0x3E  
24. #define ACCEL_ZOUT_H    0x3F  
25. #define ACCEL_ZOUT_L    0x40  
26. #define TEMP_OUT_H      0x41  
27. #define TEMP_OUT_L      0x42  
28. #define GYRO_XOUT_H     0x43  
29. #define GYRO_XOUT_L     0x44  
30. #define GYRO_YOUT_H     0x45  
31. #define GYRO_YOUT_L     0x46  
32. #define GYRO_ZOUT_H     0x47  
33. #define GYRO_ZOUT_L     0x48  
34. #define PWR_MGMT_1      0x6B  
35.   
36. #define MPU6050_MAJOR 500  
37. #define MPU6050_MINOR 0  
38.   
39. struct mpu6050_device {  
40.     struct cdev cdev;  
41.     struct i2c_client *client;  
42. };  
43. struct mpu6050_device *mpu6050;   
44.   
45. static int mpu6050_read_byte(struct i2c_client *client, unsigned char reg)  
46. {  
47.     int ret;  
48.   
49.     char txbuf[1] = { reg };  
50.     char rxbuf[1];  
51.   
52.     struct i2c_msg msg[2] = {  
53.         {client->addr, 0, 1, txbuf},  
54.         {client->addr, I2C_M_RD, 1, rxbuf}  
55.     };  
56.   
57.     ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));  
58.     if (ret < 0) {  
59.         printk("ret = %d\n", ret);  
60.         return ret;  
61.     }  
62.   
63.     return rxbuf[0];  
64. }  
65.   
66. static int mpu6050_write_byte(struct i2c_client *client, unsigned char reg, unsigned char val)  
67. {  
68.     char txbuf[2] = {reg, val};  
69.   
70.     struct i2c_msg msg[2] = {  
71.         {client->addr, 0, 2, txbuf},  
72.     };  
73.   
74.     i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));  
75.   
76.     return 0;  
77. }  
78.   
79.   
80. static int mpu6050_open(struct inode *inode, struct file *file)   
81. {  
82.     return 0;  
83. }  
84.   
85. static int mpu6050_release(struct inode *inode, struct file *file)   
86. {  
87.     return 0;  
88. }  
89.   
90. static long mpu6050_ioctl(struct file *file, unsigned int cmd, unsigned long arg)  
91. {  
92.     union mpu6050_data data;  
93.     struct i2c_client *client = mpu6050->client;  
94.   
95.     switch(cmd) {  
96.     case GET_ACCEL:  
97.         data.accel.x = mpu6050_read_byte(client, ACCEL_XOUT_L);  
98.         data.accel.x |= mpu6050_read_byte(client, ACCEL_XOUT_H) << 8;  
99.   
100.         data.accel.y = mpu6050_read_byte(client, ACCEL_YOUT_L);  
101.         data.accel.y |= mpu6050_read_byte(client, ACCEL_YOUT_H) << 8;  
102.   
103.         data.accel.z = mpu6050_read_byte(client, ACCEL_ZOUT_L);  
104.         data.accel.z |= mpu6050_read_byte(client, ACCEL_ZOUT_H) << 8;  
105.         break;  
106.   
107.     case GET_GYRO:  
108.   
109.         data.gyro.x = mpu6050_read_byte(client, GYRO_XOUT_L);  
110.         data.gyro.x |= mpu6050_read_byte(client, GYRO_XOUT_H) << 8;  
111.   
112.         data.gyro.y = mpu6050_read_byte(client, GYRO_YOUT_L);  
113.         data.gyro.y |= mpu6050_read_byte(client, GYRO_YOUT_H) << 8;  
114.   
115.         data.gyro.z = mpu6050_read_byte(client, GYRO_ZOUT_L);  
116.         data.gyro.z |= mpu6050_read_byte(client, GYRO_ZOUT_H) << 8;  
117.         break;  
118.   
119.     case GET_TEMP:    
120.         data.temp = mpu6050_read_byte(client, TEMP_OUT_L);  
121.         data.temp |= mpu6050_read_byte(client, TEMP_OUT_H) << 8;  
122.         break;  
123.   
124.     default:  
125.         printk("invalid argument\n");  
126.         return -EINVAL;  
127.     }  
128.   
129.     if (copy_to_user((void *)arg, &data, sizeof(data)))  
130.         return -EFAULT;  
131.   
132.     return sizeof(data);  
133. }  
134.   
135. struct file_operations mpu6050_fops = {  
136.     .owner      = THIS_MODULE,  
137.     .open       = mpu6050_open,  
138.     .release    = mpu6050_release,  
139.     .unlocked_ioctl = mpu6050_ioctl,  
140. };  
141.   
142. static int mpu6050_probe(struct i2c_client *client, const struct i2c_device_id *id)  
143. {  
144.     int ret;  
145.     dev_t devno = MKDEV(MPU6050_MAJOR, MPU6050_MINOR);  
146.     printk("match OK!\n");  
147.   
148.     mpu6050 = kzalloc(sizeof(*mpu6050), GFP_KERNEL);  
149.     if (mpu6050 == NULL) {  
150.         return -ENOMEM;  
151.     }  
152.   
153.     mpu6050->client = client;  
154.   
155.     ret = register_chrdev_region(devno, 1, "mpu6050");  
156.     if (ret < 0) {  
157.         printk("failed to register char device region!\n");  
158.         goto err1;  
159.     }  
160.   
161.     cdev_init(&mpu6050->cdev, &mpu6050_fops);  
162.     mpu6050->cdev.owner = THIS_MODULE;  
163.     ret = cdev_add(&mpu6050->cdev, devno, 1);  
164.     if (ret < 0) {  
165.         printk("failed to add device\n");  
166.         goto err2;  
167.     }  
168.       
169.     mpu6050_write_byte(client, PWR_MGMT_1, 0x00);  
170.     mpu6050_write_byte(client, SMPLRT_DIV, 0x07);  
171.     mpu6050_write_byte(client, CONFIG, 0x06);  
172.     mpu6050_write_byte(client, GYRO_CONFIG, 0xF8);  
173.     mpu6050_write_byte(client, ACCEL_CONFIG, 0x19);  
174.   
175.     return 0;  
176. err2:  
177.     unregister_chrdev_region(devno, 1);  
178. err1:  
179.     kfree(mpu6050);  
180.     return ret;  
181. }  
182.   
183. static int mpu6050_remove(struct i2c_client *client)  
184. {  
185.     dev_t devno = MKDEV(MPU6050_MAJOR, MPU6050_MINOR);  
186.     cdev_del(&mpu6050->cdev);  
187.     unregister_chrdev_region(devno, 1);  
188.     kfree(mpu6050);  
189.   
190.     return 0;  
191. }  
192.   
193. static const struct i2c_device_id mpu6050_id[] = {  
194.     { "mpu6050", 0},  
195.     {}  
196. };   
197.   
198. static struct of_device_id mpu6050_dt_match[] = {  
199.     {.compatible = "invense,mpu6050" },  
200.     {/*northing to be done*/},  
201. };  
202.   
203. struct i2c_driver mpu6050_driver = {  
204.     .driver = {  
205.         .name           = "mpu6050",  
206.         .owner          = THIS_MODULE,  
207.         .of_match_table = of_match_ptr(mpu6050_dt_match),  
208.     },  
209.     .probe      = mpu6050_probe,  
210.     .remove     = mpu6050_remove,  
211.     .id_table   = mpu6050_id,  
212. };  
213.   
214. static init _init mpu6050_init(void)  
215. {  
216.     return i2c_add_driver(&mpu6050_driver);  
217. }  
218.   
219. static void _exit mpu6050_exit(void)  
220. {  
221.     return i2c_del_driver(&mpu6050_driver);  
222. }  
223.   
224. module_init(&mpu6050_init);  
225. module_exit(&mpu6050_exit);  

 

 

 

 

test.c

 ​​

2. #include <stdio.h>  
3. #include <stdlib.h>  
4. #include <unistd.h>  
5. #include <fcntl.h>  
6. #include <sys/ioctl.h>  
7.   
8. #include "mpu6050.h"  
9.   
10. int main(int argc, const char *argv[])  
11. {  
12.     int fd;  
13.     union mpu6050_data data;   
14.       
15.     fd = open("/dev/mpu6050", O_RDWR);  
16.     if (fd < 0) {  
17.         perror("open");  
18.         exit(1);  
19.     }  
20.   
21.     while(1) {  
22.         ioctl(fd, GET_ACCEL, &data);  
23.         printf("acceleration data: x = %04x, y = %04x, z = %04x\n",   
24.                 data.accel.x, data.accel.y, data.accel.z);  
25.   
26.         ioctl(fd, GET_GYRO, &data);  
27.         printf("gyroscope data: x = %04x, y = %04x, z = %04x\n",   
28.                 data.accel.x, data.accel.y, data.accel.z);  
29.   
30.         sleep(1);  
31.     }  
32.   
33.     close(fd);  
34.   
35.     return 0;  
36. }