Linux驱动开发七：按键中断+poll机制+异步通知机制

最新推荐文章于 2023-08-09 21:49:58 发布
最新推荐文章于 2023-08-09 21:49:58 发布
阅读量2k 收藏 2
点赞数
分类专栏： c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/long123bin/article/details/40584579
版权


分析：

前面几个驱动都是获得按键值：

  1. .查询：应用程序很耗资源

  2. .中断：使用read()函数获取

  3. .poll：  指定超时时间

 

他们的共同点是：

  都是应用程序主动去读或者查询

 

疑问：

  是否有驱动主动告诉应用程序

 

答案：

  有，使用异步通知机制signal发信号

 

进程间发信号：

         Kill            -9         PID

         发送         9              接收

         Kill           -USR1       PID

要点：

  1. 注册信号处理函数

  2. 谁发

  3. 发给谁

  4. 怎么发

 

Example：

Signal.c

#include <stdio.h>

#include <signal.h>

 

void my_signal_fun(int signum)

{

         staticint cnt = 0;

         printf("signal= %d , %d times \n",signum,++cnt);

}

 

int main(int argc,char **argv)

{

         signal(SIGUSR1,my_signal_fun);

         while(1)

         {

                   sleep(1000);

         }

        

         return0;

}

Ps

…

  5770          0:00 [flush-0:12]

  6170          0:00 ./signal

  6180          0:00 ps

/ # kill -USR1 617

/ # signal = 10 , 1 times

/ # kill -USR1 617

/ # signal = 10 , 2 times

/ # kill -USR1 617

/ # signal = 10 , 3 times

 

目标：按下按键时，驱动通知应用程序

  1. 应用程序：注册信号处理函数

  2. 谁发：驱动

  3. 发给谁：发给APP的PID

  4. 怎么发：用kill_fasync函数法

 

为了使设备支持异步通知机制，驱动程序中涉及以下3项工作：

1. 支持F_SETOWN命令，能在这个控制命令处理中设置filp->f_owner为对应进程ID。

   不过此项工作已由内核完成，设备驱动无须处理。

2. 支持F_SETFL命令的处理，每当FASYNC标志改变时，驱动程序中的fasync()函数将得以执行。

   驱动中应该实现fasync()函数。

  

3. 在设备资源可获得时，调用kill_fasync()函数激发相应的信号

 

 

应用程序：

fcntl(fd, F_SETOWN, getpid());  // 告诉内核，发给谁

 

Oflags = fcntl(fd, F_GETFL);  

fcntl(fd, F_SETFL, Oflags | FASYNC);  // 改变fasync标记，最终会调用到驱动的faync> fasync_helper：初始化/释放fasync_struct


驱动代码：

fifth_drv.c

/*
 *功能：中断驱动,在按键驱动基础上修改，原理图见按键驱动,增加poll机制,增加异步通知机制
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>

#include <linux/device.h> 

#include <linux/irq.h>
#include <linux/interrupt.h>
//#include <mach/regs-gpio.h>  
//#include <mach/hardware.h>
#include <mach/gpio.h>  


#include <mach/hardware.h>  
#include <linux/sched.h>
#include <linux/poll.h>


int major;
const char *major_name = "fifth_drv";
const char *minor_name = "button";

static struct class *fifthdrv_class;
static struct class_device *fifthdrv_class_dev;

volatile unsigned long *gpncon = NULL;
volatile unsigned long *gpndat = NULL;

//声明一个按键的等待队列
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

/* 中断事件标志, 中断服务程序将它置1，fifth_drv_read将它清0 */
static volatile int ev_press = 0;

//异步
static struct fasync_struct *button_fasync;

struct pin_desc{
	unsigned int pin;
	unsigned int key_val;
};

/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
static unsigned char key_val;

