00000076 static void input_pass_event(struct input_dev *dev, 00000077 unsigned int type, unsigned int code, int value) 00000078 { 00000079 struct input_handler *handler; 00000080 struct input_handle *handle; 00000081 00000082 rcu_read_lock(); 00000083 00000084 handle = rcu_dereference(dev->grab); 00000085 if (handle) 00000086 handle->handler->event(handle, type, code, value); 00000087 else { 00000088 bool filtered = false; 00000089 00000090 list_for_each_entry_rcu(handle, &dev->h_list, d_node) { 00000091 if (!handle->open) 00000092 continue; 00000093 00000094 handler = handle->handler; 00000095 if (!handler->filter) { 00000096 if (filtered) 00000097 break; 00000098 00000099 handler->event(handle, type, code, value); 00000100 00000101 } else if (handler->filter(handle, type, code, value)) 00000102 filtered = true; 00000103 } 00000104 } 00000105 00000106 rcu_read_unlock(); 00000107 }
84至86行，如果有为Input设备指定handle，那么就执行该handle的handler的event函数，这里默认是没有指定的，用户程序可以通过ioctl函数来指定。
90行，遍历Input设备的handle链表，经过一些检查后会执行handler->event函数，即，drivers/input/evdev.c里的evdev_event函数，这时Input消息已经传递到事件驱动程序层了，暂时先不说evdev_event函数，但是要记得Input消息已经来到了这里。我们知道，应用程序使用设备之前要先open它（这里忽略了网络设备），最终会调用驱动程序里的open函数，那么下面看drivers/input/evdev.c里定义的open函数evdev_open。
00000260 static int evdev_open(struct inode *inode, struct file *file) 00000261 { 00000262 struct evdev *evdev; 00000263 struct evdev_client *client; 00000264 int i = iminor(inode) - EVDEV_MINOR_BASE; 00000265 unsigned int bufsize; 00000266 int error; 00000267 00000268 if (i >= EVDEV_MINORS) 00000269 return -ENODEV; 00000270 00000271 error = mutex_lock_interruptible(&evdev_table_mutex); 00000272 if (error) 00000273 return error; 00000274 evdev = evdev_table[i]; 00000275 if (evdev) 00000276 get_device(&evdev->dev); 00000277 mutex_unlock(&evdev_table_mutex); 00000278 00000279 if (!evdev) 00000280 return -ENODEV; 00000281 00000282 bufsize = evdev_compute_buffer_size(evdev->handle.dev); 00000283 00000284 client = kzalloc(sizeof(struct evdev_client) + 00000285 bufsize * sizeof(struct input_event), 00000286 GFP_KERNEL); 00000287 if (!client) { 00000288 error = -ENOMEM; 00000289 goto err_put_evdev; 00000290 } 00000291 00000292 client->bufsize = bufsize; 00000293 spin_lock_init(&client->buffer_lock); 00000294 client->evdev = evdev; 00000295 evdev_attach_client(evdev, client); 00000296 00000297 error = evdev_open_device(evdev); 00000298 if (error) 00000299 goto err_free_client; 00000300 00000301 file->private_data = client; 00000302 nonseekable_open(inode, file); 00000303 00000304 return 0; 00000305 00000306 err_free_client: 00000307 evdev_detach_client(evdev, client); 00000308 kfree(client); 00000309 err_put_evdev: 00000310 put_device(&evdev->dev); 00000311 return error; 00000312 }
264行，获取次设备号。
268行，如果次设备号大于EVDEV_MINORS，就不用往下走了，返回出错。
274行，从evdev_table数组中取出对应的struct evdev实例。
282行，调用evdev_compute_buffer_size函数计算环形缓冲区的长度。
00000251 static unsigned int evdev_compute_buffer_size(struct input_dev *dev) 00000252 { 00000253 unsigned int n_events = 00000254 max(dev->hint_events_per_packet * EVDEV_BUF_PACKETS, 00000255 EVDEV_MIN_BUFFER_SIZE); 00000256 00000257 return roundup_pow_of_two(n_events); 00000258 }
254行，EVDEV_BUF_PACKETS的值为8，hint_events_per_packet为0，因此n_events的值就为EVDEV_MIN_BUFFER_SIZE，即64。
257行，将n_events的值调整到2的幂次方。
回到evdev_open函数，284至290行，为struct evdev_client实例分配内存，注意所分配内存的大小。
295行，调用evdev_attach_client函数，定义如下：
00000168 static void evdev_attach_client(struct evdev *evdev, 00000169 struct evdev_client *client) 00000170 { 00000171 spin_lock(&evdev->client_lock); 00000172 list_add_tail_rcu(&client->node, &evdev->client_list); 00000173 spin_unlock(&evdev->client_lock); 00000174 synchronize_rcu(); 00000175 }
172行，就是将client加入到struct evdev实例的链表尾部。
297行，evdev_open_device函数的定义：
00000186 static int evdev_open_device(struct evdev *evdev) 00000187 { 00000188 int retval; 00000189 00000190 retval = mutex_lock_interruptible(&evdev->mutex); 00000191 if (retval) 00000192 return retval; 00000193 00000194 if (!evdev->exist) 00000195 retval = -ENODEV; 00000196 else if (!evdev->open++) { 00000197 retval = input_open_device(&evdev->handle); 00000198 if (retval) 00000199 evdev->open--; 00000200 } 00000201 00000202 mutex_unlock(&evdev->mutex); 00000203 return retval; 00000204 }
194行，exist在evdev_connect函数里已经设置为true。
196行，open计数加1。
197行，input_open_device函数在input core里定义：
00000502 int input_open_device(struct input_handle *handle) 00000503 { 00000504 struct input_dev *dev = handle->dev; 00000505 int retval; 00000506 00000507 retval = mutex_lock_interruptible(&dev->mutex); 00000508 if (retval) 00000509 return retval; 00000510 00000511 if (dev->going_away) { 00000512 retval = -ENODEV; 00000513 goto out; 00000514 } 00000515 00000516 handle->open++; 00000517 00000518 if (!dev->users++ && dev->open) 00000519 retval = dev->open(dev); 00000520 00000521 if (retval) { 00000522 dev->users--; 00000523 if (!--handle->open) { 00000524 /* 00000525 * Make sure we are not delivering any more events 00000526 * through this handle 00000527 */ 00000528 synchronize_rcu(); 00000529 } 00000530 } 00000531 00000532 out: 00000533 mutex_unlock(&dev->mutex); 00000534 return retval; 00000535 }
511至514行，如果Input设备还没准备好，那么就返回。
516行，将handle的open计数加1，表示此handle已经打开。
519行，调用Input设备里的open函数，对于本文，里面啥事也没做，直接返回0，因此521至530行不用管。
退回到evdev_open函数，301行，将文件的私有数据指针指向此client。
302行，nonseekable_open函数不说了，就是设置文件的模式，定义很简单，如下：
int nonseekable_open(struct inode *inode, struct file *filp) { filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE); return 0; }
下面是一张简单的描述evdev是怎么把client连接起来的图。
此时用户程序已经open了设备，假设接下来用户程序执行read函数读取Input消息，下面看此驱动里read函数evdev_read的定义：
00000366 static ssize_t evdev_read(struct file *file, char __user *buffer, 00000367 size_t count, loff_t *ppos) 00000368 { 00000369 struct evdev_client *client = file->private_data; 00000370 struct evdev *evdev = client->evdev; 00000371 struct input_event event; 00000372 int retval; 00000373 00000374 if (count < input_event_size()) 00000375 return -EINVAL; 00000376 00000377 if (client->head == client->tail && evdev->exist && 00000378 (file->f_flags & O_NONBLOCK)) 00000379 return -EAGAIN; 00000380 00000381 retval = wait_event_interruptible(evdev->wait, 00000382 client->head != client->tail || !evdev->exist); 00000383 if (retval) 00000384 return retval; 00000385 00000386 if (!evdev->exist) 00000387 return -ENODEV; 00000388 00000389 while (retval + input_event_size() <= count && 00000390 evdev_fetch_next_event(client, &event)) { 00000391 00000392 if (input_event_to_user(buffer + retval, &event)) 00000393 return -EFAULT; 00000394 00000395 retval += input_event_size(); 00000396 } 00000397 00000398 return retval; 00000399 }
374行，input_event_size函数的定义有两种，一种是为了考虑兼容性的，这里为了简单起见，只看不需要兼容性那种的定义，在drivers/input/input-compat.h中：
00000076 static inline size_t input_event_size(void) 00000077 { 00000078 return sizeof(struct input_event); 00000079 }
很简单，直接返回struct input_event结构体的大小。那么374行的意思就很明显了，就是说用户程序read的数据不能小于struct input_event结构体的大小。
377至379行，此时，第一和第二个条件都会成立，关键是看第三个条件，这个条件是否成立取决于用户程序是以怎样的方式打开设备文件的，是阻塞还是非阻塞，这里很明显，不能以非阻塞方式打开设备文件，否则返回出错。
381至384行，等待，有承若才会有等待，这个等待可能是无了期的，现实也是这样，承若不一定都能够实现，算了，说得有点伤感了。
接下来我们要看这个承若是怎么实现的。前面说过，Input消息已经进入了evdev_event函数，下面就看它的定义：
00000075 static void evdev_event(struct input_handle *handle, 00000076 unsigned int type, unsigned int code, int value) 00000077 { 00000078 struct evdev *evdev = handle->private; 00000079 struct evdev_client *client; 00000080 struct input_event event; 00000081 00000082 do_gettimeofday(&event.time); 00000083 event.type = type; 00000084 event.code = code; 00000085 event.value = value; 00000086 00000087 rcu_read_lock(); 00000088 00000089 client = rcu_dereference(evdev->grab); 00000090 if (client) 00000091 evdev_pass_event(client, &event); 00000092 else 00000093 list_for_each_entry_rcu(client, &evdev->client_list, node) 00000094 evdev_pass_event(client, &event); 00000095 00000096 rcu_read_unlock(); 00000097 00000098 wake_up_interruptible(&evdev->wait); 00000099 }
82至85行，填充struct input_event的实例evevt。从这里也看以知道，struct input_event表示消息的内容。
89至91行，同样可以在用户空间通过ioctl为struct evdev实例指定client，默认是没有指定的。
93、94行，遍历client_list链表，每找到一个client就调用evdev_pass_event函数，evdev_pass_event函数的定义如下：
00000053 static void evdev_pass_event(struct evdev_client *client, 00000054 struct input_event *event) 00000055 { 00000056 /* 00000057 * Interrupts are disabled, just acquire the lock. 00000058 * Make sure we don't leave with the client buffer 00000059 * "empty" by having client->head == client->tail. 00000060 */ 00000061 spin_lock(&client->buffer_lock); 00000062 do { 00000063 client->buffer[client->head++] = *event; 00000064 client->head &= client->bufsize - 1; 00000065 } while (client->head == client->tail); 00000066 spin_unlock(&client->buffer_lock); 00000067 00000068 if (event->type == EV_SYN) 00000069 kill_fasync(&client->fasync, SIGIO, POLL_IN); 00000070 }
63行，将Input消息放入client的环形缓冲区，接着client->head加1。
64行，client->head的值不能大于client->bufsize – 1，也就是当client->head的值大于client->bufsize – 1时，让client->head的值回到0，从0开始再往上递增，为什么说是环形缓冲区也就是这个原因。
68行，因为此时event->type的值是EV_KEY，所以条件不成立。
回到evdev_event函数，98行，唤醒，到这里承若已经实现了，等待是值得的，不应该为暂时的美好而停下脚本，继续往下走吧。回到evdev_read剩下的内容，这里把它贴出来好了，省得再回去看。
00000381 retval = wait_event_interruptible(evdev->wait, 00000382 client->head != client->tail || !evdev->exist); 00000383 if (retval) 00000384 return retval; 00000385 00000386 if (!evdev->exist) 00000387 return -ENODEV; 00000388 00000389 while (retval + input_event_size() <= count && 00000390 evdev_fetch_next_event(client, &event)) { 00000391 00000392 if (input_event_to_user(buffer + retval, &event)) 00000393 return -EFAULT; 00000394 00000395 retval += input_event_size(); 00000396 } 00000397 00000398 return retval; 00000399 }
382行，唤醒的条件是因为client->head != client->tail，顺便提一下，此时client->head=1，client->tail=0。
390行，evdev_fetch_next_event函数的定义：
00000348 static int evdev_fetch_next_event(struct evdev_client *client, 00000349 struct input_event *event) 00000350 { 00000351 int have_event; 00000352 00000353 spin_lock_irq(&client->buffer_lock); 00000354 00000355 have_event = client->head != client->tail; 00000356 if (have_event) { 00000357 *event = client->buffer[client->tail++]; 00000358 client->tail &= client->bufsize - 1; 00000359 } 00000360 00000361 spin_unlock_irq(&client->buffer_lock); 00000362 00000363 return have_event; 00000364 }
355行，因为client->head != client->tail，所以have_event的值不为0，356行的if条件成立。
357行，从环形缓冲区中取出一个Input消息，接着client->tail的值加1。
358行，同样是为了保证client->tail的值不会大于client->bufsize – 1。
回到evdev_read函数，此时389行的while条件成立。
392行，为了保持兼容性，input_event_to_user函数同样有两种定义，看不考虑兼容性那一种，在drivers/input/input-compat.c中。
00000110 int input_event_to_user(char __user *buffer, 00000111 const struct input_event *event) 00000112 { 00000113 if (copy_to_user(buffer, event, sizeof(struct input_event))) 00000114 return -EFAULT; 00000115 00000116 return 0; 00000117 }
就是对copy_to_user函数的封装，这样Input消息就传递到用户空间了，接下来应用程序想对它干嘛就干嘛。但是别忘了gpio_keys_report_event函数里还有一条语句没有执行，下面把gpio_keys_report_event函数的定义在贴一遍：
00000320 static void gpio_keys_report_event(struct gpio_button_data *bdata) 00000321 { 00000322 struct gpio_keys_button *button = bdata->button; 00000323 struct input_dev *input = bdata->input; 00000324 unsigned int type = button->type ?: EV_KEY; 00000325 int state = (gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low; 00000326 00000327 input_event(input, type, button->code, !!state); 00000328 input_sync(input); 00000329 }
上面的内容是从327行的input_event函数一直讲的，下面把最后一个函数的调用过程讲完，看328行的input_sync函数的定义：
00001423 static inline void input_sync(struct input_dev *dev) 00001424 { 00001425 input_event(dev, EV_SYN, SYN_REPORT, 0); 00001426 }
其实就是input_event函数的封装，只是参数值不一样而已，这里需要记住它的后三个参数。
在input_event函数里会调用input_handle_event函数，这里有必要把input_handle_event函数的定义再贴一遍：
00000215 static void input_handle_event(struct input_dev *dev, 00000216 unsigned int type, unsigned int code, int value) 00000217 { 00000218 int disposition = INPUT_IGNORE_EVENT; 00000219 00000220 switch (type) { 00000221 00000222 case EV_SYN: 00000223 switch (code) { 00000224 case SYN_CONFIG: 00000225 disposition = INPUT_PASS_TO_ALL; 00000226 break; 00000227 00000228 case SYN_REPORT: 00000229 if (!dev->sync) { 00000230 dev->sync = true; 00000231 disposition = INPUT_PASS_TO_HANDLERS; 00000232 } 00000233 break; 00000234 case SYN_MT_REPORT: 00000235 dev->sync = false; 00000236 disposition = INPUT_PASS_TO_HANDLERS; 00000237 break; 00000238 } 00000239 break; 00000240 00000241 case EV_KEY: 00000242 if (is_event_supported(code, dev->keybit, KEY_MAX) && 00000243 !!test_bit(code, dev->key) != value) { 00000244 00000245 if (value != 2) { 00000246 __change_bit(code, dev->key); 00000247 if (value) 00000248 input_start_autorepeat(dev, code); 00000249 else 00000250 input_stop_autorepeat(dev); 00000251 } 00000252 00000253 disposition = INPUT_PASS_TO_HANDLERS; 00000254 } 00000255 break; 00000256 00000257 case EV_SW: 00000258 if (is_event_supported(code, dev->swbit, SW_MAX) && 00000259 !!test_bit(code, dev->sw) != value) { 00000260 00000261 __change_bit(code, dev->sw); 00000262 disposition = INPUT_PASS_TO_HANDLERS; 00000263 } 00000264 break; 00000265 00000266 case EV_ABS: 00000267 if (is_event_supported(code, dev->absbit, ABS_MAX)) 00000268 disposition = input_handle_abs_event(dev, code, &value); 00000269 00000270 break; 00000271 00000272 case EV_REL: 00000273 if (is_event_supported(code, dev->relbit, REL_MAX) && value) 00000274 disposition = INPUT_PASS_TO_HANDLERS; 00000275 00000276 break; 00000277 00000278 case EV_MSC: 00000279 if (is_event_supported(code, dev->mscbit, MSC_MAX)) 00000280 disposition = INPUT_PASS_TO_ALL; 00000281 00000282 break; 00000283 00000284 case EV_LED: 00000285 if (is_event_supported(code, dev->ledbit, LED_MAX) && 00000286 !!test_bit(code, dev->led) != value) { 00000287 00000288 __change_bit(code, dev->led); 00000289 disposition = INPUT_PASS_TO_ALL; 00000290 } 00000291 break; 00000292 00000293 case EV_SND: 00000294 if (is_event_supported(code, dev->sndbit, SND_MAX)) { 00000295 00000296 if (!!test_bit(code, dev->snd) != !!value) 00000297 __change_bit(code, dev->snd); 00000298 disposition = INPUT_PASS_TO_ALL; 00000299 } 00000300 break; 00000301 00000302 case EV_REP: 00000303 if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) { 00000304 dev->rep[code] = value; 00000305 disposition = INPUT_PASS_TO_ALL; 00000306 } 00000307 break; 00000308 00000309 case EV_FF: 00000310 if (value >= 0) 00000311 disposition = INPUT_PASS_TO_ALL; 00000312 break; 00000313 00000314 case EV_PWR: 00000315 disposition = INPUT_PASS_TO_ALL; 00000316 break; 00000317 } 00000318 00000319 if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN) 00000320 dev->sync = false; 00000321 00000322 if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event) 00000323 dev->event(dev, type, code, value); 00000324 00000325 if (disposition & INPUT_PASS_TO_HANDLERS) 00000326 input_pass_event(dev, type, code, value); 00000327 }
这时，进入的是222行的case，接着进入228行的case，229行，dev->sync的值到现在一直没有被设置过，因此if条件成立。
230行，dev->sync = true。
231行，disposition = INPUT_PASS_TO_HANDLERS。
接下来两次break，跳出switch到319行，319和322行的if条件都不成立，因此又是执行326行的input_pass_event函数，这个过程前面已经讲过了，最后也是会到达evdev_event函数，唯一不同的是，在evdev_pass_event函数会执行下面的语句。
00000068 if (event->type == EV_SYN) 00000069 kill_fasync(&client->fasync, SIGIO, POLL_IN);
这是异步通知机制发送信号到用户空间，如果用户程序有设置使用这种机制，那么用户程序中指定的函数就会被调用。
到这里，Linux Input子系统的工作过程已经说完了，当然还有其他很多内容没有分析到，不过已经对其工作原理有一个比较深入的了解了，由于本人知识水平和精力有限，没办法做到面面俱到，当中有什么错误，望不吝指出。
总结
Linux的SPI、IIC和Input子系统都已经分析过了，马上就要找工作了，如果时间允许的话，接下来我会结合实际硬件写几篇关于它们具体使用方法的文章。