前言
这次的按键驱动会分为两部分来介绍。第一,用不停轮询的方式来监听按键事件;第二,以中断的方式来响应按键事件。可以对比看一下这两种方式有什么差别。
正文
轮询方式
#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 <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
static int major;
static struct class *seconddrv_class;
static struct class_device *seconddrv_class_dev;
volatile unsigned long *gpfcon = NULL;
volatile unsigned long *gpgcon = NULL;
volatile unsigned long *gpfdat = NULL;
volatile unsigned long *gpgdat = NULL;
static int second_drv_open(struct inode *inode, struct file *file)
{
//GPF0,2配置为输入引脚
*gpfcon &= ~( (0x3<<0) | (0x3<<2) );
//GPG3,11配置为输入引脚
*gpgcon &= ~( (0x3<<3) | (0x3<<11) );
return 0;
}
static int second_drv_read(struct file *file, const __user *buf, size_t count, loff_t *ppos)
{
unsigned int key_values[4];
if (count < sizeof(key_values))
return -EINVAL;
key_values[0] = ( (*gpfdat)&(1<<0) ) ? 1 : 0;
key_values[1] = ( (*gpfdat)&(1<<2) ) ? 1 : 0;
key_values[2] = ( (*gpgdat)&(1<<3) ) ? 1 : 0;
key_values[3] = ( (*gpgdat)&(1<<11) ) ? 1 : 0;
copy_to_user(buf, key_values, sizeof(key_values));
return sizeof(key_values);
}
static struct file_operations second_fops = {
.owner = THIS_MODULE,
.open = second_drv_open,
.read = second_drv_read,
};
static int second_drv_init(void)
{
major = register_chrdev(0, "second_drv", &second_fops);
seconddrv_class = class_create(THIS_MODULE, "second_drv");
seconddrv_class_dev = class_device_create(seconddrv_class, NULL, MKDEV(major, 0), NULL, "buttons");
gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
gpfdat = gpfcon + 1;
gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
gpgdat = gpgcon + 1;
return 0;
}
void second_drv_exit(void)
{
unregister_chrdev(major, "second_drv");
class_device_unregister(seconddrv_class_dev);
class_destroy(seconddrv_class);
iounmap(gpfcon);
iounmap(gpgcon);
}
module_init(second_drv_init);
module_exit(second_drv_exit);
MODULE_LICENSE("GPL");
1、字符设备书写的老套路:
(1)注册字符设备register_chrdev(),并且将second_fops联系起来。
(2)在/sys/class目录下创建相应类second_drv,class_create()
(3)然后再调用class_device_create()函数为每个设备在/dev目录下创建buttons节点
上面三步就算完成了字符设备的创建。
2、
以前写裸板按键程序的时候,我们都是直接操作相应的寄存器地址,但是在Linux系统下,我们只能操作虚拟地址,而且CPU不会为这些已知的外设IO内存资源预先指定虚拟地址的值,所以我们需要使用ioremap函数将这些物理地址映射到虚拟地址,然后才能通过映射后的虚拟地址操作相应的寄存器。
3、
创建完一个按键的字符设备后,我们再写一个测试程序,使用不停轮询的方式检测按键事件
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
int main(int argc, char **argv)
{
int val[4];
int fd;
int cnt = 0;
fd = open("/dev/buttons", O_RDWR);
if (fd < 0)
{
printf("open fd failed\n");
return 0;
}
while (1)
{
read(fd, val, sizeof(val));
if (!val[0] || !val[1] || !val[2] || !val[3])
{
printf("%04d key pressed: %d %d %d %d\n", cnt++, val[0], val[1], val[2], val[3]);
}
}
return 1;
}
因为不停的轮询访问,所以占用的CPU资源会非常多,接近99%。所以实际生产中,这种方式肯定是不行的,下面我们使用中断的方式。
中断方式
#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>
static int major;
static struct class *thirddrv_class;
static struct class_device *thirddrv_class_dev;
volatile unsigned long *gpfcon = NULL;
volatile unsigned long *gpgcon = NULL;
volatile unsigned long *gpfdat = NULL;
volatile unsigned long *gpgdat = NULL;
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
/*中断事件标识,中断服务程序将它置为1,third_drv_read将它清零*/
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;
struct pin_desc pins_desc[4] = {
{S3C2410_GPG0, 0x01},
{S3C2410_GPG2, 0x02},
{S3C2410_GPG3, 0x03},
{S3C2410_GPG11, 0x04},
};
static irqreturn_t buttons_irq(int irq, void *dev_id)
{
struct pin_desc *pindesc = (struct pin_desc *)dev_id;
unsigned int pinval;
pinval = s3c2410_gpio_getpin(pindesc->pin);
if (pinval)
{
/*松开*/
key_val = 0x80 | pindesc->key_val;
}
else
{
/*按下*/
key_val = pindesc->key_val;
}
ev_press = 1; //表示中断发生了
wake_up_interruptible(&button_waitq);
return IRQ_RETVAL(IRQ_HANDLED);
}
static int third_drv_open(struct inode *inode, struct file *file)
{
//GPF0,2配置为输入引脚
//GPG3,11配置为输入引脚
request_irq(IRQ_EINT0, buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
request_irq(IRQ_EINT2, buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);
return 0;
}
static int third_drv_read(struct file *file, const __user *buf, size_t count, loff_t *ppos)
{
if (count != 1)
return -EINVAL;
/*如果没有按键动作,就休眠,
*当ev_press为0就进入休眠
*/
wait_event_interruptible(button_waitq, ev_press);
/*如果没有按键动作,返回键值*/
copy_to_user(buf, &key_val, 1);
ev_press = 0;
return 1;
}
static 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]);
}
static struct file_operations third_fops = {
.owner = THIS_MODULE,
.open = third_drv_open,
.read = third_drv_read,
.release = third_drv_close,
};
static int third_drv_init(void)
{
major = register_chrdev(0, "third_drv", &third_fops);
thirddrv_class = class_create(THIS_MODULE, "third_drv");
thirddrv_class_dev = class_device_create(thirddrv_class, NULL, MKDEV(major, 0), NULL, "buttons");
gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
gpfdat = gpfcon + 1;
gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
gpgdat = gpgcon + 1;
return 0;
}
void third_drv_exit(void)
{
unregister_chrdev(major, "third_drv");
class_device_unregister(thirddrv_class_dev);
class_destroy(thirddrv_class);
iounmap(gpfcon);
iounmap(gpgcon);
}
module_init(third_drv_init);
module_exit(third_drv_exit);
MODULE_LICENSE("GPL");
1、
创建字符设备的步骤和轮询方式是一样的
2、
重点在于注册中断服务,在open函数中我们对四个按键的中断服务进行注册。代码中是使用request_irq()函数,函数原型是:
int request_irq(unsigned int irq, irq_handler_t handler,
unsigned long irqflags, const char *devname, void *dev_id)
(1)irq是中断号,用来将我们的中断处理函数buttons_irq(),注册到相应的irq描述结构体irq_desc[irq]中,因为不同的中断是由不同的中断引脚产生的,我们必须用不同的中断号加以区分
(2)handler就是我们自己书写的中断处理函数,当中断发生的时候,就会回调传递进去的函数buttons_irq()
(3)irqflags是用来传递一些标志位,比如是否是共享中断(可能多个中断使用同一个中断引脚),我们的程序传递的标志位表示是双边沿触发
(4)devname可以cat /proc/interrupts看到注册了的中断服务
(5)dev_id用来区分共享中断中哪个才是我们想要调用的中断,也可以用来指定中断服务函数需要参考的数据地址。建议将设备结构指针作为dev_id参数,比如我们就是将每个中断引脚的描述结构体的首地址作为dev_id参数进行传递。
对于request_irq()函数的参数作用,可以参考这篇文章:request_irq() | 注册中断服务
如果想了解整个中断处理的架构,可以参考我另外一篇文章:Linux异常中断处理结构。可以弄清楚注册中断处理函数的流程。
3、
我们这个驱动程序的功能比较简陋,当有按键事件发生的时候,就把读取的简直打印出来,如果没有按键事件发生时,就进入等待状态,避免程序不停的轮询,占用过多的资源。third_drv_read()函数中调用的wait_event_interruptible()就是使测试程序在没有中断发生时进入等待状态。但是一般需要先定义一个队列:
DECLARE_WAIT_QUEUE_HEAD(button_waitq)
并定义一个全局变量标示当前中断服务是否正在执行
/*中断事件标识,中断服务程序将它置为1,third_drv_read将它清零*/
static volatile int ev_press = 0;
声明完队列之后,就在中断没有发生时,进入等待队列
wait_event_interruptible(button_waitq, ev_press);
当中断发生后,就重新将挂起的程序放入执行队列中
ev_press = 1; //表示中断发生了
wake_up_interruptible(&button_waitq);