/*
 * K1,K2,K3,K4对应GPN0，GPGN1，GPN2，GPN3
 */
 /*
 struct pin_desc pins_desc[4] = {
	{S3C64XX_GPN0_EINT0, 0x01},
	{S3C64XX_GPN1_EINT1, 0x02},
	{S3C64XX_GPN2_EINT2, 0x03},
	{S3C64XX_GPN3_EINT3, 0x04},
};
struct pin_desc pins_desc[4] = {
	{0, 0x01},
	{1, 0x02},
	{2, 0x03},
	{3, 0x04},
};
*/
struct pin_desc pins_desc[4] = {
	{S3C64XX_GPN(0), 0x01},
	{S3C64XX_GPN(1), 0x02},
	{S3C64XX_GPN(2), 0x03},
	{S3C64XX_GPN(3), 0x04},
};

/*
 * 确定按键值
 *中断处理程序,并置标志位为1，唤醒等待队列上等待的进程,注册用户中断处理函数,设置触发方式为双边沿触发
 */
static irqreturn_t button_irq(int irq,void *dev_id)
{
	struct pin_desc * pindesc = (struct pin_desc *)dev_id;
	unsigned int pinval;
	
//	pinval = ioread32(S3C64XX_GPNDAT);
//	pinval = gpio_get_value(S3C64XX_GPN(pindesc->pin));/* 读取中断引脚的状态 */
	pinval = gpio_get_value(pindesc->pin);/* 读取中断引脚的状态 */

	/* 确定按键值 */
	if (pinval)
	{
		/* 松开 */
		key_val = 0x80 | pindesc->key_val;
	}
	else
	{
		/* 按下 */
		key_val = pindesc->key_val;
	}

    ev_press = 1;                  /* 表示中断发生了 */
    wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */

	kill_fasync(&button_fasync,SIGIO,POLL_IN);//发信号
	return IRQ_RETVAL(IRQ_HANDLED);
}

/* open函数  */
static int fifth_drv_open(struct inode *inode,struct file *file)
{
	/* 配置GPN0、1、2、3为输入(配置为0) */
//	*gpncon &=~((0x3<<(0*2)) | (0x3<<(1*2)) | (0x3<<(2*2)) | (0x3<<(3*2)));//清零寄存器
	request_irq(IRQ_EINT(0),button_irq,IRQ_TYPE_EDGE_BOTH,"K1",&pins_desc[0]);
	request_irq(IRQ_EINT(1),button_irq,IRQ_TYPE_EDGE_BOTH,"K2",&pins_desc[1]);
	request_irq(IRQ_EINT(2),button_irq,IRQ_TYPE_EDGE_BOTH,"K3",&pins_desc[2]);
	request_irq(IRQ_EINT(3),button_irq,IRQ_TYPE_EDGE_BOTH,"K4",&pins_desc[3]);
//	request_irq(IRQ_EINT(4),button_irq,IRQ_TYPE_EDGE_BOTH,"K4",1);
	return 0;
}

/* read函数  */
static ssize_t fifth_drv_read(struct file *file,char __user *buf,size_t size,loff_t *ppos)
{
	if(size != 1)
		return -EINVAL;
		
	/* 如果没有按键动作, 休眠 */
	wait_event_interruptible(button_waitq, ev_press);

	/* 如果有按键动作, 返回键值 */
	copy_to_user(buf, &key_val, 1);
	ev_press = 0;//重新清0
	
	return 1;
}

static unsigned fifth_drv_poll(struct file *file,poll_table *wait)
{
	unsigned int mask = 0;
	
	/* 不会立即休眠  只是将进程挂到key_waitq队列, 并不会休眠 */
	poll_wait(file,&button_waitq,wait);
	
	if(ev_press)//如果没有中断产生
		mask |= POLLIN | POLLRDNORM;
	
//	printk("\t*******************\n\tpoll\n\t***********************\n");
	return mask;
}
//主要是卸载用户中断处理程序
int fifth_drv_close(struct inode* inode,struct file* file)
{
	free_irq(IRQ_EINT(0),&pins_desc[0]);
	free_irq(IRQ_EINT(1),&pins_desc[1]);
	free_irq(IRQ_EINT(2),&pins_desc[2]);
	free_irq(IRQ_EINT(3),&pins_desc[3]);
	
	return 0;
}

