打通驱动层到应用层--(一)driver层

已于 2022-09-06 14:52:03 修改
阅读量561 收藏 1
点赞数 1
分类专栏： android 打通驱动层到应用demo 文章标签： c语言 驱动开发
于 2022-09-06 14:16:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LXJSWD/article/details/126722255
版权

前言

本节为添加内核驱动程序。

一、添加

我们添加的驱动为虚拟字符设备，一般使用hello来命名该驱动，因为我使用的工程源码中已经存在了test驱动，注册为hello。因此我的驱动命名为helloxjq。
编译方式为静态编译，将驱动编入内核。
在kernel/msm-4.9/drivers/目录下创建helloxjq文件夹，在helloxjq文件夹下创建helloxjq.c、Makefile、Kconfig三个文件。
Kconfig代码如下：

config HELLOXJQ
tristate "helloxjq Android test Driver"
default y
help
It is a Android test driver.

obj-$(CONFIG_HELLOXJQ) += helloxjq.o

helloxjq.c代码如下：

#include <linux/init.h>  
#include <linux/module.h>  
#include <linux/types.h>  
#include <linux/fs.h>  
#include <linux/proc_fs.h>  
#include <linux/device.h>  

#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/fcntl.h>

#include <linux/poll.h>
#include <linux/seq_file.h>
#include <linux/mutex.h>
#include <linux/workqueue.h>

#include <asm/uaccess.h>
#include <linux/slab.h>


#include "helloxjq.h"  

/*定义主设备和从设备号变量*/  
static int helloxjq_major = 0;  
static int helloxjq_minor = 0;  

/*设备类别和设备变量*/  
static struct class* helloxjq_class = NULL;  
static struct helloxjq_dev* helloxjq_dev = NULL;  

/*传统的设备文件操作方法*/  
static int helloxjq_open(struct inode* inode, struct file* filp);  
static int helloxjq_release(struct inode* inode, struct file* filp);  
static ssize_t helloxjq_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos);  
static ssize_t helloxjq_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos);  

/*设备文件操作方法表*/  
static struct file_operations helloxjq_fops = {  
    .owner = THIS_MODULE,  
    .open = helloxjq_open,  
    .release = helloxjq_release,  
    .read = helloxjq_read,  
    .write = helloxjq_write,   
};  

/*访问设置属性方法*/  
static ssize_t helloxjq_val_show(struct device* dev, struct device_attribute* attr,  char* buf);  
static ssize_t helloxjq_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count);  

/*定义设备属性*/  
static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, helloxjq_val_show, helloxjq_val_store); 

/*打开设备方法*/  
static int helloxjq_open(struct inode* inode, struct file* filp) {  
    struct helloxjq_dev* dev;          

    /*将自定义设备结构体保存在文件指针的私有数据域中，以便访问设备时拿来用*/  
    dev = container_of(inode->i_cdev, struct helloxjq_dev, dev);  
    filp->private_data = dev;  

    return 0;  
}  

/*设备文件释放时调用，空实现*/  
static int helloxjq_release(struct inode* inode, struct file* filp) {  
    return 0;  
}  

/*读内存*/  
static ssize_t helloxjq_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos) {  
    ssize_t err = 0;  
    struct helloxjq_dev* dev = filp->private_data;          

    /*同步访问*/  
    if(down_interruptible(&(dev->sem))) {  
        return -ERESTARTSYS;  
    }  

    if(count < sizeof(dev->val)) {  
        goto out;  
    }          

    /*读字符串*/  
    if(copy_to_user(buf, dev->val, sizeof(dev->val))) {  
        err = -EFAULT;  
        goto out;  
    }  

    err = sizeof(dev->val);  

out:  
    up(&(dev->sem));  
    return err;  
}  

/*写字符串*/  
static ssize_t helloxjq_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos) {  
    struct helloxjq_dev* dev = filp->private_data;  
    ssize_t err = 0;          

    /*同步访问*/  
    if(down_interruptible(&(dev->sem))) {  
        return -ERESTARTSYS;          
    }          

    if(count != sizeof(dev->val)) {  
        goto out;          
    }          

    /*将用户写进来的字符串保存到驱动的内存中*/  
    if(copy_from_user(dev->val, buf, count)) {  
        err = -EFAULT;  
        goto out;  
    }  

    err = sizeof(dev->val);  

out:  
    up(&(dev->sem));  
    return err;  
}  


