安卓硬件驱动开发

安卓硬件驱动

Android体系的硬件抽象层（Hardware Abstract Layer， HAL） 运行在用户空间中， 它向下屏蔽硬件驱动模块的实现细节， 向上提供硬件访问服务。
Android体系的体系结构 :

依次涉及Android体系的硬件驱动模块、 硬件抽象层、 外部库 和 运行时库层、 应用步伐框架层 和 应用步伐层等
开发一个应用访问硬件的流程为 : 起首在Android体系的内核空间中为一个硬件开发驱动步伐， 接着在用户空间中为该硬件添加一个硬件抽象层模块， 并且在应用步伐框架层中添加一个硬件访问服务， 末了开发一个应用步伐来访问该硬件服务

开发Android硬件驱动步伐

实现内核驱动步伐模块

驱动步伐freg的目次结构 :

1. ~/Android/kernel/goldfish
2.     drivers
3.         freg
4.             freg.h    # 源代码文件
5.             freg.c    # 源代码文件
6.             Kconfig    # 编译选项配置文件
7.             Makefile    # 编译脚本文件

复制代码

freg.h 源代码文件 :

1. // kernel\goldfish\drivers\freg\freg.h
3. #ifndef _FAKE_REG_H_
4. #define _FAKE_REG_H_
6. #include <linux/cdev.h>
7. #include <linux/semaphore.h>
9. //定义了四个字符串常量，分别用来描述虚拟硬件设备 freg 在设备文件系统中的名称
10. #define FREG_DEVICE_NODE_NAME  "freg"
11. #define FREG_DEVICE_FILE_NAME  "freg"
12. #define FREG_DEVICE_PROC_NAME  "freg"
13. #define FREG_DEVICE_CLASS_NAME "freg"
15. // 描述虚拟硬件设备freg
16. struct fake_reg_dev
17. {
18.     // 描述一个虚拟寄存器
19.     int val;
20.     // 一个信号量, 用来同步访问虚拟寄存器 val
21.     struct semaphore sem;
22.     // 一个标准的Linux字符设备结构体变量， 用来标志该虚拟硬件设备 freg 的类型为字符设备
23.     struct cdev dev;
24. };
26. #endif

复制代码

freg.c 实现文件 :

