ANDROID HAL 详细分析

1.为什么需要HAL
1>、Android的HAL是为了一些硬件提供商提出的“保护proprietary”的驱动程序而产生的东东，简而言之，就是为了避开Linux kernal的GPL license的束缚。Android把控制硬件的动作都放到了user space中，而在kernel driver里面只有最简单的读写寄存器的操作，而完全去掉了各种功能性的操作（比如控制逻辑等），这些能够体现硬件特性的操作都放到了Android的HAL层，而Android是基于Aparch的license，因此硬件厂商可以只提供二进制代码，所以说Android知识一个开放的平台，并不是一个开源的平台。
2>、Android的HAL的实现需要通过JNI（Java Native Intereface），JNI简单说就是java程序可以调用C/C++写的动态链接库，这样的话，HAL可以使用C/C++语言编写，效率更高。而Android的app可以直接调用.so，也可以通过app->app_manager->service(java)->service(jni)->HAL来调用。第二种方法看上去很复杂，但是更加符合android的架构结构。Android的HAL，从底层往上层。

 
2.android HAL架构如下：



3.HAL的实现方式
1>. libhardware_legacy/ - 过去的实现方式、采取链接库模块的观念进行
2>. libhardware/ -现在最新的实现方式、调整为 HAL stub 的观念
3>. ril/ - Radio Interface Layer

4.HAL实现方式的比较
1>. HAL 的过去


            Android HAL / libhardware_legacy

过去的 libhardware_legacy 作法，比较是传统的「module」方式，也就是将 *.so 档案当做「shared library」来使用，在runtime（JNI 部份）以 direct function call 使用 HAL module。透过直接函数呼叫的方式，来操作驱动程序。当然，应用程序也可以不需要透过 JNI 的方式进行，直接以加载 *.so 檔（dlopen）的做法呼叫*.so 里的符号（symbol）也是一种方式。总而言之是没有经过封装，上层可以直接操作硬件。

2>. HAL 的现况


                Android HAL / libhardware

现在的 libhardware 作法，就有「stub」的味道了。HAL stub 是一种代理人（proxy）的概念，stub 虽然仍是以 *.so檔的形式存在，但 HAL 已经将 *.so 档隐藏起来了。Stub 向 HAL「提供」操作函数（operations），而 runtime 则是向 HAL 取得特定模块（stub）的 operations，再 callback 这些操作函数。这种以 indirect function call 的实作架构，让HAL stub 变成是一种「包含」关系，即 HAL 里包含了许许多多的 stub（代理人）。Runtime 只要说明「类型」，即 module ID，就可以取得操作函数。对于目前的HAL，可以认为Android定义了HAL层结构框架，通过几个接口访问硬件从而统一了调用方式。
3>. HAL_legacy和HAL的对比

HAL_legacy：旧式的HAL是一个模块，采用共享库形式，在编译时会调用到。由于采用function
call形式调用，因此可被多个进程使用，但会被mapping到多个进程空间中，造成浪费，同时需要考虑代码能否安全重入的问题（thread safe）。

HAL：新式的HAL采用HAL module和HAL stub结合形式，HAL stub不是一个share library，编译时上层只拥有访问HAL stub的函数指针，并不需要HAL stub。上层通过HAL module提供的统一接口获取并操作HAL stub，so文件只会被mapping到一个进程，也不存在重复mapping和重入问题。

5.HAL如何向上层提供接口总结

首先来看三个与HAL对上层接口有关的几个结构体：

1. struct hw_module_t;              //模块类型  
2. struct hw_module_methods_t;      //模块方法  
3. struct hw_device_t;              //设备类型,向上提供接口  

这几个数据结构是在Android工作目录/hardware/libhardware/include/hardware/hardware.h文件中定义.

一般来说，在写HAL相关代码时都得包含这个hardware.h头文件，所以有必要先了解一下这个头文件中的内容.

