Linux旋钮驱动调试(安卓)

最新推荐文章于 2024-09-13 02:45:00 发布
最新推荐文章于 2024-09-13 02:45:00 发布
阅读量965 收藏 3
点赞数
文章标签： 安卓 android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43527775/article/details/118094215
版权
本文详细介绍了在Linux环境下，针对安卓平台如何进行旋钮驱动的开发与调试。首先阐述了旋钮的特性，即通过检测电平变化来判断旋钮的正反旋转。接着，展示了驱动程序的编写，包括初始化、中断处理函数以及GPIO配置。在设备树部分，讲解了如何配置旋钮GPIO属性。然后，提到了使用`getevent`工具进行input事件调试的方法。最后，文章给出了驱动的改进版，引入了线程处理旋钮事件，提高了响应的稳定性。
摘要由CSDN通过智能技术生成

Linux旋钮驱动调试(安卓)

一、旋钮特性

旋钮转动时会有相位差，我们只需要根据这个特点去判断是正旋还是反旋做出相应的操作即可：
正旋输出两次时：
在这里插入图片描述
反旋输出两次时：
在这里插入图片描述
由上图可以发现，判断正反旋其实很简单。判断哪个引脚先出现电平变化即可。

二、驱动编写

#include<linux/init.h>
#include<linux/kernel.h>
#include<linux/module.h>
#include <linux/delay.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/irq.h>
#include <linux/of_gpio.h>
#include <linux/interrupt.h>
#include <linux/input.h>
#include <linux/platform_device.h>

#define TAG    "knod"

#define pr_info(fmt, arg...) printk(KERN_ERR fmt, ##arg)
#define DEBUG_ON    1

#define DEBUG(fmt, arg...)          do {\
					if (DEBUG_ON)\
						pr_info("<<-DEBUG->> [%d]"fmt"\n", __LINE__, ##arg);\
			} while (0)
				
#define PIN_MAX 4

int knod_pin[PIN_MAX] = {0};
int knod_start[PIN_MAX/2] = {-1};
int knod_key_events[PIN_MAX] = {KEY_VOLUMEDOWN,KEY_VOLUMEUP,KEY_VOLUMEDOWN,KEY_VOLUMEUP};
/*业务需求需要两个旋钮*/

struct input_dev *input_dev;	

static int input_dev_init(struct platform_device *pdev)
{
	int ret = 0;
	int i = 0;
	
	input_dev = input_allocate_device();
	if (!input_dev)
	{
		input_free_device(input_dev);
		return -ENOMEM;
	}

	input_dev->name = "knod";
	input_dev->dev.parent = &pdev->dev;
	input_dev->id.bustype = BUS_HOST;
	input_dev->id.vendor = 0x0001;
	input_dev->id.product = 0x0001;
	input_dev->id.version = 0x0100;

	set_bit(EV_KEY, input_dev->evbit);
	
	for(i = 0; i < PIN_MAX; i ++)
		__set_bit(knod_key_events[i] & KEY_MAX, input_dev->keybit);
	
	input_set_drvdata(input_dev,pdev);

	/*register device*/
	ret = input_register_device(input_dev);
	if (ret < 0) 
	{
		input_free_device(input_dev);
		DEBUG("##@@input register failed.ret=%d\n",ret);
		return ret;
	}

	DEBUG("##@@input register ok.\n");

	return 0;
}

irqreturn_t knod1_handler(int irq,void *date)
{

	if (!(gpio_get_value(knod_pin[0])))
		knod_start[0] = 1;
	else	
		knod_start[0] = 0;
	
	return IRQ_HANDLED;
}

irqreturn_t knod2_handler(int irq,void *date)
{
	int state;
	
	state = gpio_get_value(knod_pin[1]);
	
	if ((knod_start[0]) == (state)) 
	{ 
		input_report_key(input_dev, knod_key_events[0], 1);
		input_sync(input_dev);
		input_report_key(input_dev, knod_key_events[0], 0);
		input_sync(input_dev);
	}
	
	if ((knod_start[0]) == (!state))
	{
		input_report_key(input_dev, knod_key_events[1], 1);
		input_sync(input_dev);
		input_report_key(input_dev, knod_key_events[1], 0);
		input_sync(input_dev);
	}
	return IRQ_HANDLED;
}

