/*這段代碼是一個用戶模式下的DEMO，不是真正的驅動，它負責把按鍵的鍵值打印輸出*/ 
#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <sys/ioctl.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <sys/select.h> 
#include <sys/time.h> 
#include <errno.h> 

int main(void) 
{ 
int buttons_fd; 
int key_value; 

buttons_fd = open("/dev/buttons", 0); 
if (buttons_fd < 0) { 
perror("open device buttons"); 
exit(1); 
} 

for (;;) { 
fd_set rds; 
int ret; 

FD_ZERO(&rds); 
FD_SET(buttons_fd, &rds); 

ret = select(buttons_fd + 1, &rds, NULL, NULL, NULL); 
if (ret < 0) { 
perror("select"); 
exit(1); 
} 
if (ret == 0) { 
printf("Timeout.\n"); 
} else if (FD_ISSET(buttons_fd, &rds)) { 
int ret = read(buttons_fd, &key_value, sizeof key_value); 
if (ret != sizeof key_value) { 
if (errno != EAGAIN) 
perror("read buttons\n"); 
continue; 
} else { 
printf("buttons_value: %d\n", key_value); 
} 

} 
} 

close(buttons_fd); 
return 0; 
} 

/*下面是真正的驅動部分*/ 
#include <linux/config.h> 
#include <linux/module.h> 
#include <linux/kernel.h> 
#include <linux/init.h> 

#include <linux/miscdevice.h> 
#include <linux/sched.h> 
#include <linux/delay.h> 
#include <linux/poll.h> 
#include <linux/spinlock.h> 
#include <linux/irq.h> 
#include <linux/delay.h> 

#include <asm/hardware.h> 

#define DEVICE_NAME "buttons" 
#define BUTTON_MAJOR 232 

static struct key_info { 
int irq_no; 
unsigned int gpio_port; 
int key_no; 
} key_info_tab[4] = { 
{ IRQ_EINT1, GPIO_F1, 1 }, 
{ IRQ_EINT2, GPIO_F2, 2 }, 
{ IRQ_EINT3, GPIO_F3, 3 }, 
{ IRQ_EINT7, GPIO_F7, 4 }, 
}; 

static int ready = 0; 
static int key_value = 0; 

static DECLARE_WAIT_QUEUE_HEAD(buttons_wait); 

static void buttons_irq(int irq, void *dev_id, struct pt_regs *reg) 
{ 
struct key_info *k; 
int i; 
int found = 0; 
int up; 
int flags; 
for (i = 0; i < sizeof key_info_tab / sizeof key_info_tab[1]; i++) { 
k = key_info_tab + i; 
if (k->irq_no == irq) { 
found = 1; 
break; 
} 
} 
if (!found) { 
printk("bad irq %d in button\n", irq); 
return; 
} 

save_flags(flags); 
cli(); 
set_gpio_mode_user(k->gpio_port, GPIO_MODE_IN); 
up = read_gpio_bit(k->gpio_port); 
set_external_irq(k->irq_no, EXT_BOTH_EDGES, GPIO_PULLUP_DIS); 
restore_flags(flags); 
if (up) { 
key_value = k->key_no + 0x80; 
} else { 
key_value = k->key_no; 
} 
ready = 1; 
wake_up_interruptible(&buttons_wait); 
} 

static int request_irqs(void) 
{ 
struct key_info *k; 
int i; 
for (i = 0; i < sizeof key_info_tab / sizeof key_info_tab[1]; i++) { 
k = key_info_tab + i; 
set_external_irq(k->irq_no, EXT_BOTH_EDGES, GPIO_PULLUP_DIS); 
if (request_irq(k->irq_no, &buttons_irq, SA_INTERRUPT, DEVICE_NAME, &buttons_irq)) { 
return -1; 
} 

} 
return 0; 
} 

static void free_irqs(void) 
{ 
struct key_info *k; 
int i; 
for (i = 0; i < sizeof key_info_tab / sizeof key_info_tab[1]; i++) { 
k = key_info_tab + i; 
free_irq(k->irq_no, buttons_irq); 
} 
} 

static int matrix4_buttons_read(struct file * file, char * buffer, size_t count, loff_t *ppos) 
{ 
static int key; 
int flags; 
int repeat; 
if (!ready) 
return -EAGAIN; 
if (count != sizeof key_value) 
return -EINVAL; 
save_flags(flags); 
if (key != key_value) { 
key = key_value; 
repeat = 0; 
} else { 
repeat = 1; 
} 
restore_flags(flags); 

if (repeat) { 
return -EAGAIN; 
} 

copy_to_user(buffer, &key, sizeof key); 
ready = 0; 
return sizeof key_value; 
} 

static unsigned int matrix4_buttons_select( 
struct file *file, 
struct poll_table_struct *wait) 
{ 
if (ready) 
return 1; 
poll_wait(file, &buttons_wait, wait); 
return 0; 
} 


static int matrix4_buttons_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) 
{ 
switch(cmd) { 
default: 
return -EINVAL; 
} 
} 
static struct file_operations matrix4_buttons_fops = { 
owner: THIS_MODULE, 
ioctl: matrix4_buttons_ioctl, 
poll: matrix4_buttons_select, 
read: matrix4_buttons_read, 
}; 

static devfs_handle_t devfs_handle; 
static int __init matrix4_buttons_init(void) 
{ 
int ret; 

ready = 0; 
ret = register_chrdev(BUTTON_MAJOR, DEVICE_NAME, &matrix4_buttons_fops); 
if (ret < 0) { 
printk(DEVICE_NAME " can't register major number\n"); 
return ret; 
} 

ret = request_irqs(); 
if (ret) { 
unregister_chrdev(BUTTON_MAJOR, DEVICE_NAME); 
printk(DEVICE_NAME " can't request irqs\n"); 
return ret; 
} 
devfs_handle = devfs_register(NULL, DEVICE_NAME, DEVFS_FL_DEFAULT, 
BUTTON_MAJOR, 0, S_IFCHR | S_IRUSR | S_IWUSR, &matrix4_buttons_fops, NULL); 

return 0; 
} 

static void __exit matrix4_buttons_exit(void) 
{ 
devfs_unregister(devfs_handle); 
free_irqs(); 
unregister_chrdev(BUTTON_MAJOR, DEVICE_NAME); 
} 

module_init(matrix4_buttons_init); 
module_exit(matrix4_buttons_exit); 
MODULE_LICENSE("GPL");