Android平台与硬件间的接口-HAL Stub框架分析

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

【1】:
每一个硬件都通过 hw_module_t 来描述，我们称之为一个硬件对象。

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字节补齐
｝;
``
可以“继承”这个hw_module_t，然后扩展自己的属性，硬件对象必须定义为一个固定的名字：HMI，即：Hardware Module Information的简写.
【2】
hw_device_t结构体描述硬件模块，我们称之为：硬件的操作接口
```cpp
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方法
};

【3】
hw_module_methods_t 结构体，硬件模块对象提供的方法，

struct hw_module_methods_t{
    
    
	// 只封装了open函数指针
	int (*open)(const struct hw_module_t * module, const char * id,
		struct hw_device_t ** device);
};
```每一个硬件对象里都封装了一个函数指针open用于打开该硬件，我们理解为硬件对象的open方法，
open调用后返回这个硬件对应的Operation interface。

【4】
上述三个结构之间关系紧密，每个硬件对象由一个 hw_module_t 来描述，只要我们拿到了这个硬件对象，就可以调用它的open方法，返回这个硬件对象的硬件操作接口，然后就可以通过这些硬件操作接口来间接操作硬件了。

那用户程序如何才能拿到硬件对象呢？
答案是通过硬件id名来拿。

```cpp
// 这个就是HAL Stub对象固定的名字
#define HAL_MODULE_INFO_SYM         	HMI
// 这是字符串形式的名字
#define HAL_MODULE_INFO_SYM_AS_STR  	"HMI"
//这个函数是通过硬件名来获得硬件HAL Stub对象
int hw_get_module(const char *id, const struct hw_module_t **module);

当用户调用hw_get_module函数时，第一个参数传硬件id名，那么这个函数会从当前系统注册的硬件对象里查找传递过来的id名对应的硬件对象，然后返回之。

【5】
从调用者的角度，我们基本上没有什么障碍了，那如何注册一个硬件对象呢？
很简单，只需要声明一个结构体即可，看下面这个Led Stub注册的例子：

const struct led_module_t HAL_MODULE_INFO_SYM = {
    
    
    common: {
    
    	// 初始化父结构hw_module_t成员
        tag: HARDWARE_MODULE_TAG,
	    version_major: 1,
	    version_minor: 0,
	    id: LED_HARDWARE_MODULE_ID,
	    name: "led HAL Stub",
	    author: "farsight",
	    methods: &led_module_methods,
	}, 
	// 扩展属性放在这儿
};

我们只需要声明一个结构体led_moduel_t，起名叫HAL_MODULE_INFO_SYM，也就是固定的名字：HMI，然后将这个结构体填充好就行了。

led_module_t 又是什么结构体类型啊？前面分析 hw_modult_t 类型时说过，我们可以“继承” hw_module_t 类型，创建自己的硬件对象，然后自己再扩展特有属性.led_module_t 如下定义:

struct led_module_t {
    
    
	struct hw_module_t common;
};

这里的 led_module_t 就是 “继承” 的 hw_module_t 类型， 注意，继承加上了双引号，因为在C语言里没有继承这个概念，我们姑且这么理解。
结构体 led_module_t 封装了 hw_module_t 结构体，也就是说 led_module_t 这个新（子）结构体包含了旧（父）结构体，在新结构体里可以再扩展一些新的成员。结构体本身就具有封装特性，这与面向对象的封装和继承的类似。

【6】
该 open 方法既：methods，自然也被子结构体给“继承”下来，我们将它初始化为 led_module_methods 的地址，该结构是 hw_module_methods_t 类型的，其声明代码如下：

扫描二维码关注公众号，回复： 12845216 查看本文章

static struct hw_module_methods_t led_module_methods = {
    
    
    open: led_device_open  
};

【7】

static int led_device_open(const struct hw_module_t* module, const char* name,
	struct hw_device_t** device)
{
    
    
	struct led_device_t *led_device;
	LOGI("%s E ", __func__);
	led_device = (struct led_device_t *)malloc(sizeof(*led_device));
	memset(led_device, 0, sizeof(*led_device)); 
 
	// init hw_device_t
	led_device->common.tag= HARDWARE_DEVICE_TAG;
	led_device->common.version = 0;
	led_device->common.module= module;
	led_device->common.close = led_device_close; 
 
	// init operation interface
	led_device->set_on= led_set_on;
	led_device->set_off= led_set_off;
	led_device->get_led_count = led_getcount;
	*device= (struct hw_device_t *)led_device;
 
	if((fd=open("/dev/leds",O_RDWR))==-1)
	{
    
    
		LOGI("open error");
		return -1;
	}else
	LOGI("open ok\n");
 
	return 0;
}

led_device_open函数的功能：
Ø 分配硬件设备操作结构体led_device_t，该结构体描述硬件操作行为

Ø 初始化led_device_t的父结构体hw_device_t成员

Ø 初始化led_device_t中扩展的操作接口

Ø 打开设备，将led_device_t结构体以父结构体类型返回（面向对象里的多态）

【8】
看下 led_device_t 和其父结构体 hw_device_t 的关系：

struct led_device_t {
    
    
	struct hw_device_t common;   // led_devict_t的父结构，它里面只封装了close方法
	// 下面三个函数指针是子结构 led_device_t 对父结构 hw_device_t 的扩展，可以理解为子类扩展了父类增加了三个方法
	int (*getcount_led)(struct led_device_t *dev);
	int (*set_on)(struct led_device_t *dev);
	int (*set_off)(struct led_device_t *dev);
};

剩下的工作就是实现子结构中新扩展的三个接口。

static int led_getcount(struct led_control_device_t*dev)
{
    
    
         LOGI("led_getcount");
         return 4;
}
 
static int led_set_on(struct led_control_device_t *dev)
{
    
       
         LOGI("led_set_on");
         ioctl(fd,GPG3DAT2_ON,NULL);
         return 0;
}
 
static int led_set_off(struct led_control_device_t*dev)
{
    
    
         LOGI("led_set_off");
         ioctl(fd,GPG3DAT2_OFF,NULL);
         return 0;
}

这三个接口函数直接和底层驱动打交道去控制硬件，具体驱动就是linux部分的驱动知识了。这就是android通过321的方式，与linux底层驱动对接一般方法。

总结一下：

我们有一个硬件 id 名，通过这个 id 调用 hw_get_module(char*id, struct hw_module_t **module)函数查找注册在当前系统中与id对应的硬件对象并返回之；
硬件对象里有个通过 hw_module_methods_t 结构封装的 open 函数指针，回调这个open函数，它返回封装有硬件操作接口的 led_device_t 结构体，这样我们可以通过这个硬件接口去间接的访问硬件。

在这个过程中 hw_get_module 返回的是子结构体类型 led_module_t ，虽然函数的第二个参数类型为hw_module_t 的父类型，这里用到了面向对象里的多态的概念。

参考大神的博客:
https://outfox.blog.csdn.net/article/details/8074549
梳理记录。