irqreturn_t knod3_handler(int irq,void *date)
{
	if (!(gpio_get_value(knod_pin[2])))
		knod_start[1] = 1;
	else
		knod_start[1] = 0;
	
	return IRQ_HANDLED;
}

irqreturn_t knod4_handler(int irq,void *date)
{
	int state;
	
	state = gpio_get_value(knod_pin[3]);
	
	if ((knod_start[1]) == (state)) 
	{ 
		input_report_key(input_dev, knod_key_events[2], 1);
		input_sync(input_dev);
		input_report_key(input_dev, knod_key_events[2], 0);
		input_sync(input_dev);
	}
	
	if ((knod_start[1]) == (!state))
	{
		input_report_key(input_dev, knod_key_events[3], 1);
		input_sync(input_dev);
		input_report_key(input_dev, knod_key_events[3], 0);
		input_sync(input_dev);
	}
	
	return IRQ_HANDLED;
}



static int irq_gpio_init(void)
{
	int i = 0;
	int ret = -1;
	int irq[PIN_MAX ] = {-1};
	
	char *knod_named[PIN_MAX] = {"knob_1_gpio1","knob_1_gpio2","knob_2_gpio1","knob_2_gpio2"};
	char *request_knod_named[PIN_MAX] = {"1_knod_pin","2_knod_pin","3_knod_pin","4_knod_pin"};
	char *knod_irq_name[PIN_MAX] = {"knod-1","knod-2","knod-3","knod-4"};

	irqreturn_t (*knod_handler[PIN_MAX])(int irq,void *date);
	static struct device_node *knod_node = NULL;
	
	
	knod_node = of_find_compatible_node(NULL, NULL, "xxxx, knod");
	if(knod_node == NULL)
	{
		DEBUG("@@of_find_compatible_node_fail !!!\n");
		goto of_find_compatible_node_fail;
	}

	knod_handler[0] = knod1_handler;
	knod_handler[1] = knod2_handler;
	knod_handler[2] = knod3_handler;
	knod_handler[3] = knod4_handler;
	
	
	for(i = 0; i < PIN_MAX;i ++)
	{
		knod_pin[i] =  of_get_named_gpio(knod_node,knod_named[i], 0);
		if (!gpio_is_valid(knod_pin[i])) 
		{
			DEBUG("@@of_get_named_gpio_fail !!!,knod_pin[%d] = %d\n",i,knod_pin[i]);
			goto of_get_named_gpio_fail;
		}
	
		gpio_free(knod_pin[i]);
		ret = gpio_request(knod_pin[i], request_knod_named[i]);
		if (ret < 0) 
		{
			DEBUG("@@gpio_request_fail !!!,button_pin[%d] = %d\n",i,knod_pin[i]);
			goto gpio_request_fail;
		}
		
		gpio_direction_input(knod_pin[i]);
			
		irq[i] = gpio_to_irq(knod_pin[i]);
		if(irq[i] < 0)
		{
			DEBUG("@@request irq is failed !!!,irq[%d] = %d\n",i,irq[i]);
			goto gpio_to_irq_fail;
		}
		
		ret = request_irq(irq[i], 
						knod_handler[i],
						IRQ_TYPE_EDGE_BOTH,
						knod_irq_name[i],
						NULL);
		if(ret != 0)
		{
			DEBUG("@@@request_irq_fail !!! ret=%d,irq[%d]=%d\n",ret,i,irq[i]);
			goto request_irq_fail;
		}
		
		DEBUG("@@refunction irq ret = %d,request_irq suc = %s\n",ret,request_knod_named[i]);		
	}

	return 0;

	
request_irq_fail:	
gpio_to_irq_fail:
gpio_request_fail:
	while(--i > -1)
		gpio_free(knod_pin[i]);	
of_get_named_gpio_fail:
of_find_compatible_node_fail:
	return ret;
	
}

static int knod_probe(struct platform_device *pdev)
{
	int ret = 0,i;
	
	DEBUG("knod_probe\n");
	
	ret = irq_gpio_init();
	if(ret != 0)
	{
		DEBUG("irq_gpio_init error\n");
		return ret;
	}

	ret = input_dev_init(pdev);
	if(ret != 0)
	{
		DEBUG("input_dev_init error\n");
		goto input_dev_init_error;
	}
	
	return 0;
	
input_dev_init_error:
	for(i = 0; i < PIN_MAX; i++ )
		gpio_free(knod_pin[i]);	
	
	return ret;	
}

