输入子系统

 1 static const struct file_operations input_fops = {
 2     .owner = THIS_MODULE,
 3     .open = input_open_file,  //在该结构体中，只有一个input_open_file这个函数，这个函数只是起一个中转作用，在里面肯定还做了其他事情。
 4     .llseek = noop_llseek,
 5 };
 6 
 7 static int __init input_init(void)
 8 {
 9     int err;
10 
11     err = class_register(&input_class);
12     if (err) {
13         pr_err("unable to register input_dev class\n");
14         return err;
15     }
16 
17     err = input_proc_init();
18     if (err)
19         goto fail1;
20 
21     err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
22     if (err) {
23         pr_err("unable to register char major %d", INPUT_MAJOR);
24         goto fail2;
25     }
26 
27     return 0;

 1 static int input_open_file(struct inode *inode, struct file *file)
 2 {
 3     struct input_handler *handler;
 4     const struct file_operations *old_fops, *new_fops = NULL;
 5     int err;
 6 
 7     err = mutex_lock_interruptible(&input_mutex);
 8     if (err)
 9         return err;
10 
11     /* No load-on-demand here? */
　　 /*次设备号右移5位，即相当于除以32，以这个数为下标，从input_table数组中取出一项，赋给handler.*/
12     handler = input_table[iminor(inode) >> 5];
13     if (handler)/*handler中有一个file_operation结构体，把handler中的file_operation结构体取出来赋给new_fops.*/
14         new_fops = fops_get(handler->fops);
15 
16     mutex_unlock(&input_mutex);
17 
18     /*
19      * That‘s _really_ odd. Usually NULL ->open means "nothing special",
20      * not "no device". Oh, well...
21      */
22     if (!new_fops || !new_fops->open) {
23         fops_put(new_fops);
24         err = -ENODEV;
25         goto out;
26     }
27 
28     old_fops = file->f_op;
29     file->f_op = new_fops;   /*打开的这个文件的f_op= 新的fops*/
30 
31     err = new_fops->open(inode, file);/*调用新的fops中的open函数，以后如果读的话，就是用到了handler里面的新的fops*/
32     if (err) {
33         fops_put(file->f_op);
34         file->f_op = fops_get(old_fops);
35     }
36     fops_put(old_fops);
37 out:
38     return err;

 1 struct input_handler {
 2 
 3     void *private;
 4 
 5     void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
 6     bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
 7     bool (*match)(struct input_handler *handler, struct input_dev *dev);
 8     int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
 9     void (*disconnect)(struct input_handle *handle);
10     void (*start)(struct input_handle *handle);
11 
12     const struct file_operations *fops;
13     int minor;
14     const char *name;
15 
16     const struct input_device_id *id_table;
17 
18     struct list_head    h_list;
19     struct list_head    node;
20 };

 1 int input_register_handler(struct input_handler *handler)
 2 {
 3     struct input_dev *dev;
 4     int retval;
 5 
 6     retval = mutex_lock_interruptible(&input_mutex);
 7     if (retval)
 8         return retval;
 9 
10     INIT_LIST_HEAD(&handler->h_list);
11 
12     if (handler->fops != NULL) {
13         if (input_table[handler->minor >> 5]) {
14             retval = -EBUSY;
15             goto out;
16         }
17         input_table[handler->minor >> 5] = handler;
18     }
19 
20     list_add_tail(&handler->node, &input_handler_list);
21 
22     list_for_each_entry(dev, &input_dev_list, node)
23         input_attach_handler(dev, handler);
24 
25     input_wakeup_procfs_readers();
26 
27  out:
28     mutex_unlock(&input_mutex);
29     return retval;

 1 static struct input_handler evdev_handler = {
 2     .event        = evdev_event,
 3     .connect    = evdev_connect,
 4     .disconnect    = evdev_disconnect,
 5     .fops        = &evdev_fops,   /*这个fops以前是由我们自己构造，现在内核已经帮我们做好了。*/
 6     .minor        = EVDEV_MINOR_BASE,
 7     .name        = "evdev",
 8     .id_table    = evdev_ids,//表示该handler能够支持哪些输入设备。如果能够支持的话，就调用connect函数。
 9 };
10 
11 static int __init evdev_init(void)
12 {
　　/*input_register_handler会将evdev_handler向上注册，通过上面的分析可知，就是把这个evdev_handler放入Input_table数组
中，以次设备号右移5位为下标。这样的话，在input_open_file中获得的handler就是evdev_handler这个结构体，new_fops就是evdev_handler
结构体中的fops

*/ 13 return input_register_handler(&evdev_handler); 14 }