android HAL 理解

一、概述

    本文希望通过分析台湾的Jollen的mokoid 工程代码，解析Andorid HAL的开发方法。     

二、HAL介绍

    现有HAL架构由Patrick Brady (Google) 在2008 Google  I/O演讲中提出的，如下图。

 

 

    Android的HAL是为了保护一些硬件提供商的知识产权而提出的，是为了避开linux的GPL束缚。思路是把控制硬件的动作都放到了Android HAL中，而linux driver仅仅完成一些简单的数据交互作用，甚至把硬件寄存器空间直接映射到user space。而Android是基于Aparch的license，因此硬件厂商可以只提供二进制代码，所以说Android只是一个开放的平台，并不是一个开源的平台。也许也正是因为Android不遵从GPL，所以Greg Kroah-Hartman才在2.6.33内核将Andorid驱动从linux中删除。GPL和硬件厂商目前还是有着无法弥合的裂痕。Android想要把这个问题处理好也是不容易的。

    总结下来，Android HAL存在的原因主要有：

    1. 并不是所有的硬件设备都有标准的linux kernel的接口

    2. KERNEL DRIVER涉及到GPL的版权。某些设备制造商并不原因公开硬件驱动，所以才去用HAL方    式绕过GPL。

    3. 针对某些硬件，An有一些特殊的需求

 

三、HAL内容

1、HAL 主要的储存于以下目录：

（注意：HAL在其它目录下也可以正常编译）

l  libhardware_legacy/ - 旧的架构、采取链接库模块的观念进行

l  libhardware/ - 新架构、调整为 HAL stub 的观念

l  ril/ - Radio Interface Layer

l  msm7k  QUAL平台相关

    主要包含以下一些模块：Gps、Vibrator、Wifi、Copybit、Audio、Camera、Lights、Ril、Overlay等。

2、两种 HAL 架构比较

    目前存在两种HAL架构，位于libhardware_legacy目录下的“旧HAL架构”和位于libhardware目录下的“新HAL架构”。两种框架如下图所示。

                   图3.1   旧HAL架构                             图3.2  新HAL架构

 

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

    现在的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层结构框架，通过几个接口访问硬件从而统一了调用方式。

Android的HAL是为了保护一些硬件提供商的知识产权而提出的，是为了避开linux的GPL束缚。思路是把控制硬件的动作都放到了 Android HAL中，而linux driver仅仅完成一些简单的数据交互作用，甚至把硬件寄存器空间直接映射到user space。而Android是基于Aparch的license，因此硬件厂商可以只提供二进制代码，所以说Android只是一个开放的平台，并不是一个开源的平台。也许也正是因为Android不遵从GPL，所以Greg Kroah-Hartman才在2.6.33内核将Andorid驱动从linux中删除。GPL和硬件厂商目前还是有着无法弥合的裂痕。Android 想要把这个问题处理好也是不容易的。

总结下来，Android HAL存在的原因主要有：

    1. 并不是所有的硬件设备都有标准的linux kernel的接口

    2. KERNEL DRIVER涉及到GPL的版权。某些设备制造商并不原因公开硬件驱动，所以才去用HAL方式绕过GPL。

    3. 针对某些硬件，Android有一些特殊的需求.

HAL stub的框架比较简单，三个结构体、两个常量、一个函数，简称321架构，它的定义在：

@hardware/libhardware/include/hardware/hardware.h

@hardware/libhardware/hardware.c

2 与接口相关的几个结构体

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

?

1

2

3

structhw_module_t;              //模块类型

structhw_module_methods_t;      //模块方法

structhw_device_t;              //设备类型

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

[cpp] view plaincopy

1. /*  
2. 每一个硬件都通过hw_module_t来描述，我们称之为一个硬件对象。你可以去“继承”这个hw_module_t，然后扩展自己的属性，硬件对象必须定义为一个固定的名字：HMI，即：Hardware Module Information的简写，每一个硬件对象里都封装了一个函数指针open用于打开该硬件，我们理解为硬件对象的open方法，open调用后返回这个硬件对应的Operation interface。 
3. */  
4. struct hw_module_t｛  
5.     uint32_t tag;           // 该值必须声明为HARDWARE_MODULE_TAG  
6.     uint16_t version_major; // 主版本号  
7.     uint16_t version_minor;     // 次版本号  
8.     const char *id;         //硬件id名，唯一标识module  
9.     const char *name;       // 硬件module名字  
10.     const char * author;        // 作者  
11.     struct hw_module_methods_t* methods;    //指向封装有open函数指针的结构体  
12.     void* dso;              // module’s dso  
13.     uint32_t reserved[32-7];    // 128字节补齐  
14. ｝;  
15.   
16. /*  
17. 硬件对象的open方法描述结构体，它里面只有一个元素：open函数指针 
18. */  
19. struct hw_module_methods_t{  
20.     // 只封装了open函数指针  
21.     int (*open)(const struct hw_module_t* module, const char * id,  
22.         struct hw_device_t** device);  
23. };  
24.   
25. /* 
26. 硬件对象hw_module_t的open方法返回该硬件的Operation interface，它由hw_device_t结构体来描述，我们称之为：该硬件的操作接口 
27. */  
28. struct hw_device_t{  
29.     uint32_t tag;               // 必须赋值为HARDWARE_DEVICE_TAG  
30.     uint32_t version;               // 版本号  
31.     struct hw_module_t* module; // 该设备操作属于哪个硬件对象，可以看成硬件操作接口与硬件对象的联系  
32.     uint32_t reserved[12];          // 字节补齐  
33.     int (*close)(struct hw_device_t* device);   // 该设备的关闭函数指针，可以看做硬件的close方法  
34. }; 
    

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

