LINUX设备驱动之输入子系统(二)

技术2025-09-18 38

Eric Fang 2010-02-03

--------------------------------------------------------------

本站分析linux内核源码，版本号为2.6.32.3

转载请注明出处：http://ericfang.cublog.cn/

--------------------------------------------------------------

接上一篇文章继续分析。

二．Input handler的注册

在Input device的注册中存在下列疑问：

1，匹配dev和handler时，input_handler_list上的handler是什么时候挂上去的呢？

2，匹配成功后会调用相应handler的connect函数，此函数做了什么事？

带着这两个疑问，我们以键盘为例进行分析。

在系统启动初始化vty（vty_init函数，tty、vty部分内容将在以后分析）时会调用kbd_init()进行键盘初始化，kbd_init函数定义于drivers/char/keyboard.c：

1403 int __init kbd_init(void)

1404 {

1405 int i;

1406 int error;

1407

1408 for (i = 0; i < MAX_NR_CONSOLES; i++) {

1409 kbd_table[i].ledflagstate = KBD_DEFLEDS;

1410 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;

1411 kbd_table[i].ledmode = LED_SHOW_FLAGS;

1412 kbd_table[i].lockstate = KBD_DEFLOCK;

1413 kbd_table[i].slockstate = 0;

1414 kbd_table[i].modeflags = KBD_DEFMODE;

1415 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;

1416 }

1417

1418 error = input_register_handler(&kbd_handler);

1419 if (error)

1420 return error;

1421

1422 tasklet_enable(&keyboard_tasklet);

1423 tasklet_schedule(&keyboard_tasklet);

1424

1425 return 0;

1426 }

第1408~1416行初始化kbd_table数组，这部分与tty内容相关，以后再分析。

1418行，这里我们终于看到调用input_register_handler函数注册kbd_handler，kbd_handler定义如下：

1394 static struct input_handler kbd_handler = {

1395 .event = kbd_event,

1396 .connect = kbd_connect,

1397 .disconnect = kbd_disconnect,

1398 .start = kbd_start,

1399 .name = "kbd",

1400 .id_table = kbd_ids,

1401 };

我们看到id_table指向kbd_ids数组，kbd_ids定义如下：

1378 static const struct input_device_id kbd_ids[] = {

1379 {

1380 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,

1381 .evbit = { BIT_MASK(EV_KEY) },

1382 },

1383

1384 {

1385 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,

1386 .evbit = { BIT_MASK(EV_SND) },

1387 },

1388

1389 { }, /* Terminating entry */

1390 };

从这个id_table看到，只要input_dev设置了其evbit字段支持EV_KEY或EV_SND都会匹配到hnadler，回想一下在键盘驱动中创建input_dev后调用的atkbd_set_device_attrs设置input_dev的函数中有下列语句：

input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |

BIT_MASK(EV_MSC);

说明at键盘的input_dev会匹配到这个hnadler。

我们接着看input_register_handler函数：

1600 int input_register_handler(struct input_handler *handler)

1601 {

1602 struct input_dev *dev;

1603 int retval;

1604

1605 retval = mutex_lock_interruptible(&input_mutex);

1606 if (retval)

1607 return retval;

1608

1609 INIT_LIST_HEAD(&handler->h_list);

1610

1611 if (handler->fops != NULL) {

1612 if (input_table[handler->minor >> 5]) {

1613 retval = -EBUSY;

1614 goto out;

1615 }

1616 input_table[handler->minor >> 5] = handler;

1617 }

1618

1619 list_add_tail(&handler->node, &input_handler_list);

1620

1621 list_for_each_entry(dev, &input_dev_list, node)

1622 input_attach_handler(dev, handler);

1623

1624 input_wakeup_procfs_readers();

1625

1626 out:

1627 mutex_unlock(&input_mutex);

1628 return retval;

1629 }

第1605行获得互斥信号量，1609行初始化handler 的h_list字段，这个h_list指向的链表用于存放input_handle。

第1611~1617行，我们的kbd_handler没有定义fops函数，所以这段代码不会执行，不过我们还是看一下，这里的input_table数组是一个struct input_handler结构数组，根据设备的次设备号除以32的值为下标的元素为input_handler为什么是32?输入子系统最多支持256个设备，而input_handler结构的数组最多处理8类事件，所以分给每一类的次设备号段分配32个。

第1619行把handler链接到input_handler_list尾部。

第1621~1622用handler去匹配input_dev_list上的input_dev，input_attach_handler函数在上面已经分析过，再最后如果匹配成功会调用handler的connect函数，对于这个kbd_handler相应的函数为kbd_connect，看一下这个函数：

1314 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,

