驱动程序的四种方式

最新推荐文章于 2024-02-18 11:35:09 发布

嵌入式linux爱好者

最新推荐文章于 2024-02-18 11:35:09 发布

阅读量1.1k

点赞数

分类专栏： linux嵌入式文章标签： linux

本文链接：https://blog.csdn.net/weixin_49460450/article/details/124026993

版权

linux嵌入式专栏收录该内容

2 篇文章 0 订阅

订阅专栏

阻塞/非阻塞简介

阻塞操作是指在执行设备操作时，若不能获得资源，则挂起进程直到满足可操作的条件后再进行操作。被挂起的进程进入睡眠状态，被从调度器的运行队列移走，直到等待的条件被满足。而非阻塞操作的进程在不能进行设备操作时，并不挂起，它要么放弃，要么不停地查询，直至可以进行操作为止。

阻塞/非阻塞例程

阻塞方式

int fd;
int data = 0;
fd = open("/dev/xxx_dev", O_RDWR); /* 阻塞方式打开 */
ret = read(fd, &data, sizeof(data)); /* 读取数据 */

非阻塞方式

int fd;
int data = 0; 
fd = open("/dev/xxx_dev", O_RDWR | O_NONBLOCK); /* 非阻塞方式打开 */ 
ret = read(fd, &data, sizeof(data)); /* 读取数据 */

驱动程序：

static ssize_t sr501_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
	int ret;
	int len = (size < 4) ? size : 4;
#if 0
	wait_event_interruptible(gpio_sr501_wait, data);
	ret = copy_to_user(buf, &data, len);
	data = 0;
#endif
	ret = copy_to_user(buf, &data, len);
	data = 0;
	
	return 0;
}

去掉

#if 0

#endif

而注释掉下面那段则为堵塞，而当前情况就为非堵塞

等待队列简介

等待队列是内核中一个重要的数据结构。阻塞方式访问设备时，如果设备不可操作，那么进程就会进入休眠状态。等待队列就是来完成进程休眠操作的一种数据结构。

等待队列头的定义的初始化

DECLARE_WAIT_QUEUE_HEAD (name)

例程：

static DECLARE_WAIT_QUEUE_HEAD(gpio_sr501_wait);//注册一个等待队列gpio_sr501_wait

定义并初始化一个等待队列项

DECLARE_WAITQUEUE(name, tsk)

name就是等待队列项的名字，tsk表示这个等待队列项属于哪个任务进程，一般设置为current，在 Linux内核中 current相当于一个全局变量，表示当前进程。因此宏DECLARE_WAITQUEUE就是给当前正在运行的进程创建并初始化了一个等待队列项。

将队列项添加到等待队列头

void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)

q：等待队列项要加入的等待队列头 wait：要加入的等待队列项 返回值：无

将队列项从等待队列头移除

void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)

q:要删除的等待队列项所处的等待队列头 wait：要删除的等待队列项。 返回值：无

等待唤醒

void wake_up(wait_queue_head_t *q) 
void wake_up_interruptible(wait_queue_head_t *q)

q:就是要唤醒的等待队列头，这两个函数会将这个等待队列头中的所有进程都唤醒 wake_up函数可以唤醒处于 TASK_INTERRUPTIBLE和 TASK_UNINTERRUPTIBLE状态的进程，而wake_ up_ interruptible函数只能唤醒处于 TASK_INTERRUPTIBLE状态的进程

等待事件

wait_event(wq, condition)

等待以wq为等待队列头的等待队列被唤醒，前提是 condition条件必须满足（为真），否则一直阻塞。此函数会将进程设置为TASK _UNINTERRUPTIBLE状态

wait_event_timeout(wq, condition, timeout)

功能和 wait_event类似，但是此函数可以添加超时时间，以 jiffies为单位。此函数有返回值，如果返回0的话表示超时时间到，而且 condition为假。为1的话表示 condition为真，也就是条件满足了。

wait_event_interruptible(wq, condition)