/*写字符串到内存*/  
static ssize_t __helloxjq_set_val(struct helloxjq_dev* dev, const char* buf, size_t count) {       

    /*同步访问*/          
    if(down_interruptible(&(dev->sem))) {                  
        return -ERESTARTSYS;          
    }          
    printk(KERN_ALERT"__helloxjq_set_val.buf: %s  count:%d\n",buf,count);
    printk(KERN_ALERT"__helloxjq_set_val.dev->val: %s  count:%d\n",dev->val,count);
    strncpy(dev->val,buf, count);
    printk(KERN_ALERT"__helloxjq_set_val.dev->val: %s  count:%d\n",dev->val,count);
    up(&(dev->sem));  

    return count;  
}  

/*读取设备属性val*/  
static ssize_t helloxjq_val_show(struct device* dev, struct device_attribute* attr, char* buf) {  
    struct helloxjq_dev* hdev = (struct helloxjq_dev*)dev_get_drvdata(dev);          
    printk(KERN_ALERT"helloxjq_val_show.\n");
    printk(KERN_ALERT"%s\n",hdev->val);
    return 0;
}  

/*写设备属性val*/  
static ssize_t helloxjq_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count) {   
    struct helloxjq_dev* hdev = (struct helloxjq_dev*)dev_get_drvdata(dev);    
    printk(KERN_ALERT"helloxjq_val_store.buf: %s  count:%d\n",buf,count);

    return __helloxjq_set_val(hdev, buf, count);  
}  


/*初始化设备*/  
static int  __helloxjq_setup_dev(struct helloxjq_dev* dev) {  
    int err;  
    dev_t devno = MKDEV(helloxjq_major, helloxjq_minor);  

    memset(dev, 0, sizeof(struct helloxjq_dev));  

    cdev_init(&(dev->dev), &helloxjq_fops);  
    dev->dev.owner = THIS_MODULE;  
    dev->dev.ops = &helloxjq_fops;          

    /*注册字符设备*/  
    err = cdev_add(&(dev->dev),devno, 1);  
    if(err) {  
        return err;  
    }          

    /*初始化信号量和寄存器val的值*/  
    sema_init(&(dev->sem),1);
    dev->val = kmalloc(10,GFP_KERNEL);  
    strncpy(dev->val,"helloxjq",sizeof("helloxjq"));
    return 0;  
}  

/*模块加载方法*/  
static int __init helloxjq_init(void){   
    int err = -1;  
    dev_t dev = 0;  
    struct device* temp = NULL;  

    printk(KERN_ALERT"helloxjq_init.\n");          

    /*动态分配主设备和从设备号*/  
    err = alloc_chrdev_region(&dev, 0, HELLOXJQ_DEVICE_NUM, HELLOXJQ_DEVICE_NODE_NAME);  
    if(err < 0) {  
        printk(KERN_ALERT"Failed to alloc char dev region.\n");  
        goto fail;  
    }  

    helloxjq_major = MAJOR(dev);  
    helloxjq_minor = MINOR(dev);          

    /*分配helo设备结构体变量*/  
    helloxjq_dev = kmalloc(sizeof(struct helloxjq_dev), GFP_KERNEL);  
    if(!helloxjq_dev) {  
        err = -ENOMEM;  
        printk(KERN_ALERT"Failed to alloc helloxjq_dev.\n");  
        goto unregister;  
    }          

    /*初始化设备*/  
    err = __helloxjq_setup_dev(helloxjq_dev);  
    if(err) {  
        printk(KERN_ALERT"Failed to setup dev: %d.\n", err);  
        goto cleanup;  
    }          

    /*在/sys/class/目录下创建设备类别目录helloxjq*/  
    helloxjq_class = class_create(THIS_MODULE, HELLOXJQ_DEVICE_CLASS_NAME);  
    if(IS_ERR(helloxjq_class)) {  
        err = PTR_ERR(helloxjq_class);  
        printk(KERN_ALERT"Failed to create helloxjq class.\n");  
        goto destroy_cdev;  
    }          

    /*在/dev/目录和/sys/class/helloxjq目录下分别创建设备文件helloxjq*/  
    temp = device_create(helloxjq_class, NULL, dev, "%s", HELLOXJQ_DEVICE_FILE_NAME);  
    if(IS_ERR(temp)) {  
        err = PTR_ERR(temp);  
        printk(KERN_ALERT"Failed to create helloxjq device.");  
        goto destroy_class;  
    }          

    /*在/sys/class/helloxjq/helloxjq目录下创建属性文件val*/  
    err = device_create_file(temp, &dev_attr_val);  
    if(err < 0) {  
        printk(KERN_ALERT"Failed to create attribute val.");                  
        goto destroy_device;  
    }  

    dev_set_drvdata(temp, helloxjq_dev);          

    printk(KERN_ALERT"Succedded to initialize helloxjq device.\n");  
    return 0;  

destroy_device:  
    device_destroy(helloxjq_class, dev);  

destroy_class:  
    class_destroy(helloxjq_class);  

destroy_cdev:  
    cdev_del(&(helloxjq_dev->dev));  

cleanup:  
    kfree(helloxjq_dev);  

unregister:  
    unregister_chrdev_region(MKDEV(helloxjq_major, helloxjq_minor), 1);  

fail:  
    return err;  
}  

