This essay, I go to a deeply studying to android HAL device driver program.

  

  According to the android architecture we disscus in last essay, when we are designing a android device driver, we should follow the steps below :

  (1) linux device driver

  In this driver, we should try our best to cut down the mechanism and change them to be more concise.

  (2) HAL libraries

  The HAL serves as a standard interface that allows the Android system to call into the device driver layer while being agnostic about the lower-level implementations of your drivers and hardware.

  (3)Service libraries

  System service access the hardware in HAL libraries and provide the APIs for android framework. Service libraries usually are JNI libraries or Linux libraries.

  1、linux device driver

//s3c6410_leds_hal.c
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/pci.h>
#include <asm/uaccess.h>
#include <mach/map.h>
#include <mach/regs-gpio.h>
#include <mach/gpio-bank-m.h> #define DEVICE_NAME "s3c6410_leds_hal"
#define DEVICE_COUNT 1
#define S3C6410_LEDS_MAJOR 0
#define S3C6410_LEDS_MINOR 234 static unsigned char mem[];
static int major = S3C6410_LEDS_MAJOR;
static int minor = S3C6410_LEDS_MINOR;
static dev_t leds_number;
static struct class *leds_class = NULL; static void write_io(unsigned char buf[])
{
int i;
unsigned int tmp;
tmp = ioread32(S3C64XX_GPMDAT);
for (i = ; i < ; i++) {
if (buf[i] == '') {
tmp &= (~( << i));
} else {
tmp |= ( << i);
}
}
iowrite32(tmp, S3C64XX_GPMDAT);
} static ssize_t s3c6410_leds_hal_write(struct file *filp,
const char __user *buf, size_t count, loff_t *ppos)
{
unsigned int tmp = count; if (count > ) {
tmp = ;
} if (copy_from_user(mem, buf, tmp)) {
return -EFAULT;
} else {
write_io(mem);
}
return count;
} static struct file_operations leds_fops = {
.owner = THIS_MODULE,
.write = s3c6410_leds_hal_write,
};
static struct cdev leds_cdev; static int leds_create_device(void)
{
int ret = ;
int err = ; cdev_init(&leds_cdev, &leds_fops);
leds_cdev.owner = THIS_MODULE;
if (major > ) {
leds_number = MKDEV(major, minor);
err = register_chrdev_region(leds_number, DEVICE_COUNT, DEVICE_NAME);
if (err < ) {
printk(KERN_WARNING "register_chardev_region() failed.\n");
return err;
}
} else {
err = alloc_chrdev_region(&leds_cdev.dev, ,
DEVICE_COUNT, DEVICE_NAME);
if (err < ) {
printk(KERN_WARNING "register_chardev_region() failed.\n");
return err;
}
major = MAJOR(leds_cdev.dev);
minor = MINOR(leds_cdev.dev);
leds_number = leds_cdev.dev;
} ret = cdev_add(&leds_cdev, leds_number, DEVICE_COUNT);
leds_class = class_create(THIS_MODULE, DEVICE_NAME);
device_create(leds_class, NULL, leds_number, NULL, DEVICE_NAME);
return ret; } static int leds_init(void)
{
int ret;
ret = leds_create_device();
printk(DEVICE_NAME "\tinitialized.\n"); return ret;
} static void leds_exit(void) {
device_destroy(leds_class, leds_number);
if (leds_class) {
unregister_chrdev_region(leds_number, DEVICE_COUNT);
return;
}
printk(DEVICE_NAME"\texit.\n");
} module_init(leds_init);
module_exit(leds_exit); MODULE_LICENSE("GPL");

  Yes, this file is the same as the previous driver file, because there aren't any business-related codes in this simple led driver.

  Then we focus more in the HAL libraries and Service libraries coding.

  2、HAL libraries

  HAL modules would be compile to a Linux shared library (*.so), and these *.so files could be automaticlly loaded by android system.

  Each HAL module should provide a variable for android system loading : HAL_MODULE_INFO_SYM (never change it.)  

