imx6ul wiegand driver (linux-3.14)

//驱动代码

/*

* 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.

*/



#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/fs.h>

#include <linux/init.h>

#include <linux/delay.h>

#include <linux/poll.h>

#include <linux/irq.h>

#include <asm/irq.h>

#include <linux/interrupt.h>

#include <asm/uaccess.h>

#include <linux/platform_device.h>

#include <linux/cdev.h>

#include <linux/miscdevice.h>

#include <linux/sched.h>

#include <linux/gpio.h>



#include <linux/time.h>

#include <linux/jiffies.h>

#include <linux/slab.h> //klocall()

#include <asm/param.h> //HZ



#include <asm/uaccess.h>

#include </home/fo/DevSetting/Linux/src/kernel/linux-3.14.38/arch/arm/mach-imx/hardware.h>

#include </home/fo/DevSetting/Linux/src/kernel/linux-3.14.38/arch/arm/mach-imx/iomux-v3.h> //mxc_iomux_v3_setup_pad



#define DEVICE_NAME     "WiegandCH0"



#define OK                 0x05

#define STATE             0x00

#define KEY_TIMER_DELAY     (2*HZ/100)



#define WD1_D0_INT_PIN         IMX_GPIO_NR(4, 22)

#define WD1_D0_INT             gpio_to_irq(WD1_D0_INT_PIN)



#define WD1_D1_INT_PIN         IMX_GPIO_NR(4, 21)

#define WD1_D1_INT             gpio_to_irq(WD1_D1_INT_PIN)





int TIMING1 = 0;

int TIMING2 = 0;

int rf_openflag = 0;





struct wiegand_dev

{

    char wiegand[128]; //Wiegand Data 26Bits

    int global_var; //Global Counter

    struct timer_list RFCD_timer;

};





static struct wiegand_dev *rf_card;



static DECLARE_WAIT_QUEUE_HEAD(button_waitq);



static volatile int ev_press = 0;

static volatile int save_count=0;

static volatile int Delay_count=0;



static char convert_data(void)

{

    int i;

    if(rf_card->wiegand[0] == '0' && rf_card->wiegand[25] == '1') //Parity Check OK

    {

     for(i = 1;i <= 8;i++);



     for(i = 9;i<= 24;i++);

    }

    printk("Parity Efficacy Error!\n");

    return -1;

}









static void RFCD_timer_handler(unsigned long arg)

{

   //printk("Debug #3\n");

    //convert_data();



   if(rf_card-> save_count)

       {

     //up(&rf_card->sem);

    save_count = rf_card->global_var;

    Delay_count = 0;

     }

  else

    {

    Delay_count++;

    }



 if(Delay_count==3 && rf_card->global_var>0)

   {

    ev_press = 1;

    wake_up_interruptible(&button_waitq);

    }



  rf_card->RFCD_timer.expires = jiffies + KEY_TIMER_DELAY;

  add_timer(&rf_card->RFCD_timer);

}





static irqreturn_t jonhu_rfcd_irqhandler0(int irq, void *dev_id)

{



    udelay(20);



    if(gpio_get_value_cansleep(WD1_D0_INT_PIN)==0)

       {

            rf_card->wiegand[rf_card->global_var] = '0';

            rf_card->global_var = rf_card->global_var + 1;

    }

    udelay(500);

    return IRQ_RETVAL(IRQ_HANDLED);

}



static irqreturn_t jonhu_rfcd_irqhandler1(int irq, void *dev_id)

{

    udelay(20);


       if(gpio_get_value_cansleep(WD1_D1_INT_PIN)==0)

       {

    rf_card->wiegand[rf_card->global_var] = '1';

    rf_card->global_var = rf_card->global_var + 1;

    //printk("Debug #2\n");

    }

   udelay(500);

   return IRQ_RETVAL(IRQ_HANDLED);



}





static ssize_t jonhu_rfcd_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)

{

  // printk("Debug #5\n");

  if (!ev_press)

    {

    if (filp->f_flags & O_NONBLOCK)

        return -EAGAIN;

    else

        wait_event_interruptible(button_waitq, ev_press);

    }

   ev_press = 0;



   printk("Debug #6,Size:%d,global_var:%d\n",size,rf_card->global_var);

  if (size >= rf_card->global_var)

        size = rf_card->global_var;

   rf_card->global_var = 0;

   copy_to_user(buf, rf_card->wiegand, size);

   return size;



    //return 0;

}



static ssize_t jonhu_rfcd_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)

{

    return 0;

}



static int jonhu_request_irqs(void)

