Linux I2C驱动分析与实现(二)

====本文系本站原创,欢迎转载! 转载请注明出处:http://blog.csdn.net/yyplc====
通过上篇《Linux I2C驱动分析与实现(二)》，我们对Linux子系统已经不陌生,那么如何实现I2C驱动呢？

编写客户驱动的方法

在内核中有两种方式的i2c客户驱动的编写方法，一种叫legacy传统方式，另一种是newstyle方式. 前

一种legacy是一种旧式的方法，在2.6内核以后的标准驱动模型编写中逐渐被newstyle方式取代。本文编程实例是基于newstyle方式的来实现at24c02的驱

动。

客户驱动程序开发的一般步骤

(1)注册板载i2c设备信息

 

(2)定义i2c驱动设备id

 

(3)定义i2c_driver结构并完成其相应函数

 

(4)模块初始化时添加/撤销时删除i2c_driver

 

(5)/dev  entry 访问方法 /sysfs访问方法

 

客户设备驱动开发实例

内核为linux-2.6.30.4

基于arm9 S3c2440平台

开发一个at24c02 eeprom的客户驱动

开发一个应用程序访问I2C设备

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

根据开发客户驱动程序步骤实现对i2c设备at24c02的读写操作。

(分析at24c02 datasheet)

(1)注册板载信息

在mach-smdk2440.c文件中静态声明一个I2C设备

[cpp] view plaincopy

1. static struct i2c_board_info i2c_devices[] __initdata = {  
2.   
3.     {I2C_BOARD_INFO("24c02", 0x50), },  
4.   
5.      {}  
6.   
7. };  

在smdk2440_machine_init()函数中，向总线注册I2C设备信息：

[cpp] view plaincopy

1. i2c_register_board_info(0,i2c_devices,ARRAY_SIZE(i2c_devices));  

(2)定义i2c驱动设备id：

[cpp] view plaincopy