在头文件中定义:XXX.h

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

/*定义模块ID*/

#define XXX_HARDWARE_MODULE_ID "XXX"

 

/*硬件模块结构体*/

//见hardware.h中的hw_module_t定义的说明，xxx_module_t的第一个成员必须是hw_module_t类型，其次才是模块的一此相关信息，当然也可以不定义，

//这里就没有定义模块相关信息

structxxx_module_t {

    structhw_module_t common;

};

 

/*硬件接口结构体*/

//见hardware.h中的hw_device_t的说明，要求自定义xxx_device_t的第一个成员必须是hw_device_t类型，其次才是其它的一些接口信息.

structxxx_device_t {

    structhw_device_t common;

        //以下成员是HAL对上层提供的接口或一些属性

        intfd;

    int(*set_val)(structxxx_device_t* dev, intval);

    int(*get_val)(structxxx_device_t* dev, int* val);

};

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

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

?

1

2

3

4

5

6

7

8

9

10

11

12

13

/*模块实例变量*/

structxxx_module_t HAL_MODULE_INFO_SYM = {    //变量名必须为HAL_MODULE_INFO_SYM,这是强制要求的，你要写Android的HAL就得遵循这个游戏规则,

                                               //见hardware.h中的hw_module_t的类型信息说明.

        common: {

        tag: HARDWARE_MODULE_TAG,

        version_major: 1,

        version_minor: 0,

        id: XXX_HARDWARE_MODULE_ID,   //头文件中有定义

        name: MODULE_NAME,

        author: MODULE_AUTHOR,

        methods: &xxx_module_methods, //模块方法列表，在本地定义

    }

};

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

?

1

2

3

4

/*模块方法表*/

staticstruct hw_module_methods_t xxx_module_methods = {

    open: xxx_device_open

};

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

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

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

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

staticint xxx_device_open(conststruct hw_module_t* module,const char* name, structhw_device_t** device) {

    structxxx_device_t* dev;

    dev = (structhello_device_t*)malloc(sizeof(structxxx_device_t));//动态分配空间

     

    if(!dev) {

        LOGE("Hello Stub: failed to alloc space");

        return-EFAULT;

    }

 

    memset(dev, 0,sizeof(structxxx_device_t));

        //对dev->common的内容赋值，

        dev->common.tag = HARDWARE_DEVICE_TAG;

    dev->common.version = 0;

    dev->common.module = (hw_module_t*)module;

    dev->common.close = xxx_device_close;

        //对dev其它成员赋值

        dev->set_val = xxx_set_val;

    dev->get_val = xxx_get_val;

 

    if((dev->fd = open(DEVICE_NAME, O_RDWR)) == -1) {

        LOGE("Hello Stub: failed to open /dev/hello -- %s.",strerror(errno));

        free(dev);

        return-EFAULT;

    }

         

        //输出&(dev->common),输出的并不是dev,而是&(dev->common)!(common内不是只包含了一个close接口吗?)

    *device = &(dev->common);

    LOGI("Hello Stub: open /dev/hello successfully.");

 

    return0;

}

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

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

?

1

2

3

4

5

6

typedefstruct hw_module_methods_t {

    /** Open a specific device */

    int(*open)(conststruct hw_module_t* module,const char* id,

            structhw_device_t** device);

 

} 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的:

参考: 在Ubuntu为Android硬件抽象层（HAL）模块编写JNI方法提供Java访问硬件服务接口 这篇文章,从中可以看到这么几行代码：

?

1

2

3

4

/*通过硬件抽象层定义的硬件模块打开接口打开硬件设备*/ 

staticinline inthello_device_open(consthw_module_t* module, structhello_device_t** device) { 

     returnmodule->methods->open(module, HELLO_HARDWARE_MODULE_ID, (structhw_device_t**)device); 

}

由此可见，返回的&(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函数来返回给上层的.

文章出处：http://blog.csdn.net/flydream0/article/details/7086273

http://blog.csdn.net/mr_raptor/article/details/8074549