【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第四十章 Linux用户层和内核层

最新推荐文章于 2024-07-22 21:49:24 发布
最新推荐文章于 2024-07-22 21:49:24 发布
阅读量347 收藏 13
点赞数 7
分类专栏： # 开发指南8MM 文章标签： 嵌入式硬件 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BeiJingXunWei/article/details/140607848
版权

i.MX8MM处理器采用了先进的14LPCFinFET工艺，提供更快的速度和更高的电源效率;四核Cortex-A53，单核Cortex-M4，多达五个内核 ，主频高达1.8GHz，2G DDR4内存、8G EMMC存储。千兆工业级以太网、MIPI-DSI、USB HOST、WIFI/BT、4G模块、CAN、RS485等接口一应俱全。H264、VP8视频硬编码，H.264、H.265、VP8、VP9视频硬解码，并提供相关历程,支持8路PDM接口、5路SAI接口、2路Speaker。系统支持Android9.0(支持获取root限)Linux4.14.78+Qt5.10.1、Yocto、Ubuntu20、Debian9系统。适用于智能充电桩，物联网，工业控制，医疗，智能交通等，可用于任何通用工业和物联网应用、

【公众号】迅为电子

【粉丝群】258811263（加群获取驱动文档+例程）

第四十章 Linux用户层和内核层

本章导读

由于字符设备和块设备都良好地体现了“一切都是文件”的设计思想，掌握设备文件的读写操作，如何在Linux用户层和内核层之间传递数据就显得尤为重要。

第39章我们已经成功地使用杂项设备生成了一个设备节点，这个设备节点是用来做什么的呢？内核层和应用层是如何进行数据交互的呢？

40.1章节讲解了Linux用户层和内核层交互的基本知识

40.2章节编写了基于最简单杂项设备框架实现读写的驱动程序和测试应用程序

40.3 章节编译驱动程序及运行测试

40.4 章节讲解了应用层的内核层之间数据交互，并分别用实验测试验证。

本章内容对应视频讲解链接（在线观看）：

应用层和内核层数据传输 → https://www.bilibili.com/video/BV1Vy4y1B7ta?p=11

程序源码在网盘资料“iTOP-i.MX8MM开发板\02-i.MX8MM开发板网盘资料汇总(不含光盘内容)\嵌入式Linux开发指南(iTOP-i.MX8MM)手册配套资料\2.驱动程序例程\03-应用层与内核层互传数据”路径下。

40.1 Linux用户层和内核层交互

首先我们要明确一个概念，Linux一切皆文件！驱动文件最终通过与文件操作相关的系统调用或者C库函数（本质也是系统调用）被访问，而设备驱动的结构最终也是为了迎合提供给应用程序的API。（在Windows编程领域，习惯称操作系统的接口为API）。我们先来了解一下基本的概念。

概念1设备节点

在Linux中，所有设备都以文件的形式存放在/dev目录下，都是通过文件的方式进行访问，设备节点是Linux内核对设备的抽象，一个设备节点就是一个文件。应用程序通过一组标准化的调用执行访问设备，这些调用独立于任何特定的驱动程序。而驱动程序负责将这些标准调用映射到实际硬件的特有操作。

设备节点，驱动，硬件设备是怎样关联到一起的呢？这是通过设备号实现的，包括主设备号和次设备号。当我们创建一个设备节点时需要指定主设备号和次设备号。应用程序通过名称访问设备，而设备号指定了对应的驱动程序和对应的设备。主设备号标识设备对应的驱动程序，次设备号由内核使用，用于确定设备节点所指设备。

主设备号：驱动程序在初始化时，会注册它的驱动及对应主设备号到系统中，这样当应用程序访问设备节点时，系统就知道它所访问的驱动程序了。你可以通过/proc/devices文件来查看系统设备的主设备号。

次设备号：驱动程序遍历设备时，每发现一个它能驱动的设备，就创建一个设备对象，并为其分配一个次设备号以区分不同的设备。这样当应用程序访问设备节点时驱动程序就可以根据次设备号知道它说访问的设备了。

设备节点（设备文件）：Linux中设备节点是通过“mknod”命令来创建的。一个设备节点其实就是一个文件，Linux中称为设备文件。有一点必要说明的是，在Linux中，所有的设备访问都是通过文件的方式，一般的数据文件称为普通文件，设备节点称为设备文件。设备节点就是连接上层应用和底层驱动的桥梁，如下图所示：

设备驱动：设备驱动程序（device driver），简称驱动程序（driver），是一个允许高级(High level)计算机软件（computer software）与硬件（hardware）交互的程序，这种程序建立了一个硬件与硬件，或硬件与软件沟通的界面，经由主板上的总线（bus）或其它沟通子系统（subsystem）与硬件形成连接的机制，这样的机制使得硬件设备（device）上的数据交换成为可能。想想平时我们说的写驱动，例如点led灯的驱动，就是简单的io操作。

