编写按键中断驱动——异步机制

硬件平台：韦东山嵌入式Linxu开发板（S3C2440.v3）
软件平台：运行于VMware Workstation 12 Player下UbuntuLTS16.04_x64 系统
参考资料：《嵌入式Linux应用开发手册》、《嵌入式Linux应用开发手册第2版》
开发环境：Linux 2.6.22.6 内核、arm-linux-gcc-3.4.5-glibc-2.3.6工具链

一、前言

在之前按键中断中的查询方式、休眠——唤醒方式、poll机制都是属于同步机制，就是应用程序一直在调用驱动程序。
提问：是否可以实现由驱动程序去提醒应用程序已经准备，可以调用。
回答：可以，在Linux中，可以使用异步机制，实现驱动程序通知应用程序。
场景：下面我借助一下韦东山老师的场景来理解一下：

妈妈怎么知道卧室里小孩醒了？

时不时进房间看一下：查询方式——简单，但是累
进去房间陪小孩一起睡觉，小孩醒了会吵醒她：休眠-唤醒 ——不累，但是妈妈干不了活了
妈妈要干很多活，但是可以陪小孩睡一会，定个闹钟： poll 方式——要浪费点时间，但是可以继续干活。妈妈要么是被小孩吵醒，要么是被闹钟吵醒。
妈妈在客厅干活，小孩醒了他会自己走出房门告诉妈妈：异步通知——妈妈、小孩互不耽误

二、要点

在编程之前，我们需要对下面的问题有个清晰的答案。

1、谁发送：驱动程序发

采用异步机制的时候，驱动程序可以去提醒应用程序，可以调用。

2、发什么：信号

这时候，驱动程序通过信号去提醒应用程序。

3、发什么信号： SIGIO

/linux-2.6.22.6/include/asm-parisc/signal.h这个文件下定义了多种信号，而对于我们IO口的，采用SIGIO这个信号值。

#define SIGHUP		 1
#define SIGINT		 2
#define SIGQUIT		 3
#define SIGILL		 4
#define SIGTRAP		 5
#define SIGABRT		 6
#define SIGIOT		 6
#define SIGEMT		 7
#define SIGFPE		 8
#define SIGKILL		 9
#define SIGBUS		10
#define SIGSEGV		11
#define SIGSYS		12 /* Linux doesn't use this */
#define SIGPIPE		13
#define SIGALRM		14
#define SIGTERM		15
#define SIGUSR1		16
#define SIGUSR2		17
#define SIGCHLD		18
#define SIGPWR		19
#define SIGVTALRM	20
#define SIGPROF		21
#define SIGIO		22
#define SIGPOLL		SIGIO
#define SIGWINCH	23
#define SIGSTOP		24
#define SIGTSTP		25
#define SIGCONT		26
#define SIGTTIN		27
#define SIGTTOU		28
#define SIGURG		29
#define SIGLOST		30 /* Linux doesn't use this either */
#define	SIGUNUSED	31

4、怎么发：内核里提供有函数

在内核中了这个函数

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

struct fasync_struct **fp：定义一个结构体，用来区分是谁发送的，button_async->fa_file 非空时，可以从中得到 PID，表示发给哪一个 APP
int sig：上面所提到的信号值
int band：标志位，当 FASYNC 位发生变化时，会导致驱动程序的 fasync 被调用

5、发给谁：应用程序（APP 要把自己告诉驱动）

fcntl(fd, F_SETOWN, getpid());

通过getid()把进程的PID传给驱动

6、应用程序收到后做什么：执行信号处理函数

定义一个执行信号处理函数

void my_signal_fun(int signum)
{
	unsigned char key_val;
	read(fd, &key_val, 1);
	printf("key_val: 0x%x\n", key_val);
}

7、信号处理函数和信号，之间怎么挂钩：应用程序注册信号处理函数

signal(SIGIO, my_signal_fun);
void（* signal（int sig，void（* func）（int）））（int）;

int sig：设置处理功能的信号值。
void（* func）（int）：定义一个信号处理函数

三、代码编写

1、驱动程序

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/poll.h>

int major;
static struct class *buttondrv_class;
static struct class_device	*buttondrv_class_dev;

volatile unsigned long *gpfcon;
volatile unsigned long *gpfdat;
volatile unsigned long *gpgcon;
volatile unsigned long *gpgdat;

static struct fasync_struct *button_async;

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

/* 按键信息 */
struct pin_desc{
	unsigned int pin;
	unsigned int key_val;
};

