S3C6410 按键驱动（五） --- 驱动源代码（我采用自动分配设备号的方法，注册设备）

/**********wzk_key.c ************/
/******wzk*********/
#include "wzk_key.h"

int DOWN = 0;
/*
#define DEVICE_NAME	"keys"
#define KEY_MAJOR 232


static unsigned long key_table [] = {
       S3C64XX_GPN(0),
       S3C64XX_GPN(1),
       S3C64XX_GPN(2),
       S3C64XX_GPN(3),
       S3C64XX_GPN(4),
       S3C64XX_GPN(5),

};
*/

//timer
void my_timer_callback(unsigned long tmp)
{
	DOWN = 0;
	printk("timer\n");
}

void init_mytimer(void)
{

	init_timer(&mytimer);
	mytimer.data = 5;
	mytimer.expires = jiffies + 1;
	mytimer.function = my_timer_callback;
	add_timer(&mytimer);

	return;
}

void start_timer(int time_value)
{

	int ret;

	DOWN = 1;
	ret = mod_timer(&mytimer,jiffies + msecs_to_jiffies(time_value));
	if(ret)
	{
		printk("mod_timer error!\n");
		return;
	}

	return;
}


void clear_keys(void)
{
	int i;
	for(i = 0; i < 6; i++)
	{
		key_values[i] = '0';
	}

	return;
}

static irqreturn_t keys_interrupt(int irq,void *dev_id)
{
	struct key_irq *key_irqs = (struct key_irq *)dev_id;
	int number;

	clear_keys();

	number = key_irqs->number;
	printk("number = %d\n",number);
	if(DOWN == 0)
	{
	switch(number)
	{
		case 0:
//			key_values[number] = '1';
			start_timer(1000);	
			break;
		case 1:
//			key_values[number] = '1';	
			start_timer(1000);
			break;
		case 2:
//			key_values[number] = '1';	
			start_timer(1000);		
			break;

		case 3:
//			key_values[number] = '1';	
			start_timer(1000);	
			break;

		case 4:
//			key_values[number] = '1';	
			start_timer(1000);	
			break;

		case 5:
//			key_values[number] = '1';	
			start_timer(1000);	
			break;

/*
			tmp = readl(S3C64XX_GPNDAT);
			down = !(tmp & (1 << number));
			break;
*/
		default:
			key_values[number] = '0';
			return IRQ_RETVAL(IRQ_HANDLED);
	}

	key_values[number] = '1';
	ev_press = 1;
	wake_up_interruptible(&key_waitq);
/*
	if(down != (key_values[number] & 1))
	{
		key_values[number] = '0' + down;
		ev_press = 1;
		
		wake_up_interruptible(&key_waitq);
*/
	printk("interrupt\n");
	}
	return IRQ_RETVAL(IRQ_HANDLED);
}

int s3c6410_keys_open(struct inode *inode,struct file *file)
{

	int num;
	int ret;

	for(num = 0; num < KEYNUM; num++)
	{
		ret = request_irq(key_irqs[num].irq,keys_interrupt,key_irqs[num].flags,key_irqs[num].name,(void*)&key_irqs[num]);
	}

	init_mytimer();
	return 0;
}

int s3c6410_keys_close(struct inode *inode,struct file *file)
{
	int i;
	int ret;
	for(i = 0; i < KEYNUM; i++)
	{
		free_irq(key_irqs[i].irq,(void*)&key_irqs[i]);
	}

	ret = del_timer(&mytimer);
	if(ret)
	{
		printk("timer is using ...\n");
	}
	return 0;
}

static int s3c6410_keys_read(struct file *filp,char __user *buff,size_t count,loff_t *offp)
{
	unsigned long err;
	if(!ev_press)
	{
		wait_event_interruptible(key_waitq,ev_press);
		printk("ev_press = %d\n",ev_press);
	}

	ev_press = 0;

	err = copy_to_user((void *)buff,(const void*)(&key_values),min(sizeof(key_values),count));

	return min(sizeof(key_values),count);
}

static unsigned int s3c6410_keys_poll(struct file *file,struct poll_table_struct *wait)
{
	unsigned int mask = 0;
	poll_wait(file,&key_waitq,wait);
	if(ev_press)
		mask |= POLLIN | POLLRDNORM;
	return mask;
}

static long s3c6410_keys_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	return 0;
}


//set gpk is interrupt mode
void init_dev(void)
{
	unsigned int tmp;
	
	s3c_gpio_cfgpin(key_table[0],S3C_GPIO_SFN(2));
	s3c_gpio_cfgpin(key_table[1],S3C_GPIO_SFN(2));
	s3c_gpio_cfgpin(key_table[2],S3C_GPIO_SFN(2));
	s3c_gpio_cfgpin(key_table[3],S3C_GPIO_SFN(2));
	s3c_gpio_cfgpin(key_table[4],S3C_GPIO_SFN(2));
	s3c_gpio_cfgpin(key_table[5],S3C_GPIO_SFN(2));

	tmp = readl(S3C64XX_GPNCON);
	printk("%x\n",tmp);
}

static struct file_operations s3c6410_keys_fops = {
	.owner	= THIS_MODULE,
	.open = s3c6410_keys_open,
	.unlocked_ioctl	= s3c6410_keys_ioctl,
	.release = s3c6410_keys_close,
	.read = s3c6410_keys_read,
	.poll = s3c6410_keys_poll
};

static struct cdev cdev_keys;
struct class * my_class;
dev_t devno;

static int __init s3c6410_keys_init(void)
{
	int ret;
//	dev_t devno;
	printk(KERN_NOTICE "enter s3c6410_keys_init\n");


	devno = MKDEV(KEY_MAJOR,0);

	ret = alloc_chrdev_region(&devno,0,1,DEVICE_NAME);
	if(ret)
	{
		printk(KERN_NOTICE "can not register led device");
		return ret;
	}
	
	cdev_init(&cdev_keys,&s3c6410_keys_fops);
	cdev_keys.owner = THIS_MODULE;

	ret =cdev_add(&cdev_keys,devno,1);
	if(ret)
	{
		printk(KERN_NOTICE "can not add leds device");
		return ret;
	}

	my_class = class_create(THIS_MODULE,DEVICE_NAME);
	if(IS_ERR(my_class))
	{
		printk("Err: Failed in creating class\n");
		return -1;	
	}

	device_create(my_class,NULL,devno,NULL,DEVICE_NAME);

	init_dev();

	printk(DEVICE_NAME " initialized\n");

	return 0;
}

static void __exit s3c6410_keys_exit(void)
{

	
	device_destroy(my_class,devno);
	class_destroy(my_class);

	cdev_del(&cdev_keys);

	unregister_chrdev_region(devno,1);	

	printk(KERN_NOTICE "s3c6410_keys_exit\n");
}


module_init(s3c6410_keys_init);
module_exit(s3c6410_keys_exit);

MODULE_LICENSE("GPL");

/**********wzk_key.h***********/



#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <asm/irq.h>
#include <mach/gpio.h>
#include <mach/regs-gpio.h>
#include <mach/gpio-bank-n.h>
#include <mach/map.h>                   //S3C64XX_VA_GPIO
#include <plat/gpio-cfg.h>
#include <mach/hardware.h>
#include <linux/io.h>
#include <asm/io.h>

#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/interrupt.h>
#include <linux/semaphore.h>
#include <linux/timer.h>

#include <asm/irq.h>
#include <asm/uaccess.h>
#include <mach/irqs.h>

#include <linux/timer.h>
#include <linux/jiffies.h>

#define DEVICE_NAME     "keys"
#define KEY_MAJOR 189


static unsigned long key_table [] = {
       S3C64XX_GPN(0),
       S3C64XX_GPN(1),
       S3C64XX_GPN(2),
       S3C64XX_GPN(3),
       S3C64XX_GPN(4),
       S3C64XX_GPN(5),

};

struct key_irq{

	int irq;
	int number;
	unsigned long flags;
	char *name;
};

static struct key_irq key_irqs[] = {

	{IRQ_EINT(0),0,IRQF_TRIGGER_FALLING,"KEY1"}, 
	 //./include/linux/interrupt.h
	//./arch/arm/mach-s3c64xx/include/mach/irqs.h
	{IRQ_EINT(1),1,IRQF_TRIGGER_FALLING,"KEY2"}, 
	{IRQ_EINT(2),2,IRQF_TRIGGER_FALLING,"KEY3"}, 
	{IRQ_EINT(3),3,IRQF_TRIGGER_FALLING,"KEY4"}, 
	{IRQ_EINT(4),4,IRQF_TRIGGER_FALLING,"KEY5"}, 
	{IRQ_EINT(5),5,IRQF_TRIGGER_FALLING,"KEY6"}
};

static DECLARE_WAIT_QUEUE_HEAD(key_waitq);

#define KEYNUM 6

static volatile int ev_press = 0;
static volatile char key_values[] = {0,0,0,0,0,0};
//static volatile int press_cnt[KEYNUM] = {0,0,0,0,0,0};

static struct timer_list mytimer;