Input子系统

最新推荐文章于 2024-03-07 00:12:29 发布
最新推荐文章于 2024-03-07 00:12:29 发布
阅读量674 收藏 2
点赞数
分类专栏： 驱动开发 文章标签： 驱动开发 linux 嵌入式 exynos_4412
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52479948/article/details/129306971
版权

目录

一、input子系统基本框架

二、驱动开发步骤

三、key2-input版代码解析

四、mpu6050-input版代码解析

五、key3 input子系统版

一、input子系统基本框架

Linux内核为了两个目的：

1. 简化纯输入类外设（如：键盘、鼠标、游戏杆、轨迹球、触摸屏。。。等等）的驱动开发

2. 统一输入类外设产生的数据格式（struct input_event），更加方便应用层编程

设计了输入子系统

 Linux一般把输入类外设产生的数据叫做事件

事件处理层：接收来自核心层上报的事件，并选择对应的handler（事件处理器 struct input_handler）去处理。内核维护着多个事件处理器对象，每个input_handler对象专门处理一类事件，所有产生同类事件的设备驱动共用同一个handler。

设备驱动层：主要实现获取硬件设备的数据信息（包括触摸屏被按下、按下位置、鼠标移动、键盘按下等等），并转换为核心层定义的规范事件后提交给核心层，该层每个设备对应一个struct input_dev对象，

核心层：负责连接设备驱动层和事件处理层，为设备驱动层提供输入设备驱动的接口（struct input_dev）以及输入设备驱动的注册函数（input_register_device）,为事件处理层提供输入事件驱动的接口；通知事件处理层对事件进行处理。

二、驱动开发步骤

```c

/*init或probe函数中：

1. 创建struct input_dev对象input_allocate_device

2. 设置事件类型以及相关参数set_bit

3. 注册struct input_dev对象input_register_device

*/



/*exit或remove函数中：

1. 注销struct input_dev对象input_unregister_device

2. 销毁struct input_dev对象input_free_device

*/



/*上报事件

    两种事件上报方式：

    1. 对有中断支持的输入设备：在其中断处理函数（上半部或下半部）中上报事件

    2. 对无中断支持的输入设备：使用workqueue循环定时上报(struct delayed_work)

    主要函数：

    input_event

    input_report_abs

    input_sync

*/



```

相关接口：


```c

/*_init*/

struct input_dev *input_allocate_device(void)//创建对象



void set_bit(struct input_dev *dev,unsigned long whichbits)//设置事件类型



void input_set_abs_params(struct input_dev *dev,unsigned int axis,int min,int max,int fuzz,int flat)



int input_register_device(struct input_dev *dev)//注册input设备到内核



/*_exit*/

void input_unregister_device(struct input_dev *dev)

void input_free_device(struct input_dev *dev)



/*上报事件*/

void input_event(struct input_dev *,unsigned int t,unsigned int c,int v)



void input_report_key(struct input_dev *,unsigned int c,int v) //上报按键事件

void input_report_abs(struct input_dev *,unsigned int c,int v)//上报绝对坐标事件

   

void input_sync(struct input_dev *)//上报完成后需要调用这些函数来通知系统处理完整事件



/*应用层数据类型*/

struct input_event {

    struct timeval time;       // 时间戳

    __u16 type;             // 事件类型

    __u16 code;             // 哪个分值

    __s32 value;            // 具体值      

};

```

三、key2-input版代码解析

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/mm.h>
#include <linux/input.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <asm/uaccess.h>


struct fs4412key2_dev
{
	struct input_dev *pdev;
	
	int gpio;
	int irqno;
};

struct fs4412key2_dev *pgmydev = NULL;

irqreturn_t key2_irq_handle(int no,void *arg)
{
	struct fs4412key2_dev *pmydev = (struct fs4412key2_dev *)arg;
	int status1 = 0;
	int status2 = 0;

	status1 = gpio_get_value(pmydev->gpio);
	mdelay(1);
	status2 = gpio_get_value(pmydev->gpio);

	if(status1 != status2)
	{
		return IRQ_NONE;
	}

	if(status1)
	{
		input_event(pmydev->pdev,EV_KEY,KEY_2,0);
		input_sync(pmydev->pdev);
	}
	else
	{
		input_event(pmydev->pdev,EV_KEY,KEY_2,1);
		input_sync(pmydev->pdev);
	}

	return IRQ_HANDLED;
}