static int fifth_drv_fasync(int fd,struct file *file,int on)
{
	printk("dirver:fifth_drv_fasync\n");
	
	return fasync_helper(fd,file,on,&button_fasync);//初始化结构button_fasync
}
	
	/* 结构体  */
static struct file_operations fifth_drv_fops={
	.owner   = THIS_MODULE,/* 这是一个宏，推向编译模块时自动创建到__this_module变量  */
	.open    = fifth_drv_open,
	.read    = fifth_drv_read,
	.release = fifth_drv_close,
	.poll    = fifth_drv_poll,
	.fasync  = fifth_drv_fasync,	
};


/* 入口函数  */	
static int fifth_drv_init(void)
{
	major = register_chrdev(0,major_name,&fifth_drv_fops);
	if(major < 0)
	{
		printk("Can't register major number\n");
		return major;
	}
	
	/* 自动生成设备节点机制,获取系统消息，cat /proc/class会发现 first_drv */
     fifthdrv_class = class_create(THIS_MODULE, major_name);
     /* register your own device in sysfs, and this will cause udev to create corresponding device node */
     fifthdrv_class_dev = device_create( fifthdrv_class, NULL, MKDEV(major, 0),NULL, minor_name );
     
     /* 地址映射 */
	gpncon = (volatile unsigned long *)ioremap(0x7F008830,16);
	gpndat = gpncon + 1;//指针加1
	
	return 0;
}

/* 出口函数  */
static void fifth_drv_exit(void)
{
	unregister_chrdev(major,major_name);
	device_unregister(fifthdrv_class_dev);
	class_destroy(fifthdrv_class);
	iounmap(gpncon);
}

module_init(fifth_drv_init);
module_exit(fifth_drv_exit);
MODULE_LICENSE("GPL");

Makefile:

obj-m := fifth_drv.o

KER_DIR := /work/work/linux/


all:
	$(MAKE) -C $(KER_DIR) M=`pwd` modules
#	cp first_drv.ko /work/tftpboot/
	cp fifth_drv.ko /work/nfsroot/
	echo $^
	
clean:
	make -C $(KER_DIR) M=`pwd` modules clean

test.c:

/*
 *功能：在一定时间内没有按键中断，也返回
 */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <poll.h>
#include <signal.h>

int fd;
/*test 
 */
 void my_signal_fun(int signum)
{
	unsigned char key_vals;
	read(fd,&key_vals,1);
	printf("key_vals = 0x%x\n",key_vals);
}

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

	int Oflags ;	
	
	
	
	fd = open("/dev/button",O_RDWR);
	if(fd < 0)
	{
		printf("can't opent /dev/button\n");
		return 0;
	}
	signal(SIGIO,my_signal_fun);
	
	fcntl(fd,F_SETOWN,getpid());
	Oflags = fcntl(fd,F_GETFL);
	fcntl(fd,F_SETFL,Oflags|FASYNC);
	
	while(1)	
	{
		sleep(1000);
	}
	
	return 0;
	
}


结果：

/ # insmod  fifth_drv.ko
/ # ./test &
/ # dirver:fifth_drv_fasync
key_vals = 0x1
key_vals = 0x1
key_vals = 0x1
key_vals = 0x81
key_vals = 0x2
key_vals = 0x2
key_vals = 0x2