1. /* 
2.  * Copyright (C) 2008 The Android Open Source Project 
3.  * 
4.  * Licensed under the Apache License, Version 2.0 (the "License"); 
5.  * you may not use this file except in compliance with the License. 
6.  * You may obtain a copy of the License at 
7.  * 
8.  *      
9.  * 
10.  * Unless required by applicable law or agreed to in writing, software 
11.  * distributed under the License is distributed on an "AS IS" BASIS, 
12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
13.  * See the License for the specific language governing permissions and 
14.  * limitations under the License. 
15.  */  
16.   
17. #ifndef ANDROID_INCLUDE_HARDWARE_HARDWARE_H  
18. #define ANDROID_INCLUDE_HARDWARE_HARDWARE_H  
19.   
20. #include    
21. #include    
22.   
23. #include   
24. #include    
25.   
26. __BEGIN_DECLS  
27.   
28. /* 
29.  * Value for the hw_module_t.tag field 
30.  */  
31.   
32. #define MAKE_TAG_CONSTANT(A,B,C,D) (((A) << 24) | ((B) << 16) | ((C) << 8) | (D))  
33.   
34. #define HARDWARE_MODULE_TAG MAKE_TAG_CONSTANT('H', 'W', 'M', 'T')  
35. #define HARDWARE_DEVICE_TAG MAKE_TAG_CONSTANT('H', 'W', 'D', 'T')  
36.   
37. struct hw_module_t;  
38. struct hw_module_methods_t;  
39. struct hw_device_t;  
40.   
41. /** 
42.  * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM 
43.  * and the fields of this data structure must begin with hw_module_t 
44.  * followed by module specific information. 
45.  */  
46. //每一个硬件模块都每必须有一个名为HAL_MODULE_INFO_SYM的数据结构变量，它的第一个成员的类型必须为hw_module_t  
47. typedef struct hw_module_t {  
48.     /** tag must be initialized to HARDWARE_MODULE_TAG */  
49.     uint32_t tag;  
50.   
51.     /** major version number for the module */  
52.     uint16_t version_major;  
53.   
54.     /** minor version number of the module */  
55.     uint16_t version_minor;  
56.   
57.     /** Identifier of module */  
58.     const char *id;  
59.   
60.     /** Name of this module */  
61.     const char *name;  
62.   
63.     /** Author/owner/implementor of the module */  
64.     const char *author;  
65.   
66.     /** Modules methods */  
67.     //模块方法列表,指向hw_module_methods_t*  
68.     struct hw_module_methods_t* methods;  
69.   
70.     /** module's dso */  
71.     void* dso;  
72.   
73.     /** padding to 128 bytes, reserved for future use */  
74.     uint32_t reserved[32-7];  
75.   
76. } hw_module_t;  
77.   
78. typedef struct hw_module_methods_t {                 //硬件模块方法列表的定义，这里只定义了一个open函数  
79.     /** Open a specific device */  
80.     int (*open)(const struct hw_module_t* module, const char* id, //注意这个open函数明确指出第三个参数的类型为struct hw_device_t**  
81.             struct hw_device_t** device);  
82. } hw_module_methods_t;  
83.   
84. /** 
85.  * Every device data structure must begin with hw_device_t 
86.  * followed by module specific public methods and attributes. 
87.  */  
88. //每一个设备数据结构的第一个成员函数必须是hw_device_t类型，其次才是各个公共方法和属性  
89. typedef struct hw_device_t {  
90.     /** tag must be initialized to HARDWARE_DEVICE_TAG */  
91.     uint32_t tag;  
92.   
93.     /** version number for hw_device_t */  
94.     uint32_t version;  
95.   
96.     /** reference to the module this device belongs to */  
97.     struct hw_module_t* module;  
98.   
99.     /** padding reserved for future use */  
100.     uint32_t reserved[12];  
101.   
102.     /** Close this device */  
103.     int (*close)(struct hw_device_t* device);  
104.   
105. } hw_device_t;  
106.   
107. /** 
108.  * Name of the hal_module_info 
109.  */  
110. #define HAL_MODULE_INFO_SYM         HMI  
111.   
112. /** 
113.  * Name of the hal_module_info as a string 
114.  */  
115. #define HAL_MODULE_INFO_SYM_AS_STR  "HMI"  
116.   
117. /** 
118.  * Get the module info associated with a module by id. 
119.  * 
120.  * @return: 0 == success, <0 == error and *module == NULL 
121.  */  
122. int hw_get_module(const char *id, const struct hw_module_t **module);  
123.   
124. /** 
125.  * Get the module info associated with a module instance by class 'class_id' 
126.  * and instance 'inst'. 
127.  * 
128.  * Some modules types necessitate multiple instances. For example audio supports 
129.  * multiple concurrent interfaces and thus 'audio' is the module class 
130.  * and 'primary' or 'a2dp' are module interfaces. This implies that the files 
131.  * providing these modules would be named audio.primary..so and 
132.  * audio.a2dp..so 
133.  * 
134.  * @return: 0 == success, <0 == error and *module == NULL 
135.  */  
136. int hw_get_module_by_class(const char *class_id, const char *inst,  
137.                            const struct hw_module_t **module);  
138.   
139. __END_DECLS  
140.   
141. #endif  /* ANDROID_INCLUDE_HARDWARE_HARDWARE_H */  

