Linux下的旋钮驱动

 先看一次正旋和反旋波形上差异

 

可以看出两个波形慢了一个相位，如图中，判断正反旋的一种方法如下
绿色信号线下降开始监听黄色的信号线的状态，如果是下降沿，判断为正旋，如果是上升沿，判断为反旋，绿色信号线上升结束一次监听 

      正旋输出

    

      反旋输出

 

#include<linux/module.h>
#include<linux/gpio.h>
#include<linux/input.h>
#include <linux/interrupt.h>
#include<linux/platform_device.h>
#define knod1_pin  76  //gpio引脚号
#define knod2_pin  124  //gpio引脚号
int knod1_irq;
int knod2_irq;
int knod_start;
struct input_dev *input_dev;

static irqreturn_t knod1_irq_hander(int irq, void *dev_id)
{
	int state;
	state = gpio_get_value(knod1_pin);
	if (!state){  //下降沿
		knod_start=1;
	}else{		 //下降沿
		knod_start=0;
	}

	return IRQ_HANDLED;
}

static irqreturn_t knod2_irq_hander(int irq, void *dev_id)
{
	int state;
	state = gpio_get_value(knod2_pin);
	if (knod_start&&state) {  //下降沿
		input_report_key(input_dev, KEY_VOLUMEUP, 1);
		input_sync(input_dev);
		input_report_key(input_dev, KEY_VOLUMEUP, 0);
		input_sync(input_dev);
	}
	if (knod_start&&(!state)){
		input_report_key(input_dev, KEY_VOLUMEDOWN, 1);
		input_sync(input_dev);
		input_report_key(input_dev, KEY_VOLUMEDOWN, 0);
		input_sync(input_dev);
	}
	return IRQ_HANDLED;
}

void request_knod_irq(void)
{
	int ret;
	ret = gpio_request(knod1_pin, "knod1_pin");
	if (ret < 0){
		printk("request pin %d err!\n", knod1_pin);
		return;
	}
	ret = gpio_request(knod2_pin, "knod2_pin");
	if (ret < 0){
        printk("request pin %d err!", knod1_pin);
		return;
	}
	knod1_irq = gpio_to_irq(knod1_pin);
	knod2_irq = gpio_to_irq(knod2_pin);
	ret =request_irq(knod1_irq, knod1_irq_hander ,IRQ_TYPE_EDGE_BOTH, "knod1_irq",(void *)knod1_pin);
	if (ret < 0){
		printk("request irq %d err!\n", knod1_pin);
		return;
	}
	ret =request_irq(knod2_irq, knod2_irq_hander ,IRQ_TYPE_EDGE_BOTH, "knod2_irq", (void *)knod2_pin);
	if (ret < 0){
		printk("request irq %d err!\n", knod2_pin);
		return;
	}
}

int register_knod_input_device(void)
{
	int ret;
	input_dev = input_allocate_device();
	if (!input_dev){
		printk("failed to allocate input device err!\n");
		return -1;
	}
	input_dev->name = "knod";
	set_bit(EV_KEY, input_dev->evbit);
	set_bit(KEY_VOLUMEUP, input_dev->keybit);
	set_bit(KEY_VOLUMEDOWN, input_dev->keybit);
	ret = input_register_device(input_dev);
	if (ret){
		printk("faild to register input device!\n");
		input_free_device(input_dev);
		return -1;
	}
	return 0;
}

static void knod_release(struct device *dev)
{
	return;
}

static int knod_probe(struct platform_device *pdev)
{
	printk("%s\n", __FUNCTION__);
	pdev->dev.release = knod_release,
	request_knod_irq();
	register_knod_input_device();
	return 0;
}

static int knod_remove(struct platform_device *pdev)
{
	free_irq(knod1_irq, (void *)knod1_pin);
	free_irq(knod2_irq, (void *)knod2_pin);
	gpio_free(knod1_pin);
	gpio_free(knod2_pin);
	input_unregister_device(input_dev);
	return 0;
}

static struct platform_driver knod_driver = {
	.driver = {	
				.name = "knod",
                .owner =THIS_MODULE,
              },
	.probe  = knod_probe,
	.remove = knod_remove,
};

static struct platform_device knod_device = {
	.name = "knod",
};

static int knod_init(void)
{
	printk(KERN_INFO "knod_init!\n");
	platform_device_register(&knod_device);
	return platform_driver_register(&knod_driver);
}

static void knod_exit(void)
{
	printk(KERN_INFO "knod_exit!\n");
	platform_driver_unregister(&knod_driver);
	platform_device_unregister(&knod_device);
} 

module_init(knod_init);
module_exit(knod_exit);
MODULE_LICENSE("GPL v2");