文件对应的操作有打开，关闭，读写，那么设备节点也可以看成一个文件，那么设备节点对应的操作有打开，关闭，读写。如果我在应用层使用系统IO（系统调用）对设备节点进行打开，关闭，读写等操作会发生什么呢？

file_operations结构体是访问驱动的函数，它的里面的每个结构体成员都对应一个调用，这个结构体里面有很多的成员变量，并且结构体中的成员函数是字符设备驱动程序设计的主体内容，这些函数实际会在应用程序进行Linux的open（）、write（）、read（）、close（）等系统调用时最终被内核调用。file_operations文件操作集在定义在/home/topeet/linux/linux-imx/include/linux/fs.h下面，如下图所示。

struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
int (*iterate) (struct file *, struct dir_context *);
unsigned int (*poll) (struct file *, struct poll_table_struct *);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, loff_t, loff_t, int datasync);
int (*aio_fsync) (struct kiocb *, int datasync);
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long,unsigned long, unsigned long);
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **);
long (*fallocate)(struct file *file, int mode, loff_t offset,loff_t len);
int (*show_fdinfo)(struct seq_file *m, struct file *f);};

下面我们对file_operations结构体中的主要成员进行分析。

函数

功能

llseek（）函数

修改一个文件的当前读写位置，并将新位置返回，在出错时，这个函数返回一个负值。

read（）函数

用来从设备中读取数据，成功时函数返回读取的字节数，出错时返回一个负值。它与用户空间应用程序中的ssize_t read（int fd，void*buf，size_t count）和size_t fread（void*ptr，size_t size，size_t nmemb，FILE*stream）对应。

write（）函数

向设备发送数据，成功时该函数返回写入的字节数。如果此函数未被实现，当用户进行write（）系统调用时，将得到-EINVAL返回值。它与用户空间应用程序中的ssize_t write（int fd，const void*buf，size_t count）和size_t fwrite（const void*ptr，size_t size，size_t nmemb，FILE*stream）对应。

read（）和write（）

如果返回0，则暗示end-of-file（EOF）。

unlocked_ioctl（）

提供设备相关控制命令的实现（既不是读操作，也不是写操作），当调用成功时，返回给调用程序一个非负值。它与用户空间应用程序调用的int fcntl（int fd，int cmd，.../*arg*/）和int ioctl（int d，int request，...）对应。

mmap（）函数

将设备内存映射到进程的虚拟地址空间中，如果设备驱动未实现此函数，用户进行

mmap（）系统调用时将获得-ENODEV返回值。这个函数对于帧缓冲等设备特别有意义，帧缓冲被映射到用户空间后，应用程序可以直接访问它而无须在内核和应用间进行内存复制。它与用户空间应用程序中的

void*mmap（void*addr，size_t length，int prot，int flags，int fd，off_t offset）函数对应。

poll（）函数

一般用于询问设备是否可被非阻塞地立即读写。当询问的条件未触发时，用户空间进行select（）和poll（）系统调用将引起进程的阻塞。

aio_read（）和aio_write（）函数

分别对与文件描述符对应的设备进行异步读、写操作。设备实现这

两个函数后，用户空间可以对该设备文件描述符执行SYS_io_setup、SYS_io_submit、SYS_io_getevents、SYS_io_destroy等系统调用进行读写。

open（）函数

当用户空间调用Linux API函数open（）打开设备文件时，设备驱动的open（）函数最终被调用。驱动程序可以不实现这个函数，在这种情况下，设备的打开操作永远成功。与open（）函数对应的是release（）函数。

实际情况下我们是用不了这么多调用的。常用的调用如下所示：

当我们在应用层read设备节点的时候，就会触发我们驱动里面read这个函数。

ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);

当我们在应用层write设备节点的时候，就会触发我们驱动里面write这个函数。

ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);

当我们在应用层poll/select的时候，就会触发我们驱动里面poll这个函数。

unsigned int (*poll) (struct file *, struct poll_table_struct *);

当我们在应用层ioctl的时候，就会触发我们驱动里面ioctl这个函数。

long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);

当我们在应用层open的时候，就会触发我们驱动里面open这个函数。

int (*open) (struct inode *, struct file *);

当我们在应用层close的时候，就会触发我们驱动里面close这个函数。

int (*release) (struct inode *, struct file *);

40.2 编写驱动程序和应用程序

通过40.1章节的学习，我们已经把内核层和用户层实现数据交互的基本概念搞懂了，在上一章节的基础上我们编写驱动程序实现在内核层与应用层传数据。