由以上内容可以看出(typedef struct hw_module_t ,typedef struct hw_device_t)，如果我们要写一个自定义设备的驱动的HAL层时，我们得首先自定义两个数据结构:

假设我们要做的设备名为XXX:

在头文件中定义:XXX.h

1. /*定义模块ID*/  
2. #define XXX_HARDWARE_MODULE_ID "XXX"   
3.   
4. /*硬件模块结构体*/  
5. //见hardware.h中的hw_module_t定义的说明，xxx_module_t的第一个成员必须是hw_module_t类型，其次才是模块的一此相关信息，当然也可以不定义，  
6. //这里就没有定义模块相关信息   
7. struct xxx_module_t {  
8.     struct hw_module_t common;  
9. };  
10.   
11. /*硬件接口结构体*/  
12. //见hardware.h中的hw_device_t的说明，要求自定义xxx_device_t的第一个成员必须是hw_device_t类型，其次才是其它的一些接口信息.   
13. struct xxx_device_t {  
14.     struct hw_device_t common;  
15.         //以下成员是HAL对上层提供的接口或一些属性  
16.         int fd;  
17.     int (*set_val)(struct xxx_device_t* dev, int val);  
18.     int (*get_val)(struct xxx_device_t* dev, int* val);  
19. };  

注:特别注意xxx_device_t的结构定义，这个才是HAL向上层提供接口函数的数据结构,其成员就是我们想要关心的接口函数.

接下来我们在实现文件XXX.c文件中定义一个xxx_module_t的变量:

1. /*模块实例变量*/  
2. struct xxx_module_t HAL_MODULE_INFO_SYM = {    //变量名必须为HAL_MODULE_INFO_SYM,这是强制要求的，你要写Android的HAL就得遵循这个游戏规则,  
3.                                                //见hardware.h中的hw_module_t的类型信息说明.  它是一个宏定义：#define HAL_MODULE_INFO_SYM         HMI
4.         common: {  
5.         tag: HARDWARE_MODULE_TAG,  
6.         version_major: 1,  
7.         version_minor: 0,  
8.         id: XXX_HARDWARE_MODULE_ID,    //头文件中有定义  
9.         name: MODULE_NAME,  
10.         author: MODULE_AUTHOR,  
11.         methods: &xxx_module_methods,  //模块方法列表，在本地定义  
12.     }  
13. };  