static int knod_remove(struct platform_device *pdev)
{
	int i = 0;
	
	input_free_device(input_dev);	
	
	for(i = 0; i < PIN_MAX; i++ )
		gpio_free(knod_pin[i]);
	
	return 0;
}

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

static struct platform_device knod_device = {
    .name = "knod-dev",
    .id = -1,
};  

static int __init knod_init(void)
{
	int ret = -1;
	
	DEBUG("knod_init\n");
	
	ret = platform_device_register(&knod_device);
	if (ret) 
	{
		DEBUG("platform_device_register_failed ");
		goto platform_device_register_failed;
	}

	ret = platform_driver_register(&knod_driver);
    	if (ret) 
	{
       		DEBUG("platform_driver_register_failed ");
       		goto platform_driver_register_failed;
    }
	
	return 0;
	
platform_driver_register_failed:
	platform_device_unregister(&knod_device);
platform_device_register_failed:
	return ret;	
	
}

static void __exit knod_exit(void)
{
	DEBUG("knod exit\r\n");
	platform_driver_unregister(&knod_driver);
	platform_device_unregister(&knod_device);
}

module_init(knod_init);
module_exit(knod_exit);

MODULE_LICENSE("GPL");

三、GPIO配置(设备树)

1、dtsi配置节点属性

		knod: knod{
			compatible = "xxxx, knod";/*与驱动相对应*/
		};

2、dts配置gpio属性

&knod{
	knob_1_gpio1 = <&pio0 77 0>;
	knob_1_gpio2 = <&pio0 78 0>;
	knob_2_gpio1 = <&pio0 73 0>;
	knob_2_gpio2 = <&pio0 74 0>;
	interrupt-parent = <&pio0>;/*对应的gpio0中断控制器*/
	interrupts = <120 IRQ_TYPE_EDGE_BOTH>,<121 IRQ_TYPE_EDGE_BOTH>,<116 IRQ_TYPE_EDGE_BOTH>,<117 IRQ_TYPE_EDGE_BOTH>;/*对应的gpio中断号，中断触发方式(上下沿)*/
	status = "okay";
};

四、input事件调试

检查是否上报用getevent查看就足够了，想要了解具体的上报流程可以参考以下网址：
Android input键值从底层到应用层映射流程与修改方法

五、驱动改进版

#include<linux/init.h>
#include<linux/kernel.h>
#include<linux/module.h>
#include <linux/delay.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/irq.h>
#include <linux/of_gpio.h>
#include <linux/interrupt.h>
#include <linux/input.h>
#include <linux/platform_device.h>
#include <linux/sched.h>  
#include <linux/kthread.h> 
#include <linux/slab.h>


#define TAG    "knod"

#define pr_info(fmt, arg...) printk(KERN_ERR fmt, ##arg)
#define GPIO_DEBUG_ON    1
#define GPIO_DEBUG(fmt, arg...)          do {\

					if (GPIO_DEBUG_ON)\

						pr_info("<<-DEBUG->> [%d]"fmt"\n", __LINE__, ##arg);\

			} while (0)


#define PIN_MAX 4

#define KEY_AIR_CONDITION_UP   763
#define KEY_AIR_CONDITION_DOWN 764

#define KNOD1_RIGHT	1
#define KNOD1_LEFT	2
#define KNOD2_RIGHT	3
#define KNOD2_LEFT	4

#define KNOD1_ID 0
#define KNOD2_ID 1

#define KNOD_PIN1 0
#define KNOD_PIN2 1

#define KNOD_THREAD_STOP 0
#define KNOD_THREAD_RUN  1

#define KNOD_KEY_DOWN 1
#define KNOD_KEY_UP   0

#define KNOD_NAMED {\
"knob_1_gpio1","knob_1_gpio2",\
"knob_2_gpio1","knob_2_gpio2",\
}

#define REQUEST_KNOD_NAMED {\
"1_knod_pin","2_knod_pin",\
"3_knod_pin","4_knod_pin",\
}

#define KNOD_IRQ_NAME {\
"knod-1","knod-2",\
"knod-3","knod-4",\
}

#define KNOD_KEY_EVENTS {\
KEY_AIR_CONDITION_DOWN,KEY_AIR_CONDITION_UP,\
KEY_VOLUMEDOWN,KEY_VOLUMEUP,\
}

#define KNOD_SENSITIVITY  20