int __init fs4412key2_init(void)
{
	int ret = 0;

	struct device_node *pnode = NULL;

	pnode = of_find_node_by_path("/mykey2_node");
	if(NULL == pnode)
	{
		printk("find node failed\n");
		return -1;
	}


	pgmydev = (struct fs4412key2_dev *)kmalloc(sizeof(struct fs4412key2_dev),GFP_KERNEL);
	if(NULL == pgmydev)
	{
		printk("kmallc for struct fs4412key2_dev failed\n");
		return -1;
	}

	pgmydev->gpio = of_get_named_gpio(pnode,"key2-gpio",0);

	pgmydev->irqno = irq_of_parse_and_map(pnode,0);

	pgmydev->pdev = input_allocate_device();

	set_bit(EV_KEY,pgmydev->pdev->evbit);
	set_bit(KEY_2,pgmydev->pdev->keybit);

	ret = input_register_device(pgmydev->pdev);
	
	ret = request_irq(pgmydev->irqno,key2_irq_handle,IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,"fs4412key2",pgmydev);
	if(ret)
	{
		printk("request_irq failed\n");
		input_unregister_device(pgmydev->pdev);
		input_free_device(pgmydev->pdev);
		kfree(pgmydev);
		pgmydev = NULL;
		return -1;
	}
	return 0;
}

void __exit fs4412key2_exit(void)
{

	free_irq(pgmydev->irqno,pgmydev);

	input_unregister_device(pgmydev->pdev);
	input_free_device(pgmydev->pdev);

	kfree(pgmydev);
	pgmydev = NULL;
}


MODULE_LICENSE("GPL");

module_init(fs4412key2_init);
module_exit(fs4412key2_exit);

 

#include <sys/types.h>
#include <sys/stat.h>
#include <linux/input.h>
#include <fcntl.h>
#include <unistd.h>

#include <stdio.h>

int main(int argc,char *argv[])
{
	int fd = -1;
	struct input_event evt;
	if(argc < 2)
	{
		printf("Argument is too few\n");
		return 1;
	}

	/*open*/
	fd = open(argv[1],O_RDONLY);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 2;
	}

	/*init mpu6050*/

	while(1)
	{
		read(fd,&evt,sizeof(evt));
		if(evt.type == EV_KEY && evt.code == KEY_2)
		{
			if(evt.value)
			{
				printf("KEY2 DOWN\n");
			}
			else
			{
				printf("KEY2 UP\n");
			}
		}
	}


	/*close*/
	close(fd);
	fd = -1;
	return 0;
}

四、mpu6050-input版代码解析

 

 

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/i2c.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/input.h>
#include <linux/io.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>

#define SMPLRT_DIV 0x19
#define CONFIG 0x1A
#define GYRO_CONFIG 0x1B
#define ACCEL_CONFIG 0x1C

#define ACCEL_XOUT_H 0x3B
#define ACCEL_XOUT_L 0x3C
#define ACCEL_YOUT_H 0x3D
#define ACCEL_YOUT_L 0x3E
#define ACCEL_ZOUT_H 0x3F
#define ACCEL_ZOUT_L 0x40
#define TEMP_OUT_H 0x41
#define TEMP_OUT_L 0x42
#define GYRO_XOUT_H 0x43
#define GYRO_XOUT_L 0x44
#define GYRO_YOUT_H 0x45
#define GYRO_YOUT_L 0x46
#define GYRO_ZOUT_H 0x47
#define GYRO_ZOUT_L 0x48

#define PWR_MGMT_1  0x6B


struct mpu6050_dev
{
	struct input_dev * pinput;

	struct i2c_client *pclient;

	struct delayed_work work;
};

struct mpu6050_dev *pgmydev = NULL;

int mpu6050_read_byte(struct i2c_client *pclt,unsigned char reg)
{
	int ret = 0;
	char txbuf[1] = {reg};
	char rxbuf[1] = {0};

	struct i2c_msg msg[2] = 
	{
		{pclt->addr,0,1,txbuf},
		{pclt->addr,I2C_M_RD,1,rxbuf}
	};

	ret = i2c_transfer(pclt->adapter,msg,ARRAY_SIZE(msg));
	if(ret < 0)
	{
		printk("ret = %d,in mpu6050_read_byte\n",ret);
		return ret;
	}

	return rxbuf[0];
}