1. // kernel\goldfish\drivers\freg\freg.c
3. #include <linux/init.h>
4. #include <linux/module.h>
5. #include <linux/types.h>
6. #include <linux/fs.h>
7. #include <linux/proc_fs.h>
8. #include <linux/device.h>
9. #include <asm/uaccess.h>
11. #include "freg.h"
13. /* 主设备号 */
14. static int freg_major = 0;
15. /* 从设备号变量 */
16. static int freg_minor = 0;
18. /* 设备类别 */
19. static struct class* freg_class = NULL;
20. /* 设备变量 */
21. static struct fake_reg_dev* freg_dev = NULL;
23. /* 传统的设备文件操作方法 */
24. static int freg_open(struct inode* inode, struct file* filp);
25. static int freg_release(struct inode* inode, struct file* filp);
26. static ssize_t freg_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos);
27. static ssize_t freg_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos);
29. /* 传统的设备文件操作方法表 */
30. static struct file_operations freg_fops = {
31.         .owner = THIS_MODULE,
32.         .open = freg_open,
33.         .release = freg_release,
34.         .read = freg_read,
35.         .write = freg_write,
36. };
38. /* devfs 文件系统的设备属性操作方法 */
39. static ssize_t freg_val_show(struct device* dev, struct device_attribute* attr,  char* buf);
40. static ssize_t freg_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count);
42. /* devfs 文件系统的设备属性 */
43. static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, freg_val_show, freg_val_store);
45. /* 打开设备方法 */
46. static int freg_open(struct inode* inode, struct file* filp)
47. {
48.     struct fake_reg_dev* dev;
50.     //将自定义设备结构体保存在文件指针的私有数据域中, 以便访问设备时可以直接拿来用
51.     dev = container_of(inode->i_cdev, struct fake_reg_dev, dev);
52.     filp->private_data = dev;
54.     return 0;
55. }
57. /* 设备文件释放时调用, 空实现 */
58. static int freg_release(struct inode* inode, struct file* filp)
59. {
60.     return 0;
61. }
63. /* 读取设备的寄存器val的值 */
64. static ssize_t freg_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos)
65. {
66.     ssize_t err = 0;
67.     struct fake_reg_dev* dev = filp->private_data;
69.     /* 同步访问 */
70.     if(down_interruptible(&(dev->sem)))
71.     {   
72.         return -ERESTARTSYS;
73.     }
75.     //检查类型是否一致
76.     if(count < sizeof(dev->val))
77.     {
78.         goto out;
79.     }
81.     /* 将寄存器val的值复制到用户提供的缓冲区中 */
82.     if(copy_to_user(buf, &(dev->val), sizeof(dev->val)))
83.     {
84.         err = -EFAULT;
85.         goto out;
86.     }
88.     err = sizeof(dev->val);
90. out:
91.     // 撤销同步
92.     up(&(dev->sem));
94.     return err;
95. }
97. /* 写设备的寄存器val的值 */
98. static ssize_t freg_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos)
99. {
100.     struct fake_reg_dev* dev = filp->private_data;
101.     ssize_t err = 0;
103.     /* 同步访问 */
104.     if(down_interruptible(&(dev->sem)))
105.     {
106.         return -ERESTARTSYS;
107.     }
109.     //检查类型是否一致
110.     if(count != sizeof(dev->val))
111.     {
112.         goto out;
113.     }
115.     /* 将用户提供的缓冲区的值写到设备寄存器中 */
116.     if(copy_from_user(&(dev->val), buf, count))
117.     {
118.         err = -EFAULT;
119.         goto out;
120.     }
122.     err = sizeof(dev->val);
124. out:
125.     up(&(dev->sem));
126.     return err;
127. }
129. /* 将寄存器val的值读取到缓冲区buf中, 内部使用 */
130. static ssize_t __freg_get_val(struct fake_reg_dev* dev, char* buf)
131. {
132.     int val = 0;
134.     /* 同步访问 */
135.     if(down_interruptible(&(dev->sem)))
136.     {
137.         return -ERESTARTSYS;
138.     }
140.     val = dev->val;
142.     up(&(dev->sem));
144.     return snprintf(buf, PAGE_SIZE, "%d\n", val);
145. }
147. /* 把缓冲区buf的值写到设备寄存器val中, 内部使用 */
148. static ssize_t __freg_set_val(struct fake_reg_dev* dev, const char* buf, size_t count)
149. {
150.     int val = 0;
152.     /* 将字符串转换为数字 */
153.     val = simple_strtol(buf, NULL, 10);
155.     /* 同步访问 */
156.     if(down_interruptible(&(dev->sem)))
157.     {
158.         return -ERESTARTSYS;
159.     }
161.     dev->val = val;
162.     up(&(dev->sem));
164.     return count;
165. }
167. /* 读设备属性val的值 */
168. static ssize_t freg_val_show(struct device* dev, struct device_attribute* attr, char* buf)
169. {
170.     struct fake_reg_dev* hdev = (struct fake_reg_dev*)dev_get_drvdata(dev);
172.     return __freg_get_val(hdev, buf);
173. }
175. /* 写设备属性val的值 */
176. static ssize_t freg_val_store(struct device* dev,
177.                               struct device_attribute* attr,
178.                               const char* buf,
179.                               size_t count)
180. {
181.     struct fake_reg_dev* hdev = (struct fake_reg_dev*)dev_get_drvdata(dev);
183.     return __freg_set_val(hdev, buf, count);
184. }
186. /* 读取设备寄存器 val 的值 , 保存到page 缓冲区中*/
187. static ssize_t freg_proc_read(char* page, char** start,
188.                               off_t off,
189.                               int count,
190.                               int* eof,
191.                               void* data)
192. {
193.     if(off > 0)
194.     {
195.         *eof = 1;
196.         return 0;
197.     }
199.     return __freg_get_val(freg_dev, page);   
200. }
202. /* 把缓冲区的值 buff 保存到设备寄存器 val 中 */
203. static ssize_t freg_proc_write(struct file* filp,
204.                                const char __user *buff,
205.                                unsigned long len,
206.                                void* data)
207. {   
208.     int err = 0;
209.     char* page = NULL;
211.     if(len > PAGE_SIZE)
212.     {
213.         printk(KERN_ALERT"The buff is too large: %lu.\n", len);
214.         return -EFAULT;
215.     }
217.     page = (char*)__get_free_page(GFP_KERNEL);
218.     if(!page)
219.     {
220.         printk(KERN_ALERT"Failed to alloc page.\n");
221.         return -ENOMEM;
222.     }
224.     /* 先把用户提供的缓冲区的值复制到内核缓冲区中 */
225.     if(copy_from_user(page, buff, len))
226.     {
227.         printk(KERN_ALERT "Failed to copy buff from user.\n");
228.         err = -EFAULT;
230.         goto out;
231.     }
233.     err = __freg_set_val(freg_dev, page, len);
235. out:
236.     free_page((unsigned long)page);
237.     return err;   
238. }
240. /* 创建 /proc/freg 文件 */
241. static void freg_create_proc(void)
242. {
243.     struct proc_dir_entry* entry;
245.     entry = create_proc_entry(FREG_DEVICE_PROC_NAME, 0, NULL);
246.     if(entry)
247.     {
248.         entry->owner = THIS_MODULE;
249.         entry->read_proc = freg_proc_read;
250.         entry->write_proc = freg_proc_write;
251.     }
252. }
254. /* 删除 /proc/freg 文件 */
255. static void freg_remove_proc(void)
256. {
257.     remove_proc_entry(FREG_DEVICE_PROC_NAME, NULL);
258. }
260. /* 初始化设备 */
261. static int  __freg_setup_dev(struct fake_reg_dev* dev)
262. {
263.     int err;
264.     dev_t devno = MKDEV(freg_major, freg_minor);
266.     memset(dev, 0, sizeof(struct fake_reg_dev));
268.     /* 初始化字符设备 */
269.     cdev_init(&(dev->dev), &freg_fops);
270.     dev->dev.owner = THIS_MODULE;
271.     dev->dev.ops = &freg_fops;
273.     /* 注册字符设备 */
274.     err = cdev_add(&(dev->dev), devno, 1);
275.     if(err)
276.     {
277.         return err;
278.     }   
280.     /* 初始化信号量 */
281.     init_MUTEX(&(dev->sem));
282.     /* 初始化寄存器val的值 */
283.     dev->val = 0;
285.     return 0;
286. }
288. /* 模块加载方法 */
289. static int __init freg_init(void)
290. {
291.     int err = -1;
292.     dev_t dev = 0;
293.     struct device* temp = NULL;
295.     printk(KERN_ALERT"Initializing freg device.\n");
297.     /* 动态分配主设备号 和 从设备号 */
298.     err = alloc_chrdev_region(&dev, 0, 1, FREG_DEVICE_NODE_NAME);
299.     if(err < 0)
300.     {
301.         printk(KERN_ALERT"Failed to alloc char dev region.\n");
302.         goto fail;
303.     }
305.     freg_major = MAJOR(dev);
306.     freg_minor = MINOR(dev);
308.     /* 分配freg设备结构体 */
309.     freg_dev = kmalloc(sizeof(struct fake_reg_dev), GFP_KERNEL);
310.     if(!freg_dev)
311.     {
312.         err = -ENOMEM;
313.         printk(KERN_ALERT"Failed to alloc freg device.\n");
314.         goto unregister;
315.     }
317.     /* 初始化设备 */
318.     err = __freg_setup_dev(freg_dev);
319.     if(err)
320.     {
321.         printk(KERN_ALERT"Failed to setup freg device: %d.\n", err);
322.         goto cleanup;
323.     }
325.     /* 在/sys/class/ 目录下创建设备类别目录freg */
326.     freg_class = class_create(THIS_MODULE, FREG_DEVICE_CLASS_NAME);
327.     if(IS_ERR(freg_class))
328.     {
329.         err = PTR_ERR(freg_class);
330.         printk(KERN_ALERT"Failed to create freg device class.\n");
331.         goto destroy_cdev;
332.     }
334.     /* 在 /dev/ 目录 和 /sys/class/freg目录下分别创建设备文件frag */
335.     temp = device_create(freg_class, NULL, dev, "%s", FREG_DEVICE_FILE_NAME);
336.     if(IS_ERR(temp))
337.     {
338.         err = PTR_ERR(temp);
339.         printk(KERN_ALERT"Failed to create freg device.\n");
340.         goto destroy_class;
341.     }
343.     /* 在 /sys/class/freg/freg 目录下创建属性文件val */
344.     err = device_create_file(temp, &dev_attr_val);
345.     if(err < 0)
346.     {
347.         printk(KERN_ALERT"Failed to create attribute val of freg device.\n");
348.         goto destroy_device;
349.     }
351.     dev_set_drvdata(temp, freg_dev);
353.     /* 创建 /proc/freg文件 */
354.     freg_create_proc();
356.     printk(KERN_ALERT"Succedded to initialize freg device.\n");
358.     return 0;
360. destroy_device:
361.     device_destroy(freg_class, dev);
362. destroy_class:
363.     class_destroy(freg_class);
364. destroy_cdev:
365.     cdev_del(&(freg_dev->dev));   
366. cleanup:
367.     kfree(freg_dev);
368. unregister:
369.     unregister_chrdev_region(MKDEV(freg_major, freg_minor), 1);   
370. fail:
371.     return err;
372. }
374. /* 模块卸载方法 */
375. static void __exit freg_exit(void)
376. {
377.     dev_t devno = MKDEV(freg_major, freg_minor);
379.     printk(KERN_ALERT"Destroy freg device.\n");
381.     /* 删除 /proc/freg 文件 */
382.     freg_remove_proc();
384.     /* 注销设备类别 和 设备 */
385.     if(freg_class)
386.     {
387.         device_destroy(freg_class, MKDEV(freg_major, freg_minor));
388.         class_destroy(freg_class);
389.     }
391.     /* 删除字符设备 和 释放设备内存 */
392.     if(freg_dev)
393.     {
394.         cdev_del(&(freg_dev->dev));
395.         kfree(freg_dev);
396.     }
398.     /* 释放设备号资源 */
399.     unregister_chrdev_region(devno, 1);
400. }
402. MODULE_LICENSE("GPL");
403. MODULE_DESCRIPTION("Fake Register Driver");
405. module_init(freg_init);
406. module_exit(freg_exit);