struct knod_info
{
	u8 knod_start;
	
	s32 irq[2];
	s32 knod_right_count;
	s32 knod_left_count;
	u32 knod_pin[2];
	u32 knod_key_events[2];
};

struct knod_struct
{
	u8 knod_status;
	u8 thread_flage;
	
	spinlock_t irq_lock;
	
	struct input_dev *input_dev;	
	struct task_struct *knod_input_task;
	struct completion origin_completion;
	struct knod_info knod[PIN_MAX/2];
};

struct knod_struct *knod;

void input_knod_event(u32 knod_id,u32 knod_pin)
{
#if 0
	s32 count = 0;

	if(knod_pin == KNOD_PIN2)
		count = knod->knod[knod_id].knod_right_count;
	else
		count = knod->knod[knod_id].knod_left_count;

	GPIO_DEBUG("@@count = %d\n",count);

	while(count > 0)
	{
		if(1)	
		{

		}	

		--count;
	}
#endif
	input_report_key(knod->input_dev, knod->knod[knod_id].knod_key_events[knod_pin], KNOD_KEY_DOWN);
	input_sync(knod->input_dev);
	input_report_key(knod->input_dev, knod->knod[knod_id].knod_key_events[knod_pin], KNOD_KEY_UP);
	input_sync(knod->input_dev);
	
}

int knod_input_thread(void *data)
{
	u32 i = 0;
	
	while(1)
	{
		//GPIO_DEBUG("@@knod_input_thread knod->knod_status = %d,knod->thread_flage = %d\n",knod->knod_status,knod->thread_flage);
		if(knod->knod_status == 0)
		{
			wait_for_completion(&knod->origin_completion);
		}

		msleep(10);//Filter the fast rotation within 10ms

		switch(knod->knod_status)
		{
			case KNOD1_RIGHT:	
				input_knod_event(KNOD1_ID,KNOD_PIN2);break;

			case KNOD1_LEFT:
				input_knod_event(KNOD1_ID,KNOD_PIN1);break;

			case KNOD2_RIGHT:
				input_knod_event(KNOD2_ID,KNOD_PIN2);break;
			
			case KNOD2_LEFT:
				input_knod_event(KNOD2_ID,KNOD_PIN1);break;

			default:break;
		}

		for(i = 0;i < (PIN_MAX/2);i ++)
		{
			knod->knod[i].knod_left_count = 0;
			knod->knod[i].knod_right_count = 0;			
		}

		knod->thread_flage = KNOD_THREAD_STOP;	
		wait_for_completion(&knod->origin_completion);
	}
	return 0;
}

static int input_dev_init(struct platform_device *pdev)
{
	int ret = 0;
	int i = 0,j = 0;
	
	knod->input_dev = input_allocate_device();
	if (!knod->input_dev)
	{
		input_free_device(knod->input_dev);
		return -ENOMEM;
	}

	knod->input_dev->name = "knod";
	knod->input_dev->dev.parent = &pdev->dev;
	knod->input_dev->id.bustype = BUS_HOST;
	knod->input_dev->id.vendor = 0x0001;
	knod->input_dev->id.product = 0x0001;
	knod->input_dev->id.version = 0x0100;

	set_bit(EV_KEY, knod->input_dev->evbit);
	
	for(i = 0; i < (PIN_MAX/2); i ++)
		for(j = 0; j < 2;j ++)
			__set_bit(knod->knod[i].knod_key_events[j] & KEY_MAX, knod->input_dev->keybit);
	
	input_set_drvdata(knod->input_dev,pdev);

	/*register device*/
	ret = input_register_device(knod->input_dev);
	if (ret < 0) 
	{
		input_free_device(knod->input_dev);
		GPIO_DEBUG("##@@input register failed.ret=%d\n",ret);
		return ret;
	}

	GPIO_DEBUG("##@@input register ok.\n");

	return 0;
}

