devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

3. 编写linux内核驱动程序（Android 10）_android 内核驱动linux下编译

作者：花生_TL007 | 2024-03-27 21:44:38

赞

踩

android 内核驱动linux下编译

本文是在上文2. 编译安卓内核（pixel 2，Android 10）的基础上进行的，虚拟机环境就是上文结束时的环境。

1）首先安装vscode，方便编辑代码。

linux驱动程序简介

2）

在Linux系统中，一切皆文件。
所以在Linux中，设备也被作为一种文件来操作。而实现这些操作的，就叫做设备驱动。
在Linux中，设备被分为三类:
    - 字符设备（如，鼠标，键盘＝＝）
    - 块设备（如硬盘）
    - 网络设备（这里指网络接口，如常见的eth0,wlan0,lo）

我们都知道，Linux一切皆文件，且，Linux具有两个空间——用户与内核．那么具体到用户态的表现就是，我们Open某个设备后，我们就会得到一个在系统中唯一的文件描述符号fd。我们所有关于设备的操作，都是以fd为依据进行操作。
本文使用一个虚拟的设备，即一个字符串指针（即struct hello_android_dev中的val，可读可写）作为示例，在安卓内核中增加一个名为hello驱动程序来操作这个虚拟设备（open、release、read、write）。

增加hello驱动

3）

在drivers目录下新建hello文件夹 

在hello文件夹里新建四个文件，文件具体内容如下。

 Kconfig

  1. config HELLO
  2.  tristate "Hello Android Driver"
  3.  default n
  4.  help
  5.  This is the hello android driver.

Makefile

obj-y +=hello.o