{

    int iRet;



        printk("WD_D0 GPIO NUMBER = %d\n", WD1_D0_INT_PIN);

    iRet = gpio_request(WD1_D0_INT_PIN, "WD1_D0_IN");

    if(iRet)

    {

     printk("Get button Failed!\n");



}

        printk("WD_D0 irq = %d\n", WD1_D0_INT);





        int ret = request_irq(WD1_D0_INT, jonhu_rfcd_irqhandler0,IRQF_TRIGGER_FALLING, "WD1_D0_INT", NULL);



    if (ret)

    {

          printk("request WD1_D0_INT failed!\n");

      return ret;

    }



        printk("WD_D1 GPIO NUMBER = %d\n", WD1_D1_INT_PIN);

        //mxc_iomux_v3_setup_pad(MX6UL_PAD_CSI_DATA01__GPIO4_IO21); //configures a single pad in the iomuxer

    gpio_request(WD1_D1_INT_PIN, "WD1_D1_IN");



    printk("WD_D1 irq = %u\n", WD1_D1_INT);







       ret = request_irq(WD1_D1_INT, jonhu_rfcd_irqhandler1,IRQF_TRIGGER_FALLING, "WD1_D1_INT", NULL);



    if (ret)

    {

          //free_irq(WD1_D0_INT, NULL);

          printk("request WD1_D1_INT failed!\n");

      return ret;

    }

    printk("request succ!\n");



    return 0;

}





static void jonhu_free_irqs(void)

{

    free_irq(WD1_D0_INT, NULL);

    free_irq(WD1_D1_INT, NULL);

}



static int jonhu_rfcd_open(struct inode *inode, struct file *filp)

{

   if ( rf_openflag )

      return -EBUSY;



   rf_openflag = 1;

   TIMING1 = 0;

   TIMING2 = 0;



    printk("request irq\n");

   if(jonhu_request_irqs()<0)

        {

              printk("request  irq failed!\n");

        jonhu_free_irqs();

        return -EBUSY;

        }

   //memset(&tmr,0,sizeof(struct timer_list));

   setup_timer(&rf_card->RFCD_timer,RFCD_timer_handler,0);

   rf_card->RFCD_timer.expires = jiffies + KEY_TIMER_DELAY;

   add_timer(&rf_card->RFCD_timer);

   rf_card->global_var = 0;

   return 0;

}







int jonhu_rfcd_release(struct inode *inode, struct file *filp)

{

    sewo_free_irqs();

    rf_openflag = 0;

    del_timer_sync(&rf_card->RFCD_timer);

    return 0;

}



static unsigned int jonhu_rfcd_poll( struct file *file, struct poll_table_struct *wait)

{

    unsigned int mask = 0;

    poll_wait(file, &button_waitq, wait);

    if (ev_press)

        mask |= POLLIN | POLLRDNORM;

    return mask;

}



static struct file_operations jonhu_rfcd_fops =

{

    .owner = THIS_MODULE,

    .read = jonhu_rfcd_read,

    .write = jonhu_rfcd_write,

    .poll = jonhu_rfcd_poll,

    .open = jonhu_rfcd_open,

    .release = jonhu_rfcd_release,

};



static struct miscdevice misc = {

    .minor = MISC_DYNAMIC_MINOR,

    .name = DEVICE_NAME,

    .fops = &jonhu_rfcd_fops,

};





static int __init jonhu_wiegand_init(void)

{

    int result;

        printk("ins mode start..\n");

    result = misc_register(&misc);

    if(result < 0)

       return result;



    rf_card = kmalloc(sizeof(struct wiegand_dev),GFP_KERNEL);

    if (!rf_card)

    {

          result = -ENOMEM;

           goto fail_malloc;

    }



    memset(rf_card,0,sizeof(struct wiegand_dev));

    //init_MUTEX_LOCKED(&rf_card->sem);

        printk("ins mode sucee..\n");

    return 0;



    fail_malloc:

          misc_deregister(&misc);

    return result;

}



static void __exit jonhu_wiegand_exit(void)

{

    printk("ext mode start..\n");

    kfree(rf_card);

    misc_deregister(&misc);

}



module_init(jonhu_wiegand_init);

module_exit(jonhu_wiegand_exit);



MODULE_AUTHOR("Jon.Hu");

MODULE_DESCRIPTION("Weigand character driver");

MODULE_LICENSE("GPL");

//makefile

CROSS_COMPILE=arm-linux-

ARCH:=arm

CC:=$(CROSS_COMPILE)gcc

LD:=$(CROSS_COMPILE)ld

obj-m = WiegandCH0.o

module-objs = WiegandCH0.o

KDIR = /home/fo/DevSetting/Linux/src/kernel/linux-3.14.38

PWD = $(shell pwd)

default:

$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules

clean:

rm -rf  *.o *.ko