新建file_operation.c文件在Ubuntu的/home/topeet/imx8m/03目录下，可以在上次实验misc.c的基础上进行修改。

填充file_operation结构体

//文件操作集
struct file_operations misc_fops={

    .owner = THIS_MODULE,
    .open = misc_open,
    .release = misc_release,
    .read = misc_read,
    .write = misc_write,
};

填充接口函数

ssize_t misc_read (struct file *file, char __user *ubuf, size_t size, loff_t *loff_t) 
{
    printk("misc_read\n ");
    return 0;
}
ssize_t misc_write (struct file *file, const char __user *ubuf, size_t size, loff_t *loff_t)

{
   printk("misc_write\n ");
    return 0;
}
int misc_release(struct inode *inode,struct file *file){  
    printk("hello misc_relaease bye bye \n ");
    return 0;
}
int misc_open(struct inode *inode,struct file *file){
    printk("hello misc_open\n ");
    return 0;
}

完整驱动代码如下:

/*
 * @Descripttion: 在上一章节实现了最简单杂项设备的编写，本代码再其基础上验证内核层与应用层数据交互
 */

#include <linux/init.h>      //初始化头文件
#include <linux/module.h>    //最基本的文件，支持动态添加和卸载模块。
#include <linux/miscdevice.h>/*注册杂项设备头文件*/
#include <linux/uaccess.h>
#include <linux/fs.h>

/**
 * @name: misc_read
 * @test: 从设备中读取数据，当用户层调用函数read时，对应的，内核驱动就会调用这个函数。
 * @msg: 
 * @param {structfile} *file file结构体
 * @param {char__user} *ubuf 这是对应用户层的read函数的第二个参数void *buf
 * @param {size_t} size 对应应用层的read函数的第三个参数
 * @param {loff_t} *loff_t 这是用于存放文件的偏移量的，回想一下系统编程时，读写文件的操作都会使偏移量往后移。
 * @return {*} 当返回正数时，内核会把值传给应用程序的返回值。一般的，调用成功会返回成功读取的字节数。
如果返回负数，内核就会认为这是错误，应用程序返回-1
 */

ssize_t misc_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff_t)
{
    printk("misc_read\n ");
    return 0;
}

/**
 * @name: misc_write
 * @test: 往设备写入数据，当用户层调用函数write时，对应的，内核驱动就会调用这个函数。
 * @msg: 
 * @param {structfile} * filefile结构体
 * @param {constchar__user} *ubuf 这是对应用户层的write函数的第二个参数const void *buf
 * @param {size_t} size 对应用户层的write函数的第三个参数count。
 * @param {loff_t} *loff_t 这是用于存放文件的偏移量的，回想一下系统编程时，读写文件的操作都会使偏移量往后移。
 * @return {*} 当返回正数时，内核会把值传给应用程序的返回值。一般的，调用成功会返回成功读取的字节数。
 如果返回负数，内核就会认为这是错误，应用程序返回-1。
 */

ssize_t misc_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff_t)
{
    printk("misc_write\n ");
    return 0;
}

/**
 * @name: misc_release
 * @test: 当设备文件被关闭时内核会调用这个操作，当然这也可以不实现，函数默认为NULL。关闭设备永远成功。
 * @msg: 
 * @param {structinode} *inode 设备节点
 * @param {structfile} *file filefile结构体
 * @return {0}
 */
int misc_release(struct inode *inode,struct file *file){
    printk("hello misc_release bye bye \n");
    return 0;
}

/**
 * @name: misc_open
 * @test: 在操作设备前必须先调用open函数打开文件，可以干一些需要的初始化操作。
 * @msg: 
 * @param {structinode} *inode 设备节点
 * @param {structfile} *file filefile结构体
 * @return {0}
 */
int misc_open(struct inode *inode, struct file *file)
{
    printk("hello misc_open\n ");
    return 0;
}

//文件操作集
struct file_operations misc_fops =
    {
        .owner = THIS_MODULE,
        .open = misc_open,
        .release = misc_release,
        .read = misc_read,
        .write = misc_write,
};
//miscdevice结构体
struct miscdevice misc_dev =
    {
        .minor = MISC_DYNAMIC_MINOR,
        .name = "hello_misc",
        .fops = &misc_fops,
};

static int misc_init(void)
{
    int ret;
    ret = misc_register(&misc_dev); //注册杂项设备
    if (ret < 0)
    {
        printk("misc registe is error \n");
    }
    printk("misc registe is succeed \n");
    return 0;
}
static void misc_exit(void)
{
    misc_deregister(&misc_dev); //卸载杂项设备
    printk(" misc gooodbye! \n");
}
module_init(misc_init);
module_exit(misc_exit);
MODULE_LICENSE("GPL");