hello.h

  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_CLASS_NAME "hello"
  10. #define VAL_LENGTH 100
  11.  
  12. struct hello_android_dev {
  13.     char *val;
  14.     struct semaphore sem;
  15.     struct cdev dev;
  16. };
  17.  
  18. #endif

 hello.c

  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.  
  8. #include <linux/sched.h>
  9. #include <linux/errno.h>
  10. #include <linux/fcntl.h>
  11.  
  12. #include <linux/poll.h>
  13. #include <linux/seq_file.h>
  14. #include <linux/mutex.h>
  15. #include <linux/workqueue.h>
  16.  
  17. #include <asm/uaccess.h>
  18. #include <linux/slab.h>
  19.  
  20.  
  21. #include "hello.h"  
  22.  
  23. static int hello_major = 0;  
  24. static int hello_minor = 0;  
  25.  
  26. static struct class* hello_class = NULL;  
  27. static struct hello_android_dev* hello_dev = NULL;  
  28.  
  29.  
  30. // 这四个函数供hal层调用
  31. // 分别对应hal层打开，关闭，写入，读取操作
  32.  
  33. static int hello_open(struct inode* inode, struct file* filp);  
  34. static int hello_release(struct inode* inode, struct file* filp);  
  35. static ssize_t hello_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos);  
  36. static ssize_t hello_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos);  
  37.  
  38. static struct file_operations hello_fops = {  
  39.     .owner = THIS_MODULE,  
  40.     .open = hello_open,  
  41.     .release = hello_release,  
  42.     .read = hello_read,  
  43.     .write = hello_write,   
  44. };  
  45.  
  46.  
  47. // 这两个函数用于处理 DEVICE_ATTR 这个宏定义的处理
  48. // 这个宏主要是在 /sys/devices/virtual/ 目录下生成对应的文件，使得开发人员可以通过 cat和echo 来进行操作
  49. // 可以参考 https://www.cnblogs.com/lifexy/p/9799778.html 了解详情
  50. static ssize_t hello_val_show(struct device* dev, struct device_attribute* attr,  char* buf);  
  51. static ssize_t hello_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count);  
  52.  
  53. static DEVICE_ATTR(val, S_IRUGO|S_IWUSR, hello_val_show, hello_val_store); 
  54.  
  55. static int hello_open(struct inode* inode, struct file* filp) {  
  56.     struct hello_android_dev* dev;          
  57.     printk(KERN_ALERT"hello_open.\n");
  58.     dev = container_of(inode->i_cdev, struct hello_android_dev, dev);  
  59.     filp->private_data = dev;  
  60.     return 0;  
  61. }  
  62.  
  63.  
  64. static int hello_release(struct inode* inode, struct file* filp) {  
  65.     return 0;  
  66. }
  67.  
  68.  
  69. static ssize_t hello_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos) {
  70.  
  71.     ssize_t err = 0;
  72.     struct hello_android_dev* dev = filp->private_data;
  73.     printk(KERN_ALERT"hello_read.\n");
  74.  
  75.     if(down_interruptible(&(dev->sem))) {
  76.         return -ERESTARTSYS;
  77.     }
  78.  
  79.     if(count >= VAL_LENGTH) {
  80.         goto out;
  81.     }
  82.  
  83.     printk(KERN_ALERT"hello_read %s.\n", dev->val);
  84.     printk(KERN_ALERT"hello_read %d.\n", (int)strlen(dev->val)+1);
  85.  
  86.     if(copy_to_user(buf, dev->val, count)) {
  87.         err = -EFAULT;
  88.         goto out;
  89.     }
  90.  
  91.     err = count;
  92.  
  93. out:
  94.     up(&(dev->sem));
  95.     return err;
  96. }  
  97.  
  98. static ssize_t hello_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos) {
  99.  
  100.     struct hello_android_dev* dev = filp->private_data;
  101.     ssize_t err = 0;
  102.  
  103.     if(down_interruptible(&(dev->sem))) {
  104.         return -ERESTARTSYS;
  105.     }
  106.  
  107.     if(count >= VAL_LENGTH) {
  108.         goto out;
  109.     }
  110.  
  111.     if(copy_from_user(dev->val, buf, count)) {
  112.         err = -EFAULT;
  113.         goto out;
  114.     }
  115.     err = count;
  116.  
  117. out:  
  118.     up(&(dev->sem));  
  119.     return err;
  120. }
  121.  
  122.  
  123. static ssize_t __hello_set_val(struct hello_android_dev* dev, const char* buf, size_t count) {       
  124.     printk(KERN_ALERT"__hello_set_val.\n"); 
  125.     if(down_interruptible(&(dev->sem))) {                  
  126.         return -ERESTARTSYS;          
  127.     }          
  128.     printk(KERN_ALERT"__hello_set_val.buf: %s  count:%d\n",buf,(int)count);
  129.     printk(KERN_ALERT"__hello_set_val.dev->val: %s  count:%d\n",dev->val,(int)count);
  130.     strncpy(dev->val,buf, count);
  131.     printk(KERN_ALERT"__hello_set_val.dev->val: %s  count:%d\n",dev->val,(int)count);
  132.     up(&(dev->sem));  
  133.  
  134.     return count;  
  135. }  
  136.  
  137. static ssize_t hello_val_show(struct device* dev, struct device_attribute* attr, char* buf) {
  138.     struct hello_android_dev* hdev = (struct hello_android_dev*)dev_get_drvdata(dev);          
  139.     printk(KERN_ALERT"hello_val_show.\n");
  140.     printk(KERN_ALERT"%s\n",hdev->val);
  141.     return sprintf(buf,"%s\n",hdev->val);
  142. }  
  143.  
  144. static ssize_t hello_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count) {  
  145.     struct hello_android_dev* hdev = (struct hello_android_dev*)dev_get_drvdata(dev);    
  146.     printk(KERN_ALERT"hello_val_store.buf: %s  count:%d\n",buf,(int)count);
  147.     return __hello_set_val(hdev, buf, count+1);
  148. }  
  149.  
  150. static int  __hello_setup_dev(struct hello_android_dev* dev) {  
  151.  
  152.     int err;  
  153.     dev_t devno = MKDEV(hello_major, hello_minor);  
  154.     printk(KERN_ALERT"__hello_setup_dev.\n");
  155.     memset(dev, 0, sizeof(struct hello_android_dev));  
  156.  
  157.     cdev_init(&(dev->dev), &hello_fops);  
  158.     dev->dev.owner = THIS_MODULE;  
  159.     dev->dev.ops = &hello_fops;          
  160.  
  161.     err = cdev_add(&(dev->dev),devno, 1);  
  162.     if(err) {  
  163.         return err;  
  164.     }          
  165.  
  166. 	sema_init(&(dev->sem), 1);
  167. 	// 给val变量开辟空间，这里只有100个字节，如果设置的字符串长度超过，后面的会被丢弃
  168.     dev->val = kmalloc(VAL_LENGTH,GFP_KERNEL);
  169.     // Dev的默认值是 hello_device
  170.     strncpy(dev->val,"hello_device",strlen("hello_device")+1);
  171.     return 0;  
  172. }  
  173.  
  174. // 驱动初始化函数
  175. static int __init hello_init(void){   
  176.     int err = -1;  
  177.     dev_t dev = 0;  
  178.     struct device* temp = NULL;  
  179.  
  180.     printk(KERN_ALERT"hello_init.\n");
  181.  
  182.     err = alloc_chrdev_region(&dev, 0, 1, HELLO_DEVICE_NODE_NAME);  
  183.     if(err < 0) {  
  184.         printk(KERN_ALERT"Failed to alloc char dev region.\n");  
  185.         goto fail;  
  186.     }  
  187.  
  188.     hello_major = MAJOR(dev);  
  189.     hello_minor = MINOR(dev);          
  190.  
  191.     hello_dev = kmalloc(sizeof(struct hello_android_dev), GFP_KERNEL);  
  192.     if(!hello_dev) {  
  193.         err = -ENOMEM;  
  194.         printk(KERN_ALERT"Failed to alloc hello_dev.\n");  
  195.         goto unregister;  
  196.     }          
  197.  
  198.     err = __hello_setup_dev(hello_dev);  
  199.     if(err) {  
  200.         printk(KERN_ALERT"Failed to setup dev: %d.\n", err);  
  201.         goto cleanup;  
  202.     }          
  203.  
  204.     hello_class = class_create(THIS_MODULE, HELLO_DEVICE_CLASS_NAME);  
  205.     if(IS_ERR(hello_class)) {  
  206.         err = PTR_ERR(hello_class);  
  207.         printk(KERN_ALERT"Failed to create hello class.\n");  
  208.         goto destroy_cdev;  
  209.     }          
  210.  
  211.     temp = device_create(hello_class, NULL, dev, "%s", HELLO_DEVICE_FILE_NAME);  
  212.     if(IS_ERR(temp)) {  
  213.         err = PTR_ERR(temp);  
  214.         printk(KERN_ALERT"Failed to create hello device.");  
  215.         goto destroy_class;  
  216.     }          
  217.  
  218.     err = device_create_file(temp, &dev_attr_val);  
  219.     if(err < 0) {  
  220.         printk(KERN_ALERT"Failed to create attribute val.");                  
  221.         goto destroy_device;  
  222.     }  
  223.  
  224.     dev_set_drvdata(temp, hello_dev);          
  225.  
  226.     printk(KERN_ALERT"Succedded to initialize hello device.\n");  
  227.     return 0;  
  228.  
  229. destroy_device:  
  230.     device_destroy(hello_class, dev);  
  231.  
  232. destroy_class:  
  233.     class_destroy(hello_class);  
  234.  
  235. destroy_cdev:  
  236.     cdev_del(&(hello_dev->dev));  
  237.  
  238. cleanup:  
  239.     kfree(hello_dev);  
  240.  
  241. unregister:  
  242.     unregister_chrdev_region(MKDEV(hello_major, hello_minor), 1);  
  243.  
  244. fail:  
  245.     return err;  
  246. }  
  247.  
  248. // 驱动卸载函数
  249. static void __exit hello_exit(void) {  
  250.     dev_t devno = MKDEV(hello_major, hello_minor);  
  251.  
  252.     printk(KERN_ALERT"hello_exit\n");          
  253.  
  254.     if(hello_class) {  
  255.         device_destroy(hello_class, MKDEV(hello_major, hello_minor));  
  256.         class_destroy(hello_class);  
  257.     }          
  258.  
  259.     if(hello_dev) {  
  260.         cdev_del(&(hello_dev->dev));  
  261.         kfree(hello_dev);  
  262.     }          
  263.     if(hello_dev->val != NULL){
  264.      kfree(hello_dev->val);
  265.     }
  266.     unregister_chrdev_region(devno, 1);  
  267. }  
  268.  
  269. MODULE_LICENSE("GPL");
  270. MODULE_DESCRIPTION("Hello Driver");
  271.  
  272. module_init(hello_init);
  273. module_exit(hello_exit);

