编写一个随内核加载的简单驱动

    接上篇内核编译继续编一个简单的随内核加载的驱动。
1、进入内核代码所在路径
2、cd goldfish/drivers
3、mkdir hello
4、cd hello
5、创建hello.h

点击(此处)折叠或打开

1. #ifndef _HELLO_ANDROID_H_
   
2. #define _HELLO_ANDROID_H_
   
3. 
   
4. #include <linux/cdev.h>
   
5. #include <linux/semaphore.h>
   
6. 
   
7. #define HELLO_DEVICE_NODE_NAME "hello"
   
8. #define HELLO_DEVICE_FILE_NAME "hello"
   
9. #define HELLO_DEVICE_PROC_NAME "hello"
   
10. #define HELLO_DEVICE_CLASS_NAME "hello"
    
11. 
    
12. struct hello_android_dev {
    
13.     int val;
    
14.     struct semaphore sem;
    
15.     struct cdev dev;
    
16. };
    
17. 
    
18. #endif

6、创建hello.c

点击(此处)折叠或打开

1. #include <linux/init.h>
   
2. #include <linux/module.h>
   
3. #include <linux/types.h>
   
4. #include <linux/fs.h>
   
5. #include <linux/proc_fs.h>
   
6. #include <linux/device.h>
   
7. #include <asm/uaccess.h>
   
8. 
   
9. #include "hello.h"
   
10. 
    
11. /*主设备和从设备号变量*/
    
12. static int hello_major = 0;
    
13. static int hello_minor = 0;
    
14. 
    
15. /*设备类别和设备变量*/
    
16. static struct class* hello_class = NULL;
    
17. static struct hello_android_dev* hello_dev = NULL;
    
18. 
    
19. /*传统的设备文件操作方法*/
    
20. static int hello_open(struct inode* inode, struct file* filp);
    
21. static int hello_release(struct inode* inode, struct file* filp);
    
22. static ssize_t hello_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos);
    
23. static ssize_t hello_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos);
    
24. 
    
25. /*设备文件操作方法表*/
    
26. static struct file_operations hello_fops = {
    
27.     .owner = THIS_MODULE,
    
28.     .open = hello_open,
    
29.     .release = hello_release,
    
30.     .read = hello_read,
    
31.     .write = hello_write, 
    
32. };
    
33. 
    
34. /*访问设置属性方法*/
    
35. static ssize_t hello_val_show(struct device* dev, struct device_attribute* attr, char*buf);
    
36. static ssize_t hello_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count);
    
37. 
    
38. /*定义设备属性*/
    
39. static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, hello_val_show, hello_val_store);
    
40. 
    
41. /*打开设备方法*/
    
42. static int hello_open(struct inode* inode, struct file* filp) {
    
43.     struct hello_android_dev* dev; 
    
44.     
    
45.     /*将自定义设备结构体保存在文件指针的私有数据域中，以便访问设备时拿来用*/
    
46.     dev = container_of(inode->i_cdev, struct hello_android_dev, dev);
    
47.     filp->private_data = dev;
    
48.     
    
49.     return 0;
    
50. }
    
51. 
    
52. /*设备文件释放时调用，空实现*/
    
53. static int hello_release(struct inode* inode, struct file* filp) {
    
54.     return 0;
    
55. }
    
56. 
    
57. /*读取设备的寄存器val的值*/
    
58. static ssize_t hello_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos) {
    
59.     ssize_t err = 0;
    
60.     struct hello_android_dev* dev = filp->private_data; 
    
61. 
    
62.     /*同步访问*/
    
63.     if(down_interruptible(&(dev->sem))) {
    
64.         return -ERESTARTSYS;
    
65.     }
    
66. 
    
67.     if(count < sizeof(dev->val)) {
    
68.         goto out;
    
69.     } 
    
70. 
    
71.     /*将寄存器val的值拷贝到用户提供的缓冲区*/
    
72.     if(copy_to_user(buf, &(dev->val), sizeof(dev->val))) {
    
73.         err = -EFAULT;
    
74.         goto out;
    
75.     }
    
76. 
    
77.     err = sizeof(dev->val);
    
78. 
    
79. out:
    
80.     up(&(dev->sem));
    
81.     return err;
    
82. }
    
