Android HAL层解析：从应用到底层的调用流程

在开发Android系统过程中，很多工程师熟悉底层不熟悉上层，或者熟悉上层不熟悉底层，梳理整个调用过程对于理解Android系统上层应用对底层硬件操作是必要的，特别是对HAL层的理解，对于Android系统的设计后面可能会越来越解耦和模块化，就是上层应用不必关心底层硬件具体是如何工作的，只需要调用底层提供的统一接口即可，这种设计思想广泛的存在于当前的软件的架构设计里。

Android系统的硬件抽象层（Hardware Abstract Layer, HAL）运行在用户空间中，它向下屏蔽硬件驱动模块的实现细节，向上提供硬件访问服务。通过硬件抽象层，Android系统分为两层来支持硬件设备，其中一层实现在用户空间（User Space），另外一层是现在内核空间（Kernel Space）。传统的Linux系统把对硬件的支持完全是现在在内核空间，即把对硬件的支持完全实现在硬件驱动模块中。

画个简单流程完成APP到kerenl的调用过程图如下：

开发Android硬件驱动程序kernel部分：

在dts文件中增加 GPIO口 设备，设置的引脚默认是gpio口，如果默认不是gpio口，需要把io口设置成gpio功能。

rk3399_gpio {
        compatible = "rk3399,gpio";
        status = "okay";
        rk3399-gpio =  <&gpio1 3 GPIO_ACTIVE_HIGH>; 
    };

添加 GPIO 驱动程序。在目录kernel/drivers创建驱动目录wqiang，并在Kconfig添加关联。

  source "drivers/wqiang/Kconfig"

Makefile 

obj-y                += wqiang/

在创建驱动目录wqiang添加文件Kconfig

    config RK3399_GPIO
    bool "select rk3399 gpio"
    default y

Makefile 

obj-$(CONFIG_WQIANG_RK3399_GPIO)    += rk3399_goio.o

rk3399_gpio.c
 

	#include <linux/init.h>
	#include <linux/kernel.h>
	#include <linux/uaccess.h>
	#include <linux/proc_fs.h>
	#include <linux/module.h>
	#include <linux/slab.h>
	#include <linux/gpio.h>
	#include <linux/miscdevice.h>
	#include <linux/of_gpio.h>
	#include <linux/of_platform.h>
	#include <linux/platform_device.h>
	#include <linux/of.h>
	#include <linux/of_gpio.h>
	#include <linux/cdev.h>
	#include <linux/device.h>
	#include <linux/pci.h>
	#include <linux/proc_fs.h>
	#define DEBUG
	
	#ifdef DEBUG
	#define WQ_DBG(fmt,arg...)        do{\
	                                    printk("[wqiang-debug] line[%d]"fmt"\n", __LINE__, ##arg);\
	                                }while(0)
	#else
	#define WQ_DBG(fmt,arg...)
	#endif
	
	#define DEV_NAME "rk3399_gpio"
	#define NODE_NAME "wqtest"
	#define DEV_NOMBER 250 
	struct rk3399_gpio_data {
	        struct cdev cv;
	
	    int work_pin;        //gpio引脚
	    int work_value;      //设置gpio电平值
	    int work_status;     //gpio状态值
	};
	
	static int gpio_major = 0;  
	static int gpio_minor = 0; 
	dev_t devNomber;
	struct rk3399_gpio_data *rk3399_gpio_dev;
	struct class * gpio_cls;
	
	/*读取设备属性val*/  
	static ssize_t gpio_val_show(struct device* dev, struct device_attribute* attr, char* buf) {  
	    struct rk3399_gpio_data* hdev = (struct rk3399_gpio_data*)dev_get_drvdata(dev);
	    hdev->work_status = gpio_get_value(hdev->work_pin);                 
		WQ_DBG("--%s()--", __func__);
		
	    return snprintf(buf, PAGE_SIZE, "%d\n", hdev->work_status);
	}  
	  
	/*写设备属性val*/  
	static ssize_t gpio_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count) {   
	    struct rk3399_gpio_data* hdev = (struct rk3399_gpio_data*)dev_get_drvdata(dev);    
		WQ_DBG("--%s()--", __func__);
	    /*将字符串转换成数字*/          
	    hdev->work_value = simple_strtol(buf, NULL, 10);         	
		gpio_direction_output(hdev->work_pin, hdev->work_value); 
	
	    return count;
	}  

	/*定义设备属性*/  
	static DEVICE_ATTR(gpio_test, 0664, gpio_val_show, gpio_val_store);  
	/*打开设备方法*/
	static int gpio_drv_open(struct inode *inode, struct file *filp)
	{
    
	struct rk3399_gpio_data* pdata;          
    /*将自定义设备结构体保存在文件指针的私有数据域中，以便访问设备时拿来用*/  
    pdata = container_of(inode->i_cdev, struct rk3399_gpio_data, cv);  
    filp->private_data = pdata;
	    WQ_DBG("--%s()--", __func__);
	    return 0;
	
	}
	static int gpio_drv_release(struct inode *inode, struct file *filp)
	{
	    WQ_DBG("--%s()--", __func__);
	    return 0;
	}
	
	/*读取设备的val的值*/
	static ssize_t gpio_drv_read(struct file *filp, char __user *buf, size_t len, loff_t *pos)
	{
	struct rk3399_gpio_data* pdata;
	pdata = filp->private_data; 
	pdata->work_status = gpio_get_value(pdata->work_pin);
	    WQ_DBG("--%s()--len=%d rk3399_gpio_dev->work_value=%d", __func__,(int)len,rk3399_gpio_dev->work_value);
    if(copy_to_user(buf, &(pdata->work_status), len))
    {
        WQ_DBG("copy to user failed.");
        return -EFAULT;;
    }
    
    return sizeof(pdata->work_pin);
	}
	
	static ssize_t gpio_drv_write(struct file *filp, const char __user *buf, size_t len, loff_t *pos)
	{
	struct rk3399_gpio_data* pdata; 
	pdata = filp->private_data; 
	WQ_DBG("--%s()--", __func__);
    if(copy_from_user(&pdata->work_value, buf, len))
    {
        WQ_DBG("copy from user failed.");
        return -EFAULT;;
    }
    gpio_direction_output(pdata->work_pin, pdata->work_value);
    
    return sizeof(pdata->work_value);
	}
	
	static long gpio_drv_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
	{
	    WQ_DBG("--%s()--", __func__);
	    return 0;
	}
	
	struct file_operations gpio_fops = {
	    .owner = THIS_MODULE,
	    .open = gpio_drv_open,
	    .release = gpio_drv_release,
	    .write = gpio_drv_write,
	    .read = gpio_drv_read,
	    .unlocked_ioctl = gpio_drv_ioctl,
	};
	
	static int rk3399_gpio_probe(struct platform_device *pdev ){
	
	    int err;
        struct device_node *np = pdev->dev.of_node;
        enum of_gpio_flags flag;
        struct device *mydev;  
        //申请设备号，自动分配 fs.h
        err = alloc_chrdev_region(&devNomber,0,DEV_NOMBER,DEV_NAME);
	    if(err){
	        printk("get device nomber failed %d",err);
	        return err;
	    }
		gpio_major = MAJOR(devNomber);  
    	gpio_minor = MINOR(devNomber);
	    //申请自定义结构体内存 slab.h
	    rk3399_gpio_dev = kmalloc(sizeof(struct rk3399_gpio_data),GFP_KERNEL);