修改drivers/Kconfig，加一行

source "drivers/hello/Kconfig"

修改drivers/Makefile，加一行

obj-y                   += hello/

 

编译

4）编译

  1. cd ~/Documents/msm
  2. export PATH=$PATH:/home/test/Documents/aosp10/prebuilts/gcc/linux-x86/arm/arm-linux-androideabi-4.9/bin
  3. export PATH=$PATH:/home/test/Documents/aosp10/prebuilts/gcc/linux-x86/aarch64/aarch64-linux-android-4.9/bin
  4. export PATH=$PATH:/home/test/Documents/aosp10/prebuilts/misc/linux-x86/dtc
  5. export PATH=$PATH:/home/test/Documents/aosp10/prebuilts/misc/linux-x86/libufdt
  6. export PATH=$PATH:/home/test/Documents/aosp10/prebuilts/misc/linux-x86/lz4
  7. export ARCH=arm64
  8. export CROSS_COMPILE=/home/test/Documents/aosp10/prebuilts/gcc/linux-x86/aarch64/aarch64-linux-android-4.9/bin/aarch64-linux-android-
  9. export CROSS_COMPILE_ARM32=/home/test/Documents/aosp10/prebuilts/gcc/linux-x86/arm/arm-linux-androideabi-4.9/bin/arm-linux-androideabi-
  10. export CC=/home/test/Documents/aosp10/prebuilts/clang/host/linux-x86/clang-3289846/bin/clang
  11. make wahoo_defconfig
  12. make clean
  13. make -j16

 编译成功