复制代码

修改驱动编译文件

Kconfig 编译选项设置文件 :

1. # kernel\goldfish\drivers\freg\Kconfig
2. # 执行 make
3. menuconfig
4. 命令来设置这些编译选项
6. config FREG
7.     tristate "Fake Register Driver"
8.     default n
9.     help
10.     This is the freg driver for android system.

复制代码

驱动步伐 一般有三种方式来编译。
第一种方式是直接内建在内核中； 第二种方式是编译成内核模块； 第三种方式是不编译到内核中。
默认的编译方式为 n， 就是 不编译到内核中， 因此， 在编译驱动步伐 之前， 我们需要实行 make
menuconfig
下令来修改它的编译选项， 以便可以将 驱动步伐 内建到内核中 或 以模块的方式来编译。
Makefile 编译脚本文件 :

1. # kernel\goldfish\drivers\freg\Makefile
3. #  $（CONFIG_FREG） 是一个变量， 它的值与驱动程序freg的编译选项有关
5. #如果选择将驱动程序freg内建到内核中， 那么变量$（CONFIG_FREG） 的值为y；
6. # 如果选择以模块的方式来编译驱动程序freg， 那么变量$（CONFIG_FREG） 的值为m；
7. # 如果变量$（CONFIG_FREG） 的值既不为y， 也不为m，那么驱动程序freg就不会被编译
9. obj-$(CONFIG_FREG) += freg.o