long123bin
关注
专栏目录
Linux 驱动开发基础知识——APP 怎么读取按键值（十二）
妄北y
02-20 7533
在做单片机开发时，要读取 GPIO 按键，我们通常是执行一个循环，不断地检测 GPIO 引脚电平有没有发生变化。但是在 Linux 系统中，读取 GPIO 按键要考虑到效率，引入了很多种方法：查询方式(非阻塞)、休眠-唤醒(阻塞方式)、 poll 方式、异步通知方式。
中断事件通知应用程序
11-05
实现了应用程序与驱动程序的事件通讯。通过两种方式创建事件，一是在应用程序中创建事件对象，另一是在驱动程序中创建驱动。但完成相同的工作，都是同步驱动程序与应用程序。
关于_linux外部中断驱动异步通知应用程序
u010402372的专栏
11-26 4467
1，file 1,-> ent_test.c /* * file ent_test.c * Copyright by jiangdou QQ:344283973 * * RK3188 ENT test 20140902 * how to compile: $ arm-linux-gnueabihf-gcc -o ent_test ENT_test.c -static */
poll和异步通知的引入
gaosong819的专栏
05-20 934
在linux驱动学习的过程中，会遇到同步互斥、异步通信、poll机制、阻塞和非阻塞的这些概念，对于这些概念在什么时候引入来讲述比较好呢？下面只讲述poll机制和异步通信。 对于按键驱动，如何去返回按键值成为一个比较有意思事情。首先可以查询按键的接口返回是否按下的状态值，也可以利用中断去获取按键值。对于不断的查询和中断去获取按键值，明显可以知道中断方式所耗费的资源是比较小的。但是上面讲的实现只是驱
【IMX6ULL驱动开发学习】04.应用程序和驱动程序数据传输和交互的4种方式：非阻塞、阻塞、POLL、异步通知
最新发布
阿龙的博客
08-09 2156
应用程序和驱动程序数据传输和交互的4种方式：非阻塞、阻塞、POLL、异步通知
Linux--信号中断
weixin_42492053的博客
03-20 635
一、信号中断 信号时Linux中的一种软件中断处理机制 信号的名字都以字符SIG开头 头文件<signal.h> void (*signal(int signo,void(*func)(int)))(int); signo是信号名 func的取值： -SIG_IGN，向内核表示忽略此信号 -SIG_DFL，接到此信号后的动作是系统默认动作 二、产生中断信号 1、 2 3、 三、阻塞中...
Linux驱动开发八：按键中断+poll机制+异步通知机制+信号量及阻塞标志
long123bin的专栏
10-29 1496
 目的:          同一时刻只能有一个应用程序打开设备   解决方案： 1. 原子操作 原子操作指的是在执行过程中不会被别的代码路径所中断的操作。 常用原子操作函数举例： atomic_t v = ATOMIC_INIT(0);     //定义原子变量v并初始化为0 atomic_read(atomic_t *v);    