83. 
    
84. /*写设备的寄存器值val*/
    
85. static ssize_t hello_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos) {
    
86.     struct hello_android_dev* dev = filp->private_data;
    
87.     ssize_t err = 0; 
    
88. 
    
89.     /*同步访问*/
    
90.     if(down_interruptible(&(dev->sem))) {
    
91.         return -ERESTARTSYS; 
    
92.     } 
    
93. 
    
94.     if(count != sizeof(dev->val)) {
    
95.         goto out; 
    
96.     } 
    
97. 
    
98.     /*将用户提供的缓冲区的值写到设备寄存器去*/
    
99.     if(copy_from_user(&(dev->val), buf, count)) {
    
100.         err = -EFAULT;
     
101.         goto out;
     
102.     }
     
103. 
     
104.     err = sizeof(dev->val);
     
105. 
     
106. out:
     
107.     up(&(dev->sem));
     
108.     return err;
     
109. }
     
110. 
     
111. /*读取寄存器val的值到缓冲区buf中，内部使用*/
     
112. static ssize_t __hello_get_val(struct hello_android_dev* dev, char* buf) {
     
113.     int val = 0; 
     
114. 
     
115.     /*同步访问*/
     
116.     if(down_interruptible(&(dev->sem))) { 
     
117.         return -ERESTARTSYS; 
     
118.     } 
     
119. 
     
120.     val = dev->val; 
     
121.     up(&(dev->sem)); 
     
122. 
     
123.     return snprintf(buf, PAGE_SIZE, "%d\n", val);
     
124. }
     
125. 
     
126. /*把缓冲区buf的值写到设备寄存器val中去，内部使用*/
     
127. static ssize_t __hello_set_val(struct hello_android_dev* dev, const char* buf, size_t count) {
     
128.     int val = 0; 
     
129. 
     
130.     /*将字符串转换成数字*/ 
     
131.     val = simple_strtol(buf, NULL, 10); 
     
132. 
     
133.     /*同步访问*/ 
     
134.     if(down_interruptible(&(dev->sem))) { 
     
135.         return -ERESTARTSYS; 
     
136.     } 
     
137. 
     
138.     dev->val = val; 
     
139.     up(&(dev->sem));
     
140. 
     
141.     return count;
     
142. }
     
143. 
     
144. /*读取设备属性val*/
     
145. static ssize_t hello_val_show(struct device* dev, struct device_attribute* attr, char*buf) {
     
146.     struct hello_android_dev* hdev = (struct hello_android_dev*)dev_get_drvdata(dev); 
     
147. 
     
148.     return __hello_get_val(hdev, buf);
     
149. }
     
150. 
     
151. /*写设备属性val*/
     
152. static ssize_t hello_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count) { 
     
153.     struct hello_android_dev* hdev = (struct hello_android_dev*)dev_get_drvdata(dev); 
     
154.     
     
155.     return __hello_set_val(hdev, buf, count);
     
156. }
     
157. 
     
158. /*读取设备寄存器val的值，保存在page缓冲区中*/
     
159. static ssize_t hello_proc_read(char* page, char** start, off_t off, int count, int* eof, void* data) {
     
160.     if(off > 0) {
     
161.         *eof = 1;
     
162.         return 0;
     
163.     }
     
164. 
     
165.     return __hello_get_val(hello_dev, page);
     
166. }
     
167. 
     
168. /*把缓冲区的值buff保存到设备寄存器val中去*/
     
169. static ssize_t hello_proc_write(struct file* filp, const char __user *buff, unsigned long len, void* data) {
     
170.     int err = 0;
     
171.     char* page = NULL;
     
172. 
     
173.     if(len > PAGE_SIZE) {
     
174.         printk(KERN_ALERT"The buff is too large: %lu.\n", len);
     
175.         return -EFAULT;
     
176.     }
     
177. 
     
178.     page = (char*)__get_free_page(GFP_KERNEL);
     
179.     if(!page) { 
     
180.         printk(KERN_ALERT"Failed to alloc page.\n");
     
181.         return -ENOMEM;
     
182.     } 
     
183. 
     
184.     /*先把用户提供的缓冲区值拷贝到内核缓冲区中去*/
     
185.     if(copy_from_user(page, buff, len)) {
     
186.         printk(KERN_ALERT"Failed to copy buff from user.\n"); 
     
187.         err = -EFAULT;
     
188.         goto out;
     
189.     }
     
190. 
     
191.     err = __hello_set_val(hello_dev, page, len);
     
192. 
     
193. out:
     
194.     free_page((unsigned long)page);
     
195.     return err;
     
196. }
     