我们编写应用程序app.c,在ubuntu的/home/topeet/imx8m/03目录下，完整代码如下图所示：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main(int argc,char *argv[])
{
    int fd; //定义一个句柄
    char buf[64] = {0};
    fd = open("/dev/hello_misc",O_RDWR);//打开设备节点
    if(fd < 0)
    {
        perror("open error \n");
        return fd;
    }
    write(fd,buf,sizeof(buf));
    close(fd);
    return 0;
}

输入以下命令编译app.c，可以参考本手册“交叉编译器的安装和使用”章节编译C程序，如下所示：

40.3 编译驱动及运行测试

40.2章节我们已经编写好了驱动文件，这里我们以iTOP-iMX8MM开发板为例，将杂项设备驱动编译成模块。我们将file_operation.c文件拷贝到ubuntu的/home/topeet/imx8m/03目录下。将上次编译misc的Makefile文件和build.sh文件拷贝到file_operation.c同级目录下，修改Makefile为：

obj-m += file_operation.o
KDIR:=/home/topeet/linux/linux-imx
PWD?=$(shell pwd)
all:
	make -C $(KDIR) M=$(PWD) modules ARCH=arm64
clean:
	make -C $(KDIR) M=$(PWD) clean

拷贝好的文件如下图所示

输入“./build.sh”编译驱动程序，如下图所示： 

驱动编译完，我们通过nfs将编译好的驱动程序加载模块，输入以下命令，我们进入到共享目录/mnt/03，加载驱动模块如图所示：

insmod file_operation.ko    

ls /dev/hello_misc

 

在iMX8MM开发板上运行app程序,如下图所示，应用程序可以打开节点/dev/hello_misc，打开之后又关闭节点。 

思考：

假如我们的file_operations 里面没有read，我们在应用层read设备节点的时候会发生什么？

答：什么也不会发生，也不会报错！

40.4 应用层和内核层传递数据

我们的应用层和内核层是不能直接进行数据传输的。我们要想进行数据传输，要借助下面的这两个函数。

static inline long copy_from_user(void *to, const void __user * from, unsigned long n)

static inline long copy_to_user(void __user *to, const void *from, unsigned long n)

用户空间-->内核空间，如下图所示：

 

函数

copy_from_user(void *to, const void __user *from, unsigned long n)

参数to

目标地址（内核空间）

参数from

源地址（用户空间）

参数n

将要拷贝数据的字节数

返回值

成功返回0，失败返回没有拷贝成功的数据字节数

功能

将用户空间数据拷贝到内核空间

 内核空间-->用户空间，如下图所示：

函数

copy_to_user(void __user *to, const void *from, unsigned long n)

参数to

目标地址（用户空间）

参数from

源地址（内核空间）

参数n

将要拷贝数据的字节数

返回值

成功返回0，失败返回没有拷贝成功的数据字节数

功能

将内核空间数据拷贝到用户空间

 

40.4.1 应用层从内核层读数据

程序源码在网盘资料“iTOP-i.MX8MM开发板\02-i.MX8MM开发板网盘资料汇总(不含光盘内容)\嵌入式Linux开发指南(iTOP-i.MX8MM)手册配套资料\2.驱动程序例程\03-应用层与内核层互传数据\001”路径下。

我们修改40.2章节编写的驱动程序，我们要从内核层读数据，完整代码如下所示：

/*
 * @Descripttion: 
 * @version: 
 * @Author: sueRimn
 * @Date: 2021-02-23 12:40:42
 * @LastEditors: sueRimn
 * @LastEditTime: 2021-02-23 12:43:00
 */
#include <linux/init.h>       //初始化头文件
#include <linux/module.h>     //最基本的文件，支持动态添加和卸载模块。
#include <linux/miscdevice.h> //注册杂项设备头文件
#include <linux/uaccess.h>
#include <linux/fs.h>
/**
 * @name: misc_read
 * @test: 从设备中读取数据，当用户层调用函数read时，对应的，内核驱动就会调用这个函数。
 * @msg: 
 * @param {structfile} *file file结构体
 * @param {char__user} *ubuf 这是对应用户层的read函数的第二个参数void *buf
 * @param {size_t} size 对应应用层的read函数的第三个参数
 * @param {loff_t} *loff_t 这是用于存放文件的偏移量的，回想一下系统编程时，读写文件的操作都会使偏移量往后移。
 * @return {*} 当返回正数时，内核会把值传给应用程序的返回值。一般的，调用成功会返回成功读取的字节数。
                如果返回负数，内核就会认为这是错误，应用程序返回-1
 */