void knod_count(u32 knod_id,u32 knod_pin)
{
	u8 state;


	if(knod_pin == KNOD_PIN1)
	{
		if (!(gpio_get_value(knod->knod[knod_id].knod_pin[knod_pin])))
			knod->knod[knod_id].knod_start = 1;
		else	
			knod->knod[knod_id].knod_start = 0;
	}
	else if(knod_pin == KNOD_PIN2)
	{
		state = gpio_get_value(knod->knod[knod_id].knod_pin[knod_pin]);	
	
		if ((knod->knod[knod_id].knod_start) == (state)) 
		{ 
			if(knod_id == KNOD1_ID)
				knod->knod_status = KNOD1_LEFT;
			else 
				knod->knod_status = KNOD2_LEFT;

			++(knod->knod[knod_id].knod_left_count);
			GPIO_DEBUG("knod->knod[%d].knod_left_count=%d!!!\n",knod_id,knod->knod[knod_id].knod_left_count);
		}
	
		if ((knod->knod[knod_id].knod_start) == (!state))
		{
			if(knod_id == KNOD1_ID)
				knod->knod_status = KNOD1_RIGHT;
			else 
				knod->knod_status = KNOD2_RIGHT;

			++(knod->knod[knod_id].knod_right_count);
			GPIO_DEBUG("knod->knod[%d].knod_right_count=%d!!!\n",knod_id,knod->knod[knod_id].knod_right_count);
		}

		if(knod->thread_flage == KNOD_THREAD_STOP)	
		{
			complete(&knod->origin_completion);
			knod->thread_flage = KNOD_THREAD_RUN;
		}
	}
	else
	{
		GPIO_DEBUG("knod_pin error\n");
	}

}


irqreturn_t knod1_handler(int irq,void *date)
{
	unsigned long irqflags = 0;

	spin_lock_irqsave(&knod->irq_lock, irqflags);//prevent irq from nesting

	knod_count(KNOD1_ID,KNOD_PIN1);

	spin_unlock_irqrestore(&knod->irq_lock, irqflags);
	
	return IRQ_HANDLED;
}

irqreturn_t knod2_handler(int irq,void *date)
{
	unsigned long irqflags = 0;	

	spin_lock_irqsave(&knod->irq_lock, irqflags);//prevent irq from nesting

	knod_count(KNOD1_ID,KNOD_PIN2);

	spin_unlock_irqrestore(&knod->irq_lock, irqflags);

	return IRQ_HANDLED;
}

irqreturn_t knod3_handler(int irq,void *date)
{
	unsigned long irqflags = 0;

	spin_lock_irqsave(&knod->irq_lock, irqflags);//prevent irq from nesting

	knod_count(KNOD2_ID,KNOD_PIN1);

	spin_unlock_irqrestore(&knod->irq_lock, irqflags);	

	return IRQ_HANDLED;
}

irqreturn_t knod4_handler(int irq,void *date)
{
	unsigned long irqflags = 0;

	spin_lock_irqsave(&knod->irq_lock, irqflags);//prevent irq from nesting

	knod_count(KNOD2_ID,KNOD_PIN2);
	
	spin_unlock_irqrestore(&knod->irq_lock, irqflags);
	
	return IRQ_HANDLED;
}