197. 
     
198. /*创建/proc/hello文件*/
     
199. static void hello_create_proc(void) {
     
200.     struct proc_dir_entry* entry;
     
201.     
     
202.     entry = create_proc_entry(HELLO_DEVICE_PROC_NAME, 0, NULL);
     
203.     if(entry) {
     
204.         entry->owner = THIS_MODULE;
     
205.         entry->read_proc = hello_proc_read;
     
206.         entry->write_proc = hello_proc_write;
     
207.     }
     
208. }
     
209. 
     
210. /*删除/proc/hello文件*/
     
211. static void hello_remove_proc(void) {
     
212.     remove_proc_entry(HELLO_DEVICE_PROC_NAME, NULL);
     
213. }
     
214. 
     
215. /*初始化设备*/
     
216. static int __hello_setup_dev(struct hello_android_dev* dev) {
     
217.     int err;
     
218.     dev_t devno = MKDEV(hello_major, hello_minor);
     
219. 
     
220.     memset(dev, 0, sizeof(struct hello_android_dev));
     
221. 
     
222.     cdev_init(&(dev->dev), &hello_fops);
     
223.     dev->dev.owner = THIS_MODULE;
     
224.     dev->dev.ops = &hello_fops; 
     
225. 
     
226.     /*注册字符设备*/
     
227.     err = cdev_add(&(dev->dev),devno, 1);
     
228.     if(err) {
     
229.         return err;
     
230.     } 
     
231. 
     
232.     /*初始化信号量和寄存器val的值*/
     
233.     init_MUTEX(&(dev->sem));
     
234.     dev->val = 0;
     
235. 
     
236.     return 0;
     
237. }
     
238. 
     
239. /*模块加载方法*/
     
240. static int __init hello_init(void){ 
     
241.     int err = -1;
     
242.     dev_t dev = 0;
     
243.     struct device* temp = NULL;
     
244. 
     
245.     printk(KERN_ALERT"Initializing hello device.\n"); 
     
246. 
     
247.     /*动态分配主设备和从设备号*/
     
248.     err = alloc_chrdev_region(&dev, 0, 1, HELLO_DEVICE_NODE_NAME);
     
249.     if(err < 0) {
     
250.         printk(KERN_ALERT"Failed to alloc char dev region.\n");
     
251.         goto fail;
     
252.     }
     
253. 
     
254.     hello_major = MAJOR(dev);
     
255.     hello_minor = MINOR(dev); 
     
256. 
     
257.     /*分配helo设备结构体变量*/
     
258.     hello_dev = kmalloc(sizeof(struct hello_android_dev), GFP_KERNEL);
     
259.     if(!hello_dev) {
     
260.         err = -ENOMEM;
     
261.         printk(KERN_ALERT"Failed to alloc hello_dev.\n");
     
262.         goto unregister;
     
263.     } 
     
264. 
     
265.     /*初始化设备*/
     
266.     err = __hello_setup_dev(hello_dev);
     
267.     if(err) {
     
268.         printk(KERN_ALERT"Failed to setup dev: %d.\n", err);
     
269.         goto cleanup;
     
270.     } 
     
271. 
     
272.     /*在/sys/class/目录下创建设备类别目录hello*/
     
273.     hello_class = class_create(THIS_MODULE, HELLO_DEVICE_CLASS_NAME);
     
274.     if(IS_ERR(hello_class)) {
     
275.         err = PTR_ERR(hello_class);
     
276.         printk(KERN_ALERT"Failed to create hello class.\n");
     
277.         goto destroy_cdev;
     
278.     } 
     
279. 
     
280.     /*在/dev/目录和/sys/class/hello目录下分别创建设备文件hello*/
     
281.     temp = device_create(hello_class, NULL, dev, "%s", HELLO_DEVICE_FILE_NAME);
     
282.     if(IS_ERR(temp)) {
     
283.         err = PTR_ERR(temp);
     
284.         printk(KERN_ALERT"Failed to create hello device.");
     
285.         goto destroy_class;
     
286.     } 
     
287. 
     
288.     /*在/sys/class/hello/hello目录下创建属性文件val*/
     
289.     err = device_create_file(temp, &dev_attr_val);
     
290.     if(err < 0) {
     
291.         printk(KERN_ALERT"Failed to create attribute val."); 
     
292.         goto destroy_device;
     
293.     }
     
294. 
     
295.     dev_set_drvdata(temp, hello_dev); 
     
296. 
     
297.     /*创建/proc/hello文件*/
     
298.     hello_create_proc();
     
299. 
     
300.     printk(KERN_ALERT"Succedded to initialize hello device.\n");
     
301.     return 0;
     
302. 
     
303. destroy_device:
     
304.     device_destroy(hello_class, dev);
     
305. 
     
306. destroy_class:
     
307.     class_destroy(hello_class);
     
308. 
     
309. destroy_cdev:
     
310.     cdev_del(&(hello_dev->dev));
     
311. 
     
312. cleanup:
     
313.     kfree(hello_dev);
     
314. 
     
315. unregister:
     
316.     unregister_chrdev_region(MKDEV(hello_major, hello_minor), 1);
     
317. 
     
318. fail:
     
319.     return err;
     
320. }
     