1315 const struct input_device_id *id)

1316 {

1317 struct input_handle *handle;

1318 int error;

1319 int i;

1320

1321 for (i = KEY_RESERVED; i < BTN_MISC; i++)

1322 if (test_bit(i, dev->keybit))

1323 break;

1324

1325 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))

1326 return -ENODEV;

1327

1328 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);

1329 if (!handle)

1330 return -ENOMEM;

1331

1332 handle->dev = dev;

1333 handle->handler = handler;

1334 handle->name = "kbd";

1335

1336 error = input_register_handle(handle);

1337 if (error)

1338 goto err_free_handle;

1339

1340 error = input_open_device(handle);

1341 if (error)

1342 goto err_unregister_handle;

1343

1344 return 0;

1345

1346 err_unregister_handle:

1347 input_unregister_handle(handle);

1348 err_free_handle:

1349 kfree(handle);

1350 return error;

1351 }

第1321~1326行判断dev->keybit，如果属于例外的情况，则不再往下走，返回-ENODEV。

第1328行，为handle分配内存空间，1332~1334行初始化handle的部分字段。

第1336行调用input_register_handle注册handle，看一下这个函数：

1671 int input_register_handle(struct input_handle *handle)

1672 {

1673 struct input_handler *handler = handle->handler;

1674 struct input_dev *dev = handle->dev;

1675 int error;

1676

1677 /*

1678 * We take dev->mutex here to prevent race with

1679 * input_release_device().

1680 */

1681 error = mutex_lock_interruptible(&dev->mutex);

1682 if (error)

1683 return error;

1684 list_add_tail_rcu(&handle->d_node, &dev->h_list);

1685 mutex_unlock(&dev->mutex);

1686

1687 /*

1688 * Since we are supposed to be called from ->connect()

1689 * which is mutually exclusive with ->disconnect()

1690 * we can't be racing with input_unregister_handle()

1691 * and so separate lock is not needed here.

1692 */

1693 list_add_tail(&handle->h_node, &handler->h_list);

1694

1695 if (handler->start)

1696 handler->start(handle);

1697

1698 return 0;

1699 }

第1684、1693将handle分别链接到dev->h_list和handler->h_list。

第1695~1696行，如果handler的start函数存在，则调用它。对于这个kbd_handler相应的函数为kbd_start，看一下这个函数：

1364 static void kbd_start(struct input_handle *handle)

1365 {

1366 unsigned char leds = ledstate;

1367

1368 tasklet_disable(&keyboard_tasklet);

1369 if (leds != 0xff) {

1370 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));

1371 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));

1372 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));

1373 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);

1374 }

1375 tasklet_enable(&keyboard_tasklet);

1376 }

禁止keyboard_tasklet，初始化键盘的三个led灯及SYN_REPORT，然后启用keyboard_tasklet，这个keyboard_tasklet也是对led灯进行操作的，函数如下

1032 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);

1014 static void kbd_bh(unsigned long dummy)

1015 {

1016 struct list_head *node;

1017 unsigned char leds = getleds();

1018

1019 if (leds != ledstate) {

1020 list_for_each(node, &kbd_handler.h_list) {

1021 struct input_handle *handle = to_handle_h(node);

1022 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));

1023 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));

1024 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));

1025 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);

1026 }

1027 }

1028

1029 ledstate = leds;

1030 }

input_register_handle函数返回后，第1340行调用input_open_device函数，这个函数执行后相应的handle就能接受设备上报的事件。函数如下：

0421 int input_open_device(struct input_handle *handle)

0422 {

0423 struct input_dev *dev = handle->dev;

0424 int retval;

0425

0426 retval = mutex_lock_interruptible(&dev->mutex);

0427 if (retval)

0428 return retval;

0429

0430 if (dev->going_away) {

0431 retval = -ENODEV;

0432 goto out;

0433 }

0434

0435 handle->open++;

0436

0437 if (!dev->users++ && dev->open)

0438 retval = dev->open(dev);

0439

0440 if (retval) {

0441 dev->users--;

0442 if (!--handle->open) {

0443 /*

0444 * Make sure we are not delivering any more events

0445 * through this handle

0446 */

0447 synchronize_rcu();

0448 }

0449 }

0450

0451 out:

0452 mutex_unlock(&dev->mutex);

0453 return retval;

0454 }

增加handle的open计数，如果handle->dev->users不为0，则自增1，如果为0并且handle->dev的open函数存在则会调用它，对于前面分析的atkbd，相应的handle->dev的open函数不存在。

至此，input handler和input handler的注册都分析完了，接着将分析事件处理部分内容。

接下一篇文章。

最新回复(0)