与 wait event函数类似，但是此函数将进程设置为 TASK_INTERRUPTIBLE，就是可以被信号打断。

wait_event_interruptible_timeout(wq, condition, timeout)

与 wait event timeout函数类似，此函数也将进程设置为 TASK_INTERRUPTIBLE，可以被信号打断。

轮询

当应用程序以非阻塞的方式访问设备时，会一遍一遍的去查询我们的设备是否可以访问，这个查询操作就叫做轮询。内核中提供了poll，epoll，select函数来处理轮询操作。当应用程序在上层通过poll，epoll，select函数来查询设备时，驱动程序中的poll，epoll，select函数就要在底层实现查询，如果可以操作的话，就会从读取设备的数据或者向设备写入数据。

poll

在单个线程中， select函数能够监视的文件描述符数量有最大的限制，一般为1024，可以修改内核将监视的文件描述符数量改大，但是这样会降低效率！这个时候就可以使用poll函数， poll函数本质上和 select没有太大的差别，但是poll函数没有最大文件描述符限制，Linx应用程序中poll函数原型如下所示：

int poll(struct pollfd *fds, nfds_t nfds, int timeout)

函数参数和返回值含义如下 fds：要监视的文件描述符集合以及要监视的事件，为一个数组，数组元素都是结构体 polled类型的， pollfd结构体如下所示

struct pollfd 
{ 
    int fd; /* 文件描述符 文件描述符 文件描述符 */ 
    short events; /* 请求的事件 请求的事件 请求的事件 */
    short revents; /* 返回的事件 返回的事件 返回的事件 */ 
};

fd是要监视的文件描述符，如果f无效的话那么 events监视事件也就无效，并且 revents返回0。 events是要监视的事件，可监视的事件类型如下所示

POLLIN        //有数据可以读取。
POLLPRI        //有紧急的数据需要读取。
POLLOUT        //可以写数据POLLERR指定的文件描述符发生错误POLLHUP指定的文件描述符挂起POLLNVAL无效的请求POLLRDNORM等同于 POLLIN

revents：返回参数，也就是返回的事件，有Linux内核设置具体的返回事件。 nfds:poll函数要监视的文件描述符数量 timeout：超时时间，单位为ms 返回值：返回 revents域中不为0的 polled结构体个数，也就是发生事件或错误的文件描述符数量；0，超时；-1，发生错误

void main(void)
{ 
   int ret; 
   int fd; /* 要监视的文件描述符 */
   struct pollfd fds;
   fd = open(filename, O_RDWR | O_NONBLOCK); /* 非阻塞式访问 */ 
    /* 构造结构体 */ 
   fds.fd = fd; 
   fds.events = POLLIN; /* 监视数据是否可以读取 */
   ret = poll(&fds, 1, 500); /* 轮询文件是否可操作，超时500ms */ 
    if (ret)
     { /* 数据有效 */ 
      /* 读取数据 */ 
     } else if (ret == 0) 
     { 
         /* 超时 */ 
     } else if (ret < 0) 
     {
          /* 错误 */ 
     } 
 }

驱动程序poll

static unsigned int sr501_poll(struct file *file, poll_table *wait)
{
	unsigned int ret = 0;
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	/*
	poll_wait它的作用就是把当前进程添加到wait参数指定的等待列表(poll_table)中。
	需要注意的是这个函数是不会引起阻塞的，呵呵，谁给它取得个名字带wait的，
	给咱们添这么多麻烦。
	*/
	poll_wait(file, &gpio_sr501_wait, wait);
	/*data = 0表示没有收到数据则poll返回0，要是接收到数据则poll返回数据POLLIN | POLLRDNORM
	 *即: POLLIN 有数据可读             POLLRDNORM       有普通数据可读
	 */

	if(data)
        ret |=POLLIN;//说明有数据被取到了
   
//poll的返回值确定应用程序当前是否需要继续等待 当return为0时继续等待，非0时继续执行应用程序
    return ret;
}

应用程序poll调用导致驱动程序poll被调用，驱动程序中调用poll_wait,驱动poll最后返回值0则代表还没数据，正数则代表有收到数据