复制代码

修改内核编译文件

修改内核Kconfig文件 :
在默认情况下，在实行make
menuconfig
下令设置内核编译选项时， 编译体系是无法找到 对应的驱动Kconfig文件的。 所以需要修改内核的根Kconfig文件， 使得编译体系能够找到驱动步伐freg的Kconfig文件
当实行make
menuconfig
下令时， 编译体系会读取arch/$(ARCH) 目次下的Kconfig文件， 其中， $(ARCH) 指向编译的目标CPU体系架构
一般我们都会将$(ARCH) 的值设置为arm， 因此， 就需要修改arch/arm目次下的Kconfig文件， 使得编译体系可以找到驱动步伐freg的Kconfig文件。
Arm架构下:

1. # arch/arm/Kconfig
3. menu "Device Drivers"
5. # 将驱动程序freg的Kconfig文件包含进来
6. source "drivers/freg/Kconfig"
7. source "drivers/base/Kconfig"
8. source "drivers/connector/Kconfig"
10. # ...
12. endmenu

复制代码

x86体系架构下的Kconfig文件 :

1. # drivers/Kconfig
3. # 把drivers目录下的Kconfig文件包含进去
4. source "drivers/Kconfig"
6. endmenu

复制代码

修改内核Makefile文件 :
在默认情况下， 在实行make
下令编译内核时， 编译体系是无法找到这个Makefile文件的。 这时间， 就需要修改drivers目次下的Makefile文件， 使得编译体系能够找到驱动步伐freg的Makefile文件