int mpu6050_write_byte(struct i2c_client *pclt,unsigned char reg,unsigned char val)
{
	int ret = 0;
	char txbuf[2] = {reg,val};

	struct i2c_msg msg[1] = 
	{
		{pclt->addr,0,2,txbuf},
	};

	ret = i2c_transfer(pclt->adapter,msg,ARRAY_SIZE(msg));
	if(ret < 0)
	{
		printk("ret = %d,in mpu6050_write_byte\n",ret);
		return ret;
	}

	return 0;
}

void mpu6050_work_func(struct work_struct *pwk)
{
	struct mpu6050_dev *pmydev = container_of((struct delayed_work *)pwk,struct mpu6050_dev,work);
	unsigned short ax = 0;
	unsigned short ay = 0;
	unsigned short az = 0;
	unsigned short gx = 0;
	unsigned short gy = 0;
	unsigned short gz = 0;
	unsigned short temp = 0;

	ax = mpu6050_read_byte(pmydev->pclient,ACCEL_XOUT_L);
	ax = mpu6050_read_byte(pmydev->pclient,ACCEL_XOUT_H) << 8;
	input_report_abs(pmydev->pinput,ABS_X,ax);
			
	ay = mpu6050_read_byte(pmydev->pclient,ACCEL_YOUT_L);
	ay = mpu6050_read_byte(pmydev->pclient,ACCEL_YOUT_H) << 8;
	input_report_abs(pmydev->pinput,ABS_Y,ay);

	az = mpu6050_read_byte(pmydev->pclient,ACCEL_ZOUT_L);
	az = mpu6050_read_byte(pmydev->pclient,ACCEL_ZOUT_H) << 8;
	input_report_abs(pmydev->pinput,ABS_Z,az);
			
	gx = mpu6050_read_byte(pmydev->pclient,GYRO_XOUT_L);
	gx = mpu6050_read_byte(pmydev->pclient,GYRO_XOUT_H) << 8;
	input_report_abs(pmydev->pinput,ABS_RX,gx);
			
	gy = mpu6050_read_byte(pmydev->pclient,GYRO_YOUT_L);
	gy = mpu6050_read_byte(pmydev->pclient,GYRO_YOUT_H) << 8;
	input_report_abs(pmydev->pinput,ABS_RY,gy);

	gz = mpu6050_read_byte(pmydev->pclient,GYRO_ZOUT_L);
	gz = mpu6050_read_byte(pmydev->pclient,GYRO_ZOUT_H) << 8;
	input_report_abs(pmydev->pinput,ABS_RZ,gz);
			
	temp = mpu6050_read_byte(pmydev->pclient,TEMP_OUT_L);
	temp = mpu6050_read_byte(pmydev->pclient,TEMP_OUT_H) << 8;
	input_report_abs(pmydev->pinput,ABS_MISC,temp);

	input_sync(pmydev->pinput);
	schedule_delayed_work(&pgmydev->work,msecs_to_jiffies(1000));
}

void init_mpu6050(struct i2c_client *pclt)
{
	mpu6050_write_byte(pclt,PWR_MGMT_1,0x00);
	mpu6050_write_byte(pclt,SMPLRT_DIV,0x07);
	mpu6050_write_byte(pclt,CONFIG,0x06);
	mpu6050_write_byte(pclt,GYRO_CONFIG,0xF8);
	mpu6050_write_byte(pclt,ACCEL_CONFIG,0x19);
}

static int mpu6050_probe(struct i2c_client *pclt,const struct i2c_device_id *pid)
{
	int ret = 0;

	pgmydev = (struct mpu6050_dev *)kmalloc(sizeof(struct mpu6050_dev),GFP_KERNEL);
	if(NULL == pgmydev)
	{
		printk("kmalloc failed\n");
		return -1;
	}
	memset(pgmydev,0,sizeof(struct mpu6050_dev));

	pgmydev->pclient = pclt;

	init_mpu6050(pgmydev->pclient);

	pgmydev->pinput = input_allocate_device();

	set_bit(EV_ABS,pgmydev->pinput->evbit);
	input_set_abs_params(pgmydev->pinput,ABS_X,-32768,32767,0,0);
	input_set_abs_params(pgmydev->pinput,ABS_Y,-32768,32767,0,0);
	input_set_abs_params(pgmydev->pinput,ABS_Z,-32768,32767,0,0);
	input_set_abs_params(pgmydev->pinput,ABS_RX,-32768,32767,0,0);
	input_set_abs_params(pgmydev->pinput,ABS_RY,-32768,32767,0,0);
	input_set_abs_params(pgmydev->pinput,ABS_RZ,-32768,32767,0,0);
	input_set_abs_params(pgmydev->pinput,ABS_MISC,-32768,32767,0,0);

	ret = input_register_device(pgmydev->pinput);
	if(ret)
	{
		printk("input_register_device failed\n");

		input_free_device(pgmydev->pinput);
		pgmydev->pinput = NULL;

		kfree(pgmydev);
		pgmydev = NULL;
		return -1;
	}

	INIT_DELAYED_WORK(&pgmydev->work,mpu6050_work_func);

	schedule_delayed_work(&pgmydev->work,msecs_to_jiffies(1000));
	return 0;
}

