本文主要探讨210的input子系统。
input子系统
input子系统包含:设备驱动层,输入核心层,事件驱动层
事件处理层：接收核心层上报事件选择对应struct input_handler处理,每个input_handler对象处理一类事件,同类事件的设备驱动共用同一handler
核心层：连接设备驱动层和事件处理层,为设备驱动层提供输入设备驱动接口(struct input_dev)以及输入设备驱动注册函数(input_register_device),为事件处理层提供输入事件驱动接口,通知事件处理层对事件处理
设备驱动层:获取硬件设备信息,并转换为核心层定义的规范事件后提交给核心层,每个设备均被描述为struct input_dev对象
结构体
input_dev结构体是硬件驱动层代表input设备结构体
// include/linux/input.h
struct input_dev {const char *name; /* 设备名称 */const char *phys; /* 设备在系统中的路径 */const char *uniq; /* 设备唯一id */struct input_id id; /* input设备id号 */unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)]; unsigned long evbit[BITS_TO_LONGS(EV_CNT)]; /* 设备支持的事件类型，主要有EV_SYNC，EV_KEY，EV_KEY,EV_REL,EV_ABS等*/ 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; /* 支持最大按键数 */unsigned int keycodesize; /* 每个键值字节数 */void *keycode; /* 存储按键值的数组的首地址 */int (*setkeycode)(struct input_dev *dev,const struct input_keymap_entry *ke,unsigned int *old_keycode);int (*getkeycode)(struct input_dev *dev,struct input_keymap_entry *ke);struct ff_device *ff; /* 设备关联的反馈结构，如果设备支持 */unsigned int repeat_key; /* 最近一次按键值，用于连击 */struct timer_list timer; /* 自动连击计时器 */int rep[REP_CNT]; /* 自动连击参数 */struct input_mt *mt; /* 多点触控区域 */struct input_absinfo *absinfo; /* 存放绝对值坐标的相关参数数组 */unsigned long key[BITS_TO_LONGS(KEY_CNT)]; /* 反应设备当前的按键状态 */unsigned long led[BITS_TO_LONGS(LED_CNT)]; /* 反应设备当前的led状态 */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); /* 事件处理函数，主要是接收用户下发的命令，如点亮led */struct input_handle __rcu *grab; /* 当前占有设备的input_handle */spinlock_t event_lock; /* 事件锁 */struct mutex mutex; /* 互斥体 */unsigned int users; /* 打开该设备的用户数量（input_handle） */bool going_away; /* 标记正在销毁的设备 */struct device dev; /* 设备 */struct list_head h_list; /* 设备所支持的input handle */struct list_head node; /* 用于将此input_dev连接到input_dev_list */unsigned int num_vals; /* 当前帧中排队的值数 */unsigned int max_vals; /* 队列最大的帧数*/struct input_value *vals; /* 当前帧中排队的数组*/bool devres_managed; /* 表示设备被devres 框架管理，不需要明确取消和释放*/
};input_handler结构体是事件层代表事件处理器
// include/linux/input.h
struct input_handler {void *private; /* 存放handle数据 */void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);void (*events)(struct input_handle *handle,const struct input_value *vals, unsigned int count);bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);bool (*match)(struct input_handler *handler, struct input_dev *dev);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 file_operations *fops;bool legacy_minors;int minor;const char *name; /* 名字 */const struct input_device_id *id_table; /* input_dev匹配用的id */struct list_head h_list; /* 用于链接和handler相关的handle，input_dev与input_handler配对之后就会生成一个input_handle结构 */struct list_head node; /* 用于将该handler链入input_handler_list，链接所有注册到内核的所有注册到内核的事件处理器 */
};
input_handle结构体属于核心层代表配对input设备(input_dev)与input事件处理器(input_handler)
// include/linux/input.h
struct input_handle {void *private; /* 数据指针 */int open; /* 打开标志，每个input_handle 打开后才能操作 */const char *name; /* 设备名称 */struct input_dev *dev; /* 指向所属的input_dev */struct input_handler *handler; /* 指向所属的input_handler */struct list_head d_node; /* 用于链入所指向的input_dev的handle链表 */struct list_head h_node; /* 用于链入所指向的input_handler的handle链表 */
};Evdev字符设备事件结构体
/* drivers/input/evdev.c */
struct evdev {int open; /* 设备被打开的计数 */struct input_handle handle; /* 关联的input_handle */ wait_queue_head_t wait; /* 等待队列，当前进程读取设备，没有事件产生时，
进程就会sleep */struct evdev_client __rcu *grab; /* event响应 */
struct list_head client_list; /* evdev_client链表，说明evdev设备可以处理多个 evdev _client，可以有多个进程访问evdev设备 */spinlock_t client_lock;struct mutex mutex;struct device dev;struct cdev cdev;bool exist; /* 设备存在判断 */
};evdev_client字符设备事件响应结构体
struct evdev_client {unsigned int head; /* 动态索引，每加入一个event到buffer中，head++ */unsigned int tail; /* 动态索引，每取出一个buffer中到event，tail++ */unsigned int packet_head; /* 数据包头部 */spinlock_t buffer_lock; struct fasync_struct *fasync; /* 异步通知函数 */struct evdev *evdev;struct list_head node; /* evdev_client链表项 */int clkid;bool revoked;unsigned int bufsize;struct input_event buffer[]; /* 用来存放input_dev事件缓冲区 */
};
evdev_handler事件处理函数结构体
/* drivers/input/input.c */
static struct input_handler evdev_handler = {.event = evdev_event, /* 事件处理函数， */ .events = evdev_events, /* 事件处理函数， */.connect = evdev_connect, /* 连接函数，将事件处理和输入设备联系起来 */.disconnect = evdev_disconnect, /* 断开该链接 */.legacy_minors = true,.minor = EVDEV_MINOR_BASE,.name = "evdev", /* handler名称 */.id_table = evdev_ids, /* 断开该链接 */
};input_event结构体(按键编码信息)
/* drivers/input/evdev.c */
struct input_event { struct timeval time; /* 事件发生的时间 */ __u16 type; /* 事件类型 */ __u16 code; /* 事件码 */ __s32 value; /* 事件值 */
};
inputcore
subsys_initcall(input_init);
module_exit(input_exit);static int __init input_init(void)
{int err;input_init_abs_bypass();err = class_register(&input_class);if (err) {printk(KERN_ERR "input: unable to register input_dev class\n");return err;}err = input_proc_init();if (err)goto fail1;err = register_chrdev(INPUT_MAJOR, "input", &input_fops);if (err) {printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);goto fail2;}return 0;fail2: input_proc_exit();fail1: class_unregister(&input_class);return err;
}struct class input_class = {.name = "input",.devnode = input_devnode,
};#define INPUT_MAJOR 13static const struct file_operations input_fops = {.owner = THIS_MODULE,.open = input_open_file,
}; class_register注册输入设备类/sys/class/input
input_proc_init注册proce文件/proc/bus/input
register_chrdevs注册设备注册,主设备号为13
static int input_open_file(struct inode *inode, struct file *file)
{struct input_handler *handler;const struct file_operations *old_fops, *new_fops = NULL;int err;err = mutex_lock_interruptible(&input_mutex);if (err)return err;/* No load-on-demand here? */handler = input_table[iminor(inode) >> 5];if (handler)new_fops = fops_get(handler->fops);mutex_unlock(&input_mutex);/** That's _really_ odd. Usually NULL ->open means "nothing special",* not "no device". Oh, well...*/if (!new_fops || !new_fops->open) {fops_put(new_fops);err = -ENODEV;goto out;}old_fops = file->f_op;file->f_op = new_fops;err = new_fops->open(inode, file);if (err) {fops_put(file->f_op);file->f_op = fops_get(old_fops);}fops_put(old_fops);
out:return err;
}static const struct file_operations input_fops = {.owner = THIS_MODULE,.open = input_open_file,
};static struct input_handler *input_table[8];handler = input_table[iminor(inode) >> 5]; 获取子设备号并除以32的值为input驱动数组号,来获取对应input_handler中的fops
input_table为input_register_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 >> 5]) {retval = -EBUSY;goto out;}input_table[handler->minor >> 5] = handler;}list_add_tail(&handler->node, &input_handler_list);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;
}static int __init evdev_init(void)
{return input_register_handler(&evdev_handler);
}依据evdev.c分析input_register_hndler
static struct input_handler evdev_handler = {.event = evdev_event,.connect = evdev_connect,.disconnect = evdev_disconnect,.fops = &evdev_fops,.minor = EVDEV_MINOR_BASE,.name = "evdev",.id_table = evdev_ids,
};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
}#define EVDEV_MINOR_BASE 64static const struct input_device_id evdev_ids[] = {{ .driver_info = 1 }, /* Matches all devices */{ }, /* Terminating zero entry */
};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;struct timespec ts;ktime_get_ts(&ts);event.time.tv_sec = ts.tv_sec;event.time.tv_usec = ts.tv_nsec / NSEC_PER_USEC;event.type = type;event.code = code;event.value = value;rcu_read_lock();client = rcu_dereference(evdev->grab);if (client)evdev_pass_event(client, &event);elselist_for_each_entry_rcu(client, &evdev->client_list, node)evdev_pass_event(client, &event);rcu_read_unlock();wake_up_interruptible(&evdev->wait);
}static int evdev_connect(struct input_handler *handler, struct input_dev *dev,const struct input_device_id *id)
{struct evdev *evdev;int minor;int error;for (minor = 0; minor < EVDEV_MINORS; minor++)if (!evdev_table[minor])break;if (minor == EVDEV_MINORS) {printk(KERN_ERR "evdev: no more free evdev devices\n");return -ENFILE;}evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);if (!evdev)return -ENOMEM;INIT_LIST_HEAD(&evdev->client_list);spin_lock_init(&evdev->client_lock);mutex_init(&evdev->mutex);init_waitqueue_head(&evdev->wait);dev_set_name(&evdev->dev, "event%d", minor);evdev->exist = 1;evdev->minor = minor;evdev->handle.dev = input_get_device(dev);evdev->handle.name = dev_name(&evdev->dev);evdev->handle.handler = handler;evdev->handle.private = evdev;evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);evdev->dev.class = &input_class;evdev->dev.parent = &dev->dev;evdev->dev.release = evdev_free;device_initialize(&evdev->dev);error = input_register_handle(&evdev->handle);if (error)goto err_free_evdev;error = evdev_install_chrdev(evdev);if (error)goto err_unregister_handle;error = device_add(&evdev->dev);if (error)goto err_cleanup_evdev;return 0;err_cleanup_evdev:evdev_cleanup(evdev);err_unregister_handle:input_unregister_handle(&evdev->handle);err_free_evdev:put_device(&evdev->dev);return error;
}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)list_add_rcu(&handle->d_node, &dev->h_list);elselist_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.*/list_add_tail_rcu(&handle->h_node, &handler->h_list);if (handler->start)handler->start(handle);return 0;
} input_register_handler为事件注册函数,struct input_handler为事件处理结构体
evdev_init调用input_register_handler和struct input_handler evdev_handler注册evdev设备事件
evdev_fops为edev类型设备操作函数,EVDEV_MINOR_BASE为64存在input_table[2]中
id_table为handler支持的输入设备(input_dev->id==input_handler->id_table,调用connect)
设备驱动层
int input_register_device(struct input_dev *dev)
{static atomic_t input_no = ATOMIC_INIT(0);struct input_handler *handler;const char *path;int error;/* Every input device generates EV_SYN/SYN_REPORT events. */__set_bit(EV_SYN, dev->evbit);/* KEY_RESERVED is not supposed to be transmitted to userspace. */__clear_bit(KEY_RESERVED, dev->keybit);/* Make sure that bitmasks not mentioned in dev->evbit are clean. */input_cleanse_bitmasks(dev);/** If delay and period are pre-set by the driver, then autorepeating* is handled by the driver itself and we don't do it in input.c.*/init_timer(&dev->timer);if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {dev->timer.data = (long) dev;dev->timer.function = input_repeat_key;dev->rep[REP_DELAY] = 250;dev->rep[REP_PERIOD] = 33;}if (!dev->getkeycode)dev->getkeycode = input_default_getkeycode;if (!dev->setkeycode)dev->setkeycode = input_default_setkeycode;dev_set_name(&dev->dev, "input%ld",(unsigned long) atomic_inc_return(&input_no) - 1);error = device_add(&dev->dev);if (error)return error;path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);printk(KERN_INFO "input: %s as %s\n",dev->name ? dev->name : "Unspecified device", path ? path : "N/A");kfree(path);error = mutex_lock_interruptible(&input_mutex);if (error) {device_del(&dev->dev);return error;}list_add_tail(&dev->node, &input_dev_list);list_for_each_entry(handler, &input_handler_list, node)input_attach_handler(dev, handler);input_wakeup_procfs_readers();mutex_unlock(&input_mutex);return 0;
}static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{const struct input_device_id *id;int error;id = input_match_device(handler, dev);if (!id)return -ENODEV;error = handler->connect(handler, dev, id);if (error && error != -ENODEV)printk(KERN_ERR"input: failed to attach handler %s to device %s, ""error: %d\n",handler->name, kobject_name(&dev->dev.kobj), error);return error;
}list_add_tail(&dev->node, &input_dev_list);
list_for_each_entry(handler, &input_handler_list, node)input_attach_handler(dev, handler); 将要注册input_dev驱动设备放在input_dev_list链表中,调用input_attach_handler函数，将每个input_handle的id_table进连接接
注册input_handler类同设备注册通过inputhandle将input_handler和input_dev连接(id匹配)
int input_register_handler(struct input_handler *handler)
{......list_add_tail(&handler->node, &input_handler_list);list_for_each_entry(dev, &input_dev_list, node)input_attach_handler(dev, handler);......
}核心层提供给设备驱动层的接口函数
struct input_dev *input_allocate_device(void);
分配input_dev内存
void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code);
设置输入设备上报事件，input_set_capability(dev, EV_KEY, KEY_E);
dev:input_dev结构体,type上报事件类型,code上报具体事件
int input_register_device(struct input_dev *dev);
input核心层注册设备demo:
210内核自带轮循方式检测按键，自写中断方式
button-x210.c
#include <linux/input.h>
#include <linux/module.h>
#include <linux/init.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <mach/irqs.h>
#include <linux/interrupt.h>
#include <linux/gpio.h>#define BUTTON_IRQ_LEFT IRQ_EINT2static struct input_dev *button_dev;static irqreturn_t button_interrupt(int irq, void *dummy)
{ int flag;//中断产生,设置gpio为输入模式下获取gpio号s3c_gpio_cfgpin(S5PV210_GPH0(2), S3C_GPIO_SFN(0x0));flag = gpio_get_value(S5PV210_GPH0(2));//重新置为中断模式s3c_gpio_cfgpin(S5PV210_GPH0(2), S3C_GPIO_SFN(0x0f));//上报按键中断事件input_report_key(button_dev, KEY_LEFT, !flag);//同步按键中断input_sync(button_dev);return IRQ_HANDLED;
}static int __init button_init(void)
{ int error;//申请gpioerror = gpio_request(S5PV210_GPH0(2), "GPH0_2");if(error){printk("button-x210.c: request gpio GPH0(2) fail");return -EBUSY;}//配置gpio为中断模式s3c_gpio_cfgpin(S5PV210_GPH0(2), S3C_GPIO_SFN(0x0f));//申请中断if (request_irq(BUTTON_IRQ_LEFT, button_interrupt, 0, "button", NULL)) { printk(KERN_ERR "button-x210.c: Can't allocate irq %d\n", BUTTON_IRQ_LEFT);goto err_free_gpio;return -EBUSY; }//申请设备内存button_dev = input_allocate_device();if (!button_dev) { printk(KERN_ERR "button-x210.c: Not enough memory\n");error = -ENOMEM;goto err_free_irq; }//设备初始化button_dev->name = "x210";//设置设备上报事件input_set_capability(button_dev, EV_KEY, KEY_LEFT);//设备注册error = input_register_device(button_dev);if (error) { printk(KERN_ERR "button-x210.c: Failed to register device\n");goto err_free_dev; }return 0;err_free_dev:input_free_device(button_dev);err_free_irq:free_irq(BUTTON_IRQ_LEFT, button_interrupt);err_free_gpio:gpio_free(S5PV210_GPH0(2));return error;
}static void __exit button_exit(void)
{ input_unregister_device(button_dev); input_free_device(button_dev);free_irq(BUTTON_IRQ_LEFT, NULL);gpio_free(S5PV210_GPH0(2));
}module_init(button_init);
module_exit(button_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("cxb");
MODULE_DESCRIPTION("button module");
MODULE_ALIAS("button");button.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <linux/input.h>
#include <string.h>#define X210_KEY "/dev/input/event2"int main(void)
{int fd = -1, ret = -1;struct input_event ev;fd = open(X210_KEY, O_RDONLY);if (fd < 0){perror("open");return -1;}while (1){memset(&ev, 0, sizeof(struct input_event));ret = read(fd, &ev, sizeof(struct input_event));if (ret != sizeof(struct input_event)){perror("read");close(fd);return -1;}printf("-------------------------\n");printf("type: %hd\n", ev.type);printf("code: %hd\n", ev.code);printf("value: %d\n", ev.value);printf("\n");}close(fd);return 0;
}操作流程：
cd /root/kernel/arch/arm/mach-s5pv210rm button-x210.ovim Makefile#obj-$(CONFIG_MACH_SMDKV210) += button-x210.omake -j8