ssize_t misc_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff_t)
{
    char kbuf[] = "hehe";
    if (copy_to_user(ubuf, kbuf, strlen(kbuf)) != 0)
    {
        printk("copy_to_user error\n ");
        return -1;
    }
    printk("misc_read\n ");
    return 0;
}
/**
 * @name: misc_write
 * @test: 往设备写入数据，当用户层调用函数write时，对应的，内核驱动就会调用这个函数。
 * @msg: 
 * @param {structfile} * filefile结构体
 * @param {constchar__user} *ubuf 这是对应用户层的write函数的第二个参数const void *buf
 * @param {size_t} size 对应用户层的write函数的第三个参数count。
 * @param {loff_t} *loff_t 这是用于存放文件的偏移量的，回想一下系统编程时，读写文件的操作都会使偏移量往后移。
 * @return {*} 当返回正数时，内核会把值传给应用程序的返回值。一般的，调用成功会返回成功读取的字节数。
                如果返回负数，内核就会认为这是错误，应用程序返回-1。
 */
ssize_t misc_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff_t)
{
    char kbuf[64] = {0};
    if (copy_from_user(kbuf, ubuf, size) != 0)
    {
        printk("copy_from_user error\n ");
        return -1;
    }
    printk("kbuf is %s\n ", kbuf);
    return 0;
}
/**
 * @name: misc_release
 * @test: 当设备文件被关闭时内核会调用这个操作，当然这也可以不实现，函数默认为NULL。关闭设备永远成功。
 * @msg: 
 * @param {structinode} *inode 设备节点
 * @param {structfile} *file filefile结构体
 * @return {0}
 */
int misc_release(struct inode *inode, struct file *file)
{
    printk("hello misc_relaease bye bye \n ");
    return 0;
}
/**
 * @name: misc_open
 * @test: 在操作设备前必须先调用open函数打开文件，可以干一些需要的初始化操作。
 * @msg: 
 * @param {structinode} *inode 设备节点
 * @param {structfile} *file filefile结构体
 * @return {0}
 */
int misc_open(struct inode *inode, struct file *file)
{
    printk("hello misc_open\n ");
    return 0;
}
//文件操作集
struct file_operations misc_fops = {
    .owner = THIS_MODULE,
    .open = misc_open,
    .release = misc_release,
    .read = misc_read,
    .write = misc_write,
};
//miscdevice结构体
struct miscdevice misc_dev = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = "hello_misc",
    .fops = &misc_fops,
};
static int misc_init(void)
{
    int ret;
    ret = misc_register(&misc_dev); //注册杂项设备
    if (ret < 0)
    {
        printk("misc registe is error \n");
    }
    printk("misc registe is succeed \n");
    return 0;
}
static void misc_exit(void)
{

    misc_deregister(&misc_dev); //卸载杂项设备
    printk(" misc gooodbye! \n");
}
module_init(misc_init);
module_exit(misc_exit);
MODULE_LICENSE("GPL");

应用程序app.c，修改如下：

/*
 * @Descripttion: 
 * @version: 
 * @Author: sueRimn
 * @Date: 2021-02-23 12:36:04
 * @LastEditors: sueRimn
 * @LastEditTime: 2021-02-23 12:36:54
 */
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main(int argc,char *argv[])
{
    int fd;
    char buf[64] = {0};
    fd = open("/dev/hello_misc",O_RDWR);//打开设备节点
    if(fd < 0)
    {
        perror("open error \n");
        return fd;
    }
    //读内核层数据
    read(fd,buf,sizeof(buf));
    printf("buf is %s\n",buf);
    //write(fd,buf,sizeof(buf));
    close(fd);
    return 0;
}

 我们再次编译驱动程序和应用程序app，如下图所示：

加载驱动模块和运行应用程序如下图所示： 

从上图可以看到已经从内核里面读取到信息"hehe"并打印。

然后我们卸载驱动，如下所示：

rmmod file_operation

 

40.4.2 应用层向内核层写数据

程序源码在网盘资料“iTOP-i.MX8MM开发板\02-i.MX8MM开发板网盘资料汇总(不含光盘内容)\嵌入式Linux开发指南(iTOP-i.MX8MM)手册配套资料\2.驱动程序例程\03-应用层与内核层互传数据\002”路径下。

我们修改40.2章节编写的驱动函数，我们要从应用层读数据，完整代码如下所示：

#include <linux/init.h>       //初始化头文件
#include <linux/module.h>     //最基本的文件，支持动态添加和卸载模块。
#include <linux/miscdevice.h> //注册杂项设备头文件
#include <linux/uaccess.h>
#include <linux/fs.h>
/**
 * @name: misc_read
 * @test: 从设备中读取数据，当用户层调用函数read时，对应的，内核驱动就会调用这个函数。
 * @msg: 
 * @param {structfile} *file file结构体
 * @param {char__user} *ubuf 这是对应用户层的read函数的第二个参数void *buf
 * @param {size_t} size 对应应用层的read函数的第三个参数
 * @param {loff_t} *loff_t 这是用于存放文件的偏移量的，回想一下系统编程时，读写文件的操作都会使偏移量往后移。
 * @return {*} 当返回正数时，内核会把值传给应用程序的返回值。一般的，调用成功会返回成功读取的字节数。
                如果返回负数，内核就会认为这是错误，应用程序返回-1
 */