static int mpu6050_remove(struct i2c_client *pclt)
{
	cancel_delayed_work(&pgmydev->work);

	input_unregister_device(pgmydev->pinput);

	input_free_device(pgmydev->pinput);
	pgmydev->pinput = NULL;

	kfree(pgmydev);
	pgmydev = NULL;

	return 0;
}

struct of_device_id mpu6050_dt[] = 
{
	{.compatible = "invensense,mpu6050"},
	{}
};


struct i2c_device_id mpu6050_ids[] = 
{
	{"mpu6050",0},
	{}
};


struct i2c_driver mpu6050_driver = 
{
	.driver = {
		.name = "mpu6050",
		.owner = THIS_MODULE,
		.of_match_table = mpu6050_dt,
	},
	.probe = mpu6050_probe,
	.remove = mpu6050_remove,
	.id_table = mpu6050_ids,
};

#if 0
int __init mpu6050_driver_init(void)
{
	i2c_add_driver(&mpu6050_driver);
}

void __exit mpu6050_driver_exit(void)
{
	i2c_del_driver(&mpu6050_driver);
}
module_init(mpu6050_driver_init);
module_exit(mpu6050_driver_exit);
#else
module_i2c_driver(mpu6050_driver);
#endif

MODULE_LICENSE("GPL");

#include <sys/types.h>
#include <sys/stat.h>
#include <linux/input.h>
#include <fcntl.h>
#include <unistd.h>

#include <stdio.h>

int main(int argc,char *argv[])
{
	int fd = -1;
	struct input_event evt;
	if(argc < 2)
	{
		printf("Argument is too few\n");
		return 1;
	}

	/*open*/
	fd = open(argv[1],O_RDONLY);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 2;
	}

	/*init mpu6050*/

	while(1)
	{
		read(fd,&evt,sizeof(evt));
		if(evt.type == EV_ABS)
		{
			switch(evt.code)
			{
				case ABS_X:
					printf("Accel-x:%d\n",evt.value);
					break;
				case ABS_Y:
					printf("Accel-y:%d\n",evt.value);
					break;
				case ABS_Z:
					printf("Accel-z:%d\n",evt.value);
					break;
				case ABS_RX:
					printf("Gyro-x:%d\n",evt.value);
					break;
				case ABS_RY:
					printf("Gyro-y:%d\n",evt.value);
					break;
				case ABS_RZ:
					printf("Gyro-z:%d\n",evt.value);
					break;
				case ABS_MISC:
					printf("Temp:%d\n",evt.value);
					break;
			}
		}
	}


	/*close*/
	close(fd);
	fd = -1;
	return 0;
}

五、key3 input子系统版

 

 

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/mm.h>
#include <linux/input.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <asm/uaccess.h>


struct fs4412key3_dev
{
	struct input_dev *pdev;
	
	int gpio;
	int irqno;
};

struct fs4412key3_dev *pgmydev = NULL;

irqreturn_t key3_irq_handle(int no,void *arg)
{
	struct fs4412key3_dev *pmydev = (struct fs4412key3_dev *)arg;
	int status1 = 0;
	int status2 = 0;

	status1 = gpio_get_value(pmydev->gpio);
	mdelay(1);
	status2 = gpio_get_value(pmydev->gpio);

	if(status1 != status2)
	{
		return IRQ_NONE;
	}

	if(status1)
	{
		input_event(pmydev->pdev,EV_KEY,KEY_3,0);
		input_sync(pmydev->pdev);
	}
	else
	{
		input_event(pmydev->pdev,EV_KEY,KEY_3,1);
		input_sync(pmydev->pdev);
	}

	return IRQ_HANDLED;
}