/* 存储4个按键的信息 */
struct pin_desc pins_desc[4] = {
 	{S3C2410_GPF0,  0x01},
 	{S3C2410_GPF2,  0x02},
 	{S3C2410_GPG3,  0x03},
	{S3C2410_GPG11, 0x04},
};

/* 中断注册信息 */
struct buttonirq_decs{
	unsigned int irq;
	unsigned long flags;
	const char *devname;
	void *dev_id;
};

struct buttonirq_decs buttonirqs_decs[4] = {
	{IRQ_EINT0,	 IRQT_BOTHEDGE, "S2", &pins_desc[0]},
	{IRQ_EINT2,	 IRQT_BOTHEDGE, "S3", &pins_desc[1]},
	{IRQ_EINT11, IRQT_BOTHEDGE, "S4", &pins_desc[2]},
	{IRQ_EINT19, IRQT_BOTHEDGE, "S5", &pins_desc[3]},
};

/* 生成一个等待队列的队头，名字为button_waitq */
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

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

/* 中断服务函数 */
static irqreturn_t button_irq(int irq, void *dev_id)
{
	struct pin_desc *pindesc = (struct pin_desc *)dev_id;
	unsigned int pinval;

	pinval = s3c2410_gpio_getpin(pindesc->pin);	//读取IO口电平

	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_async, SIGIO, POLL_IN);	//发SIGIO信号
	
	return IRQ_RETVAL(IRQ_HANDLED);
}

/* open驱动函数 */
static int button_drv_open(struct inode *inode, struct file *file)
{
	unsigned int i;
	int err;

	/* 注册中断 */
	for(i = 0; i < (sizeof(buttonirqs_decs)/sizeof(buttonirqs_decs[0])); i++){
		err = request_irq(buttonirqs_decs[i].irq, button_irq, buttonirqs_decs[i].flags,
					buttonirqs_decs[i].devname, buttonirqs_decs[i].dev_id);
		if(err){
			printk("func button_drv_open err: request_irq num:%d\n", i);
			break;
		}
	}

	/* 出现错误，释放已经注册的中断 */
	if(err){
        i--;
        for (; i >= 0; i--)
            free_irq(buttonirqs_decs[i].irq, buttonirqs_decs[i].dev_id);
        return -EBUSY;
    }	
	return 0;
}

/* read驱动函数 */
static ssize_t button_drv_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
{
	
	unsigned long ret = 0;
	int err;

	/* 如果没有按键动作, 休眠 */
	err = wait_event_interruptible(button_waitq, ev_press);

	if (err){
			printk("func button_drv_read() err: wait_event_interruptible\n");
		return err;
	}
	

	/* 如果有按键动作, 返回键值 */
	ret = copy_to_user(buf, &key_val, 1);
	ev_press = 0;	//清中断标志
	
	if(ret < 0){
		printk("func button_drv_read() err: copy_to_user\n");
		return -EFAULT;
	}
	
 	return sizeof(key_val);
}

/* close驱动函数 */
int button_drv_close (struct inode *inode, struct file *file)
{
	int i;

	/* 取消中断 */
	for(i = 0; i < (sizeof(buttonirqs_decs)/sizeof(buttonirqs_decs[0])); i++)
		free_irq(buttonirqs_decs[i].irq, buttonirqs_decs[i].dev_id);

	return 0;
}

unsigned int buton_drv_poll (struct file *file, poll_table *wait)
{
	unsigned int mask = 0;
	poll_wait(file, &button_waitq, wait); // 不会立即休眠

	/* 中断已经发生 */
	if (ev_press)
		mask |= POLLIN | POLLRDNORM;

	return mask;	//返回给do_poll函数中的mask
}

/* 调用fasync_helper根据on值是否button_async->fa_file=驱动文件file，里面有PID */
static int button_drv_fasync(int fd, struct file *file, int on)
{
	printk("driver: fifth_drv_fasync\n");
	return fasync_helper(fd, file, on, &button_async);
}

static struct file_operations button_drv_fops = {
	.owner   =  THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open    =  button_drv_open,     
	.read    =	button_drv_read,
	.release =  button_drv_close,
	.poll    =  buton_drv_poll,
	.fasync	 =  button_drv_fasync,
};

/* 入口函数 
 * 执行”insmod button_drv.ko”命令时就会调用这个函数
 */
static int button_drv_init(void)
{
	//注册一个字符设备，名字为button_drv
	major = register_chrdev(0, "button_drv", &button_drv_fops);	
	
	//创建一个类，名字为buttond_rv(/class/button_drv)
	buttondrv_class = class_create(THIS_MODULE, "button_drv");	
	
	//创建一个设备节点，名为button(/dev/button)
	buttondrv_class_dev = class_device_create(buttondrv_class, NULL, MKDEV(major, 0), NULL, "button"); 

	/* 映射物理地址 */
	gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
	gpfdat = gpfcon + 1;

	gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
	gpgdat = gpgcon + 1;
	
	return 0;
}