/*模块卸载方法*/  
static void __exit helloxjq_exit(void) {  
    dev_t devno = MKDEV(helloxjq_major, helloxjq_minor);  

    printk(KERN_ALERT"helloxjq_exit\n");          

    /*销毁设备类别和设备*/  
    if(helloxjq_class) {  
        device_destroy(helloxjq_class, MKDEV(helloxjq_major, helloxjq_minor));  
        class_destroy(helloxjq_class);  
    }          

    /*删除字符设备和释放设备内存*/  
    if(helloxjq_dev) {  
        cdev_del(&(helloxjq_dev->dev));  
        kfree(helloxjq_dev);  
    }          
    if(helloxjq_dev->val != NULL){
     kfree(helloxjq_dev->val);
    }
    /*释放设备号*/  
    unregister_chrdev_region(devno, 1);  
}  

MODULE_LICENSE("GPL");  
MODULE_DESCRIPTION("Test Driver");  

module_init(helloxjq_init);  
module_exit(helloxjq_exit);

二、修改

  1. 修改arch/arm/Kconfig和drivers/kconfig两个文件，在menu "Device Drivers"和endmenu之间添加一行：
    source "drivers/helloxjq/Kconfig"
    这样，执行make menuconfig时，就可以配置helloxjq模块的编译选项了，而我们在配置Kconfig时写了default y，默认加载驱动模块，因此不用去menuconfig中配置编译选项。

  2. 修改drivers/Makefile文件，添加一行：
    obj-$(CONFIG_HELLOXJQ) += helloxjq/

  3. 在kernel/arch/arm/configs文件夹中的spyro_defconfig和spyro-perf_defconfig中添加
    CONFIG_HELLOXJQ=y
    一般教程没有这最后一步，但是我这个工程必须添加后才能编入内核。

三、编译

在源码主目录(HLOS)下编译。

source ./build/envsetup.sh
lunch 
make -j32 (也可以使用make -j32 make -j32 2>&1 | tee build.log，会在主目
录下生成build.log日志文件，便于查找错误)

四、验证

将代码工程烧录进安卓设备，通过ADB连接设备，
1、通过cd dev 查看是否有helloxjq文件夹
2、通过cat /proc/devices查看是否存在设备和对应的设备号
3、进入到sys/class目录，查看是否有helloxjq目录