static int irq_gpio_init(void)
{
	u32 i = 0,j = 0,count = 0;
	u32 ret = -1;

	u8 *knod_named[PIN_MAX] = KNOD_NAMED;
	u8 *request_knod_named[PIN_MAX] = REQUEST_KNOD_NAMED;
	u8 *knod_irq_name[PIN_MAX] = KNOD_IRQ_NAME;
	u32 knod_key_events[PIN_MAX] = KNOD_KEY_EVENTS;

	irqreturn_t (*knod_handler[PIN_MAX])(int irq,void *date);

	static struct device_node *knod_node = NULL;
	
	
	knod_node = of_find_compatible_node(NULL, NULL, "audio, knod");
	if(knod_node == NULL)
	{
		GPIO_DEBUG("@@of_find_compatible_node_fail !!!\n");
		goto of_find_compatible_node_fail;
	}


	knod = (struct knod_struct *)kmalloc( sizeof(struct knod_struct),GFP_KERNEL);
    	if (knod == NULL)
    	{
       		ret = -ENOMEM;
        	GPIO_DEBUG("[knob]:kmalloc err\n");
        	goto kmalloc_error;
    	}

	memset(knod,0,sizeof(struct knod_struct));

	knod_handler[0] = knod1_handler;
	knod_handler[1] = knod2_handler;
	knod_handler[2] = knod3_handler;
	knod_handler[3] = knod4_handler;
	

	for(i = 0,count = 0; i < (PIN_MAX/2) && count < PIN_MAX;i ++)
	{
		for(j = 0; j < 2;j ++,count++)
		{
			knod->knod[i].knod_pin[j] = of_get_named_gpio(knod_node,knod_named[count],0);
			if (!gpio_is_valid(knod->knod[i].knod_pin[j])) 
			{
				GPIO_DEBUG("@@of_get_named_gpio_fail !!!,knod->knod[%d]->knod_pin[%d] = %d\n",i,j,knod->knod[i].knod_pin[j]);
				goto of_get_named_gpio_fail;
			}
			
			gpio_free(knod->knod[i].knod_pin[j]);
			ret = gpio_request(knod->knod[i].knod_pin[j], request_knod_named[count]);
			if (ret < 0) 
			{
				GPIO_DEBUG("@@of_get_named_gpio_fail !!!,knod->knod[%d]->knod_pin[%d] = %d\n",i,j,knod->knod[i].knod_pin[j]);
				goto gpio_request_fail;
			}
		
			knod->knod[i].irq[j] = gpio_to_irq(knod->knod[i].knod_pin[j]);
			if(knod->knod[i].irq[j] < 0)
			{
				GPIO_DEBUG("@@request irq is failed !!!,knod->knod[%d]->irq[%d]  = %d\n",i,j,knod->knod[i].irq[j]);
				goto gpio_to_irq_fail;
			}	

			ret = request_irq(knod->knod[i].irq[j], 
						knod_handler[count],
						IRQ_TYPE_EDGE_BOTH,
						knod_irq_name[count],
						NULL);
			if(ret != 0)
			{
				GPIO_DEBUG("@@request irq is failed !!!,ret =%d,knod->knod[%d]->irq[%d]  = %d\n",ret,i,j,knod->knod[i].irq[j]);
				goto request_irq_fail;
			}
		
			GPIO_DEBUG("@@refunction irq ret = %d,request_irq suc = %s\n",ret,request_knod_named[count]);			
			memcpy(&knod->knod[i].knod_key_events[j],&knod_key_events[count],sizeof(knod_key_events[count]));
		}		
	}


	return 0;
	
request_irq_fail:	
gpio_to_irq_fail:
gpio_request_fail:
	for(i = 0; i < (PIN_MAX/2);i ++)
		for(j = 0; j < 2;j ++)
			gpio_free(knod->knod[i].knod_pin[j]);	
of_get_named_gpio_fail:
kmalloc_error:
of_find_compatible_node_fail:
	return ret;	
}

static int knod_probe(struct platform_device *pdev)
{
	int ret = 0,i,j;
	
	GPIO_DEBUG("knod_probe\n");
	
	ret = irq_gpio_init();
	if(ret != 0)
	{
		GPIO_DEBUG("irq_gpio_init error\n");
		goto irq_gpio_init_error;
	}

	init_completion(&knod->origin_completion);

   	knod->knod_input_task = kthread_create(knod_input_thread, NULL, "knod_input_task");
   	if(IS_ERR(knod->knod_input_task))
	{
	     	printk("Unable to start kernel thread.\n");
     		ret = PTR_ERR(knod->knod_input_task);
     		knod->knod_input_task = NULL;

     		goto kthread_create_error;
   	}

	wake_up_process(knod->knod_input_task);

	ret = input_dev_init(pdev);
	if(ret != 0)
	{
		GPIO_DEBUG("input_dev_init error\n");
		goto input_dev_init_error;
	}

	return 0;
	
input_dev_init_error:
kthread_create_error:
	for(i = 0; i < (PIN_MAX/2);i ++)
		for(j = 0; j < 2;j ++)
			gpio_free(knod->knod[i].knod_pin[j]);
irq_gpio_init_error:
	return ret;	
}

static int knod_remove(struct platform_device *pdev)
{
	int i = 0,j = 0;

	kthread_stop(knod->knod_input_task);	

	input_free_device(knod->input_dev);	
	
	for(i = 0; i < (PIN_MAX/2);i ++)
		for(j = 0; j < 2;j ++)
			gpio_free(knod->knod[i].knod_pin[j]);
	
	return 0;
}

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

static struct platform_device knod_device = {
    .name = "knod-dev",
    .id = -1,
};  

static int __init knod_init(void)
{
	int ret = -1;
	
	GPIO_DEBUG("knod_init\n");
	
	ret = platform_device_register(&knod_device);
	if (ret) 
	{
		GPIO_DEBUG("platform_device_register_failed ");
		goto platform_device_register_failed;
	}

	ret = platform_driver_register(&knod_driver);
    	if (ret) 
	{
       		GPIO_DEBUG("platform_driver_register_failed ");
       		goto platform_driver_register_failed;
    	}
	
	return 0;
	
platform_driver_register_failed:
	platform_device_unregister(&knod_device);
platform_device_register_failed:
	return ret;	
	
}

