Android7.0 APP调用驱动流程 HAL层开发流程

最新推荐文章于 2024-03-06 13:26:41 发布

一只肥啾啾

最新推荐文章于 2024-03-06 13:26:41 发布

阅读量1k

点赞数

分类专栏： Android7.0 系统层开发教程文章标签： android java c++ c语言

本文链接：https://blog.csdn.net/zzf405788549/article/details/104609886

版权

Android7.0 系统层开发教程专栏收录该内容

4 篇文章 3 订阅

订阅专栏

Android系统为硬件抽象层中的模块接口定义了编写规范，开发中必须按照这个规范来编写自己的硬件模块接口，否则就会导致无法正常访问硬件。下面我们首先介绍硬件抽象层模块接口的编写规范，然后再按照这个规范为虚拟硬件设备GpioDev_device_t开发硬件抽象层模块接口，并且分析硬件抽象层模块的加载过程，最后讨论硬件设备的访问权限问题。

4.1 HAL 编程规范介绍

Android系统的硬件抽象层以模块的形式来管理各个硬件访问接口。每一个硬件模块都对应有一个动态链接库文件，这些动态链接库文件的命令需要符合一定的规范。同时，在系统内部，每一个硬件抽象层模块都使用结构体hw_module_t来描述，而硬件设备则使用结构体hw_device_t来描述。接下来，我们就分别描述硬件抽象层模块文件的命名规范以及结构体hw_module_t和hw_device_t的定义。

结构体hw_module_t和hw_device_t及其相关的其他结构体定义在文件hardware/libhardware/include/hardware/hardware.h中。

结构体hw_module_t：

/*
 * Value for the hw_module_t.tag field
 */
 
#define MAKE_TAG_CONSTANT(A，B，C，D) (((A) << 24) | ((B) << 16) | ((C) << 8) | (D))
#define HARDWARE_MODULE_TAG MAKE_TAG_CONSTANT('H'， 'W'， 'M'， 'T')
 
/**
 * Name of the hal_module_info
 */
#define HAL_MODULE_INFO_SYM HMI
 
/**
 * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM
 * and the fields of this data structure must begin with hw_module_t
 * followed by module specific information.
 */
typedef struct hw_module_t {
    /** tag must be initialized to HARDWARE_MODULE_TAG */
    uint32_t tag;
 
    /** major version number for the module */
    uint16_t version_major;
 
    /** minor version number of the module */
    uint16_t version_minor;
 
    /** Identifier of module */
    const char *id;
 
    /** Name of this module */
    const char *name;
 
    /** Author/owner/implementor of the module */
    const char *author;
 
    /** Modules methods */
    struct hw_module_methods_t* methods;
 
    /** module's dso */
    void* dso;
 
    /** padding to 128 bytes， reserved for future use */
    uint32_t reserved[32-7];
 
} hw_module_t;

在结构体hw_module_t的定义前面有一段注释，意思是，硬件抽象层中的每一个模块都必须自定义一个硬件抽象层模块结构体，而且它的第一个成员变量的类型必须为hw_module_t。
硬件抽象层中的每一个模块都必须存在一个导出符号HAL_MODULE_IFNO_SYM，即“HMI”，它指向一个自定义的硬件抽象层模块结构体。后面我们在分析硬件抽象层模块的加载过程时，将会看到这个导出符号的意义。
结构体hw_module_t的成员变量tag的值必须设置为HARDWARE_MODULE_TAG，即设置为一个常量值('H'<<24 | 'W'<<16 | 'M'<<8 | 'T')，用来标志这是一个硬件抽象层模块结构体。
结构体hw_module_t的成员变量dso用来保存加载硬件抽象层模块后得到的句柄值。前面提到，每一个硬件抽象层模块都对应有一个动态链接库文件。加载硬件抽象层模块的过程实际上就是调用dlopen函数来加载与其对应的动态链接库文件的过程。在调用dlclose函数来卸载这个硬件抽象层模块时，要用到这个句柄值，因此，我们在加载时需要将它保存起来。

结构体hw_module_t的成员变量methods定义了一个硬件抽象层模块的操作方法列表，它的类型为hw_module_methods_t，接下来我们就介绍它的定义。

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;

结构体hw_module_methods_t只有一个成员变量，它是一个函数指针，用来打开硬件抽象层模块中的硬件设备。其中，参数module表示要打开的硬件设备所在的模块;参数id表示要打开的硬件设备的ID；参数device是一个输出参数，用来描述一个已经打开的硬件设备。由于一个硬件抽象层模块可能会包含多个硬件设备，因此，在调用结构体hw_module_methods_t的成员变量open来打开一个硬件设备时，我们需要指定它的ID。硬件抽象层中的硬件设备使用结构体hw_device_t来描述，接下来我们就介绍它的定义。

结构体hw_device_t：

#define HARDWARE_DEVICE_TAG MAKE_TAG_CONSTANT('H'， 'W'， 'D'， 'T')
 
