对于之前写驱动的时候,我们都是在APP文件中打开了一个特定的设备文件如/dev/buttons
,但是一般在实际应用过程中不会打开/dev/buttons
。一般是直接scanf()
就去获得了按键的输入。
以前写的那些驱动程序有一下缺点:
解决这个问题的答案就需要:使用现成的驱动——输入子系统(input 子系统),把自已的设备相关的驱动放到内核中这种驱动架构中去。
在使用之前,我们需要分析输入子系统(input 子系统)的大致框架。
对于输入子系统,其主要文件在/driver/input.c
input_init()
分析:在这个入口函数中,通过register_chrdev(INPUT_MAJOR, "input", &input_fops);
注册了一个设备。
/* 入口函数
3. 注册了一个设备
*/
static int __init input_init(void)
{
/*........*/
err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
/*........*/
}
file_operation
结构体分析:只有open函数,没有其他的函数,肯定在open函数中进行了其他的操作。
static const struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file,
};
input_open_file
函数分析:在input_open_file()
函数中
inode
的此设备号找到对应的句柄hander
hander->fops
赋值给新建的file_operations
结构体new_fops
file->f_op
,并将其赋值为new_fops
new_fops->open()
函数可以看出这个函数属于被调用函数,而且是通过一个设备的次设备号作为索引找到对应的句柄。
static int input_open_file(struct inode *inode, struct file *file)
{
/* 根据此设备号,在input_table[]数组里面找到对应的input_handler句柄 */
struct input_handler *handler = input_table[iminor(inode) >> 5];
const struct file_operations *old_fops, *new_fops = NULL;
int err;
/* 通过上面得到的input_handler句柄找到对应的file_operation的fops结构体,并赋值给新建的new_fops */
if (!handler || !(new_fops = fops_get(handler->fops)))
return -ENODEV;
/* 判断new_fops结构体的open函数是否为空 */
if (!new_fops->open) {
fops_put(new_fops);
return -ENODEV;
}
/* 把打开文件的file_operation结构体赋值给old_fops */
old_fops = file->f_op;
/* 把新得到的new_fops赋值给打开文件的fops: 起中转作用 */
file->f_op = new_fops;
/* 根据这个new_fops结构体调用open函数 */
err = new_fops->open(inode, file);
if (err) {
fops_put(file->f_op);
file->f_op = fops_get(old_fops);
}
fops_put(old_fops);
return err;
}
input_register_handler()
函数input_table[]
原型
static struct input_handler *input_table[8];
input_register_handler()
函数
分析:
input_table[ ]
项中node
放入链表input_dev
,都调用input_attach_handler()
,根据input_handler的id_table
判断能否支持这个input_dev
/* 注册handle函数 */
int input_register_handler(struct input_handler *handler)
{
/*.....*/
/* 判断是否为空,则进行放入数组 */
if (handler->fops != NULL) {
if (input_table[handler->minor >> 5])
return -EBUSY;
input_table[handler->minor >> 5] = handler;
}
// 放入链表
list_add_tail(&handler->node, &input_handler_list);
// 对于每个input_dev,调用input_attach_handler
list_for_each_entry(dev, &input_dev_list, node)
input_attach_handler(dev, handler); // 根据input_handler的id_table判断能否支持这个input_dev
/*.....*/
return 0;
}
input_register_handler()
函数——evdev.c
通过搜索可以查询到如下文件会调用input_register_handler()
,拿去其中的evdev.c
驱动文件进行说明。
evdev_init()
在这个入口函数只调用了input_register_handler()
,并且看见有evdev_handler
这个变量。
static int __init evdev_init(void)
{
return input_register_handler(&evdev_handler);
}
input_handler
类型的结构体evdev_handler
对于这个结构体中的函数,我们下面会进行分析。
static struct input_handler evdev_handler = {
.event = evdev_event, //事件
.connect = evdev_connect, //联系
.disconnect = evdev_disconnect, //不联系
.fops = &evdev_fops, //file_operation结构体
.minor = EVDEV_MINOR_BASE, //次设备号
.name = "evdev", //设备名字
.id_table = evdev_ids, //用来绑定设备和驱动
};
到目前为止,我们可以分析出大致的框架,目前分析的是在纯软件中,那么对于实际的硬件呢?下面就来分析下在input.c文件中的input_register_device()
函数。
input_register_device()
函数分析:
node
放入链表input_handler
,都调用input_attach_handler()
,根据input_handler的id_table
判断能否支持这个input_dev
int input_register_device(struct input_dev *dev)
{
/*......*/
// 放入链表
list_add_tail(&dev->node, &input_dev_list);
// 对于每一个input_handler,都调用input_attach_handler
list_for_each_entry(handler, &input_handler_list, node)
input_attach_handler(dev, handler); // 根据input_handler的id_table判断能否支持这个input_dev
input_wakeup_procfs_readers();
return 0;
}
input_register_device()
函数——具体的设备文件通过搜索可以查询到如下文件会调用input_register_device()
,对于一个驱动文件可以支持多个设备文件,而input_register_device()
函数就是把这些设备注册进驱动文件中。
input_attach_handler()
函数分析:可以发现到input_register_device()
和input_register_handle()
的处理过程很相似,而且都调用了input_attach_handler()
函数。
input_attach_handler()
函数
分析:
input_dev
或input_handler
时,会两两比较左边的input_dev和右边的input_handlerinput_handler
的id_table判断这个input_handler能否支持这个input_devinput_handler的connect函数
建立"连接"static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
const struct input_device_id *id;
int error;
/* 进行匹配:注册input_dev或input_handler时,会两两比较左边的input_dev和右边的input_handler */
if (handler->blacklist && input_match_device(handler->blacklist, dev))
return -ENODEV;
/* 根据input_handler的id_table判断这个input_handler能否支持这个input_dev */
id = input_match_device(handler->id_table, dev);
if (!id)
return -ENODEV;
/* 如果能支持,则调用input_handler的connect函数建立"连接" */
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->cdev.kobj), error);
return error;
}
evdev.c
对于不同的驱动,建立连接的方式都不一样,这里分析驱动文件evdev.c
的evdev_connect()
函数
分析:
input_handle结构体
input_register_handle()
函数int input_register_handle(struct input_handle *handle)
{
struct input_handler *handler = handle->handler;
//放入链表尾部
list_add_tail(&handle->d_node, &handle->dev->h_list); //dev->h_list
list_add_tail(&handle->h_node, &handler->h_list); //handler->h_list
if (handler->start)
handler->start(handle);
return 0;
}
static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
const struct input_device_id *id)
{
/*...........*/
evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); // 分配一个input_handle
/*...........*/
// 设置
evdev->handle.dev = dev; // 指向左边的input_dev
evdev->handle.name = evdev->name;
evdev->handle.handler = handler; // 指向右边的input_handler
evdev->handle.private = evdev;
sprintf(evdev->name, "event%d", minor);
//放入到构建的数组中
evdev_table[minor] = evdev;
/*......*/
// 注册
error = input_register_handle(&evdev->handle);
/*......*/
}(struct input_handler *handler, struct input_dev *dev,
const struct input_device_id *id)
{
/*...........*/
evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); // 分配一个input_handle
/*...........*/
// 设置
evdev->handle.dev = dev; // 指向左边的input_dev
evdev->handle.name = evdev->name;
evdev->handle.handler = handler; // 指向右边的input_handler
evdev->handle.private = evdev;
sprintf(evdev->name, "event%d", minor);
//放入到构建的数组中
evdev_table[minor] = evdev;
/*......*/
// 注册
error = input_register_handle(&evdev->handle);
/*......*/
}
此时对于整个输入子系统,它的大致框架如下:
input_register_handler()
向上注册处理方式——驱动文件, 硬件部分是input_register_device()
向上注册硬件层——即具体的设备文件。handler
是否支持dev
input_handler()
结构体中的.connect
函数进行连接。input_handle结构体
input_register_handle()
函数.h_list
链表中的任一一边找到对方。也是引用evdec.c
文件来说明
对于APP中调用read()
函数,最终会调用到设备的evdev_read()
函数
evdev_read()
函数static ssize_t evdev_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
{
struct evdev_client *client = file->private_data;
struct evdev *evdev = client->evdev;
int retval;
if (count < evdev_event_size())
return -EINVAL;
// 无数据并且是非阻塞方式打开,则立刻返回
if (client->head == client->tail && evdev->exist && (file->f_flags & O_NONBLOCK))
return -EAGAIN;
// 否则休眠
retval = wait_event_interruptible(evdev->wait,
client->head != client->tail || !evdev->exist);
/*........*/
return retval;
}
evdev_event()
事件函数在这个函数进行对休眠函数进行激活
static void evdev_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
{
/*.............*/
wake_up_interruptible(&evdev->wait); //激活
}
evdev_event()
事件函数猜:应该是硬件相关的代码,input_dev那层调用的
在设备的中断服务程序里,确定事件是什么,然后调用相应的input_handler的event处理函数
static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
{
/*.............*/
if (irq == gpio_to_irq(gpio)) {
unsigned int type = button->type ?: EV_KEY;
int state = (gpio_get_value(gpio) ? 1 : 0) ^ button->active_low;
// 上报事件
input_event(input, type, button->code, !!state);
input_sync(input);
}
}
return IRQ_HANDLED;
}
input_event()
函数void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
/*.....*/
if (dev->grab)
dev->grab->handler->event(dev->grab, type, code, value);
else
list_for_each_entry(handle, &dev->h_list, d_node)
/* 如果handle打开,则调用该handle->handler->event */
if (handle->open)
handle->handler->event(handle, type, code, value);
}
read
函数。even
函数来唤醒。input_dev
层的设备中断服务程序调用了event
函数。event函数
可以最终追踪到纯软件部分的input_handler结构体
中的.event
成员。