//Android.mk
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS) LOCAL_PRELINK_MODULE := false
LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
LOCAL_SHARED_LIBRARIES := liblog
LOCAL_SRC_FILES := leds_hal.c
LOCAL_MODULE := leds_hal.default
LOCAL_MODULE_TAGS := eng
include $(BUILD_SHARED_LIBRARY) //leds_hal.h
#include <hardware/hardware.h>
#include <fcntl.h>
#include <cutils/log.h> struct leds_module_t {
struct hw_module_t hw_module;
}; struct leds_device_t {
struct hw_device_t hw_device;
int (*set_on)(struct leds_device_t *dev, int32_t led);
int (*set_off)(struct leds_device_t *dev, int32_t led);
}; #define LED_HARDWARE_MODULE_ID "leds_hal"
//leds_hal.c
#include "leds_hal.h" int fd_leds = ; int leds_switch(struct leds_device_t *dev, int32_t led, int32_t on_off)
{
unsigned char buf[]; if (led < && led > ) {
LOGI("Led Stub : no this led.\n");
return -;
} if (on_off == ) {
LOGI("Led Stub : set %d led on", led);
buf[led] = '';
} else {
LOGI("Led Stub : set %d led off", led);
buf[led] = '';
} write(fd_leds, buf, );
return ;
} int leds_on(struct leds_device_t *dev, int32_t led)
{
return leds_switch(dev, led, );
} int leds_off(struct leds_device_t *dev, int32_t led)
{
return leds_switch(dev, led, );
} int leds_device_close(struct hw_device_t *device)
{
struct leds_device_t *ldt = (struct leds_device_t *) device; if (ldt)
free(ldt); close(fd_leds);
return ;
} static int leds_device_open(const struct hw_module_t *module, const char *name,
struct hw_device_t **device)
{
struct leds_device_t *leds_dev;
leds_dev = (struct leds_device_t *) malloc(sizeof(*leds_dev)); memset(leds_dev, , sizeof(*leds_dev)); leds_dev->hw_device.tag = HARDWARE_DEVICE_TAG;
leds_dev->hw_device.version = ;
leds_dev->hw_device.module = (struct hw_module_t *) module;
leds_dev->hw_device.close = leds_device_close;
leds_dev->set_on = leds_on;
leds_dev->set_off = leds_off; *device = (hw_device_t *) leds_dev; fd_leds = open("/dev/s3c6410_leds_hal", O_RDWR); if (fd_leds < ) {
LOGI("Led Stub : open /dev/s3c6410_leds_hal fail.\n");
} else {
LOGI("Led Stub : open /dev/s3c6410_leds_hal success.\n");
} return ;
} static struct hw_module_methods_t leds_module_methods = {
.open = leds_device_open
}; struct leds_module_t HAL_MODULE_INFO_SYM = {
hw_module : {
tag: HARDWARE_MODULE_TAG,
version_major: ,
version_minor: ,
id: LED_HARDWARE_MODULE_ID,
name: "Led HAL Stub",
methods: &leds_module_methods,
}
};

  Acturely, in this simple leds HAL module, we didn't get much messages about "business-related", but we can treat the leds switch functions as.

  And the more important messages we need to know are listing follow :

HAL_MODULE_INFO_SYM
hw_module_t
hw_device_t
hw_module_methods_t

  Ok, let's stop here. I wanna to talk some more about the module both in linux and android.

  In my opnions, there are a lot of design logic share with this two system.

  (1) linux

  In the picture, we can see what we should do to design a device driver :

  Create a entrance function;

  Declare a basic struct;

  Extand the struct with special operations.

  (2) android

  In the picture, we can see the android HAL is the same as linux device driver in the three absractions :

  Entrance, basic struct, expend struct.

  Then I will discuss the different between the two system ;

  [ Entrance ]

// We use functions to build the device driver in linux
module_init(leds_init); // The entrance is a variable HAL_MODULE_INFO_SYM automaticlly loaded by the system
struct leds_module_t HAL_MODULE_INFO_SYM = {
hw_module : {
tag: HARDWARE_MODULE_TAG,
version_major: ,
version_minor: ,
id: LED_HARDWARE_MODULE_ID,
name: "Led HAL Stub",
methods: &leds_module_methods,
}
};

  [ Basic Struct ]

// Basic struct in linux is a structure, we use the "struct" to create our device
static struct cdev leds_cdev; // Basic struct in android is a structure with function open, we use the "function" to create our device
static int leds_device_open(const struct hw_module_t *module, const char *name,
struct hw_device_t **device)
{
struct leds_device_t *leds_dev;
leds_dev = (struct leds_device_t *) malloc(sizeof(*leds_dev)); memset(leds_dev, , sizeof(*leds_dev)); leds_dev->hw_device.tag = HARDWARE_DEVICE_TAG;
leds_dev->hw_device.version = ;
leds_dev->hw_device.module = (struct hw_module_t *) module;
leds_dev->hw_device.close = leds_device_close;
leds_dev->set_on = leds_on;
leds_dev->set_off = leds_off; *device = (hw_device_t *) leds_dev; fd_leds = open("/dev/s3c6410_leds_hal", O_RDWR); if (fd_leds < ) {
LOGI("Led Stub : open /dev/s3c6410_leds_hal fail.\n");
} else {
LOGI("Led Stub : open /dev/s3c6410_leds_hal success.\n");
} return ;
}

  [ Extend Struct ]

