Android平台开发-Android HAL develop-Android HAL开发

 

  Android平台开发-Android HAL develop-Android HAL开发 （转） 收藏

一、HAL架构

 

    Android 的 HAL(Hardware Abstract Layer硬件抽象层)是Google因应厂商「希望不公开源码」的

    要求下，所推出的新观念，对底层的代码封装。

    在Android原始码里，HAL主要的实作储存于以下目录：
    1) libhardware_legacy/ - 过去的实作、采取链接库模块的观念进行
    2) libhardware/ - 新版的实作、调整为 HAL stub 的观念
    3) ril/ - Radio Interface Layer

 

    1、HAL 的过去：
       过去的 libhardware_legacy 作法，比较是传统的「module」方式，也就是将 *.so 档案当做
       「shared library」来使用，在runtime(JNI 部份)以 direct function call 使用 HAL

       module。透过直接函数呼叫的方式，来操作驱动程序。当然，应用程序也可以不需要透过 JNI 的方

       式进行，直接以加载 *.so ?(dlopen)的做法呼叫*.so 里的符号(symbol)也是一种方式。总而言

       之是没有经过封装，上层可以直接操作硬件。

 

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

 

    3、HAL_legacy和HAL的对比
       HAL_legacy：
       旧式的HAL是一个模块，采用共享库形式，在编译时会调用到。由于采用function call形式调用，

       因此可被多个进程使用，但会被mapping到多个进程空间中，造成浪费，同时需要考虑代码能否安全

       重入的问题(thread safe)。

　　   HAL：
       新式的HAL采用HAL module和HAL stub结合形式，HAL stub不是一个share library，编译时

       上层只拥有访问HAL stub的函数指针，并不需要HAL stub。上层通过HAL module提供的统一接口

       获取并操作HAL stub，so文件只会被mapping到一个进程，也不存在重复mapping和重入问题。

    4、HAL module架构
       HAL moudle主要分为三个结构：
        struct hw_module_t;
        struct hw_module_methods_t;
        struct hw_device_t;
 
    5、HAL使用方法
      (1) Native code通过hw_get_module调用获取HAL stub：
       hw_get_module (LED_HARDWARE_MODULE_ID, (const hw_module_t**)&module)
   (2) 通过继承hw_module_methods_t的callback来open设备：
       module->methods->open(module,LED_HARDWARE_MODULE_ID, (struct  

                                                        hw_device_t**)device);
   (3) 通过继承hw_device_t的callback来控制设备：
        sLedDevice->set_on(sLedDevice, led);
           sLedDevice->set_off(sLedDevice, led);

 

    6、HAL stub编写方法
       (1)定义自己的HAL结构体，编写头文件led.h, hardware/hardware.h
      struct led_module_t {
                struct hw_module_t common;
          };
      struct led_control_device_t {
             struct hw_device_t common;
             int fd; /* file descriptor of LED device */
             /* supporting control APIs go here */
             int (*set_on)(struct led_control_device_t *dev, int32_t led);
             int (*set_off)(struct led_control_device_t *dev, int32_t led);
      };
       (2)设计led.c 完成功能实现和HAL stub注册
       (2.1)led_module_methods继承hw_module_methods_t，实现open的callback
            struct hw_module_methods_t led_module_methods = {
            open: led_device_open
            };
       (2.2)用HAL_MODULE_INFO_SYM实例led_module_t，这个名称不可修改
            tag：需要制定为 HARDWARE_MODULE_TAG
            id：指定为 HAL Stub 的 module ID
            methods：struct hw_module_methods_t，为 HAL 所定义的「method」

　　            const struct led_module_t HAL_MODULE_INFO_SYM = {
            common: {
            tag: HARDWARE_MODULE_TAG,
            version_major: 1,
            version_minor: 0,
            id: LED_HARDWARE_MODULE_ID,
            name: "Sample LED Stub",
            author: "The Mokoid Open Source Project",
            methods: &led_module_methods,
            }
            /* supporting APIs go here. */
            };

　　       (2.3)open是一个必须实现的callback API，负责申请结构体空间，填充信息，
                注册具体操作API接口,打开Linux驱动。
            由于存在多重继承关系，只需对子结构体hw_device_t对象申请空间即可。

　　            int led_device_open(const struct hw_module_t* module, const char*

                                               name, struct hw_device_t** device)
            {
             struct led_control_device_t *dev;
             dev = (struct led_control_device_t *)malloc(sizeof(*dev));
             memset(dev, 0, sizeof(*dev));
             dev->common.tag = HARDWARE_DEVICE_TAG;
             dev->common.version = 0;
             dev->common.module = module;
             dev->common.close = led_device_close;
             dev->set_on = led_on;
             dev->set_off = led_off;
             *device = &dev->common;
             /*
             * Initialize Led hardware here.
             */
             dev->fd = open(LED_DEVICE, O_RDONLY);

　　             if (dev->fd < 0)
                 return -1;

　　             led_off(dev, LED_C608);

　　             led_off(dev, LED_C609);

　　             success:
             return 0;
             　　}

　　       (2.4)填充具体API操作代码
             int led_on(struct led_control_device_t *dev, int32_t led)
             {
             int fd;

　　             LOGI("LED Stub: set %d on.", led);
             fd = dev->fd;
             switch (led) {
                   case LED_C608:
                        ioctl(fd, 1, &led);
                        break;
                   case LED_C609:
                        ioctl(fd, 1, &led);
                        break;
                   default:
                        return -1;
                   }

　　             return 0;
            }

　　           int led_off(struct led_control_device_t *dev, int32_t led)
           {
           int fd;
           LOGI("LED Stub: set %d off.", led);
           fd = dev->fd;
           switch (led) {
                  case LED_C608:
                       ioctl(fd, 2, &led);
                       break;
                  case LED_C609:
                       ioctl(fd, 2, &led);
                       break;
                  default:
                       return -1;
           }
           return 0;
           }