一、概述
本文希望通过分析台湾的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 想要把这个问题处理好也是不容易的。
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
|
struct
hw_module_t;
//模块类型
struct
hw_module_methods_t;
//模块方法
struct
hw_device_t;
//设备类型
|
- /*
- 每一个硬件都通过hw_module_t来描述,我们称之为一个硬件对象。你可以去“继承”这个hw_module_t,然后扩展自己的属性,硬件对象必须定义为一个固定的名字:HMI,即:Hardware Module Information的简写,每一个硬件对象里都封装了一个函数指针open用于打开该硬件,我们理解为硬件对象的open方法,open调用后返回这个硬件对应的Operation interface。
- */
- struct hw_module_t{
- uint32_t tag; // 该值必须声明为HARDWARE_MODULE_TAG
- uint16_t version_major; // 主版本号
- uint16_t version_minor; // 次版本号
- const char *id; //硬件id名,唯一标识module
- const char *name; // 硬件module名字
- const char * author; // 作者
- struct hw_module_methods_t* methods; //指向封装有open函数指针的结构体
- void* dso; // module’s dso
- uint32_t reserved[32-7]; // 128字节补齐
- };
- /*
- 硬件对象的open方法描述结构体,它里面只有一个元素:open函数指针
- */
- struct hw_module_methods_t{
- // 只封装了open函数指针
- int (*open)(const struct hw_module_t* module, const char * id,
- struct hw_device_t** device);
- };
- /*
- 硬件对象hw_module_t的open方法返回该硬件的Operation interface,它由hw_device_t结构体来描述,我们称之为:该硬件的操作接口
- */
- struct hw_device_t{
- uint32_t tag; // 必须赋值为HARDWARE_DEVICE_TAG
- uint32_t version; // 版本号
- struct hw_module_t* module; // 该设备操作属于哪个硬件对象,可以看成硬件操作接口与硬件对象的联系
- uint32_t reserved[12]; // 字节补齐
- int (*close)(struct hw_device_t* device); // 该设备的关闭函数指针,可以看做硬件的close方法
- };
假设我们要做的设备名为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类型,其次才是模块的一此相关信息,当然也可以不定义,
//这里就没有定义模块相关信息
struct xxx_module_t {
struct hw_module_t common;
};
/*硬件接口结构体*/
//见hardware.h中的hw_device_t的说明,要求自定义xxx_device_t的第一个成员必须是hw_device_t类型,其次才是其它的一些接口信息.
struct xxx_device_t {
struct hw_device_t common;
//以下成员是HAL对上层提供的接口或一些属性
int fd;
int (*set_val)( struct xxx_device_t* dev, int val);
int (*get_val)( struct xxx_device_t* dev, int * val);
};
|
接下来我们在实现文件XXX.c文件中定义一个xxx_module_t的变量:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/*模块实例变量*/
struct xxx_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, //模块方法列表,在本地定义
}
};
|
1
2
3
4
|
/*模块方法表*/
static struct hw_module_methods_t xxx_module_methods = {
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
|
static int xxx_device_open( const struct hw_module_t* module, const char * name, struct hw_device_t** device) {
struct xxx_device_t* dev;
dev = ( struct hello_device_t*) malloc ( sizeof ( struct xxx_device_t)); //动态分配空间
if (!dev) {
LOGE( "Hello Stub: failed to alloc space" );
return -EFAULT;
}
memset (dev, 0, sizeof ( struct xxx_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." );
return 0;
}
|
在回答上述问题之前,让我们先看一下这xxx_device_open函数原型,还是在hardware.h头文件中,找到下面几行代码:
1
2
3
4
5
6
|
typedef struct hw_module_methods_t {
/** Open a specific device */
int (*open)( const struct hw_module_t* module, const char * id,
struct hw_device_t** device);
} hw_module_methods_t;
|
可是,dev->common不是只包含close接口吗?做为HAL的上层,它又是怎么"看得到"HAL提供的全部接口的呢?
接下来,让我们来看看做为HAL上层,它又是怎么使用由HAL返回的dev->common的:
参考: 在Ubuntu为Android硬件抽象层(HAL)模块编写JNI方法提供Java访问硬件服务接口 这篇文章,从中可以看到这么几行代码:
1
2
3
4
|
/*通过硬件抽象层定义的硬件模块打开接口打开硬件设备*/
static inline int hello_device_open( const hw_module_t* module, struct hello_device_t** device) {
return module->methods->open(module, HELLO_HARDWARE_MODULE_ID, ( struct hw_device_t**)device);
}
|
此外,在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