linux按键驱动
按键驱动，写成标准字符驱动。下面这个是这个是杨创提供的代码。
/*
*
* A button driver for UTU2410 a board based on s3c2440
*
* The source code in this file can be freely used, adapted,
* and redistributed in source or binary form, so long as an
* acknowledgment appears in derived source files.No warranty
* is attached;we cannot take responsibility for errors or
* fitness for use.
*
*
*/
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/input.h>
#include <linux/kernel.h> /* printk() */
#include <linux/fs.h> /* everything... */
#include <linux/cdev.h>
#include <linux/interrupt.h> /* request_irq() */
#include <asm/arch/regs-gpio.h>
#include <asm/arch/regs-irq.h>
#include <asm/io.h>
#include <asm/uaccess.h> /* copy_to_user() */
#include <linux/delay.h> /* mdelay() */
#include <linux/irq.h>
#define BUTTONSSTATUS_DOWNX 2
#define BUTTONSSTATUS_DOWN 0
#define BUTTONSSTATUS_UP 1
#define BUF_CLEAR _IO(0xFF, 0)
#define DEVICE_NAME "utu2440-buttons"
#define MAX_BUTTONS_BUF 16
#define BUTTONS_NUM 6
#define BUF_HEAD (utubuttons_dev.buf[utubuttons_dev.head])
#define BUF_TAIL (utubuttons_dev.buf[utubuttons_dev.tail])
#define ISBUTTONS_DOWN(buttons) (s3c2410_gpio_getpin(buttons_info_tab[buttons].gpio_port) == BUTTONSSTATUS_DOWN)
#define INCBUF(x,mod) ((++(x))&((mod)-1))
#define BUTTONS_TIME_DELAY (HZ/10)
#define BUTTONS_TIME_DELAY1 (HZ/100)
#define UTUBUTTONS_MAJOR 0
unsigned int utubuttons_major = UTUBUTTONS_MAJOR;
struct utubuttons_dev
{
struct cdev cdev;
unsigned int buttons_status[BUTTONS_NUM];
unsigned int buf[MAX_BUTTONS_BUF];
unsigned int head, tail;
wait_queue_head_t wq;
};
struct utubuttons_dev utubuttons_dev;
struct utubuttons_dev *utubuttons_devp;
struct timer_list buttons_timer[BUTTONS_NUM];
static struct buttons_info
{
int irq_no;
int irq_type;
unsigned int gpio_port;
unsigned int gpio_setting;
int buttons_code;
char *name;
}buttons_info_tab[] =
{
{
IRQ_EINT0, IRQT_FALLING, S3C2410_GPF0, S3C2410_GPF0_INP, 1, "Key Up"
},
{
IRQ_EINT1, IRQT_FALLING, S3C2410_GPF1, S3C2410_GPF1_INP, 2, "Key Down"
},
{
IRQ_EINT2, IRQT_FALLING, S3C2410_GPF2,S3C2410_GPF2_INP, 3, "Key Left"
},
{
IRQ_EINT3, IRQT_FALLING, S3C2410_GPF3,S3C2410_GPF3_INP, 4, "Key Right"
},
{
IRQ_EINT11, IRQT_FALLING, S3C2410_GPG3,S3C2410_GPG3_INP, 5, "Key Enter"
},
{
IRQ_EINT19, IRQT_FALLING, S3C2410_GPG11,S3C2410_GPG11_INP, 6, "Key Exit"
},
};
static irqreturn_t utubuttons_irq(int irq, void *dev_id)
{
int buttons = (int)dev_id;
int i;
int found = 0;
for (i = 0; i < ARRAY_SIZE(buttons_info_tab); i++)
{
if (buttons_info_tab[i].irq_no == irq) {
found = 1;
break;
}
}
if (!found)
{
printk(KERN_NOTICE"bad irq %d in button\n", irq);
return IRQ_NONE;
}
disable_irq(buttons_info_tab[buttons].irq_no);
utubuttons_dev.buttons_status[buttons] = BUTTONSSTATUS_DOWNX;
buttons_timer[buttons].expires = jiffies + BUTTONS_TIME_DELAY1;
add_timer(&buttons_timer[buttons]);
return IRQ_HANDLED;
}
static int request_irqs(void)
{
int i;
for (i = 0; i < ARRAY_SIZE(buttons_info_tab); i++)
{
s3c2410_gpio_cfgpin(buttons_info_tab[i].gpio_port, buttons_info_tab[i].gpio_setting);
set_irq_type(buttons_info_tab[i].irq_no, buttons_info_tab[i].irq_type);
if (request_irq(buttons_info_tab[i].irq_no, utubuttons_irq, SA_INTERRUPT, DEVICE_NAME, (void *)i))
{
printk(KERN_WARNING "buttons:can't get irq no.%d\n", buttons_info_tab[i].irq_no);
return -1;
}
}
return 0;
}
static void free_irqs(void)
{
int i;
for (i = 0; i < ARRAY_SIZE(buttons_info_tab); i++)
{
free_irq(buttons_info_tab[i].irq_no, (void *)i);
}
}
static void buttonsEvent(unsigned buttons)
{
BUF_HEAD = buttons_info_tab[buttons].buttons_code;
utubuttons_dev.head = INCBUF(utubuttons_dev.head, MAX_BUTTONS_BUF);
wake_up_interruptible(&(utubuttons_dev.wq));
}
static ssize_t utubuttons_read(struct file *filp,char __user *buffer, size_t count, loff_t *ppos)
{
unsigned int buttons_ret;
unsigned long flags;
retry:
if (utubuttons_dev.head != utubuttons_dev.tail)
{
local_irq_save(flags);
buttons_ret = BUF_TAIL;
utubuttons_dev.tail = INCBUF(utubuttons_dev.tail, MAX_BUTTONS_BUF);
local_irq_restore(flags);
copy_to_user(buffer, &buttons_ret, sizeof(unsigned int));
return sizeof(unsigned int);
}else
{
if (filp->f_flags & O_NONBLOCK)
{
return -EAGAIN;
}
interruptible_sleep_on(&(utubuttons_dev.wq));
if (signal_pending(current))
{
return -ERESTARTSYS;
}
goto retry;
}
return sizeof(unsigned int);
}
static int utubuttons_ioctl(struct inode *inodep, struct file *filp, unsigned
int cmd, unsigned long arg)
{
unsigned long flags;
switch (cmd)
{
case BUF_CLEAR:
local_irq_save(flags);
utubuttons_dev.head = utubuttons_dev.tail = 0;
local_irq_restore(flags);
printk(KERN_INFO "buttons buffer is cleared\n");
break;
default:
return -EINVAL;
}
return 0;
}
static void utubuttons_timer_callback(unsigned long data)
{
int buttons = data;
if (ISBUTTONS_DOWN(buttons))
{
if (utubuttons_dev.buttons_status[buttons] == BUTTONSSTATUS_DOWNX)
{
utubuttons_dev.buttons_status[buttons] = BUTTONSSTATUS_DOWN;
buttons_timer[buttons].expires = jiffies + BUTTONS_TIME_DELAY;
buttonsEvent(buttons);
add_timer(&buttons_timer[buttons]);
}else
{
buttons_timer[buttons].expires = jiffies + BUTTONS_TIME_DELAY;
add_timer(&buttons_timer[buttons]);
}
}else
{
utubuttons_dev.buttons_status[buttons] = BUTTONSSTATUS_UP;
enable_irq(buttons_info_tab[buttons].irq_no);
}
}
static int utubuttons_open(struct inode *inode, struct file *filp)
{
printk(KERN_NOTICE "utubuttons opened\n");
return 0;
}
static int utubuttons_release(struct inode *inode, struct file *filp)
{
printk(KERN_NOTICE "utubuttons released\n");
return 0;
}
static const struct file_operations utubuttons_fops =
{
.owner = THIS_MODULE,
.read = utubuttons_read,
.ioctl = utubuttons_ioctl,
.open = utubuttons_open,
.release = utubuttons_release,
};
static void utubuttons_setup_cdev(void)
{
int err,devno = MKDEV(utubuttons_major,0);
cdev_init(&utubuttons_dev.cdev,&utubuttons_fops);
utubuttons_dev.cdev.owner = THIS_MODULE;
utubuttons_dev.cdev.ops = &utubuttons_fops;
err = cdev_add(&utubuttons_dev.cdev, devno, 1);
if (err)
printk(KERN_NOTICE "Error %d adding utubuttons", err);
}
static int __init utubuttons_init(void)
{
int result, i;
dev_t devno = MKDEV(utubuttons_major,0);
printk(KERN_INFO "Initial utulinux 2440 Buttons driver!\n");
result = request_irqs();
if (result) {
unregister_chrdev_region(devno,1);
return result;
}
if (utubuttons_major)
result = register_chrdev_region(devno, 1, DEVICE_NAME);
else
{
result = alloc_chrdev_region(&devno, 0, 1, DEVICE_NAME);
utubuttons_major = MAJOR(devno);
printk(KERN_INFO "Todo: mknod /dev/%s c %d 0\n", DEVICE_NAME, utubuttons_major);
}
if (result < 0)
return result;
utubuttons_devp = kmalloc(sizeof(struct utubuttons_dev), GFP_KERNEL);
if (!utubuttons_devp)
{
result = -ENOMEM;
goto fail_malloc;
}
memset(utubuttons_devp, 0, sizeof(struct utubuttons_dev));
utubuttons_setup_cdev();
init_waitqueue_head(&(utubuttons_dev.wq));
utubuttons_dev.head = utubuttons_dev.tail = 0;
for(i = 0; i < BUTTONS_NUM; i++)
{
utubuttons_dev.buttons_status[i] = BUTTONSSTATUS_UP;
}
for(i = 0; i < BUTTONS_NUM; i++)
{
buttons_timer[i].function = utubuttons_timer_callback;
buttons_timer[i].data = i;
init_timer(&buttons_timer[i]);
}
return 0;
fail_malloc: unregister_chrdev_region(devno, 1);
return result;
}
static void __exit utubuttons_exit(void)
{
int i;
cdev_del(&utubuttons_dev.cdev);
kfree(utubuttons_devp);
unregister_chrdev_region(MKDEV(utubuttons_major, 0), 1);
free_irqs();
for(i = 0; i < BUTTONS_NUM; i++)
{
del_timer(&buttons_timer[i]);
}
}
MODULE_AUTHOR("");
MODULE_LICENSE("Dual BSD/GPL");
module_init(utubuttons_init);
module_exit(utubuttons_exit);
分析一下这个驱动。
1.数据结构分析。
a.按键的状态，个人感觉最好用一个union。按键有三种情况，按下，按起，长按
b.按键设备。1，继承字符设备；2，按键状态；3，按键的缓冲区；4，等待队列及其头尾
c.定时器。
d.按键信息，个人理解是按键在特定的开发板上的资源信息，个人感觉最好放在与特定的平台相关的代码下，有利于做到移植时的与平台无关。
1.中断号；2，中断类型；3，哪个GPIO;4,GPIO设置；5，按键编码；6，按键名称
e.其他。1.设备名称;2.主设备号。
2.驱动分析
a.入口，出口。module_init(utubuttons_init);module_exit(utubuttons_exit);
utubuttons_init主要做了以下的事情：
1.申请设备号，申请中断
2.注册设备号，分配设备内存并初始化
3.安装字符设备
4.初始化按键队列及其头尾
5.初始化按键状态和定时器
utubuttons_exit主要做了一下事情：
1.卸载字符设备
2.释放设备内存
3.注销设备号
4.释放中断
5. 释放定时器
其中，安装字符设备为其中心枢纽，联系了设备和驱动的关系
主要做了如下事情：
1.初始化字符设备，将驱动和设备关联
2.填充按键设备
3.将按键设备添加到内核中
b.标准文件驱动编写
1.文件操作指针结构赋值
2.完成相应操作
c.中断回调和时间回调，以及按键事件相应