key14irqTimer

//==============key14_irq.c======================================================
#ifndef __KERNEL__
    #define __KERNEL__
#endif
#ifndef MODULE
    #define MODULE
#endif

#include
#include
#include     /* printk() */
#include         /* __init __exit */

#include     /* size_t */
#include             /* file_operation */
#include     /* Error number */
#include     /* udelay */
#include     /* copy_to_user, copy_from_user */

#include
#include

#include
#include
#include
#include


#define DRIVER_NAME    "key14_irq"

#ifdef DEBUG
#define PRINTK(fmt, arg...)        printk(KERN_NOTICE fmt, ##arg)
#else
#define PRINTK(fmt, arg...)
#endif
/*
    KERN_EMERG        用于紧急事件,一般是系统崩溃前的提示信息
    KERN_ALERT        用于需要立即采取动作的场合
    KERN_CRIT        临界状态,通常设计验证的硬件或软件操作失败
    KERN_ERR        用于报告错误状态.设备驱动程序通常会用它报告来自硬件的问题
    KERN_WARNING    就可能出现的问题提出警告.这些问题通常不会对系统造成严重破坏
    KERN_NOTICE        有必要提示的正常情况.许多安全相关的情况用这个级别汇报
    KERN_INFO        提示性信息.有很多驱动程序在启动时用这个级别打印相关信息
    KERN_DEBUG        用于调试的信息
*/
int count=0;

static struct semaphore bufferlock;
//定义一个信号量

static spinlock_t buffer_lock = SPIN_LOCK_UNLOCKED;
// 首先需要定义一个自旋锁,该锁由kfifo维护，我们只需要定义它即可

static struct kfifo *buffer;
// 然后定义一个kfifo指针, 注意, 这里定义指针即可，不用分配空间

#define BUFFER_SIZE        256
// 使用kfifo_alloc可以创建一个BUFFER_SIZE大小的fifo, 所有空间由kfifo自动分配

static int key14_irq_Marjor = 0;        /* Driver Major Number */
//static unsigned int key_value=0;

static struct timer_list myTimer;
//定义一个定时器

static void open_irqs(void)
{
    enable_irq(IRQ_EINT0);
    enable_irq(IRQ_EINT1);
    enable_irq(IRQ_EINT2);
    enable_irq(IRQ_EINT3);
}

static void close_irqs(void)
{
    disable_irq(IRQ_EINT0);
    disable_irq(IRQ_EINT1);
    disable_irq(IRQ_EINT2);
    disable_irq(IRQ_EINT3);
}

void timerHandler(unsigned long data)
{
    char key;
     GPFCON = 0x00;
     key = GPFDAT;
     key = key & 0x0f;
     if(key!=0x0f)
     {
         key = (~key) & 0x0f;
         kfifo_put(buffer,&key, sizeof(key));
        up(&bufferlock);
    }
    GPFCON = 0xaa;
    open_irqs();
}


static void key14_irqsrv(int irq, void *dev_id, struct pt_regs *regs)
{
   
    close_irqs();
    myTimer.expires = jiffies + HZ * 4 / 100;  //0.03 * HZ
    add_timer(&myTimer);
   
}

static void register_irqsrv()
{
    request_irq(IRQ_EINT0, key14_irqsrv, SA_INTERRUPT, "key14_gpf0", (void*)0);
    request_irq(IRQ_EINT1, key14_irqsrv, SA_INTERRUPT, "key14_gpf1", (void*)1);
    request_irq(IRQ_EINT2, key14_irqsrv, SA_INTERRUPT, "key14_gpf2", (void*)2);
    request_irq(IRQ_EINT3, key14_irqsrv, SA_INTERRUPT, "key14_gpf3", (void*)3);   
}

static void unregister_irqsrv()
{
    free_irq(IRQ_EINT0, (void*)0);
    free_irq(IRQ_EINT1, (void*)1);
     free_irq(IRQ_EINT2, (void*)2);
    free_irq(IRQ_EINT3, (void*)3);
}


/* Driver Operation Functions */
static int key14_irq_open(struct inode *inode, struct file *filp)
{
//    int Minor = MINOR(inode->i_rdev);
//    filp->private_data = 0;


    MOD_INC_USE_COUNT;

    sema_init(&bufferlock,0);
   
    open_irqs();
    printk("gpg_key14 open called!\n");

    return 0;
}

static int key14_irq_release(struct inode *inode, struct file *filp)
{
//    int Minor = MINOR(inode->i_rdev);
    MOD_DEC_USE_COUNT;
    kfifo_free(buffer);
   
    del_timer(&myTimer);
    close_irqs();   
    PRINTK("gpfDriver release called!\n");
    return 0;
}


static ssize_t key14_irq_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)
{
    unsigned char key;
    down_interruptible(&bufferlock);
    if(kfifo_len(buffer) >= sizeof(key))
    {
            kfifo_get(buffer, &key, sizeof(key));
            copy_to_user(buf, &key, sizeof(key));
    }
    return sizeof(key);
}