/* 出口函数 
 * 执行”rmmod button_drv.ko”命令时就会调用这个函数
 */
static void button_drv_exit(void)
{
	unregister_chrdev(major, "button_drv"); // 卸载字符

	class_device_unregister(buttondrv_class_dev);	//删除设备节点
	class_destroy(buttondrv_class);	//销毁类
	
	/* 取消映射 */
	iounmap(gpfcon);
	iounmap(gpgcon);
}

module_init(button_drv_init);
module_exit(button_drv_exit);

MODULE_LICENSE("GPL");

2、测试（应用）程序

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


int fd;

/* 信号处理函数 */
void my_signal_fun(int signum)
{
	int ret; 
	unsigned char key_val;
	ret = read(fd, &key_val, 1);
	if(ret < 0)
		printf(" func read() err\n");
	else
		printf("key_val = 0x%x\n", key_val);
}

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

	int Oflags;

	signal(SIGIO, my_signal_fun);	//给SIGIO 信号注册信号处理函数my_signal_fun
	
	fd = open("/dev/button", O_RDWR);	
	if (fd < 0)
	{
		printf("can't open!\n");
	}

	fcntl(fd, F_SETOWN, getpid());	//把进程 ID 告诉驱动
		
	Oflags = fcntl(fd, F_GETFL);	//取得文件描述符filedes的文件状态标志
	fcntl(fd, F_SETFL, Oflags | FASYNC);	//FASYNC位发生变化时，会导致驱动程序的fasync函数被调用
	
	while (1)
	{
		sleep(1000);
	}

	return 0;
}

四、软件执行流程

重点从②开始：

② APP 给 SIGIO 这个信号注册信号处理函数 func，以后 APP 收到 SIGIO 信号时，这个函数会被自动调用；
③ 把 APP 的 PID(进程 ID)告诉驱动程序，这个调用不涉及驱动程序，在内核的文件系统层次记录 PID；
④ 读取驱动程序文件 Flag；
⑤ 设置 Flag 里面的 FASYNC 位为 1： 当 FASYNC 位发生变化时，会导致驱动程序的 fasync 被调用；
⑥⑦ 调用 faync_helper，它会根据 FAYSNC 的值决定是否设置 button_async->fa_file=驱动文件
filp：驱动文件 filp 结构体里面含有之前设置的 PID。
⑧ APP 可以做其他事；
⑨⑩ 按下按键，发生中断，驱动程序的中断服务程序被调用，里面调用 kill_fasync 发信号；
⑪⑫⑬ APP 收到信号后，它的信号处理函数被自动调用，可以在里面调用 read 函数读取按键。

第一、二期衔接——4.6 字符驱动设备之按键驱动—异步机制

编写按键中断驱动——异步机制

目录

一、前言

二、要点

1、谁发送：驱动程序发

2、发什么：信号

3、发什么信号： SIGIO

4、怎么发：内核里提供有函数

5、发给谁：应用程序（APP 要把自己告诉驱动）

6、应用程序收到后做什么：执行信号处理函数

7、信号处理函数和信号，之间怎么挂钩：应用程序注册信号处理函数

三、代码编写

1、驱动程序

2、测试（应用）程序

四、软件执行流程

五、程序运行截图

第三階段應用層——1.9 數碼相冊—在LCD上顯示BMP圖片

第三階段應用層——1.8 數碼相冊—在LCD上顯示JPG圖片

第三階段應用層——1.7 數碼相冊—電子書（6）—支持遠程打印信息

第三階段應用層——1.7 數碼相冊—電子書（1）—實現

第三階段應用層——1.7 數碼相冊—電子書（4）—select支持多輸入

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

第一、二期衔接——4.6 字符驱动设备之按键驱动—异步机制

编写按键中断驱动——异步机制

目录

一、前言

二、要点

1、谁发送：驱动程序发

2、 发什么：信号

3、 发什么信号： SIGIO

4、怎么发：内核里提供有函数

5、发给谁：应用程序（APP 要把自己告诉驱动）

6、应用程序收到后做什么：执行信号处理函数

7、信号处理函数和信号，之间怎么挂钩： 应用程序注册信号处理函数

三、代码编写

1、驱动程序

2、测试（应用）程序

四、软件执行流程

五、程序运行截图

2、发什么：信号

3、发什么信号： SIGIO

7、信号处理函数和信号，之间怎么挂钩：应用程序注册信号处理函数