poll_wait：把当前进程添加到wait参数指定的等待列表(poll_table)中，需要注意的是这个函数是不会引起阻塞的

一般在驱动程序的中断处理函数中来唤醒上层应用，并且给data赋值为正数。

static irqreturn_t gpio_sr501_isr(int irq, void *dev_id)
{
	int val;
	p_gpio_sr501 gpio_sr501 = dev_id;
	printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);	
	val = gpiod_get_value(gpio_sr501->gpiod);
	printk("key %d %d\n", gpio_sr501->gpio, val);
	data = 1;
	wake_up_interruptible(&gpio_sr501_wait);

/**
	 *kill_fasync - 释放一个信号
	 *@dev_fasync:事前使用fasync_helper注册进内核的fasync_struct对象指针的指针
	 *@filp:file指针，由fasync传入
	 *@sig:信号类型，通常使用的就是SIGIO
	 *@flag:标志，通常，如果资源可读用POLLIN，如果资源可写用POLLOUT
	 *当设备资源可用时，通过kill_fasync()发送SIGIO
	 */
	kill_fasync(&sr501_gpio_fasync, SIGIO, POLL_IN);

	return 0;
}

如果注释掉wake_up_interruptible则就实现上层应用规定时间再进行处理应用程序poll下程序。

异步通知概念

阻塞与非阻塞访问、poll函数提供了较好的解决设备访问的机制，但是如果有了异步通知，整套机制则更加完整了。异步通知的意思是：一旦设备就绪，则主动通知应用程序，这样应用程序根本就不需要查询设备状态，这一点非常类似于硬件上“中断”的概念，比较准确的称谓是“信号驱动的异步I/O”。信号是在软件层次上对中断机制的一种模拟，在原理上，一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是异步的，一个进程不必通过任何操作来等待信号的到达，事实上，进程也不知道信号到底什么时候到达。阻塞I/O意味着一直等待设备可访问后再访问，非阻塞I/O中使用poll（）意味着查询设备是否可访问，而异步通知则意味着设备通知用户自身可访问，之后用户再进行I/O处理。由此可见，这几种I/O方式可以相互补充。

Linux信号

异步通知的核心就是信号，在 arch/xtensa/include/uapi/asm/signal.h文件中定义了Linux所支持的所有信号

#define SIGHUP      1/* 终端挂起或控制进程终止 */ 
#define SIGINT      2/* 终端中断(Ctrl+C组合键) */ 
#define SIGQUIT     3 /* 终端退出(Ctrl+\组合键) */
#define SIGILL      4/* 非法指令 */ 
#define SIGTRAP     5/* debug使用，有断点指令产生 */
#define SIGABRT     6/* 由abort(3)发出的退出指令 */ 
#define SIGIOT      6 /* IOT指令 */ 
#define SIGBUS      7 /* 总线错误 */ 
#define SIGFPE      8 /* 浮点运算错误 */ 
#define SIGKILL     9 /* 杀死、终止进程 */ 
#define SIGUSR1     10 /* 用户自定义信号1 */ 
#define SIGSEGV     11 /* 段违例(无效的内存段) */
#define SIGUSR2     12 /* 用户自定义信号2 */ 
#define SIGPIPE     13 /* 向非读管道写入数据 */ 
#define SIGALRM     14 /* 闹钟 */
#define SIGTERM     15 /* 软件终止 */
#define SIGSTKFLT   16 /* 栈异常 */
#define SIGCHLD     17 /* 子进程结束 */
#define SIGCONT     18 /* 进程继续 */
#define SIGSTOP     19 /* 停止进程的执行，只是暂停 */
#define SIGTSTP     20 /* 停止进程的运行(Ctrl+Z组合键) */ 
#define SIGTTIN     21 /* 后台进程需要从终端读取数据 */ 
#define SIGTTOU     22 /* 后台进程需要向终端写数据 */
#define SIGURG      23 /* 有"紧急"数据 */
#define SIGXCPU     24 /* 超过CPU资源限制 */ 
#define SIGXFSZ     25 /* 文件大小超额 */ 
#define SIGVTALRM   26 /* 虚拟时钟信号 */ 
#define SIGPROF     27 /* 时钟信号描述 */
#define SIGWINCH    28 /* 窗口大小改变 */ 
#define SIGIO       29 /* 可以进行输入/输出操作 */
#define SIGPOLL SIGIO 
 /* #define SIGLOS 29 */ 