/**
 * Every device data structure must begin with hw_device_t
 * followed by module specific public methods and attributes.
 */
typedef struct hw_device_t {
    /** tag must be initialized to HARDWARE_DEVICE_TAG */
    uint32_t tag;
 
    /** version number for hw_device_t */
    uint32_t version;
 
    /** reference to the module this device belongs to */
    struct hw_module_t* module;
 
    /** padding reserved for future use */
    uint32_t reserved[12];
 
    /** Close this device */
    int (*close)(struct hw_device_t* device);
 
} hw_device_t;

HAL的每一个硬件设备都必须自定义一个硬件设备结构体，而且它的第一个成员变量的类型必须为hw_device_t。
结构体hw_device_t的成员变量tag的值必须设置为HARDWARE_DEVICE_TAG，即设置为一个常量值('H'<<24 | 'W'<<16 | 'D'<<8 | 'T')，用来标志这是一个硬件抽象层中的硬件设备结构体。
注意：硬件抽象层中的硬件设备是由其所在的模块提供接口来打开的，而关闭则是由硬件设备自身提供接口来完成的。
结构体hw_device_t的成员变量close是一个函数指针，它用来关闭一个硬件设备。

4.2 自定义HAL模块

每一个硬件抽象层模块在内核中都对应有一个驱动程序，硬件抽象层模块就是通过这些驱动程序来访问硬件设备的，它们是通过读写设备文件来进行通信的，也就是设备节点类似于读写“dev/tty1”，“dev/tty2”驱动文件等等。

进入目录hardware/libhardware/include/hardware，新建头文件IBankGpioDev.h。

#ifndef ANDROID_GRGDEVCTRL_INTERFACE_H
#define ANDROID_GRGDEVCTRL_INTERFACE_H
#include <hardware/hardware.h>
__BEGIN_DECLS
/**
 * The id of this module
 */
#define GRGDEV_HARDWARE_MODULE_ID "IBankGpioDev"
/**
 * The id of this device
 */
#define GRGDEV_HARDWARE_DEVICE_ID "IBankGpioDev"
struct GpioDev_module_t {
	struct hw_module_t common;
};

struct GpioDev_device_t {
	struct hw_device_t common;
	int fd;
	int (*writeGpioNode)(struct GpioDev_device_t* dev, int val,char *pNodePath);
	int (*readGpioNode)(struct GpioDev_device_t* dev, int* val);
};
__END_DECLS
#endif

按照上面介绍的HAL层编程规范我们定义GpioDev_device_t硬件设备和GpioDev_module_t模块。GpioDev_device_t第一个成员必须为hw_device_t，GpioDev_module_t的第一个成员必须为hw_module_t，这里我觉得主要用于做数据类型转换从后面介绍看到。GpioDev_device_t还定义了一些成员，fd主要用来保存打开驱动时获取的句柄、writeGpioNode和readGpioNode主要用于对驱动进行读写。宏GRGDEV_HARDWARE_MODULE_ID、GRGDEV_HARDWARE_DEVICE_ID用来表示硬件抽象层的模块ID和驱动ID，主要用来给使用HAL的时候通过这两个ID来找到当前的HAL驱动。

4.3 实现自定义HAL模块

进入到目录：hardware\libhardware\modules创建一个目录IBankGpioDev然后添加我们的HAL模块实现文件IBankGpioDev.cpp。

#include <hardware/hardware.h>
#include <hardware/IBankGpioDev.h>
#include <fcntl.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <cutils/log.h>
#include <cutils/atomic.h>
#include <iostream>
#define DEVICE_NAME "/proc/driver/md_led_on"
#define MODULE_NAME "IBankGpioDev"
#define MODULE_AUTHOR "zzf"

//按照HAL编程过程定义本地的实现函数接口
static int Grg_GpioDev_Open(const struct hw_module_t* module, const char* id, struct hw_device_t** device);
static int Grg_GpioDev_Close(struct hw_device_t* device);
static int Grg_GpioDev_WriteNode(struct GpioDev_device_t* dev, int val,char *pNodePath);
static int Grg_GpioDev_ReadNode(struct GpioDev_device_t* dev, int* val);

//初始化hw_module_methods_t 函数指针
static struct hw_module_methods_t Grg_GpioDev_module_methods = {
	open: Grg_GpioDev_Open
};

//初始化hw_module_t模块
struct GpioDev_module_t HAL_MODULE_INFO_SYM = {
	common: {
		tag: HARDWARE_MODULE_TAG,	
		version_major: 1,
		version_minor: 0,
		id: GRGDEV_HARDWARE_MODULE_ID,
		name: MODULE_NAME,
		author: MODULE_AUTHOR,
		methods: &Grg_GpioDev_module_methods,
	}
};