1. # drivers/Makefile
3. # 当 make
4. 编译内核时，编译系统就会对驱动程序 freg 进行编译
5. obj-$(CONFIG_FREG)        += freg/
6. obj-y                += gpio/
7. obj-$(CONFIG_PCI)        += pci/
8. # ...

复制代码

编译内核驱动步伐模块

在编译驱动步伐freg之前， 我们需要实行make
menuconfig
下令来设置它的编译方式

1. make
2. menuconfig

复制代码

第一个设置界面中用上下箭头键选择“Device Drivers”项， 按Enter键
第二个设置界面中继续用上下箭头键选择“Fake Register Driver”项， 按Y键或 M键， 就可以看到选项前面方括号中的字符酿成“ * ”大概“M”符号， 它们分别体现将驱动步伐freg编译到内核中 或 以模块的方式来编译
假如我们要以模块的方式来编译驱动步伐freg， 那就必须在第一个设置界面中选择“Enable loadable module support”选项， 并且按 Y 键将它的值设置为true， 就是让内核可以支持动态加载模块 .
假如要使得内核支持动态卸载模块， 那么就要在第一个设置界面中选择“Enable loadable module support”选项中的子选项“Module unloading ”， 并且按Y键将它的值设置为true。
第二个设置界面中按M 键来设置“Fake RegisterDriver”选项设置完成后， 保存编译设置选项， 退出make
menuconfig
下令
实行make
下令来编译驱动步伐freg

1. make

复制代码

驱动步伐freg编译乐成 :

编译得到的内核镜像文件zImage保存在arch/arm/boot目次下
验证内核驱动步伐模块

通过proc文件体系和devfs文件体系来验证它的功能是否正确

1. # 使用 得到的内核镜像文件zImage来启动Android模拟器
2. emulator -kernel kernel/goldfish/arch/arm/boot/zImage &
4. # # 用adb工具连接上
5. adb shell
7. # 进入 /dev目录下
8. cd dev
10. # 查看 一个设备文件freg
11. # 存在，说明成功的注册到设备文件系统中
12. ls freg

复制代码