// The extend struct means the functions include in file_operations, we have to build the callback functions in linux.
static struct file_operations leds_fops = {
.owner = THIS_MODULE,
.write = s3c6410_leds_hal_write,
}; // Instead of using the prototype, the HAL specification suggest us to create two new struct with the first element hw_module_t/hw_device_t in android.
// We can see that it is useless to create a struct in a prototype to hw_device_t, because there is no callback functions in this struct.
// If we want to extend the hw_device_t, we should create the new struct as the substruct of hw_device_t
struct leds_device_t {
struct hw_device_t hw_device;
int (*set_on)(struct leds_device_t *dev, int32_t led);
int (*set_off)(struct leds_device_t *dev, int32_t led);
};

  After compiling, we should push the leds_hal.default.so to dir /system/lib/hw in ok6410.

  I will discuss the "Service libraries" in next essay.

  

  

  

ok6410 android driver(11)的更多相关文章

  1. ok6410 android driver(5)

    Test the android driver by JNI (Java Native Interface), In the third article, we know how to compile ...

  2. ok6410 android driver(9)

    In this essay, I will write the JNI to test our leds device. If you don't know how to create a jni p ...

  3. ok6410 android driver(8)

    In the past, we know how to create and run a simple character device driver on pc, goldfish and ok64 ...

  4. ok6410 android driver(3)

    This article discusses the Makefile and how to port the module to different platform (localhost and ...

  5. ok6410 android driver(12)

    In this essay, I will talk about how to write the service libraries. TIPS : I won't discuss the name ...

  6. ok6410 android driver(10)

    From this essay, we go to a new discussion "Android Hardware Abstraction Layer". In this e ...

  7. ok6410 android driver(7)

    This article talk about how to test device driver on JNI. There are two ways to test the device driv ...

  8. ok6410 android driver(6)

    This is a short essay about the mistakes in compiling ok6410 android-2.3 source codes. If there is n ...

  9. ok6410 android driver(1)

    target system : Android (OK6410) host system : Debian Wheezy AMD64 1.Set up android system in ok6410 ...

随机推荐

  1. netsh-winsock-reset;ping的通公网IP和DNS地址和内网网关,就是不能解析域名;

    winXP cmd-------------> netsh winsock reset ============= 相关知识: netsh winsock reset命令含义是重置 Winsoc ...

  2. Swift中对C语言接口缓存的使用以及数组、字符串转为指针类型的方法

    由于Swift编程语言属于上层编程语言,而Swift中由于为了低层的高性能计算接口,所以往往需要C语言中的指针类型,由此,在Swift编程语言刚诞生的时候就有了UnsafePointer与Unsafe ...

  3. C#.Net 上传图片,限制图片大小,检查类型完整版

    C#.Net 上传图片,限制图片大小,检查类型完整版 源代码: 处理图片类,如检查图片大小,按宽度比例缩小图片 public class CImageLibrary{   public enum Va ...

  4. Oracle-ARCGIS-SDE 数据整合遇到的问题

    一. 近日在做全文检索,基础采用oracle text,版本是10g,做好管理页面后,有功能是删除索引,就是生成drop index的语句.没有想到这个全文检索的index这么直接弄还不行,经过这样删 ...

  5. ExtJs 可查询的下拉框

    最近项目中有个需求,就是有四个模块需要加载一个主表的内容,比如说这个表叫项目表(比如项目表里有两个字段一个是项目ID--projCd,还有一个是项目名称--projNm).主表的内容的要放在一个下拉框 ...

  6. 理解netty对protocol buffers的编码解码

    一,netty+protocol buffers简要说明 Netty是业界最流行的NIO框架之一优点:1)API使用简单,开发门槛低:2)功能强大,预置了多种编解码功能,支持多种主流协议:3)定制能力 ...

  7. Intellij IDEA IDE部署Servlet项目

    1.设置Project Structure 2.修改Modules中的Web项目文件默认class编译之后输出位置 3.给Modules中的Web项目添加Web模块 4.修改Web项目Web.xml文 ...

  8. Golang pprof heap profile is empty

    Q: When you use `go tool pprof` get heap data, profile is empty. A: The default sampling rate is 1 s ...

  9. [Android界面] 这样的选择器怎么实现?? 充值选择

    1  充值的或年纪的 或  1 先讲例子 http://blog.csdn.net/lmj623565791/article/details/48393217: 本文出自:[张鸿洋的博客] 一.概述 ...

  10. C++ Low level performance optimize 2

    C++ Low level performance optimize 2 上一篇 文章讨论了一些底层代码的优化技巧,本文继续讨论一些相关的内容. 首先,上一篇文章讨论cache missing的重要性 ...