#define SIGPWR      30 /* 断点重启 */ 
#define SIGSYS      31 /* 非法的系统调用 */ 
#define SIGUNUSED   31 /* 未使用信号 */

异步通知代码

void (*signal(int signum, void (*handler))(int)))(int);

例程：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <poll.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <poll.h>
#include <signal.h>


/* eg:  ./sr501_drv_test /dev/sr501_1
 除了注册SIGIO的处理函数，APP还要做什么事？想想这几个问题：

① 内核里有那么多驱动，你想让哪一个驱动给你发SIGIO信号？

APP要打开驱动程序的设备节点。

② 驱动程序怎么知道要发信号给你而不是别人？

APP要把自己的进程ID告诉驱动程序。

③ APP有时候想收到信号，有时候又不想收到信号：

应该可以把APP的意愿告诉驱动：设置Flag里面的FASYNC位为1，使能“异步通知”。
*/

/*① 编写信号处理函数*/
static int fd;

static void sig_func(int sig)

{

	int val;

	read(fd,&val,4);

	printf("have person %d\n",val);


}

int main (int argc,char **argv)
{

	int ret;
	int flags;
	int count = 0;

/*	② 注册信号处理函数            */
	
	signal(SIGIO, sig_func);  

	/* 1. 判断参数 */
	if (argc != 2) 
	{
		printf("Usage: %s <dev>\n", argv[0]);
		return -1;
	}
/*	③ 打开驱动       */
	
	fd = open(argv[1],O_RDWR | O_NONBLOCK);
	
	/*异步通知方式使用非堵塞来打开，防止read后休眠而没有返回到while(1)中的程序执行
	
	，也就是防止回不去原本任务               */

	if(fd < 0)
	{
		printf("err: %s can't open!\n",argv[1]);
		return fd;
	}
	
/*fcntl的作用是改变一个已打开文件的属性，fd是要改变的文件的描述符，cmd是命令罗列如下：

F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_SETFL, F_SETLK, F_SETLKW,F_GETLK, F_GETOWN, F_SETOWN

本节只关心F_SETOWN（设置异步IO所有权），F_GETFL（获取文件flags），F_SETFL（设置文件flags）

arg是要改变的属性内容*/	

/*	④ 把进程ID告诉驱动   */
/*首先，设置一个进程作为一个文件的属主(owner)，
 这样内核就知道该把文件的信号发送给哪个进程*/
	
	fcntl(fd, F_SETOWN, getpid());
	
/*	⑤ 使能驱动的FASYNC功能             */
	
/*  然后，给文件设置FASYNC标志，以启用异步通知机制 */

	flags = fcntl(fd, F_GETFL);
	
	fcntl(fd, F_SETFL, flags | FASYNC);
//将fd的打开方式设置为FASYNC --- 即 支持异步通知 

//该行代码执行会触发 驱动程序中 file_operations->fasync 函数	


while(1)
{
	printf("count:%d\n",count++);
	sleep(2);
}
	close(fd);

	return 0;
}

fasync_struct结构体

首先我们需要在驱动程序中定义个 fasync_struct结构体指针变量， fasync_struct结构体内容如下

struct fasync_struct 
{ spinlock_t fa_lock; 
int magic; 
int fa_fd; 
struct fasync_struct *fa_next; 
struct file *fa_file; 
struct rcu_head fa_rcu; 
};

一般将 fasync_struct结构体指针变量定义到设备结构体中，比如在xxx_dev结构体中添加一个 fasync_struct结构体指针变量，结果如下所示