ssize_t misc_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff_t)
{
    char kbuf[] = "hehe";
    if (copy_to_user(ubuf, kbuf, strlen(kbuf)) != 0)
    {
        printk("copy_to_user error\n ");
        return -1;
    }
    printk("misc_read\n ");
    return 0;
}
/**
 * @name: misc_write
 * @test: 往设备写入数据，当用户层调用函数write时，对应的，内核驱动就会调用这个函数。
 * @msg: 
 * @param {structfile} * filefile结构体
 * @param {constchar__user} *ubuf 这是对应用户层的write函数的第二个参数const void *buf
 * @param {size_t} size 对应用户层的write函数的第三个参数count。
 * @param {loff_t} *loff_t 这是用于存放文件的偏移量的，回想一下系统编程时，读写文件的操作都会使偏移量往后移。
 * @return {*} 当返回正数时，内核会把值传给应用程序的返回值。一般的，调用成功会返回成功读取的字节数。
                如果返回负数，内核就会认为这是错误，应用程序返回-1。
 */
ssize_t test_misc_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff_t)
{
    char kbuf[64] = {0};
    if (copy_from_user(kbuf, ubuf, size) != 0)
    {
        printk("copy_from_user error\n ");
        return -1;
    }
    printk("kbuf is %s\n ", kbuf);
    return 0;
}
/**
 * @name: misc_release
 * @test: 当设备文件被关闭时内核会调用这个操作，当然这也可以不实现，函数默认为NULL。关闭设备永远成功。
 * @msg: 
 * @param {structinode} *inode 设备节点
 * @param {structfile} *file filefile结构体
 * @return {0}
 */
int misc_release(struct inode *inode, struct file *file)
{
    printk("hello misc_relaease bye bye \n ");
    return 0;
}
/**
 * @name: misc_open
 * @test: 在操作设备前必须先调用open函数打开文件，可以干一些需要的初始化操作。
 * @msg: 
 * @param {structinode} *inode 设备节点
 * @param {structfile} *file filefile结构体
 * @return {0}
 */
int misc_open(struct inode *inode, struct file *file)
{
    printk("hello misc_open\n ");
    return 0;
}
//文件操作集
struct file_operations misc_fops = {
    .owner = THIS_MODULE,
    .open = misc_open,
    .release = misc_release,
    .read = misc_read,
    .write = test_misc_write
};
//miscdevice结构体
struct miscdevice misc_dev = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = "hello_misc",
    .fops = &misc_fops,
};
static int misc_init(void)
{
    int ret;
    ret = misc_register(&misc_dev); //注册杂项设备
    if (ret < 0)
    {
        printk("misc registe is error \n");
    }
    printk("misc registe is succeed \n");
    return 0;
}
static void misc_exit(void)
{
    misc_deregister(&misc_dev); //卸载杂项设备
    printk(" misc gooodbye! \n");
}
module_init(misc_init);
module_exit(misc_exit);
MODULE_LICENSE("GPL");

应用程序修改如下：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main(int argc,char *argv[])
{
    int fd;
    char buf[64] = "12345";
    fd = open("/dev/hello_misc",O_RDWR);//打开设备节点
    if(fd < 0)
    {
        perror("open error \n");
        return fd;
    }
    //read(fd,buf,sizeof(buf));
    
    write(fd,buf,sizeof(buf)); //向内核层写数据
    //printf("buf is %s\n",buf);
    
    close(fd);
    return 0;
}

我们再次编译驱动程序和应用程序，如下图所示：

加载驱动模块和运行应用程序如下图所示： 

如上图所示，我们成功从应用层读取信息"12345"到内核层。

卸载驱动，如下图所示：

 