int __init fs4412key3_init(void)
{
	int ret = 0;

	struct device_node *pnode = NULL;

	pnode = of_find_node_by_path("/mykey3_node");
	if(NULL == pnode)
	{
		printk("find node failed\n");
		return -1;
	}


	pgmydev = (struct fs4412key3_dev *)kmalloc(sizeof(struct fs4412key3_dev),GFP_KERNEL);
	if(NULL == pgmydev)
	{
		printk("kmallc for struct fs4412key3_dev failed\n");
		return -1;
	}

	pgmydev->gpio = of_get_named_gpio(pnode,"key3-gpio",0);

	pgmydev->irqno = irq_of_parse_and_map(pnode,0);

	pgmydev->pdev = input_allocate_device();

	set_bit(EV_KEY,pgmydev->pdev->evbit);
	set_bit(KEY_3,pgmydev->pdev->keybit);

	ret = input_register_device(pgmydev->pdev);
	
	ret = request_irq(pgmydev->irqno,key3_irq_handle,IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,"fs4412key3",pgmydev);
	if(ret)
	{
		printk("request_irq failed\n");
		input_unregister_device(pgmydev->pdev);
		input_free_device(pgmydev->pdev);
		kfree(pgmydev);
		pgmydev = NULL;
		return -1;
	}
	return 0;
}

void __exit fs4412key3_exit(void)
{

	free_irq(pgmydev->irqno,pgmydev);

	input_unregister_device(pgmydev->pdev);
	input_free_device(pgmydev->pdev);

	kfree(pgmydev);
	pgmydev = NULL;
}


MODULE_LICENSE("GPL");

module_init(fs4412key3_init);
module_exit(fs4412key3_exit);

宇努力学习
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Android之Input子系统事件分发流程 - CSDN博客1
08-04
Android之Input子系统事件分发流程 - CSDN博客原创2013年11月29日 08:49:08Android之Input子系统事件分发流程Andro
input子系统介绍
03-11
android input 子系统介绍，主要介绍了输入设备驱动，到子系统，到上层的数据传输过程
【Linux驱动】Input子系统
最新发布
weixin_46334900的博客
03-07 908
输入子系统由驱动层（input_driver）、核心层（input_core）以及事件层（input_event_handle）组成，如下图所示： Note：Input子系统中所有输入设备的主设备号都是13，核心层通过次设备号来将输入设备分类，例如如0-31是游戏杆，32-63是鼠标（对应Mouse Handler)、64-95是事件设备（如触摸屏，对应Event Handler)。在使用input系统时，不需要去注册字符设备，只需要向系统申请一个input_device即可。在Linux内核中，使用inp
Input子系统分析
08-05
Input子系统分析
Input子系统详解
05-15
文档详细描述了Linux Input Subsystem的设计，Linux应用编程者可以以此文档做依据编写程序。Linux驱动开发者，此文档提供Input Subsystem的设计思想，可作为设计驱动的参考
input子系统
01-11
input子系统是linux驱动的核心，设计到input子系统的模块太多太多，比如touch驱动，按键驱动以及8大sensor，在kernel中都要通过input子系统向framework上报事件，这些文档就是对input系统的一个详细的分析概括，能够让你快速深入的理解input的核心
Linux之Input子系统
风间琉璃的博客
09-27 5450
Input 子系统是管理输入的子系统， 和 pinctrl 和 gpio 子系统一样， 都是 Linux 内核针对某一类设备而创建的框架。input 子系统处理输入事务， 任何输入设备的驱动程序都可以通过 input 输入子系统提供的接口注册到内核， 利用子系统提供的功能来与用户空间交互。输入设备总类繁杂， 包括按键， 键盘， 触摸屏， 鼠标， 摇杆等， 它们本身是字符设备， 不过内核为了能将这些设备的共性抽象出来， 简化驱动的开发， 建立了一个 Input 子系统。
Input子系统（二）
天下对手教会少林武僧
09-02 968
上一篇中粗略的分析了下input_dev，input_handle，input_handler这三者之间的关系，而在实际系统当中input子系统是如何工作的呢，当然我们知道，故事肯定是围绕着它们三个发生，下面我们来看看具体的input设备的工作流程。同样以触摸屏为例。 在触摸屏驱动中，当有触摸事件产生（手接触到触摸屏的时候），触摸屏相关IC会产生中断，在中断处理函数当中，kernel或者说tp ...
【转】输入事件的传递过程
iefswang的专栏
04-23 831
接上一篇《【转】输入子系统设备模型分析 （有修改）》         当一个事件被触发设，备将向上层报告发生了什么事。为表述这个事件的传递过程我们以触摸屏为例。触摸屏的源程序在前面博文中已有详述，这里就不赘言了。 当在触摸屏上按下时会发出这样的报告：     input_report_abs(dev, ABS_X, xp);  //报告x坐标值     input_report_abs(
input子系统详解
Neil驱动的博客
04-12 1784
  Input子系统详解 一．Input子系统架构 Linux系统提供了input子系统，按键、触摸屏、键盘、鼠标等输入都可以利用input接口函数来实现设备驱动，下面是Input子系统架构： Input子系统架构 二．Input系统的组成 输入子系统由驱动层（Driv...
