嵌入式学习10--浅析输入子系统

1.输入子系统handler

我们先从输入子系统的核心层文件开始解析，kernel\drivers\input\input.c中包含了输入子系统框架需要的函数

从入口 input_init 开始，可以看到注册一个input_class->input_proc_init->register_chrdev

在这里只注册了输入子系统的class，但是没有注册device，因为此时我们也不知道需要驱动什么设备，所以只注册class，当有实际设备时，再注册相应的device。然后注册了proc虚拟文件，可以向用户呈现内核中的一些信息或是用户空间向内核发送信息。然后注册了字符设备，我们需要关注的就是fops，其中会描述怎么操作来操作这些设备。

static int __init input_init(void)
{
	int err;

	err = class_register(&input_class);

	err = input_proc_init();

	err = register_chrdev(INPUT_MAJOR, "input", &input_fops);

	return 0;
}

 通常注册字符设备，我们的fops会包含open、read、write、ioctl等函数来操作设备，但是在这个结构体中只实现了open和llseek，那我们就需要继续看看函数的具体实现。

static const struct file_operations input_fops = {
    .owner = THIS_MODULE,
    .open = input_open_file,
    .llseek = noop_llseek,
}; 

 可以看到在这里会有一个fops_get，得到了新的new_fops->open函数，继续进行操作，以后的操作也会继续使用new_fops中的函数，那我们就需要关注得到这个handler的input_table是怎么回事。

static int input_open_file(struct inode *inode, struct file *file)
{
    ......

	handler = input_table[iminor(inode) >> 5];
	if (handler)
		new_fops = fops_get(handler->fops);

	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);

    ......
}

 input_table就是由input_handler结构体定义的，其中就会包含如下结构体的内容

struct input_handler {

	void *private;

	void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
	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;
	int minor;
	const char *name;

	const struct input_device_id *id_table;

	struct list_head	h_list;
	struct list_head	node;
};

 那是如何设置这些函数的呢，我们可以通过搜索input_table看到在input_register_handler中为input_table赋值，然后将该节点加入结构体，然后再进行查找，使用input_attach_handler中input_match_device函数配对后再进行connnect，至于其中的open、read、write函数的实现细节需要根据不同的设备不同编写。到这里输入子系统的handler部分已经分析完了，我们还需要针对不同的设备进行注册，将handler和device连接起来，组合成一个完整的驱动程序。

int input_register_handler(struct input_handler *handler)
{
    ......
	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);

    ......
}

2.输入子系统device 

在介绍handler的时候就提到input_init只注册了class，而现在我们就要在这个class下注册实际的设备，我们先介绍一下device注册的流程。

注册device就是使用input_register_device函数进行注册，我们可以看到在其中会对某些位进行处理，达到匹配的效果，并且会根据设备事件的类型和模式进行不同的处理，然后用device_add将设备添加进去，最后还是通过input_attach_handler函数进行配对后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;

	__set_bit(EV_SYN, dev->evbit);

	__clear_bit(KEY_RESERVED, dev->keybit);

	input_cleanse_bitmasks(dev);

	if (!dev->hint_events_per_packet)
		dev->hint_events_per_packet =
				input_estimate_events_per_packet(dev);

	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);

	path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);

	error = mutex_lock_interruptible(&input_mutex);

	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;
}

下面使用按键做键盘的例子，具体步骤可以分为以下几步

    1.使用input_allocate_device分配一个输入设备

    2.设置输入设备的事件类别

#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
#define EV_SND            0x12
#define EV_REP            0x14
#define EV_FF             0x15
#define EV_PWR            0x16
#define EV_FF_STATUS      0x17
#define EV_MAX            0x1f
#define EV_CNT            (EV_MAX+1)

3. 设置这类输入设备产生的事件,比如键盘产生的事件就是常规的按键，如1,2,3,4,5等

4.当设备设置完成后，就需要input_register_device函数注册设备，再进行硬件相关的操作

#include <linux/module.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/miscdevice.h>
#include <linux/irq.h>
#include <linux/io.h>
#include <mach/devices.h>
#include <linux/wait.h>
#include <linux/gpio.h>
#include <linux/input.h>

#define DEBOUNCE_TIME 200

typedef struct pin_des {
	char *name;
	int irq;
	int pin;
	int key_val;
}PIN_DES;

