编写按键中断驱动——解决同步互斥阻塞
- 硬件平台：韦东山嵌入式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工具链
目录
一、前言
在上边的应用程序中，存在一个问题：同一个时间中，可以打开两个或以上的应用程序。
提问：那如果我们想要在同一时间中，只能打开一个应用程序该如何修改呢？
回答：在驱动程序中定义static int canopen = 1;
在button_drv_open函数中添加：
/* canopen != 0说明文件已经被打开，返回-EBUSY */
if(--canopen != 0){
canopen++;
return -EBUSY;
}
在button_drv_close函数中添加：
canopen++; /* 如果打开文件，关闭时canopen恢复 */
通过测试，发现这个程序可以达到上面的目的，但是还是有问题：
对于C语言，程序最终会被翻译成汇编，一条--canopen指令会被翻译成3条汇编指令（读出、修改、写回），如果一个A应用程序任务在执行读出时，此时切换到B应用程序，也执行读出命令（A、B是同一个应用程序），那么最终A、B都可以同时存在。
二、引入原子操作
1、设置原子变量
static atomic_t canopen = ATOMIC_INIT(1); //定义原子变量v并初始化为1
2、在button_drv_open中采用原子操作
/* canopen != 0说明文件已经被打开，返回-EBUSY
* 自减操作后测试其是否为0，为0则返回true，否则返回false
*/
if(!atomic_dec_and_test(&canopen)){
atomic_inc(&canopen); //原子变量增加1
return -EBUSY;
}
所以此时就引出了一个互斥的话题
3、在button_drv_close中采用原子操作
atomic_inc(&canopen); //原子变量增加1
4、完整驱动代码
#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;
static atomic_t canopen = ATOMIC_INIT(1); //定义原子变量v并初始化为1
/* 键值: 按下时, 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;
/* canopen != 0说明文件已经被打开，返回-EBUSY
* 自减操作后测试其是否为0，为0则返回true，否则返回false
*/
if(!atomic_dec_and_test(&canopen)){
atomic_inc(&canopen); //原子变量增加1
return -EBUSY;
}
/* 注册中断 */
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);
atomic_inc(&canopen); //原子变量增加1
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");
5、完整测试代码
#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;
}
6、运行结果
二、引入信号量
信号量（semaphore）是用于保护临界区的一种常用方法，只有得到信号量的进程才能执行临界区代码。当获取不到信号量时，进程进入休眠等待状态。
1、定义信号量
static DECLARE_MUTEX(button_lock); //定义互斥锁
2、在button_drv_open中获取信号量
/* 获取信号量
* 如果第一次获取。则可以获取一个信号量
* 如果第二次获取。则在down()中陷入休眠
*/
down(&button_lock);
3、在button_drv_close中释放信号量
up(&button_lock); //释放信号量
4、完整驱动代码
#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;
//static atomic_t canopen = ATOMIC_INIT(1); //定义原子变量v并初始化为1
static DECLARE_MUTEX(button_lock); //定义互斥锁
/* 键值: 按下时, 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;
#if 0
/* canopen != 0说明文件已经被打开，返回-EBUSY
* 自减操作后测试其是否为0，为0则返回true，否则返回false
*/
if(!atomic_dec_and_test(&canopen)){
atomic_inc(&canopen); //原子变量增加1
return -EBUSY;
}
#endif
/* 获取信号量
* 如果第一次获取。则可以获取一个信号量
* 如果第二次获取。则在down()中陷入休眠
*/
down(&button_lock);
/* 注册中断 */
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);
//atomic_inc(&canopen); //原子变量增加1
up(&button_lock); //释放信号量
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");
5、完整测试代码
#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;
}
6、运行结果
四、阻塞与阻塞
- 阻塞
是指在执行设备操作时若不能获得资源则挂起进程，直到满足可操作的条件后再进行操作。
被挂起的进程进入休眠状态，被从调度器的运行队列移走，直到等待的条件被满足。 - 非阻塞
进程在不能进行设备操作时并不挂起，它或者放弃，或者不停地查询，直至可以进行操作为止。
1、添加非阻塞标志
fd = open("/dev/button", O_RDWR | O_NONBLOCK);
2、在button_drv_open中采用判断采用何种方式
if(file->f_flags & O_NONBLOCK){ //非阻塞
if(down(&button_lock)) //申请信号量
return -EBUSY; //返回值给应用程序打印
}else
down(&button_lock); //阻塞方式，申请信号量
3、在button_drv_read中采用判断采用何种方式
if(file->f_flags & O_NONBLOCK){ //非阻塞
if(!ev_press) //没有按键按下
return -EAGAIN; //返回
}
4、完整驱动代码
#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;
//static atomic_t canopen = ATOMIC_INIT(1); //定义原子变量v并初始化为1
static DECLARE_MUTEX(button_lock); //定义互斥锁
/* 键值: 按下时, 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;
#if 0
/* canopen != 0说明文件已经被打开，返回-EBUSY
* 自减操作后测试其是否为0，为0则返回true，否则返回false
*/
if(!atomic_dec_and_test(&canopen)){
atomic_inc(&canopen); //原子变量增加1
return -EBUSY;
}
#endif
if(file->f_flags & O_NONBLOCK){ //非阻塞
if(down_trylock(&button_lock)) //申请信号量
return -EBUSY; //不成功，返回值给应用程序打印
}else
down(&button_lock); //阻塞方式，申请信号量
/* 注册中断 */
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;
if(file->f_flags & O_NONBLOCK){ //非阻塞
if(!ev_press) //没有按键按下
return -EAGAIN; //返回
}
/* 阻塞方式，如果没有按键动作, 休眠 */
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);
//atomic_inc(&canopen); //原子变量增加1
up(&button_lock); //释放信号量
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");
5、完整测试代码
#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 main(int argc, char **argv)
{
int ret;
unsigned char key_val;
int fd;
fd = open("/dev/button", O_RDWR | O_NONBLOCK);
if (fd < 0)
{
printf("can't open!\n");
}
while (1)
{
ret = read(fd, &key_val, 1);
printf("key_val = 0x%x ret = %d\n", key_val, ret);
}
return 0;
}
6、运行结果
489
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
