N3292x 4*4键盘驱动源码

参考SDK 3x3键盘驱动修改而来。

/* linux/driver/input/w55fa92_keypad_4*4.c
 *
 * Copyright (c) 2010 Nuvoton technology corporation
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Changelog:
 *
 */

#include <linux/init.h>
#include <linux/slab.h>
#include <asm/errno.h>
#include <asm/delay.h>
#include <linux/mm.h>
#include <linux/poll.h>
#include <linux/module.h>
#include <mach/hardware.h>
#include <asm/io.h>
#include <linux/cdev.h>
#include <linux/interrupt.h>
#include <linux/completion.h>
#include <mach/irqs.h>
#include <mach/w55fa92_keypad.h>
#include <mach/w55fa92_reg.h>
#include <mach/regs-clock.h>
#undef BIT
#include <linux/input.h>
#include <linux/bitops.h>
#define BIT(x) (1UL<<((x)%BITS_PER_LONG))

#define KPD_IRQ_NUM             W55FA92_IRQ(2) // nIRQ0
#define DEF_KPD_DELAY           HZ/20

#define KEY_COUNT    16
#define ROW_CNT        4
#define COL_CNT        4
#define COL_MASK    0x0f

//#define W55FA92_DEBUG printk

static struct input_dev *w55fa92_keypad_input_dev;
static struct timer_list kpd_timer;
static char timer_active = 0;

static u32 old_key;
static u32 new_key;
static u32 open_cnt = 0;

u32 w55fa92_key_pressing = 0;
EXPORT_SYMBOL(w55fa92_key_pressing);
/*
        {
         1, 2, 3, 4,
         5, 6, 7, 8,
         9, 10, 11, 12,
         13, 14, 15, 16

            }
*/

/*
const int key_map[KEY_COUNT] = {
                9,10,11,12,
                5,6,7,8,
                1,2,3,4,
                13,14,15,16
                        };//as #
*/
const int key_map[KEY_COUNT] = {
                7,8,9,15,
                4,5,6,14,
                1,2,3,13,
                11,10,12,16
                        };//as #


// arg = 0, from isr, 1 from timer.
static void w55fa92_check_ghost_state(void)
{
    int i,j;
    u32 check = 0;
    u32 col, check_col, cmp_col;

    for (i = 0; i < ROW_CNT; i++)
    {
        col = (new_key >> (i*COL_CNT)) & COL_MASK;

        if ((col & check) && hweight8(col) > 1)
        {
            for(j=0; j<ROW_CNT; j++)
            {
                check_col = (new_key >> (j*COL_CNT)) & COL_MASK;
                if((col & check_col) != 0)
                {
                    cmp_col = (old_key >> (j*COL_CNT)) & COL_MASK;
                    new_key = new_key & ~((cmp_col ^ check_col) << (j*COL_CNT));
                }
            }
        }

        check |= col;
    }

}

/*new_key: [0-3]: row 1
         [4-7]: row 2
         [8-11]: row 3
         [12-15]:row 4
         */
static void read_key(unsigned long arg)
{
        u32 i;

        // ISR detect key press, disable irq, use timer to read following key press until released
        if (!timer_active) {
                writel(1 << KPD_IRQ_NUM, REG_AIC_MDCR);
        w55fa92_key_pressing = 1;
                disable_irq_nosync(KPD_IRQ_NUM); //disable_irq(KPD_IRQ_NUM);
        }

         new_key = readl(REG_GPIOC_PIN) & 0x0f;
        if ((new_key & 0x0f) == 0x0f) { // all key released
                for (i = 0; i < KEY_COUNT; i++) {
                        if (old_key & (1 << i)) {
                                input_report_key(w55fa92_keypad_input_dev, key_map[i], 0); //key up
                                input_sync(w55fa92_keypad_input_dev);
                        }
                }
                old_key = 0;
                del_timer(&kpd_timer);
                timer_active = 0;
                enable_irq(KPD_IRQ_NUM);
                w55fa92_key_pressing = 0;
                return;
        }

        writel((readl(REG_GPIOC_DOUT) |(1 << 6) | (1 << 7)|(1<<4))&~(1<<5), REG_GPIOC_DOUT); // one line low,others high
        udelay(1);
        new_key = ~(readl(REG_GPIOC_PIN) >> 0) & 0xf;

        writel((readl(REG_GPIOC_DOUT) |(1 << 5) | (1 << 7)|(1<<4))&~(1<<6), REG_GPIOC_DOUT);
        udelay(1);
        new_key |= ((~(readl(REG_GPIOC_PIN) >> 0) & 0x0f)<<4);

        writel((readl(REG_GPIOC_DOUT) |(1 << 5) | (1 << 6)|(1<<4))&~(1<<7), REG_GPIOC_DOUT);
        udelay(1);
        new_key |= ((~(readl(REG_GPIOC_PIN) >> 0) & 0x0f)<<8);

        writel((readl(REG_GPIOC_DOUT) |(1 << 6) | (1 << 7)|(1<<5))&~(1<<4), REG_GPIOC_DOUT);

        udelay(1);
        new_key |= ((~(readl(REG_GPIOC_PIN) >> 0) & 0x0f)<<12);

        writel(readl(REG_GPIOC_DOUT) &~((1 << 6) | (1 << 7)|(1<<5)|(1<<4)), REG_GPIOC_DOUT);
        //printk("new_key:%x\n",new_key);
        w55fa92_check_ghost_state();

        for (i = 0; i < KEY_COUNT; i++) {
                if ((new_key ^ old_key) & (1 << i)) {// key state change
                        if (new_key & (1 << i)) {
                                input_report_key(w55fa92_keypad_input_dev, key_map[i], 1);    //key down
                        } else {
                                input_report_key(w55fa92_keypad_input_dev, key_map[i], 0);    //key up
                        }
                        input_sync(w55fa92_keypad_input_dev);
                }

        }

        old_key = new_key;

        timer_active = 1;
        if ( arg == 0 )
                mod_timer(&kpd_timer, jiffies + DEF_KPD_DELAY*2); //*3); //### to avoid key too sensitive
        else
                mod_timer(&kpd_timer, jiffies + DEF_KPD_DELAY);

        return;

}


