Additional hardware abstraction layer Android (HAL) to the Linux kernel driver module (3) on Ubuntu

      In the Android hardware abstraction layer (HAL) and an overview of the study plan in one article, we briefly describe the method of preparation of the driver in the Android system hardware. Simply put, hardware drivers on the one hand in the distribution of the Linux kernel, on the other hand distributed in user space hardware abstraction layer. Next, on Ubuntu Linux kernel driver for the preparation of the Android system a sub exemplified herein illustrate how to write drivers in the Linux kernel. In this article, we will continue to introduce Android system hardware drivers on the other hand to achieve, namely how to increase hardware modules and kernel drivers interact with the hardware abstraction layer. In this article, we'll learn how you can modify the file mode device with a Linux-like udev rules in the Android system to create a device file.

"Android system source code Scenario Analysis," a book under attack programmer network ( http://0xcc0xcd.com in) serial, click to enter!

      A reference to the preparation of the Android system on Ubuntu Linux kernel driver shown in a paper, ready exemplary kernel driver sequence. Upon completion of this kernel driver, you can get in the Android system three documents, namely / dev / hello, / sys / class / hello / hello / val and / proc / hello. In this article, we will connect the hardware abstraction layer module and a Linux kernel driver module device file / dev / hello.

      Second into the hardware / libhardware / include / hardware directory, create hello.h file:

      USER-NAME@MACHINE-NAME:~/Android$ cd hardware/libhardware/include/hardware

      USER-NAME@MACHINE-NAME:~/Android/hardware/libhardware/include/hardware$ vi hello.h

      Hello.h contents of the file are as follows:

      

   
   
#ifndef ANDROID_HELLO_INTERFACE_H
#define ANDROID_HELLO_INTERFACE_H
#include <hardware/hardware.h>

__BEGIN_DECLS

/ * Definition module ID * /
#define HELLO_HARDWARE_MODULE_ID "hello"

/ * Hardware module structure * /
struct hello_module_t {
struct hw_module_t common;
};

/ * Hardware interface structure * /
struct hello_device_t {
struct hw_device_t common;
int fd;
int (*set_val)(struct hello_device_t* dev, int val);
int (*get_val)(struct hello_device_t* dev, int* val);
};

__END_DECLS

#endif
   
   

      Here Android hardware abstraction layer according to the requirements specification, the module ID, module structure, and a hardware interface structures are defined. In the structure of the hardware interface, a file descriptor FD indicates the device, the device file corresponding to us to be treated "/ dev / hello", set_val and get_val for function interfaces of the HAL provided.

      III. Into the hardware / libhardware / modules directory, create hello directory, and add hello.c file. hello.c more content, we look at the segment.

      The first is the header file that contains the relevant definitions and related structures:

      

   
   
#define LOG_TAG "HelloStub"

#include <hardware/hardware.h>
#include <hardware/hello.h>
#include <fcntl.h>
#include <errno.h>
#include <cutils/log.h>
#include <cutils/atomic.h>

#define DEVICE_NAME "/dev/hello"
#define MODULE_NAME "Hello"
#define MODULE_AUTHOR "[email protected]"

/ * Device to open and close the interface * /
static int hello_device_open(const struct hw_module_t* module, const char* name, struct hw_device_t** device);
static int hello_device_close(struct hw_device_t* device);

/ * Device Access Interfaces * /
static int hello_set_val(struct hello_device_t* dev, int val);
static int hello_get_val(struct hello_device_t* dev, int* val);

/ * Methods table module * /
static struct hw_module_methods_t hello_module_methods = {
open: hello_device_open
};

/ * Module instance variables * /
struct hello_module_t HAL_MODULE_INFO_SYM = {
common: {
tag: HARDWARE_MODULE_TAG,
version_major: 1,
version_minor: 0,
id: HELLO_HARDWARE_MODULE_ID,
name: MODULE_NAME,
author: MODULE_AUTHOR,
methods: &hello_module_methods,
}
};
   
   

      Here, the instance variable name must be HAL_MODULE_INFO_SYM, tag must also be HARDWARE_MODULE_TAG, this is the Android hardware abstraction layer specification.

      Hello_device_open defined function:

      

   
   
static int hello_device_open(const struct hw_module_t* module, const char* name, struct hw_device_t** device) {
struct hello_device_t* dev;dev = (struct hello_device_t*) malloc( sizeof(struct hello_device_t));

if(!dev) {
LOGE( "Hello Stub: failed to alloc space");
return -EFAULT;
}

memset(dev, 0, sizeof(struct hello_device_t));
dev->common.tag = HARDWARE_DEVICE_TAG;
dev->common.version = 0;
dev->common. module = ( hw_module_t*) module;
dev->common.close = hello_device_close;
dev->set_val = hello_set_val;dev->get_val = hello_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;
}

*device = &(dev->common);
LOGI( "Hello Stub: open /dev/hello successfully.");

return 0;
}
   
   

      DEVICE_NAME is defined as "/ dev / hello". Since the device driver in the kernel file is created inside by device_create, but the device file device_create created by default only the root user can read and write, and hello_device_open usually invoked by the upper APP, APP these generally do not have root privileges, this time led open the device file failed:

      Hello Stub: failed to open /dev/hello -- Permission denied.

      The solution is similar to the Linux udev rules, under the Android open source project directory, enter the system / core / rootdir directory with a file named ueventd.rc, entered, add the line:

       /dev/hello 0666 root root

      Defined hello_device_close, hello_set_val and hello_get_val three functions:

      

    
    
static int hello_device_close(struct hw_device_t* device) {
struct hello_device_t* hello_device = (struct hello_device_t*)device;

if(hello_device) {
close(hello_device->fd);
free(hello_device);
}

return 0;
}

static int hello_set_val(struct hello_device_t* dev, int val) {
LOGI( "Hello Stub: set value %d to device.", val);

write(dev->fd, &val, sizeof(val));

return 0 ;
}

static int hello_get_val(struct hello_device_t* dev, int* val) {
if(!val) {
LOGE( "Hello Stub: error val pointer");
return -EFAULT;
}

read(dev->fd, val, sizeof(*val));

LOGI( "Hello Stub: get value %d from device", *val);

return 0;
}
    
    

      Four new Android.mk continue to file in the directory hello:

       LOCAL_PATH := $(call my-dir)

      include $(CLEAR_VARS)

      LOCAL_MODULE_TAGS := optional

      LOCAL_PRELINK_MODULE := false

      LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw

      LOCAL_SHARED_LIBRARIES := liblog

      LOCAL_SRC_FILES := hello.c

      LOCAL_MODULE := hello.default

      include $(BUILD_SHARED_LIBRARY)

      Note, LOCAL_MODULE-defined rules, hello followed by default, hello.default can guarantee that our modules can always be loaded into hard like abstraction layer.

      Five compile:

       USER-NAME@MACHINE-NAME:~/Android$ mmm hardware/libhardware/modules/hello

       After successful compilation, you can see hello.default.so files in the out / target / product / generic / system / lib / hw directory.

      Six repackage Android system image system.img:

       USER-NAME@MACHINE-NAME:~/Android$ make snod

       After re-packaged, system.img contains hardware abstraction layer module hello.default we define the.

      While we in the Android system adds a hardware abstraction layer module for our own hardware, but now Java applications can not access to our hardware. We also have to write JNI method and increase the API interface in the Android Application Frameworks layer, to make the top Application visit our hardware. In the next article, we will complete this process system, it allows us to access our own custom hardware in Java applications.