static void __exit knod_exit(void)
{
	GPIO_DEBUG("knod exit\r\n");
	platform_driver_unregister(&knod_driver);
	platform_device_unregister(&knod_device);
}

module_init(knod_init);
module_exit(knod_exit);

MODULE_LICENSE("GPL");
Born to be yours
关注
RK3399平台开发系列讲解（内核驱动外设篇）6.7、旋钮按键的驱动调试
内核笔记
03-25 2692
平台 内核版本 安卓版本 PX3 Linux3.1 Android7.1 文章目录 音量旋钮按键 主芯片连接： struct hqkeys { int keyAction; int gpio; int adc_value; int adc_state; ...
RK3399平台开发系列讲解（系统篇）1.21、百度 CarLife 总结
内核笔记
08-17 2395
在 Linux 上检测 IDE/SATA SSD 硬盘的传输速度 你知道你的硬盘在 Linux 下传输有多快吗？不打开电脑的机箱或者机柜，你知道它运行在 SATA I (150 MB/s) 、 SATA II (300 MB/s) 还是 SATA III (6.0Gb/s) 呢？ 你能够使用 hdparm 和 dd 命令来检测你的硬盘速度。它为各种硬盘的 ioctls 提供了命令行界面，这是由...
android旋转按钮驱动
10-17
android2.3旋转按钮驱动，功能为上，下确认
Linux下的旋钮驱动
Android开发
12-04 3819
先看一次正旋和反旋波形上差异 可以看出两个波形慢了一个相位，如图中，判断正反旋的一种方法如下 绿色信号线下降开始监听黄色的信号线的状态，如果是下降沿，判断为正旋，如果是上升沿，判断为反旋，绿色信号线上升结束一次监听 正旋输出 反旋输出 #include<linux/module.h> #include<li...
十六、（正点原子）Linux自带按键驱动程序
Tofu_Cabbage的博客
07-17 1007
Linux 内核也自带了 KEY 驱动，如果要使用内核自带的 KEY 驱动的话需要配置 Linux 内核，不过 Linux 内核一般默认已经使能了 KEY 驱动，但是我们还是要检查一下。选中以后就会在文件中出现“”这一行， Linux 内核就会根据这一行来将 KEY 驱动文件编译进 Linux 内核。Linux 内核自带的 KEY 驱动文件为采用了驱动框架，在 KEY 驱动上使用了子系统实现。可以看出，这就是一个标准的驱动框架，如果要使用设备树来描述 KEY 设备信息的话，设备节点的属性值要设置为“
嵌入式Linux系统下关于旋钮式编码器的驱动实现
m0_46566693的博客
06-02 569
嵌入式Linux系统下关于旋钮式编码器的驱动实现
Linux按钮驱动
生活，需要你的温暖。
05-05 1517
按钮中断例程 /************************************* NAME:EmbedSky_hello.c COPYRIGHT:www.embedsky.net *************************************/ #include #include #include #include #include #include #i
linux４．６　EC11旋转编码器的驱动
gouqu5156的博客
04-13 3853
最近项目使用了旋转编码器EC11，遍查内核，发现并没有它的驱动，查了查ＣＳＤＮ，终于找到一篇有用的。根据自己的需要和对最基础的gpio_key.c的理解，我改写出了一份EC11的专用驱动。 感谢下面博主的启发，有了这位高人的指点，我才有信心改写成功。并决定向他学习，将自己成功的代码与大家分享。 https://blog.csdn.net/aifei7320/article/details/50...
主流嵌入式开源GUI比较
热门推荐
逐梦的博客
11-03 5万+
本文主要说明了MicroWindows、MiniG、QT、GTK+、OpenGUI和FLTK，第七小节是对比的详细表格，内容是根据网上的一些资料还有各大开源GUI的官网的资料整理而来，目的是为自己以后学习把握方向。
大众车机天宝187A Hack笔记
weixin_30896763的博客
03-16 2151
0×00前言 自从去年买了车，对汽车电子系统的兴趣就上来了。这不，前一阵子逛汽车论坛，发现了有网友将老版本的天宝车机被刷上了2017新帕萨特车机的系统，支持超级蓝牙和苹果CarPlay，百度CarLife等功能。 没错，这台车机就是最近很火的天宝187A，据说被刷上去的新系统是属于天宝187B，而天宝187B是为在当时并未上市的2017款新帕萨特配备的。 我瞧了一眼我车上的车机型号，...
6410 linux按键驱动（button）
11-22
linux下面实用的按键button驱动程序！按照方法加入即可实用~
会旋转的按钮（RotationButton）
04-04
源码RotationButton，登陆的一种方式，点击后，选择指示登陆，具体看效果图。 登陆的一种方式，点击后，选择指示登陆，具体看效果图 这个是偶然从网上发现的一种登陆设计，也不知道是哪个APP的，看到了设计就仿作了一个。 用法 支持自动布局，方式是storeboard上面拖拽按钮，关联customclass即可，设置按钮标题、旋转图标的颜色等，暂不支持代码方式。 支持非自动布局，方式用代码，设置frame，addsubview 在视图上面。 两种用法，demo里面都有相应的实现。
linux标准按键驱动,Linux系统按键驱动
weixin_31156677的博客
05-16 315
Linux系统下对于按键设备不仅可以进行读操作，还可以进行写操作。对键盘、鼠标等设备进行写操作可以实现模拟按键的功能。另外，想知道/dev/input/eventX分别是哪些设备可以通过执行下面的命令进行查看，如下所示：yuhaiping@neolix:~$ cat /proc/bus/input/devicesI: Bus=0019 Vendor=0000 Product=0001 Versio...
STM32 编码器驱动/旋转编码器旋钮encoder
denghuajing的博客
01-25 1万+
本文已比较纯粹的方式介绍编码器和驱动的编写 编码器最少有两个输出信号，一种典型的结构如上图所示。AB是编码器的输出引脚。当触点和黄色的金属片接触的时候信号发生跳变沿，可以上上升沿也可以是下降沿，具体根据AB引脚默认的电平状态，和金属片电平状态。 当编码器转过一段角度后就会出现上图的波形。AB信号交替出现脉冲。上图所示的状态。B还在金属片上B是高电平,A已经不再金属片上恢复默认电平低。逆时针转动时，A触点比B触点先接触到金属片。所以A的高电平超前B的高电平。超前多少，根据金属片的长度和AB触点的间距决定。
linux 薄膜键盘驱动,全志T3核心板 (512M/1G DDR3，8G EMMC)
weixin_40001309的博客
05-15 329
T3核心板硬件资源基本需求基本硬件资源1.电源供应DC电源输入，5V单电源输入，CPU要能检测到这个电源是否供电；电池输入，锂电池电源输入；实时时钟电源，使用纽扣电池；2.显示接口要支持RGB，LVDS和MIPI接口，由于同时只能使用一个接口，所以这3个接口的管脚可以复用；3.触摸屏接口电阻屏接口，使用ADS7846或者兼容芯片，使用SPI接口；电容屏接口，使用IIC接口；4.SD卡接口CPU要预...
android2.3 旋转按钮驱动
hclydao的专栏
10-17 1668
旋转按钮如图所示: 实现功能为左，右和确定
让linux支持EC11等旋转编码器
aifei7320的专栏
11-25 4899
最近，产品基本定型了，所以开始着手升级版。说是升级版，只是在操作上面有所修改。产品需要使用旋钮进行人机交互。对linux驱动十窍通了九窍，一窍不通，所以从最低级的开始看起，然后把gpio_key.c这个东西，看了一遍又一遍。都快看吐了。 首先修改设备树文件，这个东西是linux3.0的新东西，弄的我无限糊涂，到现在依然糊涂。我只能稍微修改一点需要的东西，让我写肯定写不出来。以后再慢慢研究。在这个
【Linux】按键驱动程序
希希雾里
06-11 1832
深入学习按键驱动程序，熟悉读取数据的方式。
android 14.0 USB连接模式默认设为MTP
最新发布
安卓兼职framework和app工程师的博客
09-13 422
在14.0android系统产品开发中，在通过otg连接设备的时候，会弹出usb连接模式这时候会让客户选择当前连接电脑是 哪种模式，在项目开发中，需要以mtp模式，就是可以在电脑查看设备的内部存储的样式来设置otg连接电脑的模式， 接下来分析下相关模式，来具体实现相关功能
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值