Linux驱动开发五：中断方式获取按键值

序：  

当按下中断后，发生中断，发生以下事情

1.CPU进入异常模式，并跳转到vector_irq + stubs_offset处

2.因为在用户模式发生中断，所以跳转到__irq_usr指示的地址处

3.最终跳转到函数asm_do_IRQ处

4.在asm_do_IRQ按中断号查找到对应中断的irq_desc描述符，然后进入中断处理入口handle_irq

5.接着调用generic_handle_irq_desc

6.desc->handle_irq(irq,desc)，而这个是在中断架构初始化的时候设置的

7.接着使能中断，调用用户注册的中断处理例程链表

8.处理完成后，恢复现场

代码：

1、third_drv.c

/*
*功能：中断驱动,在按键驱动基础上修改，原理图见按键驱动
*/
#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>

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

static struct class *thirddrv_class;
static struct class_device *thirddrv_class_dev;

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

//声明一个按键的等待队列
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 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},
};

/*
* 确定按键值
*中断处理程序并置标志位为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));/* 读取中断引脚的状态 */

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

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

return IRQ_RETVAL(IRQ_HANDLED);
}

/* open函数  */
static int third_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 third_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;

return 1;
}

int third_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 struct file_operations third_drv_fops={
.owner   = THIS_MODULE,/* 这是一个宏，推向编译模块时自动创建到__this_module变量  */
.open    = third_drv_open,
.read    = third_drv_read,
.release = third_drv_close,
};

/* 入口函数  */
static int third_drv_init(void)
{
major = register_chrdev(0,major_name,&third_drv_fops);
if(major < 0)
{
printk("Can't register major number\n");
return major;
}

/* 自动生成设备节点机制,获取系统消息，cat /proc/class会发现 first_drv */
thirddrv_class = class_create(THIS_MODULE, major_name);
/* register your own device in sysfs, and this will cause udev to create corresponding device node */
thirddrv_class_dev = device_create( thirddrv_class, NULL, MKDEV(major, 0),NULL, minor_name );

/* 地址映射 */
gpncon = (volatile unsigned long *)ioremap(0x7F008830,16);
gpndat = gpncon + 1;//指针加1

return 0;
}

/* 出口函数  */
static void third_drv_exit(void)
{
unregister_chrdev(major,major_name);
device_unregister(thirddrv_class_dev);
class_destroy(thirddrv_class);
iounmap(gpncon);
}

module_init(third_drv_init);
module_exit(third_drv_exit);
MODULE_LICENSE("GPL");

2、Makefile

obj-m := third_drv.o

KER_DIR := /work/work/linux/

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

clean:
make -C $(KER_DIR) M=`pwd` modules clean

3、测试程序

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

/*test
*/

int main(int argc,char *argv[])
{
int fd;
int cnt = 0;

char key_vals;

fd = open("/dev/button",O_RDWR);
if(fd < 0)
{
printf("can't opent /dev/button\n");
return 0;
}

while(1)
{
read(fd,&key_vals,1);
printf("key_vals = 0x%x\n",key_vals);
}

return 0;

}

4、执行结果

key_vals = 0x1
key_vals = 0x81
key_vals = 0x2
key_vals = 0x2
key_vals = 0x82
key_vals = 0x3
key_vals = 0x3
key_vals = 0x83
key_vals = 0x4
key_vals = 0x4
key_vals = 0x4
key_vals = 0x84
key_vals = 0x4
key_vals = 0x84