1. # 进入到/proc
2. cd proc
4. # 读取文件freg的内容
5. cat freg
7. # 往文件freg中写入一个新的内容
8. echo '5' > freg
10. # 将文件freg的内容读取出来
11. cat freg
13. # 值一样 , 说明 proc文件系统接口成功

复制代码

1. # 进入到/sys/class/freg/freg
2. cd sys/class/freg/freg
4. # 读取val文件的内容
5. cat val
7. # 往文件val中写入一个新的内容
8. echo '0' > freg
10. # 将文件val中的内容读取出
11. cat freg
13. # 值一样 , 说明 devfs文件系统接口成功

复制代码

开发C可实行步伐验证Android硬件驱动步伐

通过编写一个C可实行步伐来验证驱动步伐freg所提供的dev文件体系接口的正确性， 这是通过调用read和write函数读写设备文件/dev/freg的内容来实现
在Android源代码工程情况中， 不但可以用C/C++语言来开发可实行步伐，还可以开发动态链接库， 也就是 so文件。
使用adb工具下令毗连上Android模拟器之后， 进入到/system/bin大概/system/lib目次中， 就可以看到很多可实行步伐大概动态链接库文件。
在Android源代码工程情况中开发的C可实行步伐源文件一般保存在external目次中，因此， 需要进入到external目次中， 并且创建一个freg目次， 用来保存我们将要开发的C可实行步伐源文件。
目次结构 :

1. ~/Android
2.     exiternal
3.         freg
4.             freg.c    # 源文件
5.             Android.mk # 编译脚本文件

复制代码

源文件 freg.c :

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <fcntl.h>
5. #define FREG_DEVICE_NAME "/dev/freg"
7. int main(int argc, char** argv)
8. {
9.     int fd = -1;
10.     int val = 0;
12.     // 以读写方式打开设备文件/dev/freg
13.     fd = open(FREG_DEVICE_NAME, O_RDWR);
14.     if(fd == -1)
15.     {
16.         printf("Failed to open device %s.\n", FREG_DEVICE_NAME);
17.         return -1;
18.     }
20.     printf("Read original value:\n");
22.     // 读取它的内容， 即读取虚拟硬件设备 freg 的寄存器 val 的内容
23.     read(fd, &val, sizeof(val));
24.     // 打印出来
25.     printf("%d.\n\n", val);
27.     val = 5;
28.     printf("Write value %d to %s.\n\n", val, FREG_DEVICE_NAME);
29.     // 将一个整数 5 写入到虚拟硬件设备 freg 的寄存器 val 中
30.     write(fd, &val, sizeof(val));
32.     printf("Read the value again:\n");
34.     // 读取它的内容， 即读取虚拟硬件设备 freg 的寄存器 val 的内容
35.     read(fd, &val, sizeof(val));
36.     // 打印
37.     printf("%d.\n\n", val);
39.     close(fd);
40.     return 0;
41. }

复制代码

编译脚本文件Android.mk :

1. # 将编译结果保存在 out/target/product/gerneric/system/bin 目录中
2. LOCAL_PATH := $(call my-dir)
3. include $(CLEAR_VARS)
4. LOCAL_MODULE_TAGS := optional
5. # 源文件
6. LOCAL_MODULE := freg
7. LOCAL_SRC_FILES := $(call all-subdir-c-files)
9. # 当前要编译的是一个可执行应用程序模块
10. include $(BUILD_EXECUTABLE)

复制代码

1. # 编译mmm ./external/freg/# 打包这个C可实行步伐make
2. snod

复制代码

编译乐成后， 就可以在out/target/product/gerneric/system/bin目次下看到一个freg文件；
打包乐成后， 编译好的文件就会包罗在out/target/product/gerneric目次下的Android体系镜像文件system.img里

1. # 将得到的 system.img 文件启动 Android模拟器
2. emulator -kernal kernel/goldfish/arch/arm/boot/zImage &
4. # adb工具连接上它
5. adb shell
7. # 进入到/system/bin目录中
8. cd system/bin
10. # 执行里面的freg文件
11. ./freg
13. # 验证驱动程序freg的dev文件系统访问接口的正确性

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。