linux 输入设备驱动
struct input_dev {
const char *name;//设备名称
const char *phys;//设备在系统中的物理路径
const char *uniq;//设备唯一识别符
struct input_id id;//设备ID,包含总线ID(PCI、USB)、厂商ID,与input_handler匹配的时会用到 unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];//位图的设备属性 unsigned long evbit[BITS_TO_LONGS(EV_CNT)];//支持的所有事件类型
//下面是每种类型支持的编码
unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];//支持的键盘事件
unsigned long relbit[BITS_TO_LONGS(REL_CNT)];//支持的鼠标相对值事件
unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];//支持的鼠标绝对值事件
unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];//支持的其它事件类型
unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];//支持的LED灯事件
unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];//支持的声效事件
unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];//支持的力反馈事件
unsigned long swbit[BITS_TO_LONGS(SW_CNT)];//支持的开关事件 unsigned int hint_events_per_packet;//事件生成的平均数量 unsigned int keycodemax;//keycode表的大小
unsigned int keycodesize;//keycode表中元素个数
void *keycode;//设备的键盘表 int (*setkeycode)(struct input_dev *dev,const struct input_keymap_entry *ke,
unsigned int *old_keycode);//配置keycode表
int (*getkeycode)(struct input_dev *dev,
struct input_keymap_entry *ke);//获取keycode表 struct ff_device *ff;//力反馈设备结构 unsigned int repeat_key;//保存上一个键值
struct timer_list timer;//软件计时器 int rep[REP_CNT];//autorepeat参数当前值 struct input_mt_slot *mt;
int mtsize;
int slot;
int trkid; struct input_absinfo *absinfo;//绝对坐标轴的信息 unsigned long key[BITS_TO_LONGS(KEY_CNT)];//按键有两种状态,按下和抬起,这个字段就是记录这两个状态。
unsigned long led[BITS_TO_LONGS(LED_CNT)];
unsigned long snd[BITS_TO_LONGS(SND_CNT)];
unsigned long sw[BITS_TO_LONGS(SW_CNT)];
//操作接口
int (*open)(struct input_dev *dev);
void (*close)(struct input_dev *dev);
int (*flush)(struct input_dev *dev, struct file *file);
int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value); struct input_handle __rcu *grab;//当前使用的handle spinlock_t event_lock;
struct mutex mutex; unsigned int users;
bool going_away; bool sync; struct device dev;//这个设备的驱动程序模型的视图 struct list_head h_list;//h_list是一个链表头,用来把handle挂载在这个上
struct list_head node;//这个node是用来连到input_dev_list上的
};
struct input_handler {
void *private;//驱动特有的数据
//当事件处理器接收到了来自input设备传来的事件时调用的处理函数,负责处理事件
void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);//该函数将被输入子系统调用区处理发送给“设备”的事件。例如,发送一个事件命令led灯点亮,实际控制硬件的操作可以放在event()函数中实现
bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);//事件过滤
bool (*match)(struct input_handler *handler, struct input_dev *dev);
//当一个input设备模块注册到内核的时候调用的,将事件处理器与输入设备联系起来的函数,
//也就是将input_dev和input_handler配对的函数
int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
void (*disconnect)(struct input_handle *handle);//实现connect相反的功能
void (*start)(struct input_handle *handle); const struct file_operations *fops;//文件操作函数集合
int minor;//次设备号
const char *name; const struct input_device_id *id_table;//事件处理器所支持的input设备
//这个链表用来链接他所支持的input_handle结构,input_dev与input_handler配对之后就会生成一个input_handle结构
struct list_head h_list;
//链接到input_handler_list,这个链表链接了所有注册到内核的事件处理器
struct list_head node;
};
struct input_handle {
//每个配对的事件处理器都会分配一个对应的设备结构,如evdev事件处理器的evdev结构,注意这个结构与设备
//驱动层的input_dev不同,初始化handle时,保存到这里。
void *private; int open;//打开标志,每个input_handle打开后才能操作,这个一般通过事件处理器的open方法间接设置
const char *name; struct input_dev *dev;//关联的input_dev结构
struct input_handler *handler;//关联的input_handler结构 struct list_head d_node;//input_handle通过d_node连接到了input_dev上的h_list链表上
struct list_head h_node;//input_handle通过h_node连接到了input_handler的h_list链表上
};
unsigned long evbit[BITS_TO_LONGS(EV_CNT)]; //事件支持的类型
unsigned long keybit[BITS_TO_LONGS(KEY_CNT)]; //按键
unsigned long relbit[BITS_TO_LONGS(REL_CNT)];
unsigned long absbit[BITS_TO_LONGS(ABS_CNT)]; //绝对坐标,其中触摸屏驱动使用的就是这个
unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];
unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];
unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];
unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];
unsigned long swbit[BITS_TO_LONGS(SW_CNT)];
evbit[BITS_TO_LONGS(EV_CNT)]; 这个数组以位掩码的形式,代表了这个设备支持的事件的类型。
dev->evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS)
absbit[BITS_TO_LONGS(ABS_CNT)]; 这个数组也是以位掩码的形式,代表这个类型的事件支持的编码触摸屏驱动支持EV_ABS,所以要设置这个数组。
static inline void input_set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat)
{ dev->absmin[axis] = min; dev->absmax[axis] = max;
dev->absfuzz[axis] = fuzz;
dev->absflat[axis] = flat;
dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis); //填充了absbit这个数组 }
input_set_abs_params(dev, ABS_X, 0, 0x3FF, 0, 0); //这个是设置ad转换的x坐标
input_set_abs_params(dev, ABS_Y, 0, 0x3FF, 0, 0); //这个是设置ad转换的y坐标input_set_abs_params(dev, ABS_PRESSURE, 0, 1, 0, 0); //这个是设置触摸屏是否按下的标志
设置ABS_X编码值范围为0-0x3ff,因为mini2440的AD转换出的数据最大为10位,所以不会超过0x3ff。
struct input_id {
__u16 bustype; //总线类型
__u16 vendor; //生产厂商
__u16 product; //产品类型
__u16 version; //版本
};
void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
void (*disconnect)(struct input_handle *handle);
void (*start)(struct input_handle *handle);
const struct input_device_id *id_table; //这个是事件处理器所支持的input设备
const struct input_device_id *blacklist; //这个是事件处理器应该忽略的input设备
struct list_headh_list; //这个链表用来链接他所支持的input_handle结构,input_dev与input_handler配对之后就会生成一个input_handle结构
struct list_headnode; //链接到input_handler_list,这个链表链接了所有注册到内核的事件处理器
struct input_handle
{ void *private; //每个配对的事件处理器都会分配一个对应的设备结构,如evdev事件处理器的evdev结构,注意这个结构与设备驱动层的input_dev不同,初始化handle时,保存到这里。
int open; //打开标志,每个input_handle 打开后才能操作,这个一般通过事件处理器的open方法间接设置
const char *name;
struct input_dev *dev; //关联的input_dev结构
struct input_handler *handler; //关联的input_handler结构
struct list_head d_node; //input_handle通过d_node连接到了input_dev上的h_list链表上 struct list_head h_node; //input_handle通过h_node连接到了input_handler的h_list链表上 };
struct evdev
{ int exist;
int open; //打开标志
int minor; //次设备号
struct input_handle handle; //关联的input_handle
wait_queue_head_t wait; //等待队列,当进程读取设备,而没有事件产生的时候,进程就会睡在其上面
struct evdev_client *grab; //强制绑定的evdev_client结构,这个结构后面再分析
struct list_head client_list; //evdev_client 链表,这说明一个evdev设备可以处理多个evdev_client,可以有多个进程访问evdev设备
spinlock_t client_lock; /* protects client_list */
struct mutex mutex;
struct device dev; //device结构,说明这是一个设备结构 };
evdev结构体在配对成功的时候生成,由handler->connect生成,对应设备文件为/class/input/event(n)。
struct evdev_client
{ struct input_event buffer[EVDEV_BUFFER_SIZE]; //这个是一个input_event数据结构的数组,input_event代表一个事件,基本成员:类型(type),编码(code),值(value)
int head; //针对buffer数组的索引
int tail; //针对buffer数组的索引,当head与tail相等的时候,说明没有事件 spinlock_t buffer_lock; /* protects access to buffer, head and tail */
struct fasync_struct *fasync; //异步通知函数
struct evdev *evdev; //evdev设备
struct list_head node; // evdev_client 链表项 };
static const struct file_operations evdev_fops = {
.owner = THIS_MODULE,
.read = evdev_read,
.write = evdev_write,
.poll = evdev_poll,
.open = evdev_open,
.release = evdev_release,
.unlocked_ioctl = evdev_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl = evdev_ioctl_compat,
#endif
.fasync = evdev_fasync,
.flush = evdev_flush
};
/*evdev设备open函数的实现过程 */
static int evdev_open(struct inode *inode, struct file *file)
{
struct evdev_client *client;
struct evdev *evdev;
/* 如果是event0,对于evdev设备来说,次设备号当然是0 */
int i = iminor(inode) - EVDEV_MINOR_BASE;
int error;
/* 如果大于32,说明超出了evdev能够容纳的最大输入设备个数 */
if (i >= EVDEV_MINORS)
return -ENODEV;
/* 由于evdev中能容纳32个输入设备,因此通过设备号event0中的0定位到是要处理的是哪一个输入设备,evdev_table中的内容在输入设备驱动注册时通过evdev_connect填充 */
evdev = evdev_table[i];
/* 判断是否设备接口存在,evdev_exist也是在evdev_connect填充为1 */
if (!evdev || !evdev->exist)
return -ENODEV;
/* 存在则分配evdev中的client来处理event* */
client = kzalloc(sizeof(struct evdev_client),GFP_KERNEL);
if (!client)
return -ENOMEM; /* 把event*中的接口指向evdev_table中对应项 */
client->evdev = evdev;
/* 把client->node链接到evdev子集中 */
list_add_tail(&client->node,&evdev->client_list);
/* 如果open是第一个打开,则会执行input_open_device*/
if (!evdev->open++ &&evdev->exist) {
error =input_open_device(&evdev->handle);
if (error) {
list_del(&client->node);
kfree(client);
return error;
}
}
/* 将file私有指针指向client*/
file->private_data = client;
return ;
}
int input_register_handle(struct input_handle *handle)
{
struct input_handler *handler = handle->handler;
struct input_dev *dev = handle->dev;
int error; /*
* We take dev->mutex here to prevent race with
* input_release_device().
*/
error = mutex_lock_interruptible(&dev->mutex);
if (error)
return error; /*
* Filters go to the head of the list, normal handlers
* to the tail.
*/
if (handler->filter)
//将handle的d_node,链接到其相关的input_dev的h_list链表中
list_add_rcu(&handle->d_node, &dev->h_list);
else
list_add_tail_rcu(&handle->d_node, &dev->h_list); mutex_unlock(&dev->mutex); /*
* Since we are supposed to be called from ->connect()
* which is mutually exclusive with ->disconnect()
* we can't be racing with input_unregister_handle()
* and so separate lock is not needed here.
*/
//将handle的d_node,链接到其相关的input_handler的h_list链表中
list_add_tail_rcu(&handle->h_node, &handler->h_list); if (handler->start)
handler->start(handle); return ;
}
这个函数基本没做什么事,就是把一个handle结构体通过d_node链表项,分别链接到input_dev的h_list,
input_handler的h_list上。以后通过这个h_list就可以遍历相关的input_handle了
3、input_register_handler()函数注册一个input_handler
int input_register_handler(struct input_handler *handler)
{
struct input_dev *dev;
int retval; retval = mutex_lock_interruptible(&input_mutex);
if (retval)
return retval; INIT_LIST_HEAD(&handler->h_list); if (handler->fops != NULL) {
if (input_table[handler->minor >> ]) {
retval = -EBUSY;
goto out;
}
input_table[handler->minor >> ] = handler;
}
//连接到input_handler_list链表中
list_add_tail(&handler->node, &input_handler_list);
//配对,遍历input_dev,和注册input_dev过程一样的
list_for_each_entry(dev, &input_dev_list, node)
input_attach_handler(dev, handler); input_wakeup_procfs_readers(); out:
mutex_unlock(&input_mutex);
return retval;
}
这个函数其实和input_register_device类似,都是要注册、配对
四、input输入子系统核心层
1、input输入子系统初始化定义在driver/input/input.c中,如下
static int __init input_init(void)
{
int err;
//向内核注册一个类,用于linux设备模型。注册后会在/sys/class下面出现input目录
err = class_register(&input_class);
if (err) {
pr_err("unable to register input_dev class\n");
return err;
}
//在/proc下创建入口项
err = input_proc_init();
if (err)
goto fail1;
//注册字符设备,设备号INPUT_MAJOR为13,设备名为input
err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
if (err) {
pr_err("unable to register char major %d", INPUT_MAJOR);
goto fail2;
} return ; fail2: input_proc_exit();
fail1: class_unregister(&input_class);
return err;
}
//子系统初始化时调用
subsys_initcall(input_init);
这个函数主要是注册了字符设备,这里和杂项设备的原理是一样,所以input设备也是一类字符设备,只不过操作
方法交给了输入子系统。从这里可以看出无论linux设备驱动这块有多复杂,他们都是由一些基本的组件构成的
2.输入子系统的核心其他部分都是提供的接口,向上连接事件处理层,向下连接驱动层。
向下对驱动层的接口主要有:
input_allocate_device这个函数主要是分配一个input_dev接口,并初始化一些基本的成员
input_unregister_device注册一个input设备input_event这个函数很重要,是驱动层向input子系统核心报告事件
的函数。
input_allocate_device分配并初始化一个input_dev结构
向上对事件处理层接口主要有:
input_register_handler注册一个事件处理器
input_register_handle注册一个input_handle结构
五、事件处理层
事件处理层与用户程序和输入子系统核心打交道,是他们两层的桥梁。一般内核有好几个事件处理器,
像evdev、mousedev、jotdev。evdev事件处理器可以处理所有的事件,触摸屏驱动就是用的这个。
1、evdev_init()事件处理层初始化
static int __init evdev_init(void)
{
return input_register_handler(&evdev_handler);
}
调用一个注册handler函数,将evdev_handler注册到系统中
2、主要的数据结构
1)evdev设备结构
struct evdev {
int open;//打开标志
int minor;//次设备号
struct input_handle handle;//关联的input_handle
wait_queue_head_t wait;//等待队列,当进程读取设备,而没有事件产生的时候,进程就会睡在其上面
struct evdev_client __rcu *grab;//强制绑定的evdev_client结构
struct list_head client_list;//evdev_client链表,这说明一个evdev设备可以处理多个evdev_client,可以有多个进程访问evdev设备
spinlock_t client_lock; /* protects client_list */
struct mutex mutex;
struct device dev;//device结构,说明这是一个设备结构
bool exist;
};
evdev结构体在配对成功的时候生成,由handler->connect生成,对应设备文件为/class/input/event(n),
如触摸屏驱动的event0,这个设备是用户空间要访问的设备,可以理解它是一个虚拟设备,因为没有对应的硬件,
但是通过handle->dev就可以找到input_dev结构,而它对应着触摸屏,设备文件为/class/input/input0。这个设备
结构生成之后保存在evdev_table中,索引值是minor
2)evdev用户端结构
struct evdev_client {
unsigned int head;//针对buffer数组的索引
unsigned int tail;//针对buffer数组的索引,当head与tail相等的时候,说明没有事件
unsigned int packet_head; /* [future] position of the first element of next packet */
spinlock_t buffer_lock; /* protects access to buffer, head and tail */
struct fasync_struct *fasync;//异步通知函数
struct evdev *evdev;//evdev设备
struct list_head node;//evdev_client链表项
unsigned int bufsize;
struct input_event buffer[];//这个是一个input_event数据结构的数组,input_event代表一个事件,基本成员:类型(type),编码(code),值(value)
};
这个结构在进程打开event0设备的时候调用evdev的open方法,在open中创建这个结构,并初始化。在关闭设备文
件的时候释放这个结构
3、主要的函数
1)evdev设备打开函数
static int evdev_open(struct inode *inode, struct file *file)
{
struct evdev *evdev;
struct evdev_client *client;
int i = iminor(inode) - EVDEV_MINOR_BASE;
unsigned int bufsize;
int error; if (i >= EVDEV_MINORS)
return -ENODEV; error = mutex_lock_interruptible(&evdev_table_mutex);
if (error)
return error;
//得到evdev设备结构,每次调用evdev_connect配对成功后都会把分配的evdev结构以minor为索引,保存在evdev_table数组中
evdev = evdev_table[i];
if (evdev)
get_device(&evdev->dev);//增加device引用计数
mutex_unlock(&evdev_table_mutex); if (!evdev)
return -ENODEV; bufsize = evdev_compute_buffer_size(evdev->handle.dev);
//分配用户端结构
client = kzalloc(sizeof(struct evdev_client) +
bufsize * sizeof(struct input_event),
GFP_KERNEL);
if (!client) {
error = -ENOMEM;
goto err_put_evdev;
} client->bufsize = bufsize;
spin_lock_init(&client->buffer_lock);
client->evdev = evdev;//使用户端与evdev设备结构联系起来
evdev_attach_client(evdev, client);//把client连接到evdev的client链表中
//打开设备
error = evdev_open_device(evdev);
if (error)
goto err_free_client; file->private_data = client;
nonseekable_open(inode, file); return ; err_free_client:
evdev_detach_client(evdev, client);
kfree(client);
err_put_evdev:
put_device(&evdev->dev);
return error;
}
2)evdev_open_device()函数
static int evdev_open_device(struct evdev *evdev)
{
int retval; retval = mutex_lock_interruptible(&evdev->mutex);
if (retval)
return retval;
//判断设备结构是否存在,在evdev_connect中初始话此成员为1
if (!evdev->exist)
retval = -ENODEV;
else if (!evdev->open++) {//evdev->open分配结构的时候没有初始化,默认为0,也就是没有打开,每次打开都会加1
retval = input_open_device(&evdev->handle);
if (retval)
evdev->open--;
} mutex_unlock(&evdev->mutex);
return retval;
}
3)input_open_device()函数
int input_open_device(struct input_handle *handle)
{
struct input_dev *dev = handle->dev;
int retval; retval = mutex_lock_interruptible(&dev->mutex);
if (retval)
return retval; if (dev->going_away) {
retval = -ENODEV;
goto out;
}
//将handle的打开计数加1,注意和evdev的open的区别
handle->open++;
//如果此input_dev没有进程在引用,并且定义了open方法,就调用open方法
if (!dev->users++ && dev->open)
retval = dev->open(dev); if (retval) {//retval=1说明没有打开成功
dev->users--;
if (!--handle->open) {//说明有其他的进程已经打开了这个handle
/*
* Make sure we are not delivering any more events
* through this handle
*/
synchronize_rcu();
}
} out:
mutex_unlock(&dev->mutex);
return retval;
}
4)evdev_read()函数
static ssize_t evdev_read(struct file *file, char __user *buffer,
size_t count, loff_t *ppos)
{
//这个客户端结构在打开的时候分配并保存在file->private_data中
struct evdev_client *client = file->private_data;
struct evdev *evdev = client->evdev;
struct input_event event;
int retval;
//用户进程每次读取设备的字节数,不要少于input_event结构的大小
if (count < input_event_size())
return -EINVAL;
//head等于tail说明目前还没有事件传回来,如果设置了非阻塞操作,则会立刻返回
if (client->packet_head == client->tail && evdev->exist &&
(file->f_flags & O_NONBLOCK))
return -EAGAIN;
//没有事件就会睡在evdev的等待队列上了,等待条件是有事件到来或者设备不存在了
retval = wait_event_interruptible(evdev->wait,
client->packet_head != client->tail || !evdev->exist); if (retval)
//如果能执行上面这条语句说明有事件传来或者,设备被关闭了,或者内核发过来终止信号
return retval; if (!evdev->exist)
return -ENODEV; while (retval + input_event_size() <= count &&
evdev_fetch_next_event(client, &event)) {
//evdev_fetch_next_event这个函数遍历client里面的input_eventbuffer数组
if (input_event_to_user(buffer + retval, &event))//将事件复制到用户空间
return -EFAULT; retval += input_event_size();
} return retval;
}
六、事件传递过程
1.事件产生
当按下触摸屏时,进入触摸屏按下中断,开始ad转换,ad转换完成进入ad完成中断,在这个中端中将事件发送出去,调用
input_report_abs(dev,ABS_X,xp);
input_report_abs(dev,ABS_Y,yp);
这两个函数调用了input_event(dev,EV_ABS,code,value)
所有的事件报告函数都调用这个函数。
2、事件报告
1)input_event()函数
void input_event(struct input_dev *dev,
unsigned int type, unsigned int code, int value)
{
unsigned long flags;
//判断是否支持此种事件类型和事件类型中的编码类型
if (is_event_supported(type, dev->evbit, EV_MAX)) { spin_lock_irqsave(&dev->event_lock, flags);
//对系统随机熵池有贡献,因为这个也是一个随机过程
add_input_randomness(type, code, value);
//事件处理函数
input_handle_event(dev, type, code, value);
spin_unlock_irqrestore(&dev->event_lock, flags);
}
}
2)input_handle_event()函数
static void input_handle_event(struct input_dev *dev,
unsigned int type, unsigned int code, int value)
{
int disposition = INPUT_IGNORE_EVENT; switch (type) { case EV_SYN:
switch (code) {
case SYN_CONFIG:
disposition = INPUT_PASS_TO_ALL;
break; case SYN_REPORT:
if (!dev->sync) {
dev->sync = true;
disposition = INPUT_PASS_TO_HANDLERS;
}
break;
case SYN_MT_REPORT:
dev->sync = false;
disposition = INPUT_PASS_TO_HANDLERS;
break;
}
break; case EV_KEY:
if (is_event_supported(code, dev->keybit, KEY_MAX) &&
!!test_bit(code, dev->key) != value) { if (value != ) {
__change_bit(code, dev->key);
if (value)
input_start_autorepeat(dev, code);
else
input_stop_autorepeat(dev);
} disposition = INPUT_PASS_TO_HANDLERS;
}
break; case EV_SW:
if (is_event_supported(code, dev->swbit, SW_MAX) &&
!!test_bit(code, dev->sw) != value) { __change_bit(code, dev->sw);
disposition = INPUT_PASS_TO_HANDLERS;
}
break; case EV_ABS:
if (is_event_supported(code, dev->absbit, ABS_MAX))
disposition = input_handle_abs_event(dev, code, &value); break; case EV_REL:
if (is_event_supported(code, dev->relbit, REL_MAX) && value)
disposition = INPUT_PASS_TO_HANDLERS; break; case EV_MSC:
if (is_event_supported(code, dev->mscbit, MSC_MAX))
disposition = INPUT_PASS_TO_ALL; break; case EV_LED:
if (is_event_supported(code, dev->ledbit, LED_MAX) &&
!!test_bit(code, dev->led) != value) { __change_bit(code, dev->led);
disposition = INPUT_PASS_TO_ALL;
}
break; case EV_SND:
if (is_event_supported(code, dev->sndbit, SND_MAX)) { if (!!test_bit(code, dev->snd) != !!value)
__change_bit(code, dev->snd);
disposition = INPUT_PASS_TO_ALL;
}
break; case EV_REP:
if (code <= REP_MAX && value >= && dev->rep[code] != value) {
dev->rep[code] = value;
disposition = INPUT_PASS_TO_ALL;
}
break; case EV_FF:
if (value >= )
disposition = INPUT_PASS_TO_ALL;
break; case EV_PWR:
disposition = INPUT_PASS_TO_ALL;
break;
} if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
dev->sync = false; if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
dev->event(dev, type, code, value); if (disposition & INPUT_PASS_TO_HANDLERS)
input_pass_event(dev, type, code, value);
}
这个函数主要是根据事件类型的不同,做相应的处理。disposition这个是事件处理的方式,默认的是
INPUT_IGNORE_EVENT,忽略这个事件,如果是INPUT_PASS_TO_HANDLERS则是传递给事件处理器,如果是
INPUT_PASS_TO_DEVICE,则是传递给设备处理。
3)input_pass_event()函数
static void input_pass_event(struct input_dev *dev,
unsigned int type, unsigned int code, int value)
{
struct input_handler *handler;
struct input_handle *handle; rcu_read_lock();
//如果是绑定的handle,则调用绑定的handler->event函数
handle = rcu_dereference(dev->grab);
if (handle)
handle->handler->event(handle, type, code, value);
else {
bool filtered = false;
//如果没有绑定,则遍历dev的h_list链表,寻找handle,如果handle已经打开,说明有进程读取设备关联的evdev
list_for_each_entry_rcu(handle, &dev->h_list, d_node) {
if (!handle->open)
continue; handler = handle->handler;
if (!handler->filter) {
if (filtered)
break;
//调用相关的事件处理器的event函数,进行事件的处理
handler->event(handle, type, code, value); } else if (handler->filter(handle, type, code, value))
filtered = true;
}
} rcu_read_unlock();
}
4)evdev_event()函数
static void evdev_event(struct input_handle *handle,
unsigned int type, unsigned int code, int value)
{
struct evdev *evdev = handle->private;
struct evdev_client *client;
struct input_event event;
//将传过来的事件,赋值给input_event结构
do_gettimeofday(&event.time);
event.type = type;
event.code = code;
event.value = value; rcu_read_lock();
//如果evdev绑定了client那么,处理这个客户端
client = rcu_dereference(evdev->grab);
if (client)
evdev_pass_event(client, &event);
else
//遍历client链表,调用evdev_pass_event函数
list_for_each_entry_rcu(client, &evdev->client_list, node)
evdev_pass_event(client, &event); rcu_read_unlock();
if (type == EV_SYN && code == SYN_REPORT)
{//唤醒等待的进程
wake_up_interruptible(&evdev->wait);
}
}
5)evdev_pass_event()函数
static void evdev_pass_event(struct evdev_client *client,
struct input_event *event)
{
/* Interrupts are disabled, just acquire the lock. */
spin_lock(&client->buffer_lock);
//将事件赋值给客户端的input_event数组
client->buffer[client->head++] = *event;
client->head &= client->bufsize - ; if (unlikely(client->head == client->tail)) {
/*
* This effectively "drops" all unconsumed events, leaving
* EV_SYN/SYN_DROPPED plus the newest event in the queue.
*/
client->tail = (client->head - ) & (client->bufsize - ); client->buffer[client->tail].time = event->time;
client->buffer[client->tail].type = EV_SYN;
client->buffer[client->tail].code = SYN_DROPPED;
client->buffer[client->tail].value = ; client->packet_head = client->tail;
} if (event->type == EV_SYN && event->code == SYN_REPORT) {
client->packet_head = client->head;
kill_fasync(&client->fasync, SIGIO, POLL_IN);
} spin_unlock(&client->buffer_lock);
}
可以看出,evdev_pass_event函数最终将事件传递给了用户端的client结构中的input_event数组中,
只需将这个input_event数组复制给用户空间,进程就能收到触摸屏按下的信息了。具体处理由具体的应用程序来完成。
linux 输入设备驱动的更多相关文章
- linux设备驱动的分层设计思想--input子系统及RTC
转自:linux设备驱动的分层设计思想 宋宝华 http://blog.csdn.net/21cnbao/article/details/5615493 1.1 设备驱动核心层和例化 在面向对象的程序 ...
- Android中Input型输入设备驱动原理分析(一)
转自:http://blog.csdn.net/eilianlau/article/details/6969361 话说Android中Event输入设备驱动原理分析还不如说Linux输入子系统呢,反 ...
- Linux设备驱动模型之I2C总线
一.I2C子系统总体架构 1.三大组成部分 (1)I2C核心(i2c-core):I2C核心提供了I2C总线驱动(适配器)和设备驱动的注册.注销方法,提供了与具体硬件无关的I2C读写函数. (2)I2 ...
- Android中Input型输入设备驱动原理分析<一>
话说Android中Event输入设备驱动原理分析还不如说Linux输入子系统呢,反正这个是没变的,在android的底层开发中对于Linux的基本驱动程序设计还是没变的,当然Android底层机制也 ...
- linux 设备驱动概述
linux 设备驱动概述 目前,Linux软件工程师大致可分为两个层次: (1)Linux应用软件工程师(Application Software Engineer): 主要利用C库函数和 ...
- Linux输入设备详解
<什么是Linux输入设备> ➤简介 Linux输入设备总类繁杂,常见的包括有按键.键盘.触摸屏.鼠标.摇杆等等,他们本身就是字符设备,而linux内核将这些设备的共同性抽象出来 ...
- Linux设备驱动中的软件架构思想
目录 更新记录 一.Linux驱动的软件架构 1.1 出发点 1.2 分离思想 1.3 分层思想 二.platform设备驱动 2.1 platform设备 2.2 platform驱动 2.3 pl ...
- Linux网络驱动--snull
snull是<Linux Device Drivers>中的一个网络驱动的例子.这里引用这个例子学习Linux网络驱动. 因为snull的源码,网上已经更新到适合最新内核,而我自己用的还是 ...
- 浅谈Android系统移植、Linux设备驱动
一.Android系统架构 第一层:Linux内核 包括驱动程序,管理内存.进程.电源等资源的程序 第二层:C/C++代码库 包括Linux的.so文件以及嵌入到APK程序中的NDK代码 第三层:An ...
随机推荐
- Ajax跨域CORS
在Ajax2.0中多了CORS允许我们跨域,但是其中有着几种的限制:Origin.Methods.Headers.Credentials 1.Origin 当浏览器用Ajax跨域请求的时候,会带上一个 ...
- ideau 2018.1.2安装和使用
此博文的各安装软件.方法技巧仅供研究使用,请勿用于商业活动.下载.操作后请于24小时内删除.对于使用过程中出现的一切问题.责任.纠纷,概不负责. 1.下载ideau-2018.1.2,点击下载,提取码 ...
- JVM调优命令-jps
JVM Process Status Tool,显示指定系统内所有的HotSpot虚拟机进程. 命令格式 1 jps [options] [hostid] options参数-l : 输出主类全名或j ...
- RESTful记录-RESTful服务
按照REST架构,一个RESTful Web服务不应该继续服务器的客户端的状态.这种限制被称为无状态.它负责客户以它的上下文传递给服务器,然后服务器可以存储这样的上下文,以处理客户端的进一步请求.例如 ...
- POJ - 3020 Antenna Placement(最小覆盖路径)
---恢复内容开始--- https://vjudge.net/problem/POJ-3020 题意 *--代表城市,o--代表空地 给城市安装无线网,一个无线网最多可以覆盖两座城市,问覆盖所有城市 ...
- spring+spring mvc+JdbcTemplate 入门小例子
大家使用这个入门时候 最好能够去 搜一下 spring mvc 的 原理,我放一张图到这里,自己琢磨下,后面去学习就容易了 给个链接 (网上一把,千万不能懒) https://www.cnblo ...
- Kafka 温故(四):Kafka的安装
Step 1: 下载Kafka > tar -xzf kafka_2.9.2-0.8.1.1.tgz> cd kafka_2.9.2-0.8.1.1 Step 2: 启动服务Kafka用到 ...
- 关于Cookie跨域的问题
Cookie是一个伟大的发明,它允许Web开发者保留他们的用户的登录状态.但是当你的站点有一个以上的域名时就会出现问题了.在Cookie规范上说,一个cookie只能用于一个域名,不能够发给其它的域名 ...
- J2EE架构
从整体上讲,J2EE是使用Java技术开发企业级应用的一种事实上的工业标准(Sun公司出于其自身利益的考虑,至今没有将Java及其相关技术纳入标准化组织的体系),它是Java技术不断适应和促进企业级应 ...
- LINUX下 USB转串口 【转】
转自:http://blog.163.com/smilexiao_11015461/blog/static/2122052182012102410399459/ 1.将设备u口插入pc2.输入#lsm ...