数字IC笔试千题解--单选题篇（二）
qq_57502075的博客
09-25 2758
所有题目结果和解释由笔者给出，答案主观性较强，若有错误欢迎评论区指出，资料整理来自于“数字IC打工人”等数字IC相关公众号，牛客网等网站真题、网络笔试真题及面经抄录。
Linux内核（十四）Input 子系统详解 I —— 子系统介绍以及相关结构体解析
weixin_43564241的博客
04-30 2018
input子系统就是管理输入的子系统，和Linux其他子系统一样，都是Linux内核针对某一类设备而创建的框架。鼠标、键盘、触摸屏等都属于输入设备，Linux将这些设备的共同特性抽象出来，这就形成了input子系统的框架。Linux内核只需要通过input框架向用户层上报输入事件（如：按键值，坐标等），不需要关心应用层的事情输入设备本质上就是字符设备，经过input框架后，最终给用户空间提供可以访问的设备节点input_dev结构体是硬件驱动层，代表一个input设备。
input输入子系统及调试实例简述
奶牛养殖场小马
02-27 846
一 引入输入子系统的目的 二 输入子系统框架 三 输入子系统之核心层简述 四 输入子系统之事件处理层简述 五 输入子系统之驱动层简述 一 引入输入子系统的目的 个人理解是为了 将输入设备的功能直接提供给用户空间，如果按照普通字符设备的方式编写输入设备，那么我们自己的驱动会生成我们自己命名的设备节点，只有我们自己知道设备节点名称，也就是只有我们自己可以打开这个设备节点，此时这种驱动程序只能自己使用...
Linux·inout子系统框架
m0_64560763的博客
08-20 548
inout子系统框架
Linux驱动之input输入子系统
qq_53221728的博客
04-29 2540
输入子系统用于实现Linux系统输入设备（鼠标 键盘 触摸屏 游戏杆）驱动的一种框架。 输入子系统从下到上分为输入驱动层、输入核心层、输入事件处理层，最终给用户空间提供可访问的设备节点。
Linux 内核驱动--多点触摸接口
joard_yang的专栏
03-05 8411
译自：linux-2.6.31.14/Documentation/input/multi-touch-protocol.txt简介 　　为了使用功能强大的多点触控设备，就需要一种方案去上报用户层所需的详细的手指触摸数据。这个文档所描述的多点触控协议可以让内核驱动程序向用户层上报任意多指的数据信息。　　使用说明　　单点触摸信息是以ABS承载并按一定顺序发送，如BTN_TOUCH、ABS_X、ABS_Y、SYNC。而多点触摸信息则是以ABS_MT承载并按一定顺序发送，如ABS_MT_POSITION_X、ABS
android input子系统分析---驱动层
Jack的博客
07-10 1724
前言: Input子系统包括标准Linux，Android核心驱动，Android相关设备驱动，G-sensor的设备驱动程序。传感器作为 一种输入设备，也是通过input系统把其数据上报给系统，或者通过input系统得到用户的配置信息。这里以传感器 为例学习input driver层。 Sensor驱动从通过I2C从寄存器中读取sensor值,然后写入/dev/input/目录下对应的文
linux input子系统
08-12
- *1* *3* [Linux之Input子系统](https://blog.csdn.net/qq_53144843/article/details/127074752)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

宇努力学习

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值