在Ubuntu上为Android系统编写Linux内核驱动程序

在智能手机时代,每个品牌的手机都有自己的个性特点。正是依靠这种与众不同的个性来吸引用户,营造品牌凝聚力和用户忠城度,典型的代表非iphone莫属了。 据统计,截止2011年5月,AppStore的应用软件数量达381062个,位居第一,而Android Market的应用软件数量达294738,紧随AppStore后面,并有望在8月份越过AppStore。随着Android系统逐步扩大市场占有率,终端设备的多样性亟需更多的移动开发人员的参与。 据业内统计,Android研发人才缺口至少30万。目前,对Android人才需求一类是偏向硬件驱动的Android人才需求,一类是偏向软件应用的Android人才需求。总的来说,对有志于从事Android硬件驱动的开发工程师来说,现在是一个大展拳脚的机会。那么,就让我们一起来看看如何为Android系统编写内核驱动程序吧。

        这里,我们不会为真实的硬件设备编写内核驱动程序。为了方便描述为Android系统编写内核驱动程序的过程,我们使用一个虚拟的硬件设备,这个设备只有一个4字节的寄存器,它可读可写。想起我们第一次学习程序语言时,都喜欢用“Hello, World”作为例子,这里,我们就把这个虚拟的设备命名为“hello”,而这个内核驱动程序也命名为hello驱动程序。其实,Android内核驱动程序和一般Linux内核驱动程序的编写方法是一样的,都是以Linux模块的形式实现的,具体可参考前面Android学习启动篇一文中提到的Linux Device Drivers一书。不过,这里我们还是从Android系统的角度来描述Android内核驱动程序的编写和编译过程。

       一. 参照前面两篇文章在Ubuntu上下载、编译和安装Android最新源代码和在Ubuntu上下载、编译和安装Android最新内核源代码(Linux Kernel)准备好Android内核驱动程序开发环境。

       二. 进入到kernel/common/drivers目录,新建hello目录:

       USER-NAME@MACHINE-NAME:~/Android$ cd kernel/common/drivers

       USER-NAME@MACHINE-NAME:~/Android/kernel/common/drivers$ mkdir hello

       三. 在hello目录中增加hello.h文件:

[cpp] view plain copy print ?
  1. #ifndef _HELLO_ANDROID_H_ 
  2. #define _HELLO_ANDROID_H_ 
  3.  
  4. #include <linux/cdev.h> 
  5. #include <linux/semaphore.h> 
  6.  
  7. #define HELLO_DEVICE_NODE_NAME  "hello" 
  8. #define HELLO_DEVICE_FILE_NAME  "hello" 
  9. #define HELLO_DEVICE_PROC_NAME  "hello" 
  10. #define HELLO_DEVICE_CLASS_NAME "hello" 
  11.  
  12. struct hello_android_dev { 
  13.     int val; 
  14.     struct semaphore sem; 
  15.     struct cdev dev; 
  16. }; 
  17.  
  18. #endif 

   这个头文件定义了一些字符串常量宏,在后面我们要用到。此外,还定义了一个字符设备结构体hello_android_dev,这个就是我们虚拟的硬件设备了,val成员变量就代表设备里面的寄存器,它的类型为int,sem成员变量是一个信号量,是用同步访问寄存器val的,dev成员变量是一个内嵌的字符设备,这个Linux驱动程序自定义字符设备结构体的标准方法。

   四.在hello目录中增加hello.c文件,这是驱动程序的实现部分。驱动程序的功能主要是向上层提供访问设备的寄存器的值,包括读和写。这里,提供了三种访问设备寄存器的方法,一是通过proc文件系统来访问,二是通过传统的设备文件的方法来访问,三是通过devfs文件系统来访问。下面分段描述该驱动程序的实现。

   首先是包含必要的头文件和定义三种访问设备的方法:

