utu2440_buttons2.c

适用于嵌入式内核(linux 2.6.11)的4*4键盘驱动程序. 消抖动, 采用4路中断, 4路扫描方式.

/*
 * Author:lili <[e-mail]>
 *
 * 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/config.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>

#include <linux/poll.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() */
#ifdef CONFIG_DEVFS_FS
#include <linux/devfs_fs_kernel.h>
#endif

#define VERSION_STRING  "Button driver for bobo2440"

#define DEVICE_NAME "utu2440-buttons"

#define EXTINT_OFF (IRQ_EINT4 - 4)

MODULE_AUTHOR("bobo <[e-mail]>");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION(VERSION_STRING);

unsigned int type=IRQT_BOTHEDGE;
unsigned int buttons_major_number=0;
struct cdev buttons_dev;
static int ready = 0;
static int key_value = 0;

static struct key_info 
{
	unsigned int irq_no;
	unsigned int gpio_port;
	int key_no;
	unsigned int IN;
	unsigned int OUT;
	unsigned int EINT;
}key_info_tab_r[4] = {
	{ IRQ_EINT0, S3C2410_GPF0, 0 , 0, S3C2410_GPF0_OUTP,S3C2410_GPF0_EINT0},
	{ IRQ_EINT1, S3C2410_GPF1, 4 , 0, S3C2410_GPF1_OUTP,S3C2410_GPF1_EINT1},
	{ IRQ_EINT2, S3C2410_GPF2, 8 , 0, S3C2410_GPF2_OUTP,S3C2410_GPF2_EINT2},
	{ IRQ_EINT3, S3C2410_GPF3, 12, 0, S3C2410_GPF3_OUTP,S3C2410_GPF3_EINT3},
};
struct key_info key_info_tab_c[4] = {
	{ 0, S3C2410_GPG3,  0 ,S3C2410_GPG3_INP, S3C2410_GPG3_OUTP,  0},
	{ 0, S3C2410_GPG11, 1 ,S3C2410_GPG11_INP,S3C2410_GPG11_OUTP, 0},
  { 0, S3C2410_GPG9 , 2 ,S3C2410_GPG9_INP, S3C2410_GPG9_OUTP,  0},
	{ 0, S3C2410_GPG10, 3 ,S3C2410_GPG10_INP,S3C2410_GPG10_OUTP, 0},
};

DECLARE_WAIT_QUEUE_HEAD(buttons_wait);