321. 
     
322. /*模块卸载方法*/
     
323. static void __exit hello_exit(void) {
     
324.     dev_t devno = MKDEV(hello_major, hello_minor);
     
325. 
     
326.     printk(KERN_ALERT"Destroy hello device.\n"); 
     
327. 
     
328.     /*删除/proc/hello文件*/
     
329.     hello_remove_proc(); 
     
330. 
     
331.     /*销毁设备类别和设备*/
     
332.     if(hello_class) {
     
333.         device_destroy(hello_class, MKDEV(hello_major, hello_minor));
     
334.         class_destroy(hello_class);
     
335.     } 
     
336. 
     
337.     /*删除字符设备和释放设备内存*/
     
338.     if(hello_dev) {
     
339.         cdev_del(&(hello_dev->dev));
     
340.         kfree(hello_dev);
     
341.     } 
     
342. 
     
343.     /*释放设备号*/
     
344.     unregister_chrdev_region(devno, 1);
     
345. }
     
346. 
     
347. MODULE_LICENSE("GPL");
     
348. MODULE_DESCRIPTION("First Android Driver");
     
349. 
     
350. module_init(hello_init);
     
351. module_exit(hello_exit);

7、创建Kconfig

点击(此处)折叠或打开

1. config HELLO
2.     tristate "First Android Driver"
3.     default n
4.     help
5.     This is the first android driver.

8、创建Makefile

点击(此处)折叠或打开

1. obj-$(CONFIG_HELLO) += hello.o

9、进入内核源代码的goldfish/arch/arm路径
10、在Kconfig文件中的menu "Device Drivers"和endmenu之间添加：
source "drivers/hello/Kconfig"
11、进入内核源代码的goldfish/drivers路径
12、在Kconfig文件中的menu "Device Drivers"和endmenu之间添加：
source "drivers/hello/Kconfig"
13、在Makefile文件中添加：
obj-$(CONFIG_HELLO) += hello/
14、进入goldfish路径
15、make menuconfig
"Device Drivers" => "First Android Drivers"选项选中
16、make
17、emulator -kernel 内核源代码路径/goldfish/arch/arm/boot/zImage -avd a_avd&
18、adb shell
19、察看驱动是否随内核加载
ls /dev
ls /proc
20、验证驱动是否可用

点击(此处)折叠或打开

1. cd proc
2. cat hello
3. echo '5' > hello
4. cat hello
5. cd /sys/class
6. cd hello
7. cd hello
8. cat val
9. echo '0' > val
10. cat val