LXJSWD
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
嵌入式中实现应用层和硬件层分层管理
qq_41854911的博客
07-03 510
以STM32为例，打开网络上下载的例程或者是购买开发板自带的例程，都会发现应用层中会有stm32f10x.h或者stm32f10x_gpio.h，这些文件严格来时属于硬件层的，如果软件层出现这些文件会显得很乱。使用过Linux的童鞋们肯定知道linux系统无法直接操作硬件层，打开linux或者rt_thread代码会发现代码中都会有device的源文件，没错，这就是驱动层。
Android Camera 架构
程序员Android
09-21 9042
和你一起终身学习，这里是程序员 Android 本篇文章主要介绍 Android 开发中的部分知识点，通过阅读本篇文章，您将收获以下内容: 一、Android Camera整体架构简述 二、 Camera App层简述 三、Camera Framework层简述 四、Camera Hal3 子系统 五、下面需要梳理的重点-正在进行 一.Android Camera整体架构简述 自Android8.0之后大多机型采用Camera API2 HAL3架构, 先盗改谷歌的一张图,读完整部代码后再看这张图,真的
【Camera专题】Qcom-Camera驱动框架浅析(Hal层-＞Driver层)
robitmind的专栏
07-06 1795
【Camera专题】Qcom-Camera驱动框架浅析(Hal层->Driver层) c枫_撸码的日子关注 0.7612019.01.23 10:46:11字数 1,423阅读 4,109 1、前言 本文主要研究高通平台Camera驱动和HAL层代码架构，熟悉高通Camera的控制流程。平台：Qcom-高通平台Hal版本：【HAL1】 知识点如下： 从HAL层到driver层：研究Camera以下内容1.打开(open)流程2.预览(preview)流程3.拍照(tackPicture)流
应用层驱动与内核驱动
qq_40334837的博客
04-23 1500
写这篇博客是因为听到一句话，应用层驱动？开始思考驱动就驱动不是在内核吗，怎么跑应用层去了。其实这个应用层驱动并不是我们常说的内核驱动，只是一个模块实现功能的一个集合，被makefile按照规则生成了一个文件叫.SO动态链接库，他本身没有驱动操作硬件的功能，而是调用内核驱动去运作，就像以前单片机里面代码功能多了，我们就用多个C文件和H文件代表每个模块，主函数main去调用他们，这样看...
DDI DEV DRV 之间的关系
泡在妞里的Feel
03-17 2326
做底层驱动的人对这名词肯定不陌生，那么他们之间又有什么样的联系呢？ DRV（Driver ）指硬件驱动：这层是直接和寄存器打交道，也是和硬件接触最紧密的软件层。一般DRV层代码会由芯片供应商提供，我们只需要按照自己的需求修改。比如：擦除LCD的显示buffer。 DEV（Device ）：也不知道起个什么汉语名字给它，因为它正好处在 硬件驱动DRV和设备驱动接口DDI之间。它完成的功能是对DR
应用层到驱动层
我的博客
12-04 6956
1、应用层—->VFS——>驱动层——–>硬件层； 2、应用层的程序要想跟底层的硬件打交道必须要有设备文件；在应用层通过open打开一个设备文件时，在VFS层会建立inode结构体和file结构体，前者是静态的描述设备的一些信息（如：设备号，节点指针，设备类型以及cdev结构体），后者则会描述设备类型的一些动态信息（如：文件方法集，读写位置，权限，私有属性等）。注意file结构体中有inode的地
AndroidQ 打通应用层到HAL层—(应用层实现)
01-03
前几篇文章陆陆续续实现了HAL，HIDL，JNI，AIDL服务，现在只差最后一步，应用层的实现我们就可以打通应用层到HAL的整个调用流程了，话不多说，上代码 应用层的实现相对比较简单，在Android Studio中进行开发，写完...
AndroidQ 打通应用层到HAL层—(HIDL服务实现)
01-03
AndroidQ 打通应用层到HAL层—(HAL模块实现)这篇文章中我们已经实现了自己的HAL，本篇我们实现一个HIDL服务，通过这个服务来调用HAL模块的函数 什么是HIDL HIDL 全称为HAL interface definition language（发音为...
AndroidQ 打通应用层到HAL层—(JNI服务和AIDL服务实现)
01-21
前面两篇文章实现了自定义HAL和HIDL服务，本篇接着往上层实现，这篇文章要写的是JNI服务和framework层AIDL服务实现，由AIDL服务调用JNI层的服务的函数，为了提供给上层APP使用 同样我们参照系统其他服务的方式来写，...
华为三层交换机实现跨网段-最简单配置步骤
11-22
这个配置是基本的三层交换机跨网段配置，实际应用中可能还需要考虑到安全策略、QoS、端口安全等因素。但作为基础配置，上述步骤已经能够满足两个不同网段的简单通信需求。在运维过程中，建议定期备份配置，以便在...
pb http 服务端、多层框架
10-18
软件供应商有公网服务器的话，可用本框架打通实现，我们用此框架实现过医生手机远程连入门诊内部查询修改自已的预约、患者资料；3.服务端即时通知功能，pb长连结客户端、http调用，服务端处理完成后，可以给在线的pb...
【Camera专题】Qcom-Camera驱动框架浅析(Hal层->Driver层)
weixin_33963189的博客
01-23 2328
1、前言 本文主要研究高通平台Camera驱动和HAL层代码架构，熟悉高通Camera的控制流程。 平台：Qcom-高通平台 Hal版本：【HAL1】 知识点如下： 从HAL层到driver层：研究Camera以下内容 1.打开(open)流程 2.预览(preview)流程 3.拍照(tackPicture)流程 2、Camera软件架构 由上图可以看出，Android Camera 框架是 ...
Hook与IoCallDriver与IofCallDriver
fengkuangfj的专栏
03-08 3380
用途之一：从内核层保护文件不被删除 IoCallDriver：一个内核例程，过滤所有的系统请求 NTSTATUS IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp ); IofCallDriver：在IoCallDriver中调用的一个例程，几乎所有的内核驱动都调用了IofCallDr
驱动和应用层的三种通信方式
07-31 1612
 作 者: sislcb时 间: 2008-01-04,11:57链 接: http://bbs.pediy.com/showthread.php?t=57666驱动程序和客户应用程序经常需要进行数据交换，但我们知道驱动程序和客户应用程序可能不在同一个地址空间，因此操作系统必须解决两者之间的数据交换。驱动层和应用层通信，主要是靠DeviceIoControl函数，下面是该函数的原型：BOOL De