static int Grg_GpioDev_Open(const struct hw_module_t* module, const char* id, struct hw_device_t** device) {
	if(!strcmp(id, GRGDEV_HARDWARE_DEVICE_ID)) {
		struct GpioDev_device_t* dev;
		dev = (struct GpioDev_device_t*)malloc(sizeof(struct GpioDev_device_t));
		if(!dev) {
			ALOGE("Failed to alloc space for GpioDev_device_t.");
			return -EFAULT;	
		}
		memset(dev, 0, sizeof(struct GpioDev_device_t));
		dev->common.tag = HARDWARE_DEVICE_TAG;
		dev->common.version = 0;
		dev->common.module = (hw_module_t*)module;
		dev->common.close = Grg_GpioDev_Close;
		dev->writeGpioNode = Grg_GpioDev_WriteNode;
		dev->readGpioNode = Grg_GpioDev_ReadNode;
	
		if((dev->fd = open(DEVICE_NAME, O_RDWR)) == -1) {
			ALOGE("Failed to open device file /proc/driver/md_led_on -- %s.", strerror(errno));
			free(dev);
			return -EFAULT;
		}
		*device = &(dev->common);
		ALOGI("Open device file /proc/driver/md_led_on successfully.");	
		return 0;
	}
	ALOGI("GRGDEV_HARDWARE_DEVICE_ID =  %s.",id);	
	return -EFAULT;
}

static int Grg_GpioDev_Close(struct hw_device_t* device) {
	struct GpioDev_device_t* gpio_device = (struct GpioDev_device_t*)device;
	if(gpio_device) {
		close(gpio_device->fd);
		free(gpio_device);
	}
	return 0;
}

static int Grg_GpioDev_WriteNode(struct GpioDev_device_t* dev, int val,char *pNodePath){
	if(!dev) {
		ALOGE("Null dev pointer.");
		return -EFAULT;
	}
	ALOGI("Set value %d to device file /proc/driver/.", val);
	write(dev->fd, &val, sizeof(val));
	return 0;
}

static int Grg_GpioDev_ReadNode(struct GpioDev_device_t* dev, int* val)
{
	if(!dev){
		ALOGE("Null dev pointer.");
		return -EFAULT;
	}
	if(!val) {
		ALOGE("Null val pointer.");
		return -EFAULT;
	}
	read(dev->fd, val, sizeof(*val));
	*val = ret;
	ALOGI("Get value %d from device file /proc/driver/.", *val);
	return 0;
}

前面提到，一个硬件抽象层模块可能会包含多个硬件设备，而这些硬件设备的打开操作都是由函数Grg_GpioDev_Open来完成的，因此，函数Grg_GpioDev_Open会根据传进来的参数id来判断要打开哪一个硬件设备。

在我们定义的硬件抽象层模块GpioDev_module_t中，只有一个虚拟硬件设备，它使用结构体GpioDev_device_t来描述。因此，函数Grg_GpioDev_Open发现参数id与虚拟硬件设备IBankGpioDev的ID值匹配以后，就会分配一个GpioDev_device_t结构体，并且对它的成员变量进行初始化。按照硬件抽象层模块编写规范，硬件抽象层中的硬件设备标签(dev->common.tag)必须设置为HARDWARE_DEVICE_TAG。除此之外，我们还将虚拟硬件设备的关闭函数设置为Grg_GpioDev_Close，并且将它的读写函数设置为Grg_GpioDev_ReadNode和Grg_GpioDev_WriteNode。

初始化完成用来描述虚拟硬件设备的结构体GpioDev_device_t之后，我们就可以调用open函数来打开虚拟硬件设备文件/proc/driver/md_led_on了，并且将得到的文件描述符保存在结构体GpioDev_device_t的成员变量fd中。

虚拟硬件设备的关闭函数Grg_GpioDev_Close的实现比较简单，它主要是关闭设备文件/proc/driver/md_led_on，以及释放设备在打开时所分配的资源。

Android.mk文件如下：

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE_TAGS := optional
LOCAL_PRELINK_MODULE := false
LOCAL_MODULE_RELATIVE_PATH := hw 
LOCAL_SHARED_LIBRARIES := \
        liblog \
LOCAL_SRC_FILES := IBankGpioDev.cpp
LOCAL_MODULE := IBankGpioDev.default
include $(BUILD_SHARED_LIBRARY)

添加Android.mk后，执行“mmm ./hardware/libhardware/modules/IBankGpioDev/

”命令就可以对硬件抽象层模块进行编译。

至此HAL层工作已经完成，这时候可以在JNI层找到HAL模块并对模块进行读写操作。

一只肥啾啾

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Android7.0 APP调用驱动流程 HAL层开发流程

Android系统为硬件抽象层中的模块接口定义了编写规范，开发中必须按照这个规范来编写自己的硬件模块接口，否则就会导致无法正常访问硬件。下面我们首先介绍硬件抽象层模块接口的编写规范，然后再按照这个规范为虚拟硬件设备GpioDev_device_t开发硬件抽象层模块接口，并且分析硬件抽象层模块的加载过程，最后讨论硬件设备的访问权限问题。4.1 HAL 编程规范介绍Android系统...
复制链接

扫一扫