打包并刷入手机 

5）打包，新开一个terminal

  1. cd ~/Documents/aosp10
  2. export TARGET_PREBUILT_KERNEL=/home/test/Documents/msm/arch/arm64/boot/Image.lz4-dtb
  3. source build/envsetup.sh
  4. lunch
  5. aosp_walleye-userdebug
  6. time make bootimage

6）刷入手机

新开一个terminal

  1. cd ~/Documents/aosp10
  2. sudo su
  3. source build/envsetup.sh
  4. lunch
  5. aosp_walleye-userdebug
  6. adb reboot bootloader
  7. cd out/target/product/walleye/
  8. fastboot flash boot boot.img
  9. fastboot reboot

测试

7）

  1. adb shell
  2. su
  3. ls -l /dev/hello
  4. ls -l /sys/devices/virtual/hello/hello/
  5. cd /sys/devices/virtual/hello/hello/
  6. cat val
  7. echo "my_driver\0" > val
  8. cat val

本文涉及到的知识主要和Android架构中的linux内核层相关

参考

AndroidQ 从app到驱动 第一章 编写Linux内核驱动程序_长乐居士-CSDN博客

在Ubuntu上为Android系统编写Linux内核驱动程序_老罗的Android之旅-CSDN博客

Linux Char-Driver （字符驱动　摘要）(一)_Sky的专栏-CSDN博客

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/327173
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号