参考：https://blog.csdn.net/fengyuwuzu0519/article/details/71046343
字符设备驱动程序之中断方式的按键驱动_编写代码
使用中断方式，那么肯定有一个中断的初始化注册，就是告诉内核，我按下按键的时候会触发一个中断，同时一定有一个中断处理函数来处理中断发生时应该做什么。
linux内核中 如何告诉内核我按下按键了给我触发中断并实现中断处理函数呢。
注册中断（open驱动程序时调用）：int request_irq(unsigned int irq, irq_handler_t handler,unsigned long irqflags, const char *devname, void *dev_id)
request_irq()函数参数解析：
※※※重要！！void *：void即“无类型”，void *则为“无类型指针”，可以指向任何数据类型。所以后面的代码传进来结构体。
1、从原理图可知IRQ中断号irq：（IRQ_EINT0……）
2、向系统注册的中断处理函数，中断发生时，系统调用这个函数，dev_id参数被传递给它，中断处理函数handler的格式：
3、触发方式：irqflags：type（IRQT_BOTHEDGE双边沿触发：上升沿和下降沿都可以触发中断）。
4、devname：中断名称，可以使用cat /proc/interrupts 查看此名称
5、dev_id：用法很简单。在free_irq卸载时，通过irq与dev_id结合在一起，来确定卸载哪一个irqaction结构。
释放中断（卸载驱动程序时，解除按键中断）：
void free_irq(unsigned int irq, void *dev_id)
参数：irq中断号。dev_id用法很简单，在free_irq卸载时，通过irq与dev_id结合在一起，来确定卸载哪一个irqaction结构。
驱动程序：third_drv.c
/*
一、驱动框架：
1.先定义file_operations结构体，其中有对设备的打开，读和写的操作函数。
2.分别定义相关的操作函数
3.定义好对设备的操作函数的结构体（file_operations）后，将其注册到内核的file_operations结构数组中。
此设置的主设备号为此结构在数组中的下标。
4.定义出口函数：卸载注册到内核中的设备相关资源
5.修饰 入口 和 出口函数
6.给系统提供更多的内核消息，在sys目录下提供设备的相关信息。应用程序udev可以据此自动创建设备节点，
创建一个class设备类，在此类下创建设备
*/
#include <linux/module.h> //内涵头文件，含有一些内核常用函数的原形定义。
#include <linux/kernel.h> //最基本的文件，支持动态添加和卸载模块。Hello World驱动要这一个文件就可以。
#include <linux/fs.h> //包含了文件操作相关的struct的定义，例如struct file_operations
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h> //包含了copy_to_user、copy_from_user等内核访问用户进程内存地址的函数定义
#include <asm/irq.h>
#include <asm/io.h> //包含了ioremap、ioread等内核访问IO内存等函数的定义
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
static struct class *thirddrv_class; //一个类
static struct class_device *thirddrv_class_dev; //一个类里面再建立一个设备
volatile unsigned long *gpfcon;
volatile unsigned long *gpfdat;
volatile unsigned long *gpgcon;
volatile unsigned long *gpgdat;
static irqreturn_t button_irq(int irq, void *dev_id)
{
printk("irq = %d\n",irq);
return IRQ_HANDLED;
}
static int third_drv_open(struct inode *inode, struct file *file)
{
/* 配置GPF0,2为输入引脚 */
/* 配置GPF3,11为输入引脚 */
request_irq(IRQ_EINT0, button_irq, IRQT_BOTHEDGE, "S2", 1); //配置为中断引脚
request_irq(IRQ_EINT2, button_irq, IRQT_BOTHEDGE, "S3", 1);
request_irq(IRQ_EINT11, button_irq, IRQT_BOTHEDGE, "S4", 1);
request_irq(IRQ_EINT19, button_irq, IRQT_BOTHEDGE, "S5", 1);
return 0;
}
ssize_t third_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
/* 返回4个引脚的电平 */
unsigned char key_vals[4];
int regval;
//如果传进来的size不等于我们返回的4个字节，返回一个错误值
if (size != sizeof(key_vals))
return -EINVAL;
/* 读GPF0,2为输入引脚 */
regval = *gpfdat;
key_vals[0]=(regval & (1<<0)) ? 1 : 0;
key_vals[1]=(regval & (1<<2)) ? 1 : 0;
/* 读GPG3,11为输入引脚 */
regval = *gpgdat;
key_vals[2]=(regval & (1<<3)) ? 1 : 0;
key_vals[3]=(regval & (1<<11)) ? 1 : 0;
copy_to_user(buf, key_vals, sizeof(key_vals));
return sizeof(key_vals);
}
int third_drv_close(struct inode *inode, struct file *file)
{
free_irq(IRQ_EINT0, 1);
free_irq(IRQ_EINT2, 1);
free_irq(IRQ_EINT11, 1);
free_irq(IRQ_EINT19, 1);
return 0;
}
static struct file_operations third_drv_fops = {
.owner = THIS_MODULE, /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
.open = third_drv_open,
.read = third_drv_read,
.release = third_drv_close,
};
int major;
static int third_drv_init(void)
{
major = register_chrdev(0, "third_drv", &third_drv_fops);
//创建一个类
thirddrv_class = class_create(THIS_MODULE, "firstdrv");
//在这个类下面再创建一个设备
//mdev是udev的一个简化版本
//mdev应用程序，就会被内核调用，会根据类和类下面的设备这些信息
thirddrv_class_dev = class_device_create(thirddrv_class, NULL, MKDEV(major, 0), NULL, "buttons");/* /dev/buttons */
//建立地址映射：物理地址->虚拟地址
gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16); //指向的是虚拟地址，第一个参数是物理开始地址，第二个是长度（字节）
gpfdat = gpfcon + 1; //加1,实际加4个字节
gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16); //指向的是虚拟地址，第一个参数是物理开始地址，第二个是长度（字节）
gpgdat = gpgcon + 1; //加1,实际加4个字节
return 0;
}
static void third_drv_exit(void)
{
unregister_chrdev(major, "third_drv");
class_device_unregister(thirddrv_class_dev);
class_destroy(thirddrv_class);
iounmap(gpfcon);
iounmap(gpgcon);
return 0;
}
module_init(third_drv_init);
module_exit(third_drv_exit);
MODULE_LICENSE("GPL");
验证驱动中断：（下面步骤，不写应用程序来验证驱动程序）
使用命令：exec 5</dev/buttons，打开/dev/buttons这个设备，定位到文件描述符fd5，挂载到5下，会调用open）
cat /proc/interrupts （产生的中断的信息）
使用ps命令查看，当前进程是-sh（shell），PID是772。
使用命令，ls -l /proc/772/fd，文件描述符fd5指向/dev/buttons，以后通过文件描述符5来访问buttons设备。
（
exec是用来执行一个进程的）
（
linux中，所有设备都是文件，/dev/buttons也是文件，有文件描述符exec 5</dev/button 将 /dev/button文件关联到文件描述符5，以后对5的操作，就是对设备文件的操作）
（
在Shell里执行exec 5</dev/button，因此5是Shell新打开的文件描述符，Shell的进程ID是772）
（
在proc文件系统里772的fd目录，表示772进程打开的文件描述符）
（ps查看当前进程（可以查看进程状态s：休眠））
使用命令，exec 5<&-，关闭文件描述符fd5，释放中断。（会调用release）
测试：（按下按键）
IRQ_EINT0：16=16+0，IRQ_EINT2：18=16+2，IRQ_EINT11：55=16+39，IRQ_EINT19（复位键）：63=16+47。
因为是双边沿触发，所以每次按下按键，松开按键，打印两次。
优化上面的程序（读出按键值）
1、内核有一个系统函数s3c2410_gpio_getpin（引脚PIN）：读出引脚的值。
2、定义了一个结构体pin_desc：
这个结构体在request_irq函数里传进去。
3、在read函数中，如果没有按键动作发生，休眠（让出CPU，不返回）；如果有按键动作发生，直接返回。
休眠：wait_event_interruptible(button_waitq, ev_press)
（把进程挂在button_waitq队列里面）
如果ev_press=0，让应用程序休眠，不返回，程序停止在此处。当被唤醒时，从此处继续执行。
定义上面两个参数：
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
/* 中断时间标志，中断服务程序将它置1，third_drv_read将它清0 */
static volatile int ev_press=0;
4、当中断发生，执行中断处理函数，此时唤醒队列中次应用的进程，继续执行，返回结果。
唤醒：（去button_waitq队列，把挂在这个队列的进程唤醒）
ev_press = 1; /* 表示中断发生了 */
wake_up_interruptible(&button_waitq); /* 唤醒休眠的进程,去button_wq队列的进程唤醒 */
完整的驱动代码：third_drv.c
/*
一、驱动框架：
1.先定义file_operations结构体，其中有对设备的打开，读和写的操作函数。
2.分别定义相关的操作函数
3.定义好对设备的操作函数的结构体（file_operations）后，将其注册到内核的file_operations结构数组中。
此设置的主设备号为此结构在数组中的下标。
4.定义出口函数：卸载注册到内核中的设备相关资源
5.修饰 入口 和 出口函数
6.给系统提供更多的内核消息，在sys目录下提供设备的相关信息。应用程序udev可以据此自动创建设备节点，
创建一个class设备类，在此类下创建设备
*/
#include <linux/module.h> //内涵头文件，含有一些内核常用函数的原形定义。
#include <linux/kernel.h> //最基本的文件，支持动态添加和卸载模块。Hello World驱动要这一个文件就可以。
#include <linux/fs.h> //包含了文件操作相关的struct的定义，例如struct file_operations
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h> //包含了copy_to_user、copy_from_user等内核访问用户进程内存地址的函数定义
#include <asm/irq.h>
#include <asm/io.h> //包含了ioremap、ioread等内核访问IO内存等函数的定义
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
static struct class *thirddrv_class; //一个类
static struct class_device *thirddrv_class_dev; //一个类里面再建立一个设备
volatile unsigned long *gpfcon;
volatile unsigned long *gpfdat;
volatile unsigned long *gpgcon;
volatile unsigned long *gpgdat;
/* 下面两个是定义休眠函数的参数 */
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
/* 中断时间标志，中断服务程序将它置1，third_drv_read将它清0 */
static volatile int ev_press=0;
/* 引脚描述的结构体 */
struct pin_desc{
unsigned int pin;
unsigned int key_val;
};
/* 键值：按下时，0x01，0x02，0x03，0x04 */
/* 键值：松开时，0x81，0x82，0x83，0x84 */
static unsigned char keyval; //键值
/* 在request_irq函数中把结构体传进去 */
struct pin_desc pins_desc[4] = { //键值先赋初始值0x01,0x02,0x03,0x04
{S3C2410_GPF0, 0x01}, //pin=S3C2410_GPF0, key_val(按键值)=0x01
{S3C2410_GPF2, 0x02}, //pin=S3C2410_GPF2, key_val(按键值)=0x02
{S3C2410_GPG3, 0x03}, //pin=S3C2410_GPF3, key_val(按键值)=0x03
{S3C2410_GPG11, 0x04}, //pin=S3C2410_GPF11, key_val(按键值)=0x04
};
/*
* 确定按键值
*/
static irqreturn_t button_irq(int irq, void *dev_id) //中断处理函数
{
/* irq = IRQ_EINT0 …… */
/* dev_id = 结构体struct pins_desc */
struct pin_desc * pindesc = (struct pin_desc *)dev_id;
unsigned int pinval;
/* 读取引脚PIN值 */
pinval = s3c2410_gpio_getpin(pindesc->pin);
/* 确定按键值,按下管脚低电平，松开管脚高电平 */
if(pinval)
{
/* 松开 */
keyval = 0x80 | pindesc->key_val; //规定的：0x8X
}
else
{
/* 按下 */
keyval = pindesc->key_val; //0x0X
}
/* 唤醒 */
ev_press = 1; /* 表示中断发生了 */
wake_up_interruptible(&button_waitq); /* 唤醒休眠的进程,去button_wq队列,把挂在队列下的进程唤醒 */
return IRQ_RETVAL(IRQ_HANDLED);
}
static int third_drv_open(struct inode *inode, struct file *file)
{
/* 配置GPF0,2为输入引脚 */
/* 配置GPF3,11为输入引脚 */
/* request_irq函数的第五个参数是void *,为无类型指针，可以指向任何数据类型 */
request_irq(IRQ_EINT0, button_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
request_irq(IRQ_EINT2, button_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
request_irq(IRQ_EINT11, button_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
request_irq(IRQ_EINT19, button_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);
return 0;
}
ssize_t third_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
if (size != 1)
return -EINVAL;
/* 如果没有按键动作，休眠，休眠：让出CPU */
/* 休眠时，把进程挂在button_wq 队列里 */
/* 如果休眠后被唤醒，就会从这里继续往下执行 */
/* 一开始没有按键按下，ev_press = 0 */
wait_event_interruptible(button_waitq, ev_press);//ev_press=0,休眠,让我们的测试程序休眠;ev_press!=0,直接往下运行
/* 如果有按键动作，返回键值 */
copy_to_user(buf, &keyval, 1); //把键值 拷回去
ev_press = 0; //清零，如果不清零,下次再读，立马往下执行，返回原来的值
return 1;
}
int third_drv_close(struct inode *inode, struct file *file)
{
free_irq(IRQ_EINT0, &pins_desc[0]);
free_irq(IRQ_EINT2, &pins_desc[1]);
free_irq(IRQ_EINT11, &pins_desc[2]);
free_irq(IRQ_EINT19, &pins_desc[3]);
return 0;
}
static struct file_operations third_drv_fops = {
.owner = THIS_MODULE, /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
.open = third_drv_open,
.read = third_drv_read,
.release = third_drv_close,
};
int major;
static int third_drv_init(void)
{
major = register_chrdev(0, "third_drv", &third_drv_fops);
//创建一个类
thirddrv_class = class_create(THIS_MODULE, "firstdrv");
//在这个类下面再创建一个设备
//mdev是udev的一个简化版本
//mdev应用程序，就会被内核调用，会根据类和类下面的设备这些信息
thirddrv_class_dev = class_device_create(thirddrv_class, NULL, MKDEV(major, 0), NULL, "buttons");/* /dev/buttons */
//建立地址映射：物理地址->虚拟地址
gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16); //指向的是虚拟地址，第一个参数是物理开始地址，第二个是长度（字节）
gpfdat = gpfcon + 1; //加1,实际加4个字节
gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16); //指向的是虚拟地址，第一个参数是物理开始地址，第二个是长度（字节）
gpgdat = gpgcon + 1; //加1,实际加4个字节
return 0;
}
static void third_drv_exit(void)
{
unregister_chrdev(major, "third_drv");
class_device_unregister(thirddrv_class_dev);
class_destroy(thirddrv_class);
iounmap(gpfcon);
iounmap(gpgcon);
return 0;
}
module_init(third_drv_init);
module_exit(third_drv_exit);
MODULE_LICENSE("GPL");
测试程序：thirddrvtest.c
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
/* thirddrvtest
*/
int main(int argc, char **argv)
{
int fd;
unsigned char key_val;
int cnt = 0;
fd = open("/dev/buttons", O_RDWR);
if (fd < 0)
{
printf("can't open!\n");
}
while (1)
{
//用查询方式读按键坏处：占用CPU大
//根本不知道按键什么时候按下，不可预料，只能不断地读，知道它返回
read(fd, &key_val, 1);
printf("key_val = 0x%x\n", key_val);
}
return 0;
}
Makefile文件
KERN_DIR = /work/system/linux-2.6.22.6 all: make -C $(KERN_DIR) M=`pwd` modules clean: make -C $(KERN_DIR) M=`pwd` modules clean rm -rf modules.order obj-m += third_drv.o
最后进行测试：
insmod third_drv.ko
./thirddrvtest & （在后台执行）
然后按下开发板的四个按键，再松开。。
怎么卸载模块呢？
因为模块正在被使用
所以，先找到在后台运行的程序thirddrvtest，查看它的进程号为845，
用命令kill -9 845杀死进程，
再卸载模块。
书上或者光盘的参考代码：s3c24xx_button.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/irq.h>
#include <linux/interrupt.h>
#include <asm/uaccess.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#define DEVICE_NAME "buttons" /* 加载模式后，执行”cat /proc/devices”命令看到的设备名称 */
#define BUTTON_MAJOR 232 /* 主设备号 */
struct button_irq_desc {
int irq;
unsigned long flags;
char *name;
};
/* 用来指定按键所用的外部中断引脚及中断触发方式, 名字 */
static struct button_irq_desc button_irqs [] = {
{IRQ_EINT19, IRQF_TRIGGER_FALLING, "KEY1"}, /* K1 */
{IRQ_EINT11, IRQF_TRIGGER_FALLING, "KEY2"}, /* K2 */
{IRQ_EINT2, IRQF_TRIGGER_FALLING, "KEY3"}, /* K3 */
{IRQ_EINT0, IRQF_TRIGGER_FALLING, "KEY4"}, /* K4 */
};
/* 按键被按下的次数(准确地说，是发生中断的次数) */
static volatile int press_cnt [] = {0, 0, 0, 0};
/* 等待队列:
* 当没有按键被按下时，如果有进程调用s3c24xx_buttons_read函数，
* 它将休眠
*/
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
/* 中断事件标志, 中断服务程序将它置1，s3c24xx_buttons_read将它清0 */
static volatile int ev_press = 0;
static irqreturn_t buttons_interrupt(int irq, void *dev_id)
{
volatile int *press_cnt = (volatile int *)dev_id;
*press_cnt = *press_cnt + 1; /* 按键计数加1 */
ev_press = 1; /* 表示中断发生了 */
wake_up_interruptible(&button_waitq); /* 唤醒休眠的进程 */
return IRQ_RETVAL(IRQ_HANDLED);
}
/* 应用程序对设备文件/dev/buttons执行open(...)时，
* 就会调用s3c24xx_buttons_open函数
*/
static int s3c24xx_buttons_open(struct inode *inode, struct file *file)
{
int i;
int err;
for (i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++) {
// 注册中断处理函数
err = request_irq(button_irqs[i].irq, buttons_interrupt, button_irqs[i].flags,
button_irqs[i].name, (void *)&press_cnt[i]);
if (err)
break;
}
if (err) {
// 释放已经注册的中断
i--;
for (; i >= 0; i--)
free_irq(button_irqs[i].irq, (void *)&press_cnt[i]);
return -EBUSY;
}
return 0;
}
/* 应用程序对设备文件/dev/buttons执行close(...)时，
* 就会调用s3c24xx_buttons_close函数
*/
static int s3c24xx_buttons_close(struct inode *inode, struct file *file)
{
int i;
for (i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++) {
// 释放已经注册的中断
free_irq(button_irqs[i].irq, (void *)&press_cnt[i]);
}
return 0;
}
/* 应用程序对设备文件/dev/buttons执行read(...)时，
* 就会调用s3c24xx_buttons_read函数
*/
static int s3c24xx_buttons_read(struct file *filp, char __user *buff,
size_t count, loff_t *offp)
{
unsigned long err;
/* 如果ev_press等于0，休眠 */
wait_event_interruptible(button_waitq, ev_press);
/* 执行到这里时，ev_press等于1，将它清0 */
ev_press = 0;
/* 将按键状态复制给用户，并清0 */
err = copy_to_user(buff, (const void *)press_cnt, min(sizeof(press_cnt), count));
memset((void *)press_cnt, 0, sizeof(press_cnt));
return err ? -EFAULT : 0;
}
/* 这个结构是字符设备驱动程序的核心
* 当应用程序操作设备文件时所调用的open、read、write等函数，
* 最终会调用这个结构中的对应函数
*/
static struct file_operations s3c24xx_buttons_fops = {
.owner = THIS_MODULE, /* 这是一个宏，指向编译模块时自动创建的__this_module变量 */
.open = s3c24xx_buttons_open,
.release = s3c24xx_buttons_close,
.read = s3c24xx_buttons_read,
};
/*
* 执行“insmod s3c24xx_buttons.ko”命令时就会调用这个函数
*/
static int __init s3c24xx_buttons_init(void)
{
int ret;
/* 注册字符设备驱动程序
* 参数为主设备号、设备名字、file_operations结构；
* 这样，主设备号就和具体的file_operations结构联系起来了，
* 操作主设备为BUTTON_MAJOR的设备文件时，就会调用s3c24xx_buttons_fops中的相关成员函数
* BUTTON_MAJOR可以设为0，表示由内核自动分配主设备号
*/
ret = register_chrdev(BUTTON_MAJOR, DEVICE_NAME, &s3c24xx_buttons_fops);
if (ret < 0) {
printk(DEVICE_NAME " can't register major number\n");
return ret;
}
printk(DEVICE_NAME " initialized\n");
return 0;
}
/*
* 执行”rmmod s3c24xx_buttons.ko”命令时就会调用这个函数
*/
static void __exit s3c24xx_buttons_exit(void)
{
/* 卸载驱动程序 */
unregister_chrdev(BUTTON_MAJOR, DEVICE_NAME);
}
/* 这两行指定驱动程序的初始化函数和卸载函数 */
module_init(s3c24xx_buttons_init);
module_exit(s3c24xx_buttons_exit);
/* 描述驱动程序的一些信息，不是必须的 */
MODULE_AUTHOR("http://www.100ask.net"); // 驱动程序的作者
MODULE_DESCRIPTION("S3C2410/S3C2440 BUTTON Driver"); // 一些描述信息
MODULE_LICENSE("GPL"); // 遵循的协议