linux gpio中断程序,【嵌入式Linux驱动开发】十三、GPIO按键中断驱动程序编写
weixin_31499919的博客
05-02 1459
这个世界是由概率学统治的，所以每一个成功的人，都应该心怀疚歉和感恩，致敬和他们一样野心聪明勤奋坚持，却没有得到概率女神青睐的人们。文章目录零、写在前面的话一、按键驱动框架1.1 LED驱动回顾1.2 按键驱动编写思路二、编程2.1 设备树相关2.1.1 编写设备树2.2 驱动代码相关2.2.1 编写驱动程序零、写在前面的话停更的这段时间，一直在快马加鞭的干毕设论文，初稿最近刚完成，还需要再完善。毕...
嵌入式Linux按键驱动，支持短按和长按检测
03-15
本文将深入探讨如何实现一个支持短按和长按检测的按键驱动，利用平台驱动框架、按键中断、内核定时器以及POLL机制，确保在休眠-唤醒场景下也能高效工作，并支持异步通知和非阻塞IO操作。 首先，我们要理解嵌入式...
Linux驱动开发之异步通知实验
weixin_57037095的博客
03-24 1237
Linux驱动开发之异步通知实验【文后附有完整代码】 九步学会异步通知
linux下中断处理程序示例，含驱动和应用程序
08-19
该示例提供了中断处理的详细代码，含驱动程序和应用程序。用户可以直接调用接口进行中断函数的处理。
Linux中断
the_wan的博客
09-25 567
参考：《Linux驱动开发入门与实战》 《正点原子：I.MX6U 嵌入式 Linux 驱动开发指南》 1. 中断的概念 中断是指在CPU正常运行期间，由于外部事件或由程序预先安排的事件引起的CPU暂时停止正在运行的程序，转而为该内部或外部事件或预先安排的事件服务的程序中去，服务完毕后再返回取继续运行被暂时中断的程序。 2. 中断的分类 2.1 中断的宏观分类 中断从宏观上可以分为两大类，即硬中断和软中断。 硬中断 硬中断就是由系统硬...
linux device drive 第六章代码示例-scullpipe的实验（poll和fasync方法的实现）之二
敏于思，慎于行
11-23 1424
一 测试程序头文件 scull.h #include /* needed for the _IOW etc stuff used later */ /* * Ioctl definitions */ /* Use 'k' as magic number */ #define SCULL_IOC_MAGIC 'k' /* Please use a different 8-bit numb
Linux中断（interrupt）子系统之五：软件中断（softIRQ）
qq_34497438的博客
01-14 253
软件中断（softIRQ）是内核提供的一种延迟执行机制，它完全由软件触发，虽然说是延迟机制，实际上，在大多数情况下，它与普通进程相比，能得到更快的响应时间。软中断也是其他一些内核机制的基础，比如tasklet，高分辨率timer等。 /******************************************************************************************...
linux device drive 第六章代码示例-scullpipe的实验（poll和fasync方法的实现）之三
敏于思，慎于行
11-23 1158
实验测试结果 [Tekkaman2440@SBC2440V4]#cd /lib/modules/ [Tekkaman2440@SBC2440V4]#insmod pipe.ko [Tekkaman2440@SBC2440V4]#cat /proc/devices Character devices: 1 mem 2 pty 3 ttyp 4 /dev/vc/0 4 tty
Linux中断异步通知笔记
zhou8400的专栏
09-01 872
异步通知笔记 应用程序需要完成如下三个步骤： 1）signal(SIGIO, sig_handler); 调用signal函数，让指定的信号SIGIO与处理函数sig_handler对应。 2）fcntl(fd, F_SET_OWNER, getpid()); 指定一个进程作为文件的“属主(filp->owner)”，这样内核才知道信号要发给哪个进程。 3）f_flags = fcnt
linux中断如何通知应用程序,linux中断和异步通知 基于QT210
weixin_42501881的博客
05-06 675
#include static dev_t devno;static struct cdev cdev;static struct class* buttons_class;static struct device* buttons_device;static wait_queue_head_t button_waitq;static struct timer_list buttons_timer...
阻塞IO，异步通知，中断，时间定时器（Linux驱动２）
mmhhj的专栏
03-12 740
1 阻塞和非阻塞IO说明: 阻塞IO,当资源不可用时,进程就阻塞住.非阻塞IO,当资源不可用时,进程不被阻塞. 系统通过等待队列实现阻塞IO,等待队列的调度与系统调度有关. 非阻塞IO,需要用户不断查询状态.用户侧通过select,FD_SET等宏来实现,驱动侧需要实现poll函数. 变量 wait_queue_head_t head wait_queue_t
Linux GPIO中断异步通知
AI.PLAY
11-29 1356
Ubuntu 中，通常有线网卡为eth0，无线网卡则为wlan0，后续增加的以此类推（可能某些无线网卡型号命名为eth1，而非wlan0）。 ifconfig简介 ifconfig 是一个用来查看、配置、启用或禁用网络接口的工具，这个工具极为常用的（说的是喜欢动命令的人……）。 查看 Ubuntu 中，通常有线网卡为eth0，无线网卡则为wlan0，后续增加的以此类推（可能某些无线网卡型号命名为e
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值