/* 按键的消抖*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <asm/io.h>
#include <asm/uaccess.h>
int major=250;
int minor=0;
dev_t devno;
struct cdev cdev;
static struct class *cls;
static struct device *test_device;
static struct resource *key_res1;
static struct resource *key_res2;
static int key_num;
wait_queue_head_t rq; //定义队列的头
static int flage=0;
//定时器的结构体
static struct timer_list key_timer;
static int hello_open (struct inode *inode, struct file *filep)
{
printk("hello_open enter completed...\n");
return 0;
}
static int hello_release(struct inode *inode, struct file *filep)
{
printk("hello_release completed...\n");
return 0;
}
static ssize_t hello_read (struct file *filep, char __user *buf, size_t len, loff_t *pos)
{
if(len !=4)
{
return -EINVAL;
}
printk(" block of...get data and read data send to user\n");
wait_event_interruptible(rq, flage!=0);
if(copy_to_user(buf,&key_num,sizeof(int)))
{
return -EFAULT;
}
printk("send date to user sucessfully...\n");
flage = 0;
return len;
}
struct file_operations hello_ops =
{
.open = hello_open,
.read = hello_read,
.release = hello_release,
};
/*如果按键抖动 会执行n 次 该回调函数 最后按键稳定了 才会执行key_timer_handler*/
static irqreturn_t key_handler(int irqnum, void *dev_id)
{
//printk("irqnum = %d \n",irqnum);
key_timer.expires = jiffies + 500;
/*???ˉ?óê±£?*/
key_timer.data = irqnum;
mod_timer(&key_timer, key_timer.expires); //修改该定时器
printk("some time after ---> enter timer...\n");
return IRQ_HANDLED;
}
/*中断函数可能调用很多次 但定时器函数只调用一次 key_handler执行时间到了才会执行key_timer_handler 否者不会 这就是原理*/
static void key_timer_handler(unsigned long irqnum)
{
printk("enter timer.....\n");
if( key_res1->start == key_timer.data)
{
key_num =1;
}
if( key_res2->start == key_timer.data)
{ key_num =2;
}
flage = 1 ;
printk("wake up block....\n");
wake_up_interruptible(&rq);
}
static int key_probe(struct platform_device *pdev)
{
int ret;
key_res1 = platform_get_resource(pdev,IORESOURCE_IRQ, 0);
key_res2 = platform_get_resource(pdev,IORESOURCE_IRQ, 1);
ret = request_irq(key_res1->start, key_handler, key_res1->flags, "key1", NULL);
ret = request_irq(key_res2->start, key_handler, key_res2->flags, "key2", NULL);
ret = register_chrdev(major,"hello",&hello_ops);
printk("major = %d \n", ret);
//产生设备节点
devno = MKDEV(major,minor);
cls = class_create(THIS_MODULE,"hello1");
if(IS_ERR(cls))
{
unregister_chrdev(major,"hello");
return -EBUSY;
}
test_device = device_create(cls,NULL,devno,NULL,"dev_node");
if(IS_ERR(test_device))
{
class_destroy(cls);
unregister_chrdev(major,"hello");
return -EBUSY;
}
init_waitqueue_head(&rq);
//初始化定时器
init_timer(&key_timer);
key_timer.function = key_timer_handler; //注意:此条语句属于初始化,
//添加(注册)定时器
add_timer(&key_timer);
return 0;
}
static int key_remove(struct platform_device *pdev)
{
del_timer(&key_timer);
free_irq(key_res1->start, NULL);
free_irq(key_res2->start, NULL);
device_destroy(cls,devno);
class_destroy(cls);
unregister_chrdev(major,"hello");
return 0;
}
static struct of_device_id key_id[]=
{
{.compatible = "fs4412,key"},
};
static struct platform_driver key_driver=
{
.probe = key_probe,
.remove = key_remove,
.driver =
{
.name="fs4412-key",
.of_match_table = key_id,
},
};
static int pwmdev_init(void)
{
return platform_driver_register(&key_driver);
}
static void pwmdev_exit(void)
{
platform_driver_unregister(&key_driver);
return;
}
//module_param(devno,uint,0600);
MODULE_LICENSE("GPL");
module_init(pwmdev_init);
module_exit(pwmdev_exit);
//insmod hello.ko major=249
linux 驱动 -》按键 中断 request_irq 延时防抖mod_timer
最新推荐文章于 2024-06-30 23:17:01 发布