static ssize_t key14_irq_write(struct file *filp, const char *buf, size_t count, loff_t *f_pos)
{
    PRINTK("gpf_key14 write called!\n");
    return 1;
}

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

/* Driver Operation structure */
static struct file_operations key14_irq_fops = {
    owner:    THIS_MODULE,
    write:    key14_irq_write,
    read:        key14_irq_read,
    ioctl:    key14_irq_ioctl,
    open:        key14_irq_open,
    release:    key14_irq_release,
};

/* Module Init & Exit function */
#ifdef CONFIG_DEVFS_FS
devfs_handle_t devfs_gpfDriver_dir;
devfs_handle_t devfs_gpfDriver_raw;
#endif
static int __init myModule_init(void)
{
            /* Module init code */
    PRINTK("myModule_init\n");
            /* Driver register */
    key14_irq_Marjor = register_chrdev(0, DRIVER_NAME, &key14_irq_fops);
    if(key14_irq_Marjor < 0)
    {
        PRINTK("register char device fail!\n");
        return key14_irq_Marjor;
    }
    PRINTK("register key14_irq OK! Major = %d\n", key14_irq_Marjor);

    set_external_irq(IRQ_EINT0, EXT_FALLING_EDGE, 0);
    set_external_irq(IRQ_EINT1, EXT_FALLING_EDGE, 0);
    set_external_irq(IRQ_EINT2, EXT_FALLING_EDGE, 0);
    set_external_irq(IRQ_EINT3, EXT_FALLING_EDGE, 0);

    register_irqsrv();

    buffer = kfifo_alloc(BUFFER_SIZE, GFP_KERNEL, &buffer_lock);


    init_timer(&myTimer);

    myTimer.data = (unsigned long)0;
    myTimer.function = &timerHandler;
   
   

#ifdef CONFIG_DEVFS_FS
    devfs_gpfDriver_dir = devfs_mk_dir(NULL, "key14_irq", NULL);
    devfs_gpfDriver_raw = devfs_register(devfs_gpfDriver_dir, "0", DEVFS_FL_DEFAULT, key14_irq_Marjor, 0, S_IFCHR | S_IRUSR | S_IWUSR, &key14_irq_fops, NULL);
    PRINTK("add dev file to devfs OK!\n");
#endif
    return 0;
}

static void __exit myModule_exit(void)
{
    /* Module exit code */
    PRINTK("myModule_exit\n");
    /* Driver unregister */
   
    unregister_irqsrv();
   
    if(key14_irq_Marjor > 0)
    {
#ifdef CONFIG_DEVFS_FS
        devfs_unregister(devfs_gpfDriver_raw);
        devfs_unregister(devfs_gpfDriver_dir);
#endif
        unregister_chrdev(key14_irq_Marjor, DRIVER_NAME);
    }
    return;
}

MODULE_AUTHOR("dengwei");
MODULE_LICENSE("Dual BSD/GPL");
module_init(myModule_init);
module_exit(myModule_exit);
//==================Makefile================================================
OUTPUT = key14_irq.o
OUTPUT_DIR = output

KERNEL = /home/dengwei/driver_test/kernel_2.4.18
CROSSPREFIX = /usr/local/arm/2.95.3/bin/arm-linux-
CFLAGS = -Wall -I$(KERNEL)/include -c -DDEBUG
#CFLAGS += -DEXPORT_SYMTAB -DMODVERSIONS -include $(KERNEL)/include/linux/modversions.h

DEST = $(foreach fn, $(OUTPUT), $(OUTPUT_DIR)/$(fn))
ECHO_OK = echo -e "\x1b[40G\x1b[34m[   OK   ]\x1b[0m"
ECHO_FAILED = echo -e "\x1b[40G\x1b[31m[ FAILED ]\x1b[0m"


all: $(OUTPUT_DIR) $(OUTPUT_DIR)/$(OUTPUT)

$(OUTPUT_DIR):
    @mkdir $@
    @chmod 777 -R $@

$(OUTPUT_DIR)/%.o: %.c
    @echo -n "Compling $^..."
    @if $(CROSSPREFIX)gcc $(CFLAGS) $^ -o $@; then $(ECHO_OK); else $(ECHO_FAILED); fi

clean:
    @find . \( -name '*.[oas]' -o -name install.sh \) -type f -print | xargs rm -f
    @echo "Cleaned!"
//=================test.c==================================================
#include
#include
#include
#include


int main()
{
    int i;
    int gpg_key;
    char key;
   
    gpg_key= open("/dev/key14_irq/0", O_RDWR);

    printf("gpg_key=%d\n",gpg_key);
    while(1)
    {   
        read(gpg_key,&key,1);
        printf("the key is %d\n",key );
       
    }
}