static irqreturn_t w55fa92_kpd_irq(int irq, void *dev_id) {

        u32 src;

        src = readl(REG_IRQTGSRC1);

        read_key(0);

        // clear source
       writel(src & 0x000000f, REG_IRQTGSRC1);

        return IRQ_HANDLED;
}


int w55fa92_kpd_open(struct input_dev *dev) {

        if (open_cnt > 0) {
                goto exit;
        }

        new_key = old_key = 0;
        init_timer(&kpd_timer);
        kpd_timer.function = read_key;    /* timer handler */
        kpd_timer.data = 1;
        writel((1 << KPD_IRQ_NUM), REG_AIC_SCCR); // force clear previous interrupt, if any.

        writel(readl(REG_IRQTGSRC1) & 0x000000f, REG_IRQTGSRC1); // clear source

        if (request_irq(KPD_IRQ_NUM, w55fa92_kpd_irq, IRQF_DISABLED, "Keypad",NULL) != 0) {
                printk("register the keypad_irq failed!\n");
                return -1;
        }
        //enable falling edge triggers
       writel((readl(REG_IRQENGPC)& ~(0x000f0000)) | 0x000000f, REG_IRQENGPC);

exit:
        open_cnt++;
        return 0;
}



void w55fa92_kpd_close(struct input_dev *dev) {

        open_cnt--;
        if (open_cnt == 0) {
            //disable falling edge triggers
            writel((readl(REG_IRQENGPC)& ~(0x000f000f)), REG_IRQENGPC);

                del_timer(&kpd_timer);
                free_irq(KPD_IRQ_NUM,NULL);
        }
        return;
}


static int __init w55fa92_kpd_reg(void) {

        int i, err;
        //PORTC[0-3] for Interrupt
        writel(readl(REG_GPIOC_OMD) & ~((1 << 0)|(1 << 1)|(1 << 2) | (1 << 3)), REG_GPIOC_OMD); // input
        writel(readl(REG_GPIOC_PUEN) | ((1 << 0)|(1 << 1)|(1 << 2) | (1 << 3)), REG_GPIOC_PUEN); // pull-up
        writel(readl(REG_IRQSRCGPC) & ~(0xFF), REG_IRQSRCGPC); // GPC[1~4] as nIRQ0 source
        writel((readl(REG_IRQENGPC)& ~(0x000F0000)) | 0x000000F, REG_IRQENGPC); // falling edge trigger
        writel((readl(REG_AIC_SCR1)& ~(0x00C70000)) | 0x00470000, REG_AIC_SCR1);//
         //GPC[4-7]:key other 4lines
        writel(readl(REG_GPIOC_OMD) | ((1 <<4 )|(1 << 5)|(1 << 6)|(1 << 7)), REG_GPIOC_OMD); // output
        writel(readl(REG_GPIOC_PUEN) | ((1 <<4 )|(1 << 5)|(1 << 6)|(1 << 7)), REG_GPIOC_PUEN); // pull up
        writel(readl(REG_GPIOC_DOUT) &~((1 <<4 )|(1 << 5)|(1 << 6)|(1 << 7)), REG_GPIOC_DOUT); // low
        writel(readl(REG_GPCFUN0) & ~(0xFFFFFFFF), REG_GPCFUN0);

        writel(readl(REG_DBNCECON) |0x71, REG_DBNCECON);
        if (!(w55fa92_keypad_input_dev = input_allocate_device())) {
                printk("upsmaker001 Keypad Drvier Allocate Memory Failed!\n");
                err = -ENOMEM;
                goto fail;
        }

        w55fa92_keypad_input_dev->name = "upsmaker001 Keypad";
        w55fa92_keypad_input_dev->phys = "input/event1";
        w55fa92_keypad_input_dev->id.bustype = BUS_HOST;
        w55fa92_keypad_input_dev->id.vendor = 0x0005;
        w55fa92_keypad_input_dev->id.product = 0x0001;
        w55fa92_keypad_input_dev->id.version = 0x0100;

        w55fa92_keypad_input_dev->open = w55fa92_kpd_open;
        w55fa92_keypad_input_dev->close = w55fa92_kpd_close;

        w55fa92_keypad_input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_SYN) | BIT(EV_REP);

        for (i = 0; i < KEY_MAX; i++)
                set_bit(i+1, w55fa92_keypad_input_dev->keybit);

        err = input_register_device(w55fa92_keypad_input_dev);
        if (err) {

                input_free_device(w55fa92_keypad_input_dev);
                return err;
        }

        // must set after input device
        w55fa92_keypad_input_dev->rep[REP_DELAY] = 300; //250ms
        w55fa92_keypad_input_dev->rep[REP_PERIOD] = 200; //ms

        printk("upsmaker001 keypad driver has been initialized successfully!\n");

        return 0;

fail:
        input_free_device(w55fa92_keypad_input_dev);
        return err;
}

static void __exit w55fa92_kpd_exit(void) {
        free_irq(KPD_IRQ_NUM, NULL);
        input_unregister_device(w55fa92_keypad_input_dev);
}

module_init(w55fa92_kpd_reg);
module_exit(w55fa92_kpd_exit);

MODULE_AUTHOR("upsmaker001 eRain");
MODULE_DESCRIPTION("KeyPad 4*4 driver@2015.4.9");
MODULE_LICENSE("GPL");