struct xxx_dev 
{ 
    struct device *dev; 
    struct class *cls;
    struct cdev cdev;
 ...... 
     struct fasync_struct *async_queue; /* 异步相关结构体 */
 };

fasync函数

如果要使用异步通知，需要在设备驱动中实现file_ operations操作集中的 fasync函数，此函数格式如下所示：

int (*fasync) (int fd, struct file *filp, int on)

fasync函数里面一般通过调用 fasync_helper函数来初始化前面定义的 fasync_struct结构体指针， fasync_helper函数原型如下

int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)

fasync_helper函数的前三个参数就是 fasync函数的那三个参数，第四个参数就是要初始化的 fasync_ struct结构体指针变量。当应用程序通过结构体指针变量。当应用程序通过“ fcntl(fd, F_SETFL, flags | FASYNC)”改变fasync标记的时候，驱动程序 file_operations操作集中的 fasync函数就会执行。

struct xxx_dev 
{ 
    ......
    struct fasync_struct *async_queue; /* 异步相关结构体 */ 
}; 
static int xxx_fasync(int fd, struct file *filp, int on)
{
     struct xxx_dev *dev = (xxx_dev)filp->private_data; 
     if (fasync_helper(fd, filp, on, &dev->async_queue) < 0) 
     return -EIO; 
     return 0; 
 } 
     static struct file_operations xxx_ops =
 { 
       ...... 
      .fasync = xxx_fasync,
      ...... 
 };

在关闭驱动文件的时候需要在file_ operations操作集中的 release函数中释放 fasyn_fasync struct的释放函数同样为 fasync_helper, release函数参数参考实例如下

static int xxx_release(struct inode *inode, struct file *filp) 
 { 
     return xxx_fasync(-1, filp, 0); /* 删除异步通知 */
 }

static struct file_operations xxx_ops =
 { 
    ...... 
    .release = xxx_release, 
 };

第3行通过调用示例代码 xxx_fasync函数来完成 fasync_struct的释放工作，但是，其最终还是通过 fasync_helper函数完成释放工作。

kill_fasync函数

当设备可以访问的时候，驱动程序需要向应用程序发出信号，相当于产生“中断” kill_fasync函数负责发送指定的信号， kill_fasync函数原型如下所示

void kill_fasync(struct fasync_struct **fp, int sig, int band)

函数参数和返回值含义如下： fasync struct 要操作的文件指针 sig：要发送的信号 band：可读时设置为 POLL IN，可写时设置为 POLL OUT。返回值：无。

应用程序对异步通知的处理

应用程序对异步通知的处理包括以下三步 1、注册信号处理函数应用程序根据驱动程序所使用的信号来设置信号的处理函数，应用程序使用 signal函数来设置信号的处理函数。前面已经详细的讲过了，这里就不细讲了。 2、将本应用程序的进程号告诉给内核使用fcntl（fd, F_SETOWN, getpid)将本应用程序的进程号告诉给内核 3、开启异步通知使用如下两行程序开启异步通知：

flags = fcntl(fd, F_GETFL); /* 获取当前的进程状态*/ 
fcntl(fd, F_SETFL, flags | FASYNC); /* 开启当前进程异步通知功能 */

重点就是通过 fcntl函数设置进程状态为 FASYNC，经过这一步，驱动程序中的 fasync函数就会执行。

嵌入式linux爱好者

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
驱动程序的四种方式

阻塞/非阻塞简介阻塞操作是指在执行设备操作时，若不能获得资源，则挂起进程直到满足可操作的条件后再进行操作。被挂起的进程进入睡眠状态，被从调度器的运行队列移走，直到等待的条件被满足。而非阻塞操作的进程在不能进行设备操作时，并不挂起，它要么放弃，要么不停地查询，直至可以进行操作为止。阻塞/非阻塞例程阻塞方式int fd;int data = 0;fd = open("/dev/xxx_dev", O_RDWR); /* 阻塞方式打开 */ret = read(fd, ..
复制链接

扫一扫