北京迅为
关注
  • 7
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【正点原子】I.MX6U嵌入式Linux驱动开发指南V1.7.pdf.7z
09-21
《正点原子》I.MX6U嵌入式Linux驱动开发指南是一本专注于嵌入式系统中Linux驱动程序开发的专业书籍。I.MX6U是NXP（原飞思卡尔）公司推出的一款高性能、低功耗的ARM Cortex-A9处理器，广泛应用于各种嵌入式设备和...
【正点原子】I.MX6U嵌入式Linux驱动开发指南V1.0.pdf
10-26
【正点原子】I.MX6U嵌入式Linux驱动开发指南V1.0.pdf 官方下载完整版，2019.10.26发布完整版
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第一篇 嵌入式Linux入门篇-第二十三章 安装 SSH
BeiJingXunWei的博客
07-11 904
i.MX8MM处理器采用了先进的14LPCFinFET工艺，提供更快的速度和更高的电源效率;四核Cortex-A53，单核Cortex-M4，多达五个内核 ，主频高达1.8GHz，2G DDR4内存、8G EMMC存储。千兆工业级以太网、MIPI-DSI、USB HOST、WIFI/BT、4G模块、CAN、RS485等接口一应俱全。H264、VP8视频硬编码，H.264、H.265、VP8、VP9视频硬解码，并提供相关历程,支持8路PDM接口、5路SAI接口、2路Speaker。
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第四十三章 驱动模块传参
BeiJingXunWei的博客
07-22 627
再下来三位为不同组用户权限。在编写应用程序的时候，我们可以给main函数传递参数，比如void main(int argc,char *argv[])，这个功能大家用起来已经很熟练了。iTOP-i.MX8MM开发板\02-i.MX8MM开发板网盘资料汇总(不含光盘内容)\嵌入式Linux开发指南(iTOP-i.MX8MM)手册配套资料\2.驱动程序例程\05-驱动模块传参。如上图所示，查看到变量a的读写权限为-r,意为可读，驱动程序里面设置的变量a的权限为S_IRUSR，意为可读，所以变量a传参成功。
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第三十六章 Linux驱动初探
BeiJingXunWei的博客
07-19 850
Linux设备驱动会以内核模块的形式出现，因为linux内核的整体架构就非常庞大，包含的组件也非常多，如果把所有的功能都编译到linux内核中会使得内核非常臃肿，为了解决这个问题，更方便地新增和删除功能，linux提供了这样的机制，这种机制被称为模块。单片机开发包括：程序设计（PC端软件编程），程序送往执行（将编程好的软件下载到单片机，需要编程器或者下载线），单片机系统的设计（硬件上设计你需要的任务的执行机构，如控制开关，温度检测，红外传输等等，都是根据你的所需，然后在选择对应的硬件器件）。
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第四十二章 LED驱动实验
BeiJingXunWei的博客
07-22 605
我们已经学会了杂项设备驱动编写的基本流程，其实需求已经完成了一半了，我们已经注册了杂项设备，并生成了设备节点。接下来我们要完成控制LED的逻辑操作，那么控制LED就涉及到了对寄存器的操作，但是对寄存器的操作我们是不能直接访问的，因为linux不能直接访问我们的物理地址，需要把物理地址先映射成虚拟地址，我们完成这一步转换需要用到ioremap函数。”，因为我们的内核里面已经的驱动了，像复用关系的寄存器，电气属性的寄存器，就可以不用设置了，直接设置数据寄存器和方向寄存器就可以了。
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第一篇 嵌入式Linux入门篇-第十三章 Linux连接档
BeiJingXunWei的博客
07-09 801
如果说硬连接到我们的目录，那么我们连接的数据需要连同被连接目录下所有数据都要创建硬连接，如果说我们将根目录下的 etc 用硬连接创建一个硬连接的目录，那么不光是我们的文件要被创建，这个文件下面所有的文件名都要创建一个硬连接，这样呢就会给工作环境造成一个很大的工作量，而且非常的复杂，所以现在还不支持。不管我们是修改 test1.c 或者是修改 test2.c 还是 test3.c ，只要修改一个，我们的文件就会被同时修改，因为他们的 inode 号都是相同的。我们可以利用这个特点来做文件的备份。
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第三十九章 Linux MISC驱动
BeiJingXunWei的博客
07-22 262
misc 的意思是混合的杂项的，所以 misc 设备驱动也叫做杂项设备驱动，当我们板子上的某个设备没有办法分类时，就可以用 misc 设备驱动。设备号包含主设备号和次设备号，设备号是计算机识别设备的一种方式，主设备号相同的就被视为同一类设备，主设备号在Linux系统里面是唯一的，次设备号不一定唯一。所有的 misc 设备驱动的主设备号都为 10，不同的设备使用不同的从设备号。通过39.1章节的学习，我们已经把杂项设备的基本概念搞懂了，在本实验中，使用 misc 设备驱动的方式来编写最简单的杂项设备的驱动。
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第三十七章 Linux内核模块
BeiJingXunWei的博客
07-22 429
模块本身不被编译入内核映像，从而控制了内核的大小。为了使读者初步建立对模块的感性认识，在第36.3章节我们已经写了一个最简单的驱动helloworld，那么这个章节将来学习怎么将我们写的驱动编译成驱动文件。我们来解释一下makefile的第一行，-m意思是把我们的驱动编译成模块,那么生成的中间文件的名字一般是和驱动C文件同名，这里是helloworld.o。”章节，此后的章节，我们也是通过nfs的方式往开发板传输文件，以后便不再赘述，大家也可以使用U盘的方式拷贝到开发板，但是为了方便调试，最好使用nfs。
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第四十六章 自动创建设备节点
BeiJingXunWei的博客
07-22 762
这样，加载模块的时候，用户空间中的udev会自动响应device_create，去/sysfs下寻找对应的类从而创建设备节点。Linux 驱动实验中，当我们通过 insmod 命令加载模块后，还需要通过 mknod 命令来手动创建设备节点，这样使用起来太麻烦了，并且不可能每个设备都去这样操作，Linux 系统的存在就是为了方便使用，所以我们来看一下如何实现自动创建设备节点，当加载模块时，在/dev 目录下自动创建相应的设备文件。46.3章节在46.2章节的基础上，编写创建设备的驱动程序，并编译为驱动模块。
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第四十五章 注册字符类设备
BeiJingXunWei的博客
07-22 585
cdev_add（）函数和cdev_del（）函数分别向系统添加和删除一个cdev，完成字符设备的注册和注销。对cdev_add（）的调用通常发生在字符设备驱动模块加载函数中，而对cdev_del（）函数的调用则通常发生在字符设备驱动模块卸载函数中。cdev结构体的dev_t成员定义了设备号，为32位，其中12位为主设备号，20位为次设备号。cdev_init（）函数用于初始化cdev的成员，并建立cdev和file_operations之间的连接。在整个Linux设备驱动的学习中，字符设备驱动较为基础。
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第一篇 嵌入式Linux入门篇-第十四章 Linux目录结构讲解
BeiJingXunWei的博客
07-09 944
我们打开文件管理，从最顶层开始，点击 computer ，这就是我们 ubuntu 的最顶层，左上角有一个 “/” ，“/” 就是根目录，在这个目录下，我们可以进到下边任意一个子目录，比如说作者点击 home 这个文件夹，然后再点击 topeet 这个文件夹，下边有很多的子文件夹，这些子文件夹就好比大树的枝干，一层一层的往下延伸。所以说从理论上来讲，linux目录结构可以是随意安排的，就是说我想往哪延伸就往哪延伸，没有任何的限制，但是如果我们所有的人都这样做，不同的人想法不同，那么我们很容易就出现混乱了。
【正点原子】I.MX6U嵌入式Linux驱动开发指南V1.6.7z
06-08
《I.MX6U嵌入式Linux驱动开发指南》是一本深入探讨嵌入式系统中Linux驱动程序开发的专业教程，特别针对NXP公司的I.MX6U处理器。这本书旨在帮助开发者理解和掌握在嵌入式环境中如何有效地编写和调试Linux驱动程序，以...
imx6ull嵌入式linux驱动开发指南pdf（正点原子）
05-21
本资源为 i.MX6ULL 嵌入式 Linux 驱动开发指南，旨在帮助开发者快速掌握 i.MX6ULL 嵌入式 Linux 驱动开发的技术。该指南涵盖了从基本概念到高级开发的方方面面，涵盖了驱动开发、内核编译、 Roots 文件系统构建、...
嵌入式硬件电路常用设计软件
了不起的小白君的博客
07-04 3317
Cadence Allegro是Cadence公司推出的先进PCB（Printed Circuit Board，印刷电路板）设计布线工具，也是目前最高端、最主流的PCB软件代表之一。Multisim是美国国家仪器（NI）有限公司推出的以Windows为基础的仿真工具，适用于板级的模拟/数字电路板的设计工作。Altium Designer（简称AD）是Protel的升级版，是一款集电路原理图设计、PCB设计、嵌入式软件开发以及FPGA设计等功能于一体的综合性设计软件。
Linux：Linux发展史
最新发布
weixin_51142926的博客
07-22 1130
大家好！此篇文章并非技术博文，而是简单了解Linux的时代背景和发展史，只有知其所以然才能让我们更好地让走进Liunx的世界！
Linux -软件安装
z2331198564653的博客
07-18 865
项目开发好需要部署，而项目本身可能依赖其他软件。这时在部署项目时就需要安装依赖的软件。比如: jdk mysql tomcat redis rabbitmq es等。
【Linux服务器Java环境搭建】010在linux中安装Redis，以及对Redis的配置与远程连接
liuzhenhe1988的专栏
07-19 955
好久没有更新博客了，今天下了班回到家，看到电脑桌上尘封已久的《Spring Boot应用开发实战》，翻开目录想起来之前写的系列【Linux服务器Java环境搭建】还未完结，那就继续吧，今天主要是按linux服务器中安装和配置redis。本系列其他文章，请查看系列【Linux服务器Java环境搭建】

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值