应用层和驱动层的同步与异步的处理逻辑及底层实现
程序员人生
02-20 2559
应用层的实现： 1ReadFile、WriteFile、DeviceIoControl等，这些都有两种操作方式，一种是同步，一种是异步。 操作设备的Win32API主要是这3个函数ReadFile、WriteFile、DeviceIoControl 以DeviceIOControl为例，它的同步&异步操作如下： 同步操作时，它的内部会创建一个IRP_MJ_DEV
记不住的笔记
入门虽易，精通不易，且学且珍惜！
11-26 4853
年龄大了，记性差了，列一下我常忘记的基础知识 1.CIT暗码：*#*#00#*#*,*#*#564548#*#*  *#889# 2.修改TP方向：echo 1 > sys/class/input/input0/device/flipx 3.修改手机方向分辨率：     编译：device/qcom/d801/system.prop（ro.sf.lcd_density = 120 
浅谈高通平台NON-HLOS.bin文件生成和镜像加载过程
热门推荐
yxw0609131056的博客
08-27 1万+
      声明：本文只用于个人学习交流，若不慎造成侵权，请及时联系我，立即予以改正        NON-HLOS.bin文件是BP侧的一个镜像，最终被烧写到modem分区，但最近研究发现，其不仅仅包含modem镜像，它还包含ADSP镜像、Wcnss镜像、Venus镜像、Widevine镜像，还有一些安全相关的镜像。AP侧Init进程解析init.rc时，会通过kernel PIL驱动程序加载...
Linux（一）LED驱动程序框架（应用层和驱动层分析）
qq_26972441的博客
09-01 886
Linux（一）LED驱动程序框架（应用层和驱动层分析）
self-service-password和AD域打通
最新发布
06-07
可以使用LDAP协议来实现self-service-password和AD域的打通。具体的实现步骤如下： 1. 在AD域中创建一个专门用于self-service-password的用户，并授予该用户适当的权限。 2. 在self-service-password的配置文件中，配置AD域的连接信息，包括AD域的IP地址、端口号、管理员账号和密码等。 3. 在self-service-password的配置文件中，配置LDAP的搜索基准DN和用户过滤条件，以便self-service-password能够正确地在AD域中查找用户。 4. 在self-service-password的配置文件中，配置密码策略和验证策略，以确保用户能够安全地修改自己的密码。 5. 在self-service-password的Web界面中，添加AD域的认证方式，并配置相关参数。 通过上述步骤，就可以实现self-service-password和AD域的打通，让用户可以方便地修改自己的密码，并且不需要管理员的介入。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值