1. static struct i2c_device_id foo_idtable[] = {  
2.   
3.     { “24c01", 0x51 },  
4.   
5.     {“20402”，0x50 },  
6.   
7.     {}  
8.   
9. };  

(3)定义i2c_driver结构并完成其相应函数:

[cpp] view plaincopy

1. static struct i2c_driver my_i2c_driver = {  
2.   
3.     .driver = {  
4.   
5.       .name = "i2c_demo",  
6.   
7.       .owner = THIS_MODULE,  
8.   
9.     },  
10.   
11.     .probe = my_i2c_probe,  
12.   
13.     .remove = my_i2c_remove,  
14.   
15.     .id_table = my_ids,  
16.   
17. };  

(4)模块初始化时添加/撤销时删除i2c_driver

[cpp] view plaincopy

1. static int __init  my_i2c_client(void)  
2.   
3. {  
4.   
5.    return i2c_add_driver(&my_i2c_driver);  
6.   
7. }  
8.   
9. static void __exit my_i2c_exit(void)  
10.   
11. {  
12.   
13.    i2c_del_driver(&my_i2c_driver);  
14.   
15. }  

(5)使用/dev entry 访问方法

注册字符设备

[cpp] view plaincopy

1. register_chrdev(I2C_MAJOR,DEVICE_NAME,&i2c_fops);  
2.   
3. 创建类class_create(THIS_MODULE, DEVICE_NAME);  
4.   
5. 在/dev下创建设备节点  
6.   
7. device_create(my_dev_class, &client->dev,MKDEV(I2C_MAJOR, 0), NULL, DEVICE_NAME);  

"实现代码附件下载",有需要请留言，邮件发～

谁能告诉我csdn为什么不可以上传附件？

代码测试结果：

[cpp] view plaincopy

1. #include <linux/kernel.h>  
2. #include <linux/module.h>  
3. #include <linux/fs.h>  
4. #include <linux/slab.h>  
5. #include <linux/init.h>  
6. #include <linux/list.h>  
7. #include <linux/i2c.h>  
8. #include <linux/i2c-dev.h>  
9. #include <linux/smp_lock.h>  
10. #include <linux/jiffies.h>  
11. #include <asm/uaccess.h>  
12. #include <linux/delay.h>  
13.   
14.   
15. #define DEBUG 1  
16. #ifdef DEBUG  
17. #define dbg(x...) printk(x)  
18. #else   
19. #define dbg(x...) (void)(0)  
20. #endif  
21.   
22. #define I2C_MAJOR 89  
23. #define DEVICE_NAME "at24c02"  
24. static struct class *my_dev_class;  
25. static struct i2c_client *my_client;  
26. static struct i2c_driver my_i2c_driver;  
27.   
28.   
29. static struct i2c_device_id my_ids[] = {  
30.     {"24c01",0x50},  
31.     {"24c02",0x50},  
32.     {"24c08",0x50},  
33.     {}  
34. };  
35.   
36. MODULE_DEVICE_TABLE(i2c,my_ids);  
37.   
38. static int my_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)  
39. {  
40.     int res;  
41.     struct device *dev;  
42.   
43.     dbg("probe:name = %s,flag =%d,addr = %d,adapter = %d,driver = %s\n",client->name,  
44.          client->flags,client->addr,client->adapter->nr,client->driver->driver.name );  
45.   
46.     dev = device_create(my_dev_class, &client->dev,  
47.                      MKDEV(I2C_MAJOR, 0), NULL,  
48.                      DEVICE_NAME);  
49.     if (IS_ERR(dev))  
50.     {  
51.         dbg("device create error\n");  
52.         goto out;  
53.     }  
54.     my_client = client;  
55.       
56.     return 0;  
57. out:  
58.     return -1;  
59. }  
60. static int  my_i2c_remove(struct i2c_client *client)  
61. {  
62.   
63.     dbg("remove\n");  
64.     return 0;  
65. }  
66.   
67. static ssize_t at24c02_read(struct file *fd, char *buf, ssize_t count, loff_t *offset)  
68. {  
69.     char *tmp;  
70.     int ret;  
71.     char data_byte;  
72.     char reg_addr = 0,i;  
73.     struct i2c_client *client = (struct i2c_client*) fd->private_data;  
74.     struct i2c_msg msgs[2];  
75.   
76.     dbg("read:count = %d,offset = %ld\n",count,*offset);  
77.     tmp = kmalloc(count,GFP_KERNEL);  
78.   
79.     if (!tmp)  
80.     {  
81.         dbg("malloc error in read function\n");  
82.         goto out;  
83.     }  
84.   
85.     reg_addr = *offset;  
86.     msgs[0].addr = client->addr;  
87.     msgs[0].flags = client->flags & (I2C_M_TEN|I2C_CLIENT_PEC) ;  
88.     msgs[0].len = 1;  
89.     msgs[0].buf = (char *)?_addr;  
90.       
91.     msgs[1].addr= client->addr;  
92.     msgs[1].flags = client->flags & (I2C_M_TEN|I2C_CLIENT_PEC);  
93.     msgs[1].flags |= I2C_M_RD;  
94.     msgs[1].len = count;  
95.     msgs[1].buf = (char*)tmp;  
96.   
97.     ret = i2c_transfer(client->adapter,&msgs,2);  
98.     if (ret != 2)  
99.         goto out;  
100.     if (copy_to_user(buf, tmp, count))  
101.         goto out;  
102.       
103.     kfree(tmp);  
104.     return count;  
105. out:  
106.     kfree(tmp);  
107.     return -1;    
108.       
109. }  
110.   
111.   
112. static int at24c02_ioctl(struct file *fd, unsigned int cmd, unsigned long arg)  
113. {  
114.     dbg("ioctl code ...\n");  
115.     return 0;  
116. }  
117.   
118. static ssize_t at24c02_write(struct file *fd, char *buf, ssize_t count, loff_t *offset)  
119. {  
120.     int ret,i;  
121.     char *tmp;  
122.     int errflg;  
123.     struct i2c_msg msg;  
124.     struct i2c_client *client = (struct i2c_client*) fd->private_data;  
125.     char tmp_data[2];  
126.   
127.     dbg("write:count = %d,offset = %ld\n",count,*offset);  
128.     tmp = kmalloc(count, GFP_KERNEL);  
129.     if (!tmp)  
130.         goto out;  
131.     if (copy_from_user(tmp, buf, count))  
132.         goto out;  
133.     msg.addr = client->addr;  
134.     msg.flags = client->flags & (I2C_M_TEN | I2C_CLIENT_PEC);  
135.     for (i = 0; i < count; i++) {  
136.         msg.len = 2;  
137.         tmp_data[0] = *offset + i;  
138.         tmp_data[1] = tmp[i];  
139.         msg.buf = tmp_data;  
140.         ret = i2c_transfer(client->adapter,&msg,1);  
141.         if (ret != 1)  
142.             goto out;  
143.         msleep(1);  
144.     }   
145.     kfree(tmp);  
146.   
147.     return ((ret == 1) ? count:ret);  
148. out:  
149.     kfree(tmp);  
150.     return -1;  
151.       
152. }  
153. static int at24c02_open(struct inode *inode, struct file *fd)  
154. {  
155.   
156.     fd->private_data =(void*)my_client;  
157.     return 0;  
158.   
159. }  
160.   
161. static int at24c02_release(struct inode *inode, struct file *fd)  
162. {  
163.     dbg("release\n");  
164.     fd->private_data = NULL;  
165.       
166.     return 0;     
167.   
168. }  
169.   
170. static const struct file_operations i2c_fops = {  
171.     .owner = THIS_MODULE,  
172.     .open   = at24c02_open,  
173.     .read  = at24c02_read,  
174.     .write = at24c02_write,  
175.     .unlocked_ioctl = at24c02_ioctl,  
176.     .release = at24c02_release,  
177. };  
178.   
179. static struct i2c_driver my_i2c_driver = {  
180.     .driver = {  
181.         .name = "i2c_demo",  
182.         .owner = THIS_MODULE,  
183.     },  
184.     .probe = my_i2c_probe,  
185.     .remove = my_i2c_remove,  
186.     .id_table = my_ids,  
187. };  
188.   
189. static int __init my_i2c_init(void)  
190. {  
191.     int res;  
192.       
193.       
194.     res = register_chrdev(I2C_MAJOR,DEVICE_NAME,&i2c_fops);  
195.     if (res)  
196.     {  
197.         dbg("register_chrdev error\n");  
198.         return -1;  
199.     }  
200.     my_dev_class = class_create(THIS_MODULE, DEVICE_NAME);  
201.     if (IS_ERR(my_dev_class))  
202.     {  
203.         dbg("create class error\n");  
204.         unregister_chrdev(I2C_MAJOR, DEVICE_NAME);  
205.         return -1;  
206.     }  
207.     return i2c_add_driver(&my_i2c_driver);  
208. }  
209.   
210. static void __exit my_i2c_exit(void)  
211. {  
212.     unregister_chrdev(I2C_MAJOR, DEVICE_NAME);  
213.     class_destroy(my_dev_class);  
214.     i2c_del_driver(&my_i2c_driver);  
215.       
216. }  
217.   
218. MODULE_AUTHOR("itspy<[e-mail]>");  
219. MODULE_DESCRIPTION("i2c client driver demo");  
220. MODULE_LICENSE("GPL");  
221. module_init(my_i2c_init);  
222. module_exit(my_i2c_exit);