static inline void s3c_irq_ack(unsigned int irqno)
{
	unsigned long bitval = 1UL << (irqno - IRQ_EINT0);

	__raw_writel(bitval, S3C2410_SRCPND);
	__raw_writel(bitval, S3C2410_INTPND);
} 
static void s3c_irqext_ack(unsigned int irqno)
{
	unsigned long req;
	unsigned long bit;
	unsigned long mask;

	bit = 1UL << (irqno - EXTINT_OFF);


	mask = __raw_readl(S3C2410_EINTMASK);

	__raw_writel(bit, S3C2410_EINTPEND);
         req = __raw_readl(S3C2410_EINTPEND);
 	req &= ~mask;

	/* not sure if we should be acking the parent irq... */

	if (irqno <= IRQ_EINT7 ) {
		if ((req & 0xf0) == 0)
			s3c_irq_ack(IRQ_EINT4t7);
	} else {
		if ((req >> 8) == 0)
			s3c_irq_ack(IRQ_EINT8t23);
	}
}
static int s3c_irqext_type(unsigned int irq, unsigned int type)
{
	unsigned long extint_reg;
	unsigned long gpcon_reg;
	unsigned long gpcon_offset, extint_offset;
	unsigned long newvalue = 0, value;

	if ((irq >= IRQ_EINT0) && (irq <= IRQ_EINT3))
	{
		gpcon_reg = (unsigned long)S3C2410_GPFCON;
		extint_reg = (unsigned long)S3C2410_EXTINT0;
		gpcon_offset = (irq - IRQ_EINT0) * 2;
		extint_offset = (irq - IRQ_EINT0) * 4;
	}
	else if ((irq >= IRQ_EINT4) && (irq <= IRQ_EINT7))
	{
		gpcon_reg = (unsigned long)S3C2410_GPFCON;
		extint_reg = (unsigned long)S3C2410_EXTINT0;
		gpcon_offset = (irq - (EXTINT_OFF)) * 2;
		extint_offset = (irq - (EXTINT_OFF)) * 4;
	}
	else if ((irq >= IRQ_EINT8) && (irq <= IRQ_EINT15))
	{
		gpcon_reg = (unsigned long)S3C2410_GPGCON;
		extint_reg = (unsigned long)S3C2410_EXTINT1;
		gpcon_offset = (irq - IRQ_EINT8) * 2;
		extint_offset = (irq - IRQ_EINT8) * 4;
	}
	else if ((irq >= IRQ_EINT16) && (irq <= IRQ_EINT23))
	{
		gpcon_reg = (unsigned long)S3C2410_GPGCON;
		extint_reg = (unsigned long)S3C2410_EXTINT2;
		gpcon_offset = (irq - IRQ_EINT8) * 2;
		extint_offset = (irq - IRQ_EINT16) * 4;
	} else
		return -1;

	/* Set the GPIO to external interrupt mode */
	value = __raw_readl(gpcon_reg);
	value = (value & ~(3 << gpcon_offset)) | (0x02 << gpcon_offset);
	__raw_writel(value, gpcon_reg);

	/* Set the external interrupt to pointed trigger type */
	switch (type)
	{
		case IRQT_NOEDGE:
			printk(KERN_WARNING "No edge setting!\n");
			break;

		case IRQT_RISING:
			newvalue = S3C2410_EXTINT_RISEEDGE;
			break;

		case IRQT_FALLING:
			newvalue = S3C2410_EXTINT_FALLEDGE;
			break;

		case IRQT_BOTHEDGE:
			newvalue = S3C2410_EXTINT_BOTHEDGE;
			break;

		case IRQT_LOW:
			newvalue = S3C2410_EXTINT_LOWLEV;
			break;

		case IRQT_HIGH:
			newvalue = S3C2410_EXTINT_HILEV;
			break;

		default:
			printk(KERN_ERR "No such irq type %d", type);
			return -1;
	}

	value = __raw_readl(extint_reg);
	value = (value & ~(7 << extint_offset)) | (newvalue << extint_offset);
	__raw_writel(value, extint_reg);

	return 0;
}

static irqreturn_t buttons_irq(int irq,void *dev_id,struct pt_regs *req)
{
	struct key_info *k,*l;
	int i;
	int found = 0;
	int up ;
	unsigned long  flags;

	for (i = 0; i < sizeof key_info_tab_r / sizeof key_info_tab_r[1]; i++) {
		k = key_info_tab_r + i;
		if (k->irq_no == irq) {
			found = 1;
			break;
		}
	}
	if (!found) 
	{
		printk("bad irq %d in button\n", irq);
		return IRQ_NONE;
	}
	local_irq_save(flags);
	s3c2410_gpio_cfgpin(k->gpio_port, k->OUT);
	s3c2410_gpio_setpin(k->gpio_port, 0);
	
	mdelay(1);
	for (i = 0; i < sizeof key_info_tab_c / sizeof key_info_tab_c[1]; i++) 
	{
		l = key_info_tab_c + i;
		s3c2410_gpio_cfgpin(l->gpio_port, l->OUT);
		s3c2410_gpio_setpin(l->gpio_port, 1);
		mdelay(1);		
		s3c2410_gpio_cfgpin(l->gpio_port, l->IN);
		up = s3c2410_gpio_getpin(l->gpio_port);
		s3c2410_gpio_cfgpin(l->gpio_port, l->OUT);
		s3c2410_gpio_setpin(l->gpio_port, 0);
		if(0 == up) break;
	}
	//mdelay(1);
	local_irq_restore(flags);
  
  s3c_irqext_type(irq,  type);
	if(irq<IRQ_EINT7)
		s3c_irq_ack(irq);
	else
		s3c_irqext_ack(irq);
	if (!up) 
	{
		key_value = k->key_no+l->key_no;
		ready=1;
		printk("buttons key_value is %d \n", key_value);
	}
	wake_up_interruptible(&buttons_wait);
	//printk("buttons_row is %d \n buttons_col is %d\n", k->key_no, l->key_no);
	/*LED Test add by lili 2007-6 for UTU2440 board*/

	if(0 == up)
	{
		s3c2410_gpio_setpin(S3C2410_GPF4, 0);
	}
	else
	{
		s3c2410_gpio_setpin(S3C2410_GPF4, 1);
	}	
/*	if((key_value == 2))
	{
		s3c2410_gpio_setpin(S3C2410_GPF5, 0);
	}
	if((key_value == 3))
	{
		s3c2410_gpio_setpin(S3C2410_GPF6, 0);
	}
	if((key_value == 4))
	{
		s3c2410_gpio_setpin(S3C2410_GPF7, 0);
	}
	if((key_value == 5))
	{
		s3c2410_gpio_setpin(S3C2410_GPF4, 0);
		s3c2410_gpio_setpin(S3C2410_GPF5, 0);
		s3c2410_gpio_setpin(S3C2410_GPF6, 0);
		s3c2410_gpio_setpin(S3C2410_GPF7, 0);
	}
	if((key_value == 6))
	{
		s3c2410_gpio_setpin(S3C2410_GPF4, 1);
		s3c2410_gpio_setpin(S3C2410_GPF5, 1);
		s3c2410_gpio_setpin(S3C2410_GPF6, 1);
		s3c2410_gpio_setpin(S3C2410_GPF7, 1);
	}
*/
	return IRQ_HANDLED;
}