注意到上面有HAL_MODULE_INFO_SYM变量的成员common中包含一个函数列表xxx_module_methods,而这个成员函数列表是在本地自定义的。那么这个成员函数列是不是就是HAL向上层提供函数的地方呢？很失望，不是在这里，前面我们已经说过了，是在xxx_device_t中定义的,这个xxx_module_methods实际上只提供了一个open函数，就相当于只提供了一个模块初始化函数.其定义如下:

1. /*模块方法表*/  
2. static struct hw_module_methods_t xxx_module_methods = {  
3.     open: xxx_device_open  
4. };  

注意到，上边的函数列表中只列出了一个xxx_device_open函数，这个函数也是需要在本地实现的一个函数。前面说过，这个函数只相当于模块初始化函数。

那么HAL又到底是怎么将xxx_device_t中定义的接口提供到上层去的呢?

且看上面这个函数列表中唯一的一个xxx_device_open的定义:

1. static int xxx_device_open(const struct hw_module_t* module, const char* name, struct hw_device_t** device) {  
2.     struct xxx_device_t* dev;  
3.     dev = (struct hello_device_t*)malloc(sizeof(struct xxx_device_t));//动态分配空间  
4.       
5.     if(!dev) {  
6.         LOGE("Hello Stub: failed to alloc space");  
7.         return -EFAULT;  
8.     }  
9.   
10.     memset(dev, 0, sizeof(struct xxx_device_t));  
11. 
    
12.     //对dev->common的内容赋值，   
13.     dev->common.tag = HARDWARE_DEVICE_TAG;  
14.     dev->common.version = 0;  
15.     dev->common.module = (hw_module_t*)module;  
16.     dev->common.close = xxx_device_close;  
17.         
18.     //对dev其它成员赋值   
19.     dev->set_val = xxx_set_val;  
20.     dev->get_val = xxx_get_val;  
21.   
22.     if((dev->fd = open(DEVICE_NAME, O_RDWR)) == -1) {  
23.         LOGE("Hello Stub: failed to open /dev/hello -- %s.", strerror(errno));  
24.         free(dev);  
25.         return -EFAULT;  
26.     }  
27.           
28.     //输出&(dev->common),输出的并不是dev,而是&(dev->common)!(common内不是只包含了一个close接口吗?)  
29.     *device = &(dev->common);  
30.     LOGI("Hello Stub: open /dev/hello successfully.");  
31.   
32.     return 0;  
33. }  

经验告诉我们，一般在进行模块初始化的时候，模块的接口函数也会“注册”，上面是模块初始化函数，那么接口注册在哪？于是我们找到*device =&(dev->common);这行代码，可问题是，这样一来，返回给调用者不是&(dev->common)吗？而这个dev->common仅仅只包含了一个模块关闭接口！到底怎么回事？为什么不直接返回dev,dev下不是提供所有HAL向上层接口吗?

在回答上述问题之前，让我们先看一下这xxx_device_open函数原型,还是在hardware.h头文件中,找到下面几行代码:

1. typedef struct hw_module_methods_t {  
2.     /** Open a specific device */  
3.     int (*open)(const struct hw_module_t* module, const char* id,  
4.             struct hw_device_t** device);  
5.   
6. } hw_module_methods_t;  

这是方法列表的定义，明确要求了方法列表中有且只一个open方法，即相当于模块初始化方法，且，这个方法的第三个参数明确指明了类型是struct hw_device_t **,而不是用户自定义的xxx_device_t,这也就是解译了在open函数实现内为什么输出的是&(dev->common)而不是dev了，原来返回的类型在hardware.h中的open函数原型中明确指出只能返回hw_device_t类型.

可是，dev->common不是只包含close接口吗？做为HAL的上层，它又是怎么"看得到"HAL提供的全部接口的呢?

接下来，让我们来看看做为HAL上层，它又是怎么使用由HAL返回的dev->common的:

1. /*通过硬件抽象层定义的硬件模块打开接口打开硬件设备*/    
2. static inline int hello_device_open(const hw_module_t* module, struct hello_device_t** device) {    
3.      return module->methods->open(module, HELLO_HARDWARE_MODULE_ID, (struct hw_device_t**)device);    
4. }    

由此可见，返回的&(dev->common)最终会返回给struce hello_device_t **类型的输出变量device,换句话说，类型为hw_device_t的dev->common在初始化函数open返回后，会强制转化为xxx_device_t来使用，终于明白了，原来如此！另外，在hardware.h中对xxx_device_t类型有说明，要求它的第一个成员的类型必须是hw_device_t，原来是为了HAL上层使用时的强制转化的目的，如果xxx_device_t的第一个成员类型不是hw_device_t，那么HAL上层使用中强制转化就没有意义了，这个时候，就真的“看不到”HAL提供的接口了.

此外，在hardware.h头文件中，还有明确要求定义xxx_module_t类型时，明确要求第一个成员变量类型必须为hw_module_t，这也是为了方便找到其第一个成员变量common,进而找到本地定义的方法列表，从而调用open函数进行模块初始化.

综上所述，HAL是通过struct xxx_device_t这个结构体向上层提供接口的.

即：接口包含在struct xxx_device_t这个结构体内。

而具体执行是通过struct xxx_module_t HAL_MODULE_INFO_SYM这个结构体变量的函数列表成员下的open函数来返回给上层的.

6.上层APP调用底层硬件驱动过程解析

一、硬件驱动层

进入kernel/drivers文件夹中，创建一文件夹，放入驱动程序。包括头文件，C文件，Makefile，Kconfig。同时对drivers下的Makefile跟Kconfig进行相应的添加，这样配置编译选项后，即可编译。编译完后，可以在/dev，/proc，/sys/class中得到相应的文件，其中dev下的文件即为该设备文件。

二、硬件抽象层

进入源码根目录下的hardware/libhardware/include/hardware新建头文件，在hardware/libhardware/modules中新建目录，在该目录下放入C文件调用设备文件（open函数打开/dev/XXX设备文件），最后在该目录下创建Android.mk文件，编译后得到XXX.default.so文件。重新打包后，system.img就包含我们定义的硬件抽象层模块XXX.default。

三、应用框架层

进入frameworks/base/services/jni目录，创建com_android_server_XXXService.cpp文件（#include  以此调用抽象层方法 ），实现jni方法。com_android_server前缀表示的是包名，表示硬件服务XXXService是放在frameworks/base/services/java目录下的com/android/server目录的。对同目录下的onload.cpp文件进行修改，这样，在Android系统初始化时，就会自动加载该JNI方法调用表。同时修改该目录下的Android.mk。

进入到frameworks/base/core/java/android/os目录，新增IXXXService.aidl接口定义文件，该文件提供功能函数。在frameworks/base目录下的Android.mk添加该aidl文件。进入frameworks/base/services/java/com/android/server目录，新增XXXService.java（主要是通过调用JNI方法来提供硬件服务），修改同目录的SystemServer.java文件，在ServerThread::run函数中增加加载XXXService的代码。

这样，重新打包后的system.img系统镜像文件就在Application Frameworks层中包含了我们自定义的硬件服务XXXService了，并且会在系统启动的时候，自动加载XXXService。这时，应用程序就可以通过Java接口来访问XXX硬件服务了。

四、APP应用层

用eclipse编写应用层的APP。程序通过ServiceManager.getService("XXX")来获得XXXService，接着通过IXXXService.Stub.asInterface函数转换为IXXXService接口。然后把出R文件的其他文件都拷到/packages/experimental下，在该APP目录下创建Android.mk文件。编译后安装该生成的apk即可使用该程序调用底层硬件驱动。

        

大概整个过程就这样，上层app调用框架层的java接口，java接口通过jni调用硬件抽象层，硬件抽象层则通过打开设备文件调用底层硬件驱动。