一 引入输入子系统的目的
二 输入子系统框架
三 输入子系统之核心层简述
四 输入子系统之事件处理层简述
五 输入子系统之驱动层简述
六 TP调试记录
一 引入输入子系统的目的
个人理解是为了 将输入设备的功能直接提供给用户空间，如果按照普通字符设备的方式编写输入设备，那么我们自己的驱动会生成我们自己命名的设备节点，只有我们自己知道设备节点名称，也就是只有我们自己可以打开这个设备节点，此时这种驱动程序只能自己使用。如果想使自己的驱动程序生成的节点成为“公共的”，即生成的节点可以直接被打开使用，各种应用程序都可以调用该节点，那么就引入 “输入子系统”
二 输入子系统框架
输入子系统分为三部分：
1：设备层 如matrix_key.c / gpio_keys.c等等 ：和硬件相关的底层驱动（我们需要实现的部分），主要实现对硬件设备的读写访问，中断设置，把底层硬件的输入事件 上报给核心层。
2：核心层 input.c ：为 设备驱动层输入设备 以及 事件处理层 提供注册和操作的接口，并且传递设备层数据到时间处理层
3：事件处理层 Evdev.c ：则是用户编程的接口（设备节点），并处理驱动层提交的数据处理。
三 输入子系统之核心层简述
3.1 核心层功能
1创建注册字符设备
2为设备驱动层提供注册操作接口
3为事件处理层提供注册操作接口
4为 设备驱动层 与 事件处理层 提供匹配函数接口
3.2 关键函数举例
//创建字符设备结构体 ： truct file_operations input_handlers_fileops
//注册字符设备 ： __init input_init
//创建 proc 文件系统相关 ： __init input_proc_init(void)
//用于匹配 底层驱动 与 上层handler (匹配成功则调用 handler的connect函数) ：input_attach_handler
//进行 handler 与 device（输入设备） 的匹配 ：struct input_device_id *input_match_device
3.3 关键函数说明
//注册字符设备
static int __init input_init(void)
{
int err;
//创建设备类
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;
//注册字符设备
err = register_chrdev_region(MKDEV(INPUT_MAJOR, 0),
INPUT_MAX_CHAR_DEVICES, "input");
if (err) {
pr_err("unable to register char major %d", INPUT_MAJOR);
goto fail2;
}
return 0;
fail2: input_proc_exit();
fail1: class_unregister(&input_class);
return err;
}
//创建 proc 文件系统相关
static int __init input_proc_init(void)
{
struct proc_dir_entry *entry;
//在 /proc/bus 目录下创建 input目录
proc_bus_input_dir = proc_mkdir("bus/input", NULL);
if (!proc_bus_input_dir)
return -ENOMEM;
//在 /proc/bus/input 目录下创建 devices 文件
entry = proc_create("devices", 0, proc_bus_input_dir,
&input_devices_fileops);
if (!entry)
goto fail1;
//在 /proc/bus/input 目录下创建 handlers 文件
entry = proc_create("handlers", 0, proc_bus_input_dir,
&input_handlers_fileops);
if (!entry)
goto fail2;
return 0;
fail2: remove_proc_entry("devices", proc_bus_input_dir);
fail1: remove_proc_entry("bus/input", NULL);
return -ENOMEM;
}
//创建字符设备结构体
static const struct file_operations input_handlers_fileops = {
.owner = THIS_MODULE,
.open = input_proc_handlers_open,
.read = seq_read,
.llseek = seq_lseek,
.release = seq_release,
};
//用于匹配 底层驱动 与 上层handler (匹配成功则调用 handler的connect函数)
static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
const struct input_device_id *id;
int error;
//进行 handler 与 device（输入设备） 的匹配
id = input_match_device(handler, dev);
if (!id)
return -ENODEV;
//如果匹配成功 则调用 handler中的connect函数进行连接
error = handler->connect(handler, dev, id);
if (error && error != -ENODEV)
pr_err("failed to attach handler %s to device %s, error: %d\n",
handler->name, kobject_name(&dev->dev.kobj), error);
return error;
}
static const struct input_device_id *input_match_device(struct input_handler *handler,
struct input_dev *dev)
{
const struct input_device_id *id;
//遍历 handler->id_table 中的全部 input_device_id（输入设备ID）
for (id = handler->id_table; id->flags || id->driver_info; id++) {
if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
if (id->bustype != dev->id.bustype)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
if (id->vendor != dev->id.vendor)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
if (id->product != dev->id.product)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
if (id->version != dev->id.version)
continue;
if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX))
continue;
if (!bitmap_subset(id->keybit, dev->keybit, KEY_MAX))
continue;
if (!bitmap_subset(id->relbit, dev->relbit, REL_MAX))
continue;
if (!bitmap_subset(id->absbit, dev->absbit, ABS_MAX))
continue;
if (!bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX))
continue;
if (!bitmap_subset(id->ledbit, dev->ledbit, LED_MAX))
continue;
if (!bitmap_subset(id->sndbit, dev->sndbit, SND_MAX))
continue;
if (!bitmap_subset(id->ffbit, dev->ffbit, FF_MAX))
continue;
if (!bitmap_subset(id->swbit, dev->swbit, SW_MAX))
continue;
if (!handler->match || handler->match(handler, dev))
return id;
}
return NULL;
}
3.4 小结：
核心层为 设备驱动层 提供的接口有：
//分配 input_dev 结构体
input_allocate_device(void) ：
//设置 输入设备所上报的事件
input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
//向 核心层 注册设备
int input_register_device(struct input_dev *dev)
核心层为 事件层 提供的接口有：
input_register_handler :事件层向核心层注册 handler （handler 与 input_dev成对应关系）
input_regiser_handle :事件层向核心层注册 handle (不同于 handler，handle是用于记录匹配成功的 handler与input_dev) handle是用于记录匹配成功的 handler与input_dev,可以通过 handle获得 input_dev 以及 handler的信息
核心层关键点1
输入系统注册设备时，设备注册 与 handler注册 后的匹配过过程 和 platform平台有些相似，设备与 handler 注册时都会各自把 dev 或 handler 挂在各自设备链表 或 事件链表上，然后去遍历对方的事件链表 或 设备链表，input_dev 与 handler是多对多的关系
核心层关键点2
input_dev_list 链表上的 input_dev设备节点
input_handler_list 链表上的 handler 事件节点
input_dev_list 链表 和 input_handler_list 链表 上对应的节点都会有一个 匹配记录结构体 handle,用于记录匹配信息，所以 两个链表上的节点 可以通过handle 互相访问；
核心层关键点3
核心层总结：
1创建注册字符设备
2为设备驱动层提供注册操作接口
3为事件处理层提供注册操作接口
4为 设备驱动层 与 事件处理层 提供匹配函数接口
四 输入子系统之事件处理层简述
注意 ：此处 事件处理层 只做简单描述，主要是为了加强印象，日后有时间补充。
struct input_handler {
void *private;
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 file_operations *fops;
int minor; //次设备号
const char *name;
const struct input_device_id *id_table;
const struct input_device_id *blacklist;
struct list_head h_list; //h_list是一个链表头，用来把handle挂载在这个上
struct list_head node; //这个node是用来连到input_handler_list上的
};
struct input_handle {
void *private;
int open;
const char *name;
struct input_dev *dev; //指向input_dev
struct input_handler *handler; //指向input_handler
struct list_head d_node; //连到input_dev的h_list上
struct list_head h_node; //连到input_handler的h_list上
};
1 事件处理层描述：
输入子系统上层其实是由多个事件（handler）组成的，各个事件之间的关系是平行关系，互不干扰，用的较多的是event,此处以event为例，事件处理层 属于 input输入子系统上层
2 事件处理层主要框架简述
static const struct input_device_id evdev_ids[] = {
{ .driver_info = 1 }, /* Matches all devices */
{ }, /* Terminating zero entry */
};
MODULE_DEVICE_TABLE(input, evdev_ids);
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",
.id_table = evdev_ids,
};
static int __init evdev_init(void)
{
return input_register_handler(&evdev_handler);
}
static void __exit evdev_exit(void)
{
input_unregister_handler(&evdev_handler);
}
module_init(evdev_init);
module_exit(evdev_exit);
五 输入子系统之驱动层简述
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; //设备的键盘表
//配置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);
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)];
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;
spinlock_t event_lock;
struct mutex mutex;
unsigned int users;
bool going_away;
struct device dev;
struct list_head h_list; //h_list是一个链表头，用来把handle挂载在这个上
struct list_head node; //这个node是用来连到input_dev_list上的
unsigned int num_vals;
unsigned int max_vals;
struct input_value *vals;
bool devres_managed;
};
// input_dev->evbit 表示设备支持的事件类型，可以是下列值的组合
#define EV_SYN 0x00 //同步事件
#define EV_KEY 0x01 //绝对二进制值，如键盘或按钮
#define EV_REL 0x02 //绝对结果，如鼠标设备
#define EV_ABS 0x03 //绝对整数值，如操纵杆或书写板
#define EV_MSC 0x04 //其它类
#define EV_SW 0x05 //开关事件
#define EV_LED 0x11 //LED或其它指示设备
#define EV_SND 0x12 //声音输出，如蜂鸣器
#define EV_REP 0x14 //允许按键自重复
#define EV_FF 0x15 //力反馈
#define EV_PWR 0x16 //电源管理事件
说明：
在输入子系统框架下，我们一般的编写驱动也就是对device部分j即驱动层进行编写（分配input_dev并配置，驱动入口，出口，中断时进行中断判断，然后上报事件等），然后对该device的input_dev进行注册。
问题：我们在编写 输入子系统驱动的时候，是怎么将驱动层与事务管理层联系起来的，驱动层千篇一律的一个步骤代码中道理做了什么？
5.1 驱动层关键代码说明
//步骤一：
1. 分配一个 input_dev 设备结构体
2. 初始化 设置 input 输入设备结构体设备属性
3. 设置你的input设备支持的事件类型以及所支持的事件
//步骤二：
1. 注册中断处理函数，在中断处理程序中上报事件
//步骤三：
1. 注册输入设备到输入字系统
注意：驱动层input输入子系统的工作很简单，主要在 prob函数 和 中断函数中,
static int matrix_keypad_probe(struct platform_device *pdev)
{
//输入设备结构体
struct input_dev *input_dev;
//将会分配一个 input_dev 设备结构体，并且在 /sys/class/input/input-n 下创建设备属性文件
input_dev = input_allocate_device();
//初始化 设置 input 输入设备结构体
input_dev->name = pdev->name;
input_dev->id.bustype = BUS_HOST;
input_dev->dev.parent = &pdev->dev;
input_dev->open = matrix_keypad_start;
input_dev->close = matrix_keypad_stop;
//设置支持的按键事件类型，如设置支持按键类型
input_dev->evbit[0] = BIT_MASK(EV_KEY);
//所支持的事件 如设置支持 KEY_F18/KEY_F19/KEY_F20/KEY_F21/KEY_F22按键事件
set_bit(KEY_F18, input_dev->keybit);
set_bit(KEY_F19, input_dev->keybit);
set_bit(KEY_F20, input_dev->keybit);
set_bit(KEY_F21, input_dev->keybit);
set_bit(KEY_F22, input_dev->keybit);
//注册 input输入设备
err = input_register_device(keypad->input_dev);
}
//上报事件
XXXX_interrupt
{
//提交输入事件
input_event(input_dev, EV_MSC, MSC_SCAN, code);
//提交按键值
input_report_key(input_dev,keycodes[code],new_state[col] & (1 << row));
//同步
input_sync(input_dev);
}
5.2 input_register_device关键信息分析
int input_register_device(struct input_dev *dev)
{
struct input_devres *devres = NULL;
struct input_handler *handler;
unsigned int packet_size;
const char *path;
int error;
if (dev->devres_managed) {
devres = devres_alloc(devm_input_device_unregister,
sizeof(struct input_devres), GFP_KERNEL);
if (!devres)
return -ENOMEM;
devres->input = dev;
}
/* 看注释 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);
packet_size = input_estimate_events_per_packet(dev);
if (dev->hint_events_per_packet < packet_size)
dev->hint_events_per_packet = packet_size;
dev->max_vals = dev->hint_events_per_packet + 2;
dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);
if (!dev->vals) {
error = -ENOMEM;
goto err_devres_free;
}
/*
* 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.
*/
if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD])
input_enable_softrepeat(dev, 250, 33);
if (!dev->getkeycode)
dev->getkeycode = input_default_getkeycode;
if (!dev->setkeycode)
dev->setkeycode = input_default_setkeycode;
error = device_add(&dev->dev);
if (error)
goto err_free_vals;
path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
pr_info("%s as %s\n",
dev->name ? dev->name : "Unspecified device",
path ? path : "N/A");
kfree(path);
error = mutex_lock_interruptible(&input_mutex);
if (error)
goto err_device_del;
list_add_tail(&dev->node, &input_dev_list);
/ 将新分配的input设备连接到input_dev_list链表上
list_for_each_entry(handler, &input_handler_list, node)
input_attach_handler(dev, handler);///遍历input_handler_list链表，配对 input_dev 和 input_handler，
input_wakeup_procfs_readers();
mutex_unlock(&input_mutex);
if (dev->devres_managed) {
dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n",
__func__, dev_name(&dev->dev));
devres_add(dev->dev.parent, devres);
}
return 0;
err_device_del:
device_del(&dev->dev);
err_free_vals:
kfree(dev->vals);
dev->vals = NULL;
err_devres_free:
devres_free(devres);
return error;
}
输入系统大致流程： 设备驱动 --> 核心层 --> 事件处理层 --> 用户空间
六 输入子系统实例1
场景说明：
3288主板I2C4 连接外部单片机小板，外部小板按键板按键 发生变化时通过中断提示3288主板，3288主板通过i2c获取外部小板某寄存器内数值。将这按键变化的数值 与内核输入子系统中的 KEY_F18, KEY_F19, KEY_F20, KEY_F21, KEY_F22 一一对应。并将键值上报。
static int chensai_i2c_read( struct i2c_client* client,unsigned char reg,uint8_t *data, char device_addr)
{
int ret;
struct i2c_msg msgs[] = {
{
.addr = device_addr,
.flags = 0,
// .len = 1,
.len = sizeof(reg),
.buf = ®,// 寄存器地址
},
{
.addr = device_addr,
// .flags = I2C_M_RD,0x01
.flags = I2C_M_RD,
.len = sizeof(data),
.buf = data,// 寄存器的值
},
};
ret = i2c_transfer(client->adapter, msgs, 2);
if (ret < 0)
{
printk("i2c read error\n");
}
return ret;
}
static irqreturn_t chensai_irq_handler(int irq, void *dev_id)
{
int gpio_val;
int keys_val[5];
int i;//,j;
disable_irq_nosync(chensai_irq_num);
chensai_i2c_read(chensai_client, register_addr, key_status, chensai_iic_addr);
key_status_val = key_status[0];
DBG("%s key_status_val=%d\n", __func__, key_status_val);
for( i=0; i < 5; i++)
{
if(key_status_val & (1 << i))
{
keys_val[i] = 1;
}else{
keys_val[i] = 0;
}
}
//上报
input_report_key(input_dev, KEY_F18, keys_val[0]);
input_report_key(input_dev, KEY_F19, keys_val[1]);
input_report_key(input_dev, KEY_F20, keys_val[2]);
input_report_key(input_dev, KEY_F21, keys_val[3]);
input_report_key(input_dev, KEY_F22, keys_val[4]);
input_sync(input_dev);
enable_irq(chensai_irq_num);
return IRQ_HANDLED;
}
static int chensai_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int error;
int ret;
unsigned int gpio_num;
struct device_node *np = client->dev.of_node;
enum of_gpio_flags flags;
static struct task_struct *task;
DBG("%s : chensai_probe\n", __func__);
//将会分配一个 input_dev 设备结构体，并且在 /sys/class/input/input-n 下创建设备属性文件
input_dev = input_allocate_device();
// input输入子系统设备属性
input_dev->name = "chensai_input_device";
input_dev->phys = "chensai-input";
input_dev->id.bustype = BUS_HOST;
input_dev->id.vendor = 1;
input_dev->id.product = 1;
input_dev->id.version = 1;
input_dev->evbit[0] = BIT_MASK(EV_KEY);//设置支持的按键事件类型
//设置支持 KEY_F18/KEY_F19/KEY_F20/KEY_F21/KEY_F22按键事件
set_bit(KEY_F18, input_dev->keybit);
set_bit(KEY_F19, input_dev->keybit);
set_bit(KEY_F20, input_dev->keybit);
set_bit(KEY_F21, input_dev->keybit);
set_bit(KEY_F22, input_dev->keybit);
error = input_register_device(input_dev);
if(error){
printk("Failed to register input_dev\n");
}
gpio_num =of_get_named_gpio_flags(np, "irq-gpio", 0, &flags);
DBG("%s gpio_num=%d\n", __func__, gpio_num);
if (!gpio_is_valid(gpio_num)){
DBG("%s gpio_is_unvalid \n", __func__);
}
if (gpio_request(gpio_num, "irq-gpio")) {
DBG("%s failed to request irq-gpio, gpio_num =%d\n", __func__, gpio_num);
}
gpio_direction_input(gpio_num);
chensai_irq_num = gpio_to_irq(gpio_num); //将gpio转换成对应的中断号
DBG("%s chensai_irq_num=%d\n", __func__, chensai_irq_num);
ret = request_irq(chensai_irq_num, chensai_irq_handler, IRQ_TYPE_EDGE_FALLING, "chensai_irq", NULL);
if (ret) {
printk("request_irq error\n");
}
chensai_client = client;
return 0;
}
static const struct i2c_device_id chensai_id[] = {
{"chensai_keyboard", 0},
{}
};
MODULE_DEVICE_TABLE(i2c, chensai_id);
static struct i2c_driver chensai_drv = {
.driver = {
.name = "chensai",
.owner = THIS_MODULE,
},
.probe = chensai_probe,
.id_table = chensai_id,
};
static int chensai_init(void)
{
i2c_add_driver(&chensai_drv);
return 0;
}
static void chensai_exit(void)
{
i2c_del_driver(&chensai_drv);
input_unregister_device(input_dev);
free_irq(chensai_irq_num, chensai_irq_handler);
}
module_init(chensai_init);
module_exit(chensai_exit);
MODULE_LICENSE("GPL");
六 TP调试记录
如果出现触摸屏出现触摸坐标偏移或者完全反向等现象，需要在驱动中调整
根据从设备树中 索引的 “tp-size”查找
mGtpChange_X2Y = FALSE;// X 轴 Y轴 坐标需要对调
mGtp_X_Reverse = FALSE; //X轴标是否需要对调
mGtp_Y_Reverse = FALSE; //Y轴是否需要对调
三个参数
扫一扫
56
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