[cpp] view plain copy print ?
  1. #include <linux/init.h> 
  2. #include <linux/module.h> 
  3. #include <linux/types.h> 
  4. #include <linux/fs.h> 
  5. #include <linux/proc_fs.h> 
  6. #include <linux/device.h> 
  7. #include <asm/uaccess.h> 
  8.  
  9. #include "hello.h" 
  10.  
  11. /*主设备和从设备号变量*/ 
  12. static int hello_major = 0; 
  13. static int hello_minor = 0; 
  14.  
  15. /*设备类别和设备变量*/ 
  16. static struct class* hello_class = NULL; 
  17. static struct hello_android_dev* hello_dev = NULL; 
  18.  
  19. /*传统的设备文件操作方法*/ 
  20. static int hello_open(struct inode* inode, struct file* filp); 
  21. static int hello_release(struct inode* inode, struct file* filp); 
  22. static ssize_t hello_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos); 
  23. static ssize_t hello_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos); 
  24.  
  25. /*设备文件操作方法表*/ 
  26. static struct file_operations hello_fops = { 
  27.     .owner = THIS_MODULE, 
  28.     .open = hello_open, 
  29.     .release = hello_release, 
  30.     .read = hello_read, 
  31.     .write = hello_write,  
  32. }; 
  33.  
  34. /*访问设置属性方法*/ 
  35. static ssize_t hello_val_show(struct device* dev, struct device_attribute* attr,  char* buf); 
  36. static ssize_t hello_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count); 
  37.  
  38. /*定义设备属性*/ 
  39. static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, hello_val_show, hello_val_store); 

        定义传统的设备文件访问方法,主要是定义hello_open、hello_release、hello_read和hello_write这四个打开、释放、读和写设备文件的方法:

[cpp] view plain copy print ?
  1. /*打开设备方法*/ 
  2. static int hello_open(struct inode* inode, struct file* filp) { 
  3.     struct hello_android_dev* dev;         
  4.      
  5.     /*将自定义设备结构体保存在文件指针的私有数据域中,以便访问设备时拿来用*/ 
  6.     dev = container_of(inode->i_cdev, struct hello_android_dev, dev); 
  7.     filp->private_data = dev; 
  8.      
  9.     return 0; 
  10.  
  11. /*设备文件释放时调用,空实现*/ 
  12. static int hello_release(struct inode* inode, struct file* filp) { 
  13.     return 0; 
  14.  
  15. /*读取设备的寄存器val的值*/ 
  16. static ssize_t hello_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos) { 
  17.     ssize_t err = 0; 
  18.     struct hello_android_dev* dev = filp->private_data;         
  19.  
  20.     /*同步访问*/ 
  21.     if(down_interruptible(&(dev->sem))) { 
  22.         return -ERESTARTSYS; 
  23.     } 
  24.  
  25.     if(count < sizeof(dev->val)) { 
  26.         goto out; 
  27.     }         
  28.  
  29.     /*将寄存器val的值拷贝到用户提供的缓冲区*/ 
  30.     if(copy_to_user(buf, &(dev->val), sizeof(dev->val))) { 
  31.         err = -EFAULT; 
  32.         goto out; 
  33.     } 
  34.  
  35.     err = sizeof(dev->val); 
  36.  
  37. out: 
  38.     up(&(dev->sem)); 
  39.     return err; 
  40.  
  41. /*写设备的寄存器值val*/ 
  42. static ssize_t hello_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos) { 
  43.     struct hello_android_dev* dev = filp->private_data; 
  44.     ssize_t err = 0;         
  45.  
  46.     /*同步访问*/ 
  47.     if(down_interruptible(&(dev->sem))) { 
  48.         return -ERESTARTSYS;         
  49.     }         
  50.  
  51.     if(count != sizeof(dev->val)) { 
  52.         goto out;         
  53.     }         
  54.  
  55.     /*将用户提供的缓冲区的值写到设备寄存器去*/ 
  56.     if(copy_from_user(&(dev->val), buf, count)) { 
  57.         err = -EFAULT; 
  58.         goto out; 
  59.     } 
  60.  
  61.     err = sizeof(dev->val); 
  62.  
  63. out: 
  64.     up(&(dev->sem)); 
  65.     return err; 

       定义通过devfs文件系统访问方法,这里把设备的寄存器val看成是设备的一个属性,通过读写这个属性来对设备进行访问,主要是实现hello_val_show和hello_val_store两个方法,同时定义了两个内部使用的访问val值的方法__hello_get_val和__hello_set_val:

[cpp] view plain copy print ?
  1. /*读取寄存器val的值到缓冲区buf中,内部使用*/ 
  2. static ssize_t __hello_get_val(struct hello_android_dev* dev, char* buf) { 
  3.     int val = 0;         
  4.  
  5.     /*同步访问*/ 
  6.     if(down_interruptible(&(dev->sem))) {                 
  7.         return -ERESTARTSYS;         
  8.     }         
  9.  
  10.     val = dev->val;         
  11.     up(&(dev->sem));         
  12.  
  13.     return snprintf(buf, PAGE_SIZE, "%d\n", val); 
  14.  
  15. /*把缓冲区buf的值写到设备寄存器val中去,内部使用*/ 
  16. static ssize_t __hello_set_val(struct hello_android_dev* dev, const char* buf, size_t count) { 
  17.     int val = 0;         
  18.  
  19.     /*将字符串转换成数字*/         
  20.     val = simple_strtol(buf, NULL, 10);         
  21.  
  22.     /*同步访问*/         
  23.     if(down_interruptible(&(dev->sem))) {                 
  24.         return -ERESTARTSYS;         
  25.     }         
  26.  
  27.     dev->val = val;         
  28.     up(&(dev->sem)); 
  29.  
  30.     return count; 
  31.  
  32. /*读取设备属性val*/ 
  33. static ssize_t hello_val_show(struct device* dev, struct device_attribute* attr, char* buf) { 
  34.     struct hello_android_dev* hdev = (struct hello_android_dev*)dev_get_drvdata(dev);         
  35.  
  36.     return __hello_get_val(hdev, buf); 
  37.  
  38. /*写设备属性val*/ 
  39. static ssize_t hello_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count) {  
  40.     struct hello_android_dev* hdev = (struct hello_android_dev*)dev_get_drvdata(dev);   
  41.      
  42.     return __hello_set_val(hdev, buf, count); 

        定义通过proc文件系统访问方法,主要实现了hello_proc_read和hello_proc_write两个方法,同时定义了在proc文件系统创建和删除文件的方法hello_create_proc和hello_remove_proc:

[cpp] view plain copy print ?
  1. /*读取设备寄存器val的值,保存在page缓冲区中*/ 
  2. static ssize_t hello_proc_read(char* page, char** start, off_t off, int count, int* eof, void* data) { 
  3.     if(off > 0) { 
  4.         *eof = 1; 
  5.         return 0; 
  6.     } 
  7.  
  8.     return __hello_get_val(hello_dev, page); 
  9.  
  10. /*把缓冲区的值buff保存到设备寄存器val中去*/ 
  11. static ssize_t hello_proc_write(struct file* filp, const char __user *buff, unsigned long len, void* data) { 
  12.     int err = 0; 
  13.     char* page = NULL; 
  14.  
  15.     if(len > PAGE_SIZE) { 
  16.         printk(KERN_ALERT"The buff is too large: %lu.\n", len); 
  17.         return -EFAULT; 
  18.     } 
  19.  
  20.     page = (char*)__get_free_page(GFP_KERNEL); 
  21.     if(!page) {                 
  22.         printk(KERN_ALERT"Failed to alloc page.\n"); 
  23.         return -ENOMEM; 
  24.     }         
  25.  
  26.     /*先把用户提供的缓冲区值拷贝到内核缓冲区中去*/ 
  27.     if(copy_from_user(page, buff, len)) { 
  28.         printk(KERN_ALERT"Failed to copy buff from user.\n");                 
  29.         err = -EFAULT; 
  30.         goto out; 
  31.     } 
  32.  
  33.     err = __hello_set_val(hello_dev, page, len); 
  34.  
  35. out: 
  36.     free_page((unsigned long)page); 
  37.     return err; 
  38.  
  39. /*创建/proc/hello文件*/ 
  40. static void hello_create_proc(void) { 
  41.     struct proc_dir_entry* entry; 
  42.      
  43.     entry = create_proc_entry(HELLO_DEVICE_PROC_NAME, 0, NULL); 
  44.     if(entry) { 
  45.         entry->owner = THIS_MODULE; 
  46.         entry->read_proc = hello_proc_read; 
  47.         entry->write_proc = hello_proc_write; 
  48.     } 
  49.  
  50. /*删除/proc/hello文件*/ 
  51. static void hello_remove_proc(void) { 
  52.     remove_proc_entry(HELLO_DEVICE_PROC_NAME, NULL); 

   最后,定义模块加载和卸载方法,这里只要是执行设备注册和初始化操作:

[cpp] view plain copy print ?
  1. /*初始化设备*/ 
  2. static int  __hello_setup_dev(struct hello_android_dev* dev) { 
  3.     int err; 
  4.     dev_t devno = MKDEV(hello_major, hello_minor); 
  5.  
  6.     memset(dev, 0, sizeof(struct hello_android_dev)); 
  7.  
  8.     cdev_init(&(dev->dev), &hello_fops); 
  9.     dev->dev.owner = THIS_MODULE; 
  10.     dev->dev.ops = &hello_fops;         
  11.  
  12.     /*注册字符设备*/ 
  13.     err = cdev_add(&(dev->dev),devno, 1); 
  14.     if(err) { 
  15.         return err; 
  16.     }         
  17.  
  18.     /*初始化信号量和寄存器val的值*/ 
  19.     init_MUTEX(&(dev->sem)); 
  20.     dev->val = 0; 
  21.  
  22.     return 0; 
  23.  
  24. /*模块加载方法*/ 
  25. static int __init hello_init(void){  
  26.     int err = -1; 
  27.     dev_t dev = 0; 
  28.     struct device* temp = NULL; 
  29.  
  30.     printk(KERN_ALERT"Initializing hello device.\n");         
  31.  
  32.     /*动态分配主设备和从设备号*/ 
  33.     err = alloc_chrdev_region(&dev, 0, 1, HELLO_DEVICE_NODE_NAME); 
  34.     if(err < 0) { 
  35.         printk(KERN_ALERT"Failed to alloc char dev region.\n"); 
  36.         goto fail; 
  37.     } 
  38.  
  39.     hello_major = MAJOR(dev); 
  40.     hello_minor = MINOR(dev);         
  41.  
  42.     /*分配helo设备结构体变量*/ 
  43.     hello_dev = kmalloc(sizeof(struct hello_android_dev), GFP_KERNEL); 
  44.     if(!hello_dev) { 
  45.         err = -ENOMEM; 
  46.         printk(KERN_ALERT"Failed to alloc hello_dev.\n"); 
  47.         goto unregister; 
  48.     }         
  49.  
  50.     /*初始化设备*/ 
  51.     err = __hello_setup_dev(hello_dev); 
  52.     if(err) { 
  53.         printk(KERN_ALERT"Failed to setup dev: %d.\n", err); 
  54.         goto cleanup; 
  55.     }         
  56.  
  57.     /*在/sys/class/目录下创建设备类别目录hello*/ 
  58.     hello_class = class_create(THIS_MODULE, HELLO_DEVICE_CLASS_NAME); 
  59.     if(IS_ERR(hello_class)) { 
  60.         err = PTR_ERR(hello_class); 
  61.         printk(KERN_ALERT"Failed to create hello class.\n"); 
  62.         goto destroy_cdev; 
  63.     }         
  64.  
  65.     /*在/dev/目录和/sys/class/hello目录下分别创建设备文件hello*/ 
  66.     temp = device_create(hello_class, NULL, dev, "%s", HELLO_DEVICE_FILE_NAME); 
  67.     if(IS_ERR(temp)) { 
  68.         err = PTR_ERR(temp); 
  69.         printk(KERN_ALERT"Failed to create hello device."); 
  70.         goto destroy_class; 
  71.     }         
  72.  
  73.     /*在/sys/class/hello/hello目录下创建属性文件val*/ 
  74.     err = device_create_file(temp, &dev_attr_val); 
  75.     if(err < 0) { 
  76.         printk(KERN_ALERT"Failed to create attribute val.");                 
  77.         goto destroy_device; 
  78.     } 
  79.  
  80.     dev_set_drvdata(temp, hello_dev);         
  81.  
  82.     /*创建/proc/hello文件*/ 
  83.     hello_create_proc(); 
  84.  
  85.     printk(KERN_ALERT"Succedded to initialize hello device.\n"); 
  86.     return 0; 
  87.  
  88. destroy_device: 
  89.     device_destroy(hello_class, dev); 
  90.  
  91. destroy_class: 
  92.     class_destroy(hello_class); 
  93.  
  94. destroy_cdev: 
  95.     cdev_del(&(hello_dev->dev)); 
  96.  
  97. cleanup: 
  98.     kfree(hello_dev); 
  99.  
  100. unregister: 
  101.     unregister_chrdev_region(MKDEV(hello_major, hello_minor), 1); 
  102.  
  103. fail: 
  104.     return err; 
  105.  
  106. /*模块卸载方法*/ 
  107. static void __exit hello_exit(void) { 
  108.     dev_t devno = MKDEV(hello_major, hello_minor); 
  109.  
  110.     printk(KERN_ALERT"Destroy hello device.\n");         
  111.  
  112.     /*删除/proc/hello文件*/ 
  113.     hello_remove_proc();         
  114.  
  115.     /*销毁设备类别和设备*/ 
  116.     if(hello_class) { 
  117.         device_destroy(hello_class, MKDEV(hello_major, hello_minor)); 
  118.         class_destroy(hello_class); 
  119.     }         
  120.  
  121.     /*删除字符设备和释放设备内存*/ 
  122.     if(hello_dev) { 
  123.         cdev_del(&(hello_dev->dev)); 
  124.         kfree(hello_dev); 
  125.     }         
  126.  
  127.     /*释放设备号*/ 
  128.     unregister_chrdev_region(devno, 1); 
  129.  
  130. MODULE_LICENSE("GPL"); 
  131. MODULE_DESCRIPTION("First Android Driver"); 
  132.  
  133. module_init(hello_init); 
  134. module_exit(hello_exit); 

    五.在hello目录中新增Kconfig和Makefile两个文件,其中Kconfig是在编译前执行配置命令make menuconfig时用到的,而Makefile是执行编译命令make是用到的:

       Kconfig文件的内容

       config HELLO
           tristate "First Android Driver"
           default n
           help
           This is the first android driver.
      Makefile文件的内容
      obj-$(CONFIG_HELLO) += hello.o
      在Kconfig文件中,tristate表示编译选项HELLO支持在编译内核时,hello模块支持以模块、内建和不编译三种编译方法,默认是不编译,因此,在编译内核前,我们还需要执行make menuconfig命令来配置编译选项,使得hello可以以模块或者内建的方法进行编译。
      在Makefile文件中,根据选项HELLO的值,执行不同的编译方法。
      六. 修改arch/arm/Kconfig和drivers/kconfig两个文件,在menu "Device Drivers"和endmenu之间添加一行:
      source "drivers/hello/Kconfig"
        这样,执行make menuconfig时,就可以配置hello模块的编译选项了。.
        七. 修改drivers/Makefile文件,添加一行:
        obj-$(CONFIG_HELLO) += hello/
        八. 配置编译选项:
        USER-NAME@MACHINE-NAME:~/Android/kernel/common$ make menuconfig
        找到"Device Drivers" => "First Android Drivers"选项,设置为y。
        注意,如果内核不支持动态加载模块,这里不能选择m,虽然我们在Kconfig文件中配置了HELLO选项为tristate。要支持动态加载模块选项,必须要在配置菜单中选择Enable loadable module support选项;在支持动态卸载模块选项,必须要在Enable loadable module support菜单项中,选择Module unloading选项。
        九. 编译:
        USER-NAME@MACHINE-NAME:~/Android/kernel/common$ make
        编译成功后,就可以在hello目录下看到hello.o文件了,这时候编译出来的zImage已经包含了hello驱动。
        十. 参照 在Ubuntu上下载、编译和安装Android最新内核源代码(Linux Kernel)一文所示,运行新编译的内核文件,验证hello驱动程序是否已经正常安装:
        USER-NAME@MACHINE-NAME:~/Android$ emulator -kernel ./kernel/common/arch/arm/boot/zImage &
        USER-NAME@MACHINE-NAME:~/Android$ adb shell
        进入到dev目录,可以看到hello设备文件:
        root@android:/ # cd dev
        root@android:/dev # ls
        进入到proc目录,可以看到hello文件:
        root@android:/ # cd proc
        root@android:/proc # ls
        访问hello文件的值:
        root@android:/proc # cat hello
        0
        root@android:/proc # echo '5' > hello
        root@android:/proc # cat hello
        5
        进入到sys/class目录,可以看到hello目录:
        root@android:/ # cd sys/class
        root@android:/sys/class # ls
        进入到hello目录,可以看到hello目录:
        root@android:/sys/class # cd hello
        root@android:/sys/class/hello # ls
        进入到下一层hello目录,可以看到val文件:
        root@android:/sys/class/hello # cd hello
        root@android:/sys/class/hello/hello # ls
        访问属性文件val的值:
        root@android:/sys/class/hello/hello # cat val
        5
        root@android:/sys/class/hello/hello # echo '0'  > val
        root@android:/sys/class/hello/hello # cat val
        0
        至此,我们的hello内核驱动程序就完成了,并且验证一切正常。这里我们采用的是系统提供的方法和驱动程序进行交互,也就是通过proc文件系统和devfs文件系统的方法,下一篇文章中,我们将通过自己编译的C语言程序来访问/dev/hello文件来和hello驱动程序交互,敬请期待。

你可能感兴趣的:(android,struct,ubuntu,Module,Class,linux内核)