input输入子系统源码部分函数分析

/*
*	源文件目录：
*			/drivers/input/input.c
*/

入口函数：
static int __init input_init(void)
1、		err = class_register(&input_class);				/* class设备节点生成 */
2、             err = input_proc_init();			/* 为添加到proc文件系统的设备节点文件做一些初始化工作 */
3、	        err = register_chrdev(INPUT_MAJOR, "input", &input_fops);	/* 注册为字符型驱动 */

/*
* input_fops结构体分析
*/
static const struct file_operations input_fops = {
.owner = THIS_MODULE,								/* 模块所属者 */
.open = input_open_file,						/* 打开操作函数 */
.llseek = noop_llseek,							/* 绕过llseek操作 */
};

/*
* input_open_file函数分析
*/
static int input_open_file(struct inode *inode, struct file *file)
1. struct input_handler *handler;			/* handler声明 */
/*
* input_hanler结构体：
* 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;
*	};
*/
2. const struct file_operations *old_fops, *new_fops = NULL;		/* file_operations结构体声明 */
3. err = mutex_lock_interruptible(&input_mutex);			/* 上互斥锁操作 */
4. handler = input_table[iminor(inode) >> 5];				/* input_table链表中第iminor(inode) >> 5节点的handler */
5. if (handler)								/* 是否存在此handler */
new_fops = fops_get(handler->fops);			/* 存在内容则取出此handler的fops结构体赋予new_fops */
6. mutex_unlock(&input_mutex);					/* 解除互斥锁 */
7. 	old_fops = file->f_op;
file->f_op = new_fops;				/* 交换file_operation，使input设备可使用相应的操作函数 */
8. err = new_fops->open(inode, file);				/* 使用对于的打开函数 */
9. fops_put(old_fops);							/* 释放old_fops */

/*
*  input_register_device函数分析
*/
int input_register_device(struct input_dev *dev);
1. static atomic_t input_no = ATOMIC_INIT(0);				/* 原子变量初始化 */
2. struct input_handler *handler;					/* 新handler声明 */
3. /* Every input device generates EV_SYN/SYN_REPORT events. */		/* 设置dev结构体 */
__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);
4. init_timer(&dev->timer);					/* 初始化一个定时器 */
5. error = device_add(&dev->dev);					/* 添加设备 */
/*
*	device_add函数分析
*/
int device_add(struct device *dev)
1. dev = get_device(dev);																								/* 获取dev的kobj */
struct device *get_device(struct device *dev);
\--->return dev ? to_dev(kobject_get(&dev->kobj)) : NULL;
2. parent = get_device(dev->parent);		/* 获取父类驱动的kobj */
setup_parent(dev, parent);			/* 启动父类驱动 */
3. error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);/* 将dev->kobj, dev->kobj.parent添加至内核中 */

6. error = mutex_lock_interruptible(&input_mutex);						/* 上互斥锁 */
7. list_add_tail(&dev->node, &input_dev_list);							/* 添加到input_dev_list队列中 */
8. list_for_each_entry(handler, &input_handler_list, node)
input_attach_handler(dev, handler);		/* 遍历每个节点 */
9. input_wakeup_procfs_readers();					/* 唤醒procfs_readers */
10. mutex_unlock(&input_mutex);								/* 解除互斥锁 */

/*
* input_register_handler函数分析
*/
int input_register_handler(struct input_handler *handler)；
1. struct input_dev *dev;							/* input_dev结构体指针声明 */
2. retval = mutex_lock_interruptible(&input_mutex);					/* 上互斥锁 */
3. INIT_LIST_HEAD(&handler->h_list);							/* 初始化list的前级与后继指针都指向list */
4. if (handler->fops != NULL) {								/* 判断是否有值handler->fops */
if (input_table[handler->minor >> 5]) {					/* 判断input_table[handler->minor >> 5]节点是否有值 */
retval = -EBUSY;
goto out;
}
input_table[handler->minor >> 5] = handler;			/* 将handler添加到input_table[handler->minor >> 5]节点上 */
}
5. list_add_tail(&handler->node, &input_handler_list);			/* 将handler->node放入到队列中 */
6. list_for_each_entry(dev, &input_dev_list, node)
input_attach_handler(dev, handler);			/* 遍历每个节点 */
7. input_wakeup_procfs_readers();					/* 唤醒procfs_readers */

/*
* input_allocate_device函数分析
*/
struct input_dev *input_allocate_device(void);
1. struct input_dev *dev;						/* input_dev结构体声明 */
2. dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);			/* input_dev结构体空间分配 */
/*
* 分析kzalloc函数
*/
static inline void *kzalloc(size_t size, gfp_t flags)
\-->return kmalloc(size, flags | __GFP_ZERO);
3. if (dev) {								/* 初始化dev的成员变量 */
dev->dev.type = &input_dev_type;
dev->dev.class = &input_class;
device_initialize(&dev->dev);
/*
* device_initialize函数
*/
void device_initialize(struct device *dev)
{
dev->kobj.kset = devices_kset;
kobject_init(&dev->kobj, &device_ktype);
INIT_LIST_HEAD(&dev->dma_pools);
mutex_init(&dev->mutex);
lockdep_set_novalidate_class(&dev->mutex);
spin_lock_init(&dev->devres_lock);
INIT_LIST_HEAD(&dev->devres_head);
device_pm_init(dev);
set_dev_node(dev, -1);
}
/*
* 互斥锁初始化
*/
mutex_init(&dev->mutex);
/*
* 自旋锁初始化
*/
spin_lock_init(&dev->event_lock);
INIT_LIST_HEAD(&dev->h_list);
INIT_LIST_HEAD(&dev->node);

__module_get(THIS_MODULE);
}

/*
* input_attach_handler函数分析
*/
static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)；
1. id = input_match_device(handler, dev);					/* 比较handler与dev的id */
2. error = handler->connect(handler, dev, id);					/* 调用相应handler的connet函数 */

/*
* input_register_handle函数分析
*/
int input_register_handle(struct input_handle *handle)
1. error = mutex_lock_interruptible(&dev->mutex);				/* 上互斥锁 */
2. if (handler->filter)								/* 使dev->h_list指向handle->d_node */
list_add_rcu(&handle->d_node, &dev->h_list);
else
list_add_tail_rcu(&handle->d_node, &dev->h_list);
3. mutex_unlock(&dev->mutex);						/* 解除互斥锁 */1
4. list_add_tail_rcu(&handle->h_node, &handler->h_list);	/* 使handler->h_list指向handle->h_node */