static int request_irqs(void)
{
	struct key_info *k;
	int i,request;
	unsigned int irq;
  for (i = 0; i < sizeof key_info_tab_r / sizeof key_info_tab_r[1]; i++) 
  {
      		k = key_info_tab_r + i;
      		irq=k->irq_no;
      		s3c2410_gpio_pullup(k->gpio_port, 0);
      		s3c_irqext_type(irq,  type);
      		
      		if(irq<IRQ_EINT7)
      			s3c_irq_ack(irq);
      		else
      			s3c_irqext_ack(irq);
		request =request_irq(k->irq_no,&buttons_irq,SA_INTERRUPT,DEVICE_NAME,NULL);
      		if (request) 
      		{
      			printk(KERN_WARNING "buttons:can't get irq no.\n");
						return -1;
					}
	
	}
	return 0;
}

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

static ssize_t buttons_read(struct file *filp,char __user *buffer,size_t count,loff_t *ppos)
{       
	static int key;
	unsigned long  flags;
	if (!ready) { 
		return -EAGAIN;
	}
        if (count != sizeof key_value)
        	return -EINVAL;
	local_irq_save(flags);
	key = key_value;

	local_irq_restore(flags);
        copy_to_user(buffer, &key, sizeof key);
	ready = 0;

	return sizeof key_value;
}

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

static struct file_operations buttons_fops = {
	.owner	=	THIS_MODULE,
	.read	=	buttons_read,
	.poll = buttons_select,
};

static int __init buttons_init(void)
{
        int ret,devno;
        int i;
        dev_t dev;
        ret = alloc_chrdev_region(&dev,0,1,DEVICE_NAME);
        buttons_major_number = MAJOR(dev);
	printk(KERN_INFO "Initial utulinux 2440 Buttons driver!\n");
        if (ret<0) {
                printk(KERN_WARNING "button:can't get major number %d\n",buttons_major_number);
                return ret;
        }
        
        for (i = 0; i < sizeof key_info_tab_c / sizeof key_info_tab_c[1]; i++) 
				{
				struct key_info *l= key_info_tab_c + i;
				s3c2410_gpio_pullup(l->gpio_port, 0);
				
				s3c2410_gpio_cfgpin(l->gpio_port, l->OUT);
				s3c2410_gpio_setpin(l->gpio_port, 0);
		
				}        
        
        ret = request_irqs();
        if (ret) {
                unregister_chrdev_region(dev,1);
                printk(KERN_WARNING "button:can't request irqs\n");
                return ret;
        }

				        
        devno = MKDEV(buttons_major_number,0);
        cdev_init(&buttons_dev,&buttons_fops);
        buttons_dev.owner = THIS_MODULE;
        buttons_dev.ops   = &buttons_fops;

        ret = cdev_add(&buttons_dev,devno,1);
        if (ret) {
                free_irqs();
                unregister_chrdev_region(dev,1);
                printk(KERN_NOTICE "Error %d adding buttons device\n",ret);
                return ret;
        }
        printk(KERN_INFO "Todo: mknod  /dev/%s  c %d 0\n",DEVICE_NAME,buttons_major_number);
        return 0;
}

static void __exit buttons_cleanup(void)
{
        dev_t dev=MKDEV(buttons_major_number,0);
        free_irqs();
        cdev_del(&buttons_dev);
        unregister_chrdev_region(dev,1);
        printk(KERN_INFO "unregistered the %s\n",DEVICE_NAME);
}

module_init(buttons_init);
module_exit(buttons_cleanup);