static PIN_DES pin_dev[] = {
	[0] = {"k4", IRQ_GPIO_B_START+31, PAD_GPIO_B+31, KEY_L},
	[1] = {"k3", IRQ_GPIO_B_START+30, PAD_GPIO_B+30, KEY_S},
	[2] = {"k2", IRQ_GPIO_A_START+28, PAD_GPIO_A+28, KEY_ENTER},
	[3] = {"k6", IRQ_GPIO_B_START+9,  PAD_GPIO_B+9,  KEY_LEFTSHIFT},
};

static struct input_dev *input_dev;
static struct timer_list key_timer;

static int key_input_open(struct inode *inode, struct file *filp)
{
	printk(KERN_WARNING "key input open\n");
	return 0;
}

static ssize_t key_input_read(struct file *filp, char __user *user_buf, size_t size, loff_t *offset)
{
	return 0;
}

static ssize_t key_input_write(struct file *filp, const char __user *user_buf, size_t size, loff_t *offset)
{
	return 0;
}

static long key_input_ioctl(struct file *filp, unsigned int cmd, unsigned long args)
{
	return 0;
}

static int key_input_release(struct inode *inode, struct file *filp)
{
	printk(KERN_WARNING "key input close\n");
	return 0;
}

static irqreturn_t keys_isr(int irq, void *dev_id)
{	
	key_timer.data = irq;
	mod_timer(&key_timer, jiffies+DEBOUNCE_TIME);

	return IRQ_HANDLED;
}

static void key_timer_isr(unsigned long data)
{
	int i = 0;
	
	for(i = 0; i < 4; i++){
		if(data == pin_dev[i].irq){
			if(gpio_get_value(pin_dev[i].pin)){
				input_event(input_dev, EV_KEY, pin_dev[i].key_val, 0);
			} else {
				input_event(input_dev, EV_KEY, pin_dev[i].key_val, 1);
			}
		} 
	}

	input_sync(input_dev);				
}

static const struct file_operations key_input_fops = {
	.owner   = THIS_MODULE,
	.open    = key_input_open,
	.read    = key_input_read,
	.write   = key_input_write,
	.unlocked_ioctl = key_input_ioctl,
	.release = key_input_release
};

static int __init key_input_init(void)
{
	int i = 0;
	int ret = 0;

	//分配input_dev
	input_dev = input_allocate_device();
	if(input_dev == NULL){
		ret = -ENXIO;
		printk(KERN_WARNING "input_allocate_device fail\n");
		goto input_allocate_device_err;
	}
	
	//设置输入设备的事件类别
	set_bit(EV_KEY, input_dev->evbit);

	//设置重复输入
	set_bit(EV_REP, input_dev->evbit);
	
	//设置这类输入设备产生的事件
	input_dev->name = "6818 keys";
	set_bit(KEY_L, input_dev->keybit);
	set_bit(KEY_S, input_dev->keybit);
	set_bit(KEY_ENTER, input_dev->keybit);
	set_bit(KEY_LEFTSHIFT, input_dev->keybit);
	
	//注册输入设备
	ret = input_register_device(input_dev);
	if(ret){
		ret = -ENODEV;
		printk(KERN_WARNING "input_register_device fail\n");
		goto input_register_device_err;
	}
	
	//硬件相关操作，防抖
	init_timer(&key_timer);
	key_timer.function = key_timer_isr;
	add_timer(&key_timer);
	
        //申请按键中断
	for(i = 0; i < 4; i++){
		ret = request_irq(pin_dev[i].irq, keys_isr, IRQ_TYPE_EDGE_BOTH, pin_dev[i].name, (void *)&pin_dev[i].key_val);
		if(ret){
			ret = -ENODEV;
			printk(KERN_WARNING "request_irq fail\n");
			goto request_irq_err;
		}
	}
	
	return 0;
	
request_irq_err:
	while(i--)
		free_irq(pin_dev[i].irq, (void *)&pin_dev[i].key_val);

input_register_device_err:
	input_free_device(input_dev);

input_allocate_device_err:
	return ret;

}

static void __exit key_input_exit(void)
{
	int i = 4;

	while(i--)
		free_irq(pin_dev[i].irq, (void *)&pin_dev[i].key_val);
	
	input_unregister_device(input_dev);
	input_free_device(input_dev);
} 

module_init(key_input_init);
module_exit(key_input_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("6818 key input");

3.验证结果

当驱动程序下载到开发班上运行时，按下按键会看到有L S出现，但是在我这块板子上没有显示出来，具体原因不太清楚，但是通过注册的event来看，是注册成功了的，并且通过hexdump /device/input/event4，确实是有数据产生，并且产生的数据能够和相应的按键值和状态匹配上，说明按键是成功添加了的，至于显示问题还需要深入研究。