hid-multitouch驱动源代码分析

转载地址：http://blog.youkuaiyun.com/jiangbei_lengyu/article/details/8996585

hid驱动代码看了一下，顺便做了做笔记，不详细，见谅。

Hid驱动代码(kernel/drivers/hid/hid-multitouch.c)。

[cpp]  view plain  copy

1. static int __init mt_init(void)  
2. {  
3.     return hid_register_driver(&mt_driver);  
4. }  

这里面主要是调用了一个hid_register_driver函数。看一下传进去的参数。

[cpp]  view plain  copy

1. static struct hid_driver mt_driver = {  
2.     .name = "hid-multitouch",  
3.     .id_table = mt_devices,  
4.     .probe = mt_probe,  
5.     .remove = mt_remove,  
6.     .input_mapping = mt_input_mapping,  
7.     .input_mapped = mt_input_mapped,  
8.     .feature_mapping = mt_feature_mapping,  
9.     .usage_table = mt_grabbed_usages,  
10.     .event = mt_event,  
11. #ifdef CONFIG_PM  
12.     .reset_resume = mt_reset_resume,  
13. #endif  
14. };  

上面都是一些基本的动作。重点看一下hid_register_driver函数。

hid_register_driver是定义在inlcude/linux/hid.h中的一个宏。

[cpp]  view plain  copy

1. #define hid_register_driver(driver) \  
2.     __hid_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)  

__hid_register_driver定义在drivers/hid/hid-core.c中。

[cpp]  view plain  copy

1. int __hid_register_driver(struct hid_driver *hdrv, struct module *owner,  
2.         const char *mod_name)  
3. {  
4.     int ret;  
5.   
6.     hdrv->driver.name = hdrv->name;  
7.     hdrv->driver.bus = &hid_bus_type;  
8.     hdrv->driver.owner = owner;  
9.     hdrv->driver.mod_name = mod_name;  
10.   
11.     INIT_LIST_HEAD(&hdrv->dyn_list);  
12.     spin_lock_init(&hdrv->dyn_lock);  
13.   
14.     ret = driver_register(&hdrv->driver);  
15.     if (ret)  
16.         return ret;  
17.   
18.     ret = driver_create_file(&hdrv->driver, &driver_attr_new_id);  
19.     if (ret)  
20.         driver_unregister(&hdrv->driver);  
21.   
22.     return ret;  
23. }  
24. EXPORT_SYMBOL_GPL(__hid_register_driver);  

在上面的那段代码中首先填充了hid_driver结构体变量hdrv的一些成员。注意到有这样一行代码hdrv->driver.bus = &hid_bus_type;这里指定了hdrv的驱动总线类型。

[cpp]  view plain  copy

1. static struct bus_type hid_bus_type = {  
2.     .name       = "hid",  
3.     .match      = hid_bus_match,  
4.     .probe      = hid_device_probe,  
5.     .remove     = hid_device_remove,  
6.     .uevent     = hid_uevent,  
7. };  

这个hid_bus_type在之前已经注册到系统中了。

在初始化了链表和锁之后，利用driver_register将hdrv->driver注册到系统中。

driver_register是个很通用的函数，看过驱动模型的人大都会了解，这里就不详细说明了。

[cpp]  view plain  copy

1. int driver_register(struct device_driver *drv)  
2. {  
3.     int ret;  
4.     struct device_driver *other;  
5.   
6.     BUG_ON(!drv->bus->p);  
7.   
8.     if ((drv->bus->probe && drv->probe) ||  
9.         (drv->bus->remove && drv->remove) ||  
10.         (drv->bus->shutdown && drv->shutdown))  
11.         printk(KERN_WARNING "Driver '%s' needs updating - please use "  
12.             "bus_type methods\n", drv->name);  
13.   
14.     other = driver_find(drv->name, drv->bus);  
15.     if (other) {  
16.         printk(KERN_ERR "Error: Driver '%s' is already registered, "  
17.             "aborting...\n", drv->name);  
18.         return -EBUSY;  
19.     }  
20.   
21.     ret = bus_add_driver(drv);  
22.     if (ret)  
23.         return ret;  
24.     ret = driver_add_groups(drv, drv->groups);  
25.     if (ret)  
26.         bus_remove_driver(drv);  
27.     return ret;  
28. }  

首先利用driver_find函数从我们这个驱动所属的总线中找寻名字和我们的driver相同的驱动，如果能够找到，说明在这个总线下面已经有一个同样的驱动了，所以会返回出错标志。如果找不到这样一个驱动就会把我们现在的这个驱动添加到这个总线下面，添加过程中使用的是bus_add_driver函数。代码如下：

[cpp]  view plain  copy

1. int bus_add_driver(struct device_driver *drv)  
2. {  
3.     struct bus_type *bus;  
4.     struct driver_private *priv;  
5.     int error = 0;  
6.   
7.     bus = bus_get(drv->bus);  
8.     if (!bus)  
9.         return -EINVAL;  
10.   
11.     pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);  
12.   
13.     priv = kzalloc(sizeof(*priv), GFP_KERNEL);  
14.     if (!priv) {  
15.         error = -ENOMEM;  
16.         goto out_put_bus;  
17.     }  
18.     klist_init(&priv->klist_devices, NULL, NULL);  
19.     priv->driver = drv;  
20.     drv->p = priv;  
21.     priv->kobj.kset = bus->p->drivers_kset;  
22.     error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,  
23.                      "%s", drv->name);  
24.     if (error)  
25.         goto out_unregister;  
26.   
27.     if (drv->bus->p->drivers_autoprobe) {  
28.         error = driver_attach(drv);  
29.         if (error)  
30.             goto out_unregister;  
31.     }  
32.     klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);  
33.     module_add_driver(drv->owner, drv);  
34.   
35.     error = driver_create_file(drv, &driver_attr_uevent);  
36.     if (error) {  
37.         printk(KERN_ERR "%s: uevent attr (%s) failed\n",  
38.             __func__, drv->name);  
39.     }  
40.     error = driver_add_attrs(bus, drv);  
41.     if (error) {  
42.         /* How the hell do we get out of this pickle? Give up */  
43.         printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",  
44.             __func__, drv->name);  
45.     }  
46.   
47.     if (!drv->suppress_bind_attrs) {  
48.         error = add_bind_files(drv);  
49.         if (error) {  
50.             /* Ditto */  
51.             printk(KERN_ERR "%s: add_bind_files(%s) failed\n",  
52.                 __func__, drv->name);  
53.         }  
54.     }  
55.   
56.     kobject_uevent(&priv->kobj, KOBJ_ADD);  
57.     return 0;  
58.   
59. out_unregister:  
60.     kobject_put(&priv->kobj);  
61.     kfree(drv->p);  
62.     drv->p = NULL;  
63. out_put_bus:  
64.     bus_put(bus);  
65.     return error;  
66. }  

着重看一下几行代码：

[cpp]  view plain  copy

1. if (drv->bus->p->drivers_autoprobe) {  
2.     error = driver_attach(drv);  
3.     if (error)  
4.         goto out_unregister;  
5. }  

在bus注册的过程中bus->p->drivers_autoprobe会被设置为1，所以这里的if里面的代码是可以执行的。

[cpp]  view plain  copy

1. int driver_attach(struct device_driver *drv)  
2. {  
3.     return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);  
4. }  

在这里最终会去执行__driver_attach函数。

[cpp]  view plain  copy

1. static int __driver_attach(struct device *dev, void *data)  
2. {  
3.     struct device_driver *drv = data;  
4.   
5.     /* 
6.      * Lock device and try to bind to it. We drop the error 
7.      * here and always return 0, because we need to keep trying 
8.      * to bind to devices and some drivers will return an error 
9.      * simply if it didn't support the device. 
10.      * 
11.      * driver_probe_device() will spit a warning if there 
12.      * is an error. 
13.      */  
14.   
15.     if (!driver_match_device(drv, dev))  
16.         return 0;  
17.   
18.     if (dev->parent) /* Needed for USB */  
19.         device_lock(dev->parent);  
20.     device_lock(dev);  
21.     if (!dev->driver)  
22.         driver_probe_device(drv, dev);  
23.     device_unlock(dev);  
24.     if (dev->parent)  
25.         device_unlock(dev->parent);  
26.   
27.     return 0;  
28. }  

在这里面有几行代码是我们需要的

[cpp]  view plain  copy

1. if (!driver_match_device(drv, dev))  
2.     return 0;  

match_device?对，这里就是去执行一些match操作。

[cpp]  view plain  copy

1. static inline int driver_match_device(struct device_driver *drv,  
2.                       struct device *dev)  
3. {  
4.     return drv->bus->match ? drv->bus->match(dev, drv) : 1;  
5. }  

看到没，这里其实调用的就是bus上的match函数。我们这里先做个记号，我们继续沿着代码往下走，回头再具体的去看那些match的东西。

回到__driver_attach函数中继续看下面的代码

[cpp]  view plain  copy

1. if (!dev->driver)  
2.     driver_probe_device(drv, dev);  

从名字上可以判断出，这里是去probe device。

[cpp]  view plain  copy

1. int driver_probe_device(struct device_driver *drv, struct device *dev)  
2. {  
3.     int ret = 0;  
4.   
5.     if (!device_is_registered(dev))  
6.         return -ENODEV;  
7.   
8.     pr_debug("bus: '%s': %s: matched device %s with driver %s\n",  
9.          drv->bus->name, __func__, dev_name(dev), drv->name);  
10.   
11.     pm_runtime_get_noresume(dev);  
12.     pm_runtime_barrier(dev);  
13.     ret = really_probe(dev, drv);  
14.     pm_runtime_put_sync(dev);  
15.   
16.     return ret;  
17. }  

继续去调用really_probe函数。

[cpp]  view plain  copy

1. static int really_probe(struct device *dev, struct device_driver *drv)  
2. {  
3.     int ret = 0;  
4.   
5.     atomic_inc(&probe_count);  
6.     pr_debug("bus: '%s': %s: probing driver %s with device %s\n",  
7.          drv->bus->name, __func__, drv->name, dev_name(dev));  
8.     WARN_ON(!list_empty(&dev->devres_head));  
9.   
10.     dev->driver = drv;  
11.     if (driver_sysfs_add(dev)) {  
12.         printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",  
13.             __func__, dev_name(dev));  
14.         goto probe_failed;  
15.     }  
16.   
17.     if (dev->bus->probe) {  
18.         ret = dev->bus->probe(dev);  
19.         if (ret)  
20.             goto probe_failed;  
21.     } else if (drv->probe) {  
22.         ret = drv->probe(dev);  
23.         if (ret)  
24.             goto probe_failed;  
25.     }  
26.   
27.     driver_bound(dev);  
28.     ret = 1;  
29.     pr_debug("bus: '%s': %s: bound device %s to driver %s\n",  
30.          drv->bus->name, __func__, dev_name(dev), drv->name);  
31.     goto done;  
32.   
33. probe_failed:  
34.     devres_release_all(dev);  
35.     driver_sysfs_remove(dev);  
36.     dev->driver = NULL;  
37.   
38.     if (ret == -EPROBE_DEFER) {  
39.         /* Driver requested deferred probing */  
40.         dev_info(dev, "Driver %s requests probe deferral\n", drv->name);  
41.         driver_deferred_probe_add(dev);  
42.     } else if (ret != -ENODEV && ret != -ENXIO) {  
43.         /* driver matched but the probe failed */  
44.         printk(KERN_WARNING  
45.                "%s: probe of %s failed with error %d\n",  
46.                drv->name, dev_name(dev), ret);  
47.     } else {  
48.         pr_debug("%s: probe of %s rejects match %d\n",  
49.                drv->name, dev_name(dev), ret);  
50.     }  
51.     /* 
52.      * Ignore errors returned by ->probe so that the next driver can try 
53.      * its luck. 
54.      */  
55.     ret = 0;  
56. done:  
57.     atomic_dec(&probe_count);  
58.     wake_up(&probe_waitqueue);  
59.     return ret;  
60. }  

看这里出现的这段代码

[cpp]  view plain  copy

1. if (dev->bus->probe) {  
2.     ret = dev->bus->probe(dev);  
3.     if (ret)  
4.         goto probe_failed;  
5. } else if (drv->probe) {  
6.     ret = drv->probe(dev);  
7.     if (ret)  
8.         goto probe_failed;  
9. }  

如果bus的probe函数存在就调用bus的probe函数，否则就去调用driver的probe函数。这几个probe函数就是我们在前面看到的那个probe函数。

到现在为止我们知道，在add driver的过程中，我们首先要去调用bus的match函数，然后再去调用bus的probe函数。在这里我们了解到这些就可以了，想具体的再去详细看的话，可以找设备驱动模型的资料去了解。

好，回到hid-core.c文件中，我们先去看看bus的match函数。还记得那个bus_type结构体hid_bus_type吧？

[cpp]  view plain  copy

1. static struct bus_type hid_bus_type = {  
2.     .name       = "hid",  
3.     .match      = hid_bus_match,  
4.     .probe      = hid_device_probe,  
5.     .remove     = hid_device_remove,  
6.     .uevent     = hid_uevent,  
7. };  

这里面就是我们需要的match和probe函数。我们先看hid_bus_match函数。

[cpp]  view plain  copy

1. static int hid_bus_match(struct device *dev, struct device_driver *drv)  
2. {  
3.     struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);  
4.     struct hid_device *hdev = container_of(dev, struct hid_device, dev);  
5.   
6.     if ((hdev->quirks & HID_QUIRK_MULTITOUCH) &&  
7.         !strncmp(hdrv->name, "hid-multitouch", 14))  
8.         return 1;  
9.   
10.     if (!hid_match_device(hdev, hdrv))  
11.         return 0;  
12.   
13.     /* generic wants all that don't have specialized driver */  
14.     if (!strncmp(hdrv->name, "generic-", 8) && !hid_ignore_special_drivers)  
15.         return !hid_match_id(hdev, hid_have_special_driver);  
16.   
17.     return 1;  
18. }  

首先利用container_of从系统中取出hid_driver结构体和hid_device结构体。

如果hdev的quirks变量里面包含有HID_QUIRK_MULTITOUCH变量并且hdrv的name为"hid-multitouch"，那就直接返回一个1，下面的就不用匹配了。否则调用hid_match_device匹配函数，进行匹配。

[cpp]  view plain  copy

1. static const struct hid_device_id *hid_match_device(struct hid_device *hdev,  
2.         struct hid_driver *hdrv)  
3. {  
4.     struct hid_dynid *dynid;  
5.   
6.     spin_lock(&hdrv->dyn_lock);  
7.     list_for_each_entry(dynid, &hdrv->dyn_list, list) {  
8.         if (hid_match_one_id(hdev, &dynid->id)) {  
9.             spin_unlock(&hdrv->dyn_lock);  
10.             return &dynid->id;  
11.         }  
12.     }  
13.     spin_unlock(&hdrv->dyn_lock);  
14.   
15.     return hid_match_id(hdev, hdrv->id_table);  
16. }  

在这里面主要是要匹配vendor id 和product id。涉及到两个函数一并贴出来。

[cpp]  view plain  copy

1. static bool hid_match_one_id(struct hid_device *hdev,  
2.         const struct hid_device_id *id)  
3. {  
4.     return id->bus == hdev->bus &&  
5.         (id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&  
6.         (id->product == HID_ANY_ID || id->product == hdev->product);  
7. }  
8.   
9. const struct hid_device_id *hid_match_id(struct hid_device *hdev,  
10.         const struct hid_device_id *id)  
11. {  
12.     for (; id->bus; id++)  
13.         if (hid_match_one_id(hdev, id))  
14.             return id;  
15.   
16.     return NULL;  
17. }  

首先从hid_driver结构体的dyn_list中依次取出hid_device_id结构体变量id,将其总线类型，vendor id, product id依次与hid_device结构体变量hdev的对应值匹配，如果匹配成功就返回hid_device_id结构体。如果无法匹配的话，就调用hid_match_id函数将hdev与hdrv的id_table匹配。

匹配过程就是上面那样，下面调用hid_device_probe函数。

[cpp]  view plain  copy

1. static int hid_device_probe(struct device *dev)  
2. {  
3.     struct hid_driver *hdrv = container_of(dev->driver,  
4.             struct hid_driver, driver);  
5.     struct hid_device *hdev = container_of(dev, struct hid_device, dev);  
6.     const struct hid_device_id *id;  
7.     int ret = 0;  
8.   
9.     if (down_interruptible(&hdev->driver_lock))  
10.         return -EINTR;  
11.   
12.     if (!hdev->driver) {  
13.         id = hid_match_device(hdev, hdrv);  
14.         if (id == NULL) {  
15.             if (!((hdev->quirks & HID_QUIRK_MULTITOUCH) &&  
16.                 !strncmp(hdrv->name, "hid-multitouch", 14))) {  
17.                 ret = -ENODEV;  
18.                 goto unlock;  
19.             }  
20.         }  
21.   
22.         hdev->driver = hdrv;  
23.         if (hdrv->probe) {  
24.             ret = hdrv->probe(hdev, id);  
25.         } else { /* default probe */  
26.             ret = hid_parse(hdev);  
27.             if (!ret)  
28.                 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);  
29.         }  
30.         if (ret)  
31.             hdev->driver = NULL;  
32.     }  
33. unlock:  
34.     up(&hdev->driver_lock);  
35.     return ret;  
36. }  

probe过程相当的简单，首先再次匹配一遍，将hdrv保存到hdev的driver里面。如果hdrv的probe函数存在就调用hdrv的probe函数，否则调用一个default的probe函数。当然在这里我们是调用我们自己的probe函数啦。

我们重新把hid_driver的结构体成员表贴一下。

[cpp]  view plain  copy

1. static struct hid_driver mt_driver = {  
2.     .name = "hid-multitouch",  
3.     .id_table = mt_devices,  
4.     .probe = mt_probe,  
5.     .remove = mt_remove,  
6.     .input_mapping = mt_input_mapping,  
7.     .input_mapped = mt_input_mapped,  
8.     .feature_mapping = mt_feature_mapping,  
9.     .usage_table = mt_grabbed_usages,  
10.     .event = mt_event,  
11. #ifdef CONFIG_PM  
12.     .reset_resume = mt_reset_resume,  
13. #endif  
14. };  

现在我们着重看mt_probe函数。

[cpp]  view plain  copy

1. static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)  
2. {  
3.     int ret, i;  
4.     struct mt_device *td;  
5.     struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */  
6.   
7.     if (id) {  
8.         for (i = 0; mt_classes[i].name ; i++) {  
9.             if (id->driver_data == mt_classes[i].name) {  
10.                 mtclass = &(mt_classes[i]);  
11.                 break;  
12.             }  
13.         }  
14.     }  
15.   
16.     /* This allows the driver to correctly support devices 
17.      * that emit events over several HID messages. 
18.      */  
19.     hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;  
20.     hdev->quirks &= ~HID_QUIRK_MULTITOUCH;  
21.   
22.     td = kzalloc(sizeof(struct mt_device), GFP_KERNEL);  
23.     if (!td) {  
24.         dev_err(&hdev->dev, "cannot allocate multitouch data\n");  
25.         return -ENOMEM;  
26.     }  
27.     td->mtclass = *mtclass;  
28.     td->inputmode = -1;  
29.     td->maxcontact_report_id = -1;  
30.     hid_set_drvdata(hdev, td);  
31.   
32.     td->fields = kzalloc(sizeof(struct mt_fields), GFP_KERNEL);  
33.     if (!td->fields) {  
34.         dev_err(&hdev->dev, "cannot allocate multitouch fields data\n");  
35.         ret = -ENOMEM;  
36.         goto fail;  
37.     }  
38.   
39.     ret = hid_parse(hdev);  
40.     if (ret != 0)  
41.         goto fail;  
42.   
43.     ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);  
44.     if (ret)  
45.         goto fail;  
46.   
47.     mt_post_parse(td);  
48.   
49.     if (!id && td->touches_by_report == 1) {  
50.         /* the device has been sent by hid-generic */  
51.         mtclass = &td->mtclass;  
52.         mtclass->quirks |= MT_QUIRK_ALWAYS_VALID;  
53.         mtclass->quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP;  
54.         mtclass->quirks &= ~MT_QUIRK_VALID_IS_INRANGE;  
55.         mtclass->quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE;  
56.     }  
57.   
58.     td->slots = kzalloc(td->maxcontacts * sizeof(struct mt_slot),  
59.                 GFP_KERNEL);  
60.     if (!td->slots) {  
61.         dev_err(&hdev->dev, "cannot allocate multitouch slots\n");  
62.         hid_hw_stop(hdev);  
63.         ret = -ENOMEM;  
64.         goto fail;  
65.     }  
66.   
67.     ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group);  
68.   
69.     mt_set_maxcontacts(hdev);  
70.     mt_set_input_mode(hdev);  
71.   
72.     kfree(td->fields);  
73.     td->fields = NULL;  
74.   
75.     return 0;  
76.   
77. fail:  
78.     kfree(td->fields);  
79.     kfree(td);  
80.     return ret;  
81. }  

代码中涉及到一个结构体mt_class

[cpp]  view plain  copy

1. struct mt_class {  
2.     __s32 name; /* MT_CLS */  
3.     __s32 quirks;  
4.     __s32 sn_move;  /* Signal/noise ratio for move events */  
5.     __s32 sn_width; /* Signal/noise ratio for width events */  
6.     __s32 sn_height;    /* Signal/noise ratio for height events */  
7.     __s32 sn_pressure;  /* Signal/noise ratio for pressure events */  
8.     __u8 maxcontacts;  
9.     bool is_indirect;   /* true for touchpads */  
10. };  

这个是multitouch class结构体。从mt_classes数组中取得一个mt_class结构体，方法是去匹配id->driver_data和每个数组的name成员。然后填充结构体mt_device *td，调用hid_parse函数。看一下这个函数。

[cpp]  view plain  copy

1. /** 
2.  * hid_parse - parse HW reports 
3.  * 
4.  * @hdev: hid device 
5.  * 
6.  * Call this from probe after you set up the device (if needed). Your 
7.  * report_fixup will be called (if non-NULL) after reading raw report from 
8.  * device before passing it to hid layer for real parsing. 
9.  */  
10. static inline int __must_check hid_parse(struct hid_device *hdev)  
11. {  
12.     int ret;  
13.   
14.     if (hdev->status & HID_STAT_PARSED)  
15.         return 0;  
16.   
17.     ret = hdev->ll_driver->parse(hdev);  
18.     if (!ret)  
19.         hdev->status |= HID_STAT_PARSED;  
20.   
21.     return ret;  
22. }  

hdev的status变量保存了hid的status flags。如果我们已经parse过一次，其status中将会保存了一个HID_STAT_PARSEDflag。也就不用再次parse了。如果没有那个状态就调用hdev->ll_driver->parse(hdev)函数。

到这里为止，我们终于要面对这个这个hdev参数了，由于这个multitouch是通过usb连接的，所以这里在drivers/hid/usbhid/里面我们能够找到这个hdev结构，同样我们可以在里面找到这样一行代码：

[cpp]  view plain  copy

1. hid->ll_driver = &usb_hid_driver;  

看一下usb_hid_deiver

[cpp]  view plain  copy

1. static struct hid_ll_driver usb_hid_driver = {  
2.     .parse = usbhid_parse,  
3.     .start = usbhid_start,  
4.     .stop = usbhid_stop,  
5.     .open = usbhid_open,  
6.     .close = usbhid_close,  
7.     .power = usbhid_power,  
8.     .hidinput_input_event = usb_hidinput_input_event,  
9. };  

可以看到这里面有几个函数，有我们现在需要的usbhid_parse。这个函数太复杂了我们后面分析。

接下来是这行代码ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);

[cpp]  view plain  copy

1. static inline int __must_check hid_hw_start(struct hid_device *hdev,  
2.         unsigned int connect_mask)  
3. {  
4.     int ret = hdev->ll_driver->start(hdev);  
5.     if (ret || !connect_mask)  
6.         return ret;  
7.     ret = hid_connect(hdev, connect_mask);  
8.     if (ret)  
9.         hdev->ll_driver->stop(hdev);  
10.     return ret;  
11. }  

同样，这里是调用的刚才这个usb_hid_driver结构体里面的函数start。具体涉及到usbhid目录下的文件都在后面补上。

下面调用hid_connect函数。

[cpp]  view plain  copy

1. int hid_connect(struct hid_device *hdev, unsigned int connect_mask)  
2. {  
3.     static const char *types[] = { "Device", "Pointer", "Mouse", "Device",  
4.         "Joystick", "Gamepad", "Keyboard", "Keypad",  
5.         "Multi-Axis Controller"  
6.     };  
7.     const char *type, *bus;  
8.     char buf[64];  
9.     unsigned int i;  
10.     int len;  
11.     int ret;  
12.   
13.     if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE)  
14.         connect_mask |= (HID_CONNECT_HIDDEV_FORCE | HID_CONNECT_HIDDEV);  
15.     if (hdev->quirks & HID_QUIRK_HIDINPUT_FORCE)  
16.         connect_mask |= HID_CONNECT_HIDINPUT_FORCE;  
17.     if (hdev->bus != BUS_USB)  
18.         connect_mask &= ~HID_CONNECT_HIDDEV;  
19.     if (hid_hiddev(hdev))  
20.         connect_mask |= HID_CONNECT_HIDDEV_FORCE;  
21.   
22.     if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev,  
23.                 connect_mask & HID_CONNECT_HIDINPUT_FORCE))  
24.         hdev->claimed |= HID_CLAIMED_INPUT;  
25.     if (hdev->quirks & HID_QUIRK_MULTITOUCH) {  
26.         /* this device should be handled by hid-multitouch, skip it */  
27.         return -ENODEV;  
28.     }  
29.   
30.     if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect &&  
31.             !hdev->hiddev_connect(hdev,  
32.                 connect_mask & HID_CONNECT_HIDDEV_FORCE))  
33.         hdev->claimed |= HID_CLAIMED_HIDDEV;  
34.     if ((connect_mask & HID_CONNECT_HIDRAW) && !hidraw_connect(hdev))  
35.         hdev->claimed |= HID_CLAIMED_HIDRAW;  
36.   
37.     if (!hdev->claimed) {  
38.         hid_err(hdev, "claimed by neither input, hiddev nor hidraw\n");  
39.         return -ENODEV;  
40.     }  
41.   
42.     if ((hdev->claimed & HID_CLAIMED_INPUT) &&  
43.             (connect_mask & HID_CONNECT_FF) && hdev->ff_init)  
44.         hdev->ff_init(hdev);  
45.   
46.     len = 0;  
47.     if (hdev->claimed & HID_CLAIMED_INPUT)  
48.         len += sprintf(buf + len, "input");  
49.     if (hdev->claimed & HID_CLAIMED_HIDDEV)  
50.         len += sprintf(buf + len, "%shiddev%d", len ? "," : "",  
51.                 hdev->minor);  
52.     if (hdev->claimed & HID_CLAIMED_HIDRAW)  
53.         len += sprintf(buf + len, "%shidraw%d", len ? "," : "",  
54.                 ((struct hidraw *)hdev->hidraw)->minor);  
55.   
56.     type = "Device";  
57.     for (i = 0; i < hdev->maxcollection; i++) {  
58.         struct hid_collection *col = &hdev->collection[i];  
59.         if (col->type == HID_COLLECTION_APPLICATION &&  
60.            (col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&  
61.            (col->usage & 0xffff) < ARRAY_SIZE(types)) {  
62.             type = types[col->usage & 0xffff];  
63.             break;  
64.         }  
65.     }  
66.   
67.     switch (hdev->bus) {  
68.     case BUS_USB:  
69.         bus = "USB";  
70.         break;  
71.     case BUS_BLUETOOTH:  
72.         bus = "BLUETOOTH";  
73.         break;  
74.     default:  
75.         bus = "<UNKNOWN>";  
76.     }  
77.   
78.     ret = device_create_bin_file(&hdev->dev, &dev_bin_attr_report_desc);  
79.     if (ret)  
80.         hid_warn(hdev,  
81.              "can't create sysfs report descriptor attribute err: %d\n", ret);  
82.   
83.     hid_info(hdev, "%s: %s HID v%x.%02x %s [%s] on %s\n",  
84.          buf, bus, hdev->version >> 8, hdev->version & 0xff,  
85.          type, hdev->name, hdev->phys);  
86.   
87.     return 0;  
88. }  
89. EXPORT_SYMBOL_GPL(hid_connect);  

这里首先根据hdev的quirks值去改变connect_mask值。然后判断connect_mask是否具有HID_CONNECT_HIDINPUT标志，如果具有那个标志就执行hidinput_connect函数。可以看出这个函数就是将hid子系统跟input子系统联系起来的函数。

[cpp]  view plain  copy

1. /* 
2.  * Register the input device; print a message. 
3.  * Configure the input layer interface 
4.  * Read all reports and initialize the absolute field values. 
5.  */  
6.   
7. int hidinput_connect(struct hid_device *hid, unsigned int force)  
8. {  
9.     struct hid_report *report;  
10.     struct hid_input *hidinput = NULL;  
11.     struct input_dev *input_dev;  
12.     int i, j, k;  
13.   
14.     INIT_LIST_HEAD(&hid->inputs);  
15.   
16.     if (!force) {  
17.         for (i = 0; i < hid->maxcollection; i++) {  
18.             struct hid_collection *col = &hid->collection[i];  
19.             if (col->type == HID_COLLECTION_APPLICATION ||  
20.                     col->type == HID_COLLECTION_PHYSICAL)  
21.                 if (IS_INPUT_APPLICATION(col->usage))  
22.                     break;  
23.         }  
24.   
25.         if (i == hid->maxcollection)  
26.             return -1;  
27.     }  
28.   
29.     report_features(hid);  
30.   
31.     for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {  
32.         if (k == HID_OUTPUT_REPORT &&  
33.             hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)  
34.             continue;  
35.   
36.         list_for_each_entry(report, &hid->report_enum[k].report_list, list) {  
37.   
38.             if (!report->maxfield)  
39.                 continue;  
40.   
41.             if (!hidinput) {  
42.                 hidinput = kzalloc(sizeof(*hidinput), GFP_KERNEL);  
43.                 input_dev = input_allocate_device();  
44.                 if (!hidinput || !input_dev) {  
45.                     kfree(hidinput);  
46.                     input_free_device(input_dev);  
47.                     hid_err(hid, "Out of memory during hid input probe\n");  
48.                     goto out_unwind;  
49.                 }  
50.   
51.                 input_set_drvdata(input_dev, hid);  
52.                 input_dev->event =  
53.                     hid->ll_driver->hidinput_input_event;  
54.                 input_dev->open = hidinput_open;  
55.                 input_dev->close = hidinput_close;  
56.                 input_dev->setkeycode = hidinput_setkeycode;  
57.                 input_dev->getkeycode = hidinput_getkeycode;  
58.   
59.                 input_dev->name = hid->name;  
60.                 input_dev->phys = hid->phys;  
61.                 input_dev->uniq = hid->uniq;  
62.                 input_dev->id.bustype = hid->bus;  
63.                 input_dev->id.vendor  = hid->vendor;  
64.                 input_dev->id.product = hid->product;  
65.                 input_dev->id.version = hid->version;  
66.                 input_dev->dev.parent = hid->dev.parent;  
67.                 hidinput->input = input_dev;  
68.                 list_add_tail(&hidinput->list, &hid->inputs);  
69.             }  
70.   
71.             for (i = 0; i < report->maxfield; i++)  
72.                 for (j = 0; j < report->field[i]->maxusage; j++)  
73.                     hidinput_configure_usage(hidinput, report->field[i],  
74.                                  report->field[i]->usage + j);  
75.   
76.             if (hid->quirks & HID_QUIRK_MULTI_INPUT) {  
77.                 /* This will leave hidinput NULL, so that it 
78.                  * allocates another one if we have more inputs on 
79.                  * the same interface. Some devices (e.g. Happ's 
80.                  * UGCI) cram a lot of unrelated inputs into the 
81.                  * same interface. */  
82.                 hidinput->report = report;  
83.                 if (hid->driver->input_register &&  
84.                         hid->driver->input_register(hid, hidinput))  
85.                     goto out_cleanup;  
86.                 if (input_register_device(hidinput->input))  
87.                     goto out_cleanup;  
88.                 hidinput = NULL;  
89.             }  
90.         }  
91.     }  
92.   
93.     if (hid->quirks & HID_QUIRK_MULTITOUCH) {  
94.         /* generic hid does not know how to handle multitouch devices */  
95.         if (hidinput)  
96.             goto out_cleanup;  
97.         goto out_unwind;  
98.     }  
99.   
100.     if (hidinput && hid->driver->input_register &&  
101.             hid->driver->input_register(hid, hidinput))  
102.         goto out_cleanup;  
103.   
104.     if (hidinput && input_register_device(hidinput->input))  
105.         goto out_cleanup;  
106.   
107.     return 0;  
108.   
109. out_cleanup:  
110.     list_del(&hidinput->list);  
111.     input_free_device(hidinput->input);  
112.     kfree(hidinput);  
113. out_unwind:  
114.     /* unwind the ones we already registered */  
115.     hidinput_disconnect(hid);  
116.   
117.     return -1;  
118. }  
119. EXPORT_SYMBOL_GPL(hidinput_connect);  

注意到传给force的参数为connect_mask & HID_CONNECT_HIDINPUT_FORCE，也就是说如果connect_mask含有HID_CONNECT_HIDINPUT_FORCE标志的话，第一个if里面的代码就不需要执行了。report_features之后是一个大大的for循环。在这里面主要是建立input_dev结构体，并将该结构体添加到对应的链表中。这样就将hid子系统和input子系统联系起来了。

Usb设备代码

multitouch是通过usb连接到板子上的，我们在前面函数调用的时候都有提到过hdev，即hid_device结构体指针，那个这个东西是什么呢？在哪里定义的？我们现在就看看这部分代码。

这部分的代码位于drivers/hid/usbhid/目录下。首先看一下init函数，位于hid-core.c文件中。

[cpp]  view plain  copy

1. static int __init hid_init(void)  
2. {  
3.     int retval = -ENOMEM;  
4.   
5.     retval = hid_register_driver(&hid_usb_driver);  
6.     if (retval)  
7.         goto hid_register_fail;  
8.     retval = usbhid_quirks_init(quirks_param);  
9.     if (retval)  
10.         goto usbhid_quirks_init_fail;  
11.     retval = usb_register(&hid_driver);  
12.     if (retval)  
13.         goto usb_register_fail;  
14.     printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");  
15.   
16.     return 0;  
17. usb_register_fail:  
18.     usbhid_quirks_exit();  
19. usbhid_quirks_init_fail:  
20.     hid_unregister_driver(&hid_usb_driver);  
21. hid_register_fail:  
22.     return retval;  
23. }  

在hid_init函数中，主要是调用了三个函数，即hid_register_driver，usbhid_quirks_init，usb_register。

关于对这部分代码的解析可以参考一下文档

http://www.cnblogs.com/sdphome/archive/2011/09/29/2195799.html

在那篇文档中对hid写的很详细，大家可以去深入的看看，在这里我主要简单的介绍一下需要用到的函数，其他的就不一一的去解释了。

主要看我们在multitouch中调用到的那几个函数。

ret = hdev->ll_driver->parse(hdev);

在这里会调用到parse函数也就是usbhid_parse。

[cpp]  view plain  copy

1. static int usbhid_parse(struct hid_device *hid)  
2. {  
3.     struct usb_interface *intf = to_usb_interface(hid->dev.parent);  
4.     struct usb_host_interface *interface = intf->cur_altsetting;  
5.     struct usb_device *dev = interface_to_usbdev (intf);  
6.     struct hid_descriptor *hdesc;  
7.     u32 quirks = 0;  
8.     unsigned int rsize = 0;  
9.     char *rdesc;  
10.     int ret, n;  
11.   
12.     quirks = usbhid_lookup_quirk(le16_to_cpu(dev->descriptor.idVendor),  
13.             le16_to_cpu(dev->descriptor.idProduct));  
14.   
15.     if (quirks & HID_QUIRK_IGNORE)  
16.         return -ENODEV;  
17.   
18.     /* Many keyboards and mice don't like to be polled for reports, 
19.      * so we will always set the HID_QUIRK_NOGET flag for them. */  
20.     if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT) {  
21.         if (interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_KEYBOARD ||  
22.             interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE)  
23.                 quirks |= HID_QUIRK_NOGET;  
24.     }  
25.   
26.     if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) &&  
27.         (!interface->desc.bNumEndpoints ||  
28.          usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) {  
29.         dbg_hid("class descriptor not present\n");  
30.         return -ENODEV;  
31.     }  
32.   
33.     hid->version = le16_to_cpu(hdesc->bcdHID);  
34.     hid->country = hdesc->bCountryCode;  
35.   
36.     for (n = 0; n < hdesc->bNumDescriptors; n++)  
37.         if (hdesc->desc[n].bDescriptorType == HID_DT_REPORT)  
38.             rsize = le16_to_cpu(hdesc->desc[n].wDescriptorLength);  
39.   
40.     if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) {  
41.         dbg_hid("weird size of report descriptor (%u)\n", rsize);  
42.         return -EINVAL;  
43.     }  
44.   
45.     if (!(rdesc = kmalloc(rsize, GFP_KERNEL))) {  
46.         dbg_hid("couldn't allocate rdesc memory\n");  
47.         return -ENOMEM;  
48.     }  
49.   
50.     hid_set_idle(dev, interface->desc.bInterfaceNumber, 0, 0);  
51.   
52.     ret = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber,  
53.             HID_DT_REPORT, rdesc, rsize);  
54.     if (ret < 0) {  
55.         dbg_hid("reading report descriptor failed\n");  
56.         kfree(rdesc);  
57.         goto err;  
58.     }  
59.   
60.     ret = hid_parse_report(hid, rdesc, rsize);  
61.     kfree(rdesc);  
62.     if (ret) {  
63.         dbg_hid("parsing report descriptor failed\n");  
64.         goto err;  
65.     }  
66.   
67.     hid->quirks |= quirks;  
68.   
69.     return 0;  
70. err:  
71.     return ret;  
72. }  

这段代码中首先通过vendor id和product id 去获得对应设备的quirks，然后根据描述符类型去选择一下操作，由于这里的hid驱动不仅仅是为multitouch服务的，所以这里的判断比较多。得到描述符信息，调用hid_parse_report去解析这些描述符。

继续看下一个函数

int ret =hdev->ll_driver->start(hdev);

这里调用的是usbhid_start函数。

[cpp]  view plain  copy

1. static int usbhid_start(struct hid_device *hid)  
2. {  
3.     struct usb_interface *intf = to_usb_interface(hid->dev.parent);  
4.     struct usb_host_interface *interface = intf->cur_altsetting;  
5.     struct usb_device *dev = interface_to_usbdev(intf);  
6.     struct usbhid_device *usbhid = hid->driver_data;  
7.     unsigned int n, insize = 0;  
8.     int ret;  
9.   
10.     clear_bit(HID_DISCONNECTED, &usbhid->iofl);  
11.   
12.     usbhid->bufsize = HID_MIN_BUFFER_SIZE;  
13.     hid_find_max_report(hid, HID_INPUT_REPORT, &usbhid->bufsize);  
14.     hid_find_max_report(hid, HID_OUTPUT_REPORT, &usbhid->bufsize);  
15.     hid_find_max_report(hid, HID_FEATURE_REPORT, &usbhid->bufsize);  
16.   
17.     if (usbhid->bufsize > HID_MAX_BUFFER_SIZE)  
18.         usbhid->bufsize = HID_MAX_BUFFER_SIZE;  
19.   
20.     hid_find_max_report(hid, HID_INPUT_REPORT, &insize);  
21.   
22.     if (insize > HID_MAX_BUFFER_SIZE)  
23.         insize = HID_MAX_BUFFER_SIZE;  
24.   
25.     if (hid_alloc_buffers(dev, hid)) {  
26.         ret = -ENOMEM;  
27.         goto fail;  
28.     }  
29.   
30.     for (n = 0; n < interface->desc.bNumEndpoints; n++) {  
31.         struct usb_endpoint_descriptor *endpoint;  
32.         int pipe;  
33.         int interval;  
34.   
35.         endpoint = &interface->endpoint[n].desc;  
36.         if (!usb_endpoint_xfer_int(endpoint))  
37.             continue;  
38.   
39.         interval = endpoint->bInterval;  
40.   
41.         /* Some vendors give fullspeed interval on highspeed devides */  
42.         if (hid->quirks & HID_QUIRK_FULLSPEED_INTERVAL &&  
43.             dev->speed == USB_SPEED_HIGH) {  
44.             interval = fls(endpoint->bInterval*8);  
45.             printk(KERN_INFO "%s: Fixing fullspeed to highspeed interval: %d -> %d\n",  
46.                    hid->name, endpoint->bInterval, interval);  
47.         }  
48.   
49.         /* Change the polling interval of mice. */  
50.         if (hid->collection->usage == HID_GD_MOUSE && hid_mousepoll_interval > 0)  
51.             interval = hid_mousepoll_interval;  
52.   
53.         ret = -ENOMEM;  
54.         if (usb_endpoint_dir_in(endpoint)) {  
55.             if (usbhid->urbin)  
56.                 continue;  
57.             if (!(usbhid->urbin = usb_alloc_urb(0, GFP_KERNEL)))  
58.                 goto fail;  
59.             pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);  
60.             usb_fill_int_urb(usbhid->urbin, dev, pipe, usbhid->inbuf, insize,  
61.                      hid_irq_in, hid, interval);  
62.             usbhid->urbin->transfer_dma = usbhid->inbuf_dma;  
63.             usbhid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;  
64.         } else {  
65.             if (usbhid->urbout)  
66.                 continue;  
67.             if (!(usbhid->urbout = usb_alloc_urb(0, GFP_KERNEL)))  
68.                 goto fail;  
69.             pipe = usb_sndintpipe(dev, endpoint->bEndpointAddress);  
70.             usb_fill_int_urb(usbhid->urbout, dev, pipe, usbhid->outbuf, 0,  
71.                      hid_irq_out, hid, interval);  
72.             usbhid->urbout->transfer_dma = usbhid->outbuf_dma;  
73.             usbhid->urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;  
74.         }  
75.     }  
76.   
77.     usbhid->urbctrl = usb_alloc_urb(0, GFP_KERNEL);  
78.     if (!usbhid->urbctrl) {  
79.         ret = -ENOMEM;  
80.         goto fail;  
81.     }  
82.   
83.     usb_fill_control_urb(usbhid->urbctrl, dev, 0, (void *) usbhid->cr,  
84.                  usbhid->ctrlbuf, 1, hid_ctrl, hid);  
85.     usbhid->urbctrl->transfer_dma = usbhid->ctrlbuf_dma;  
86.     usbhid->urbctrl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;  
87.   
88.     if (!(hid->quirks & HID_QUIRK_NO_INIT_REPORTS))  
89.         usbhid_init_reports(hid);  
90.   
91.     set_bit(HID_STARTED, &usbhid->iofl);  
92.   
93.     /* Some keyboards don't work until their LEDs have been set. 
94.      * Since BIOSes do set the LEDs, it must be safe for any device 
95.      * that supports the keyboard boot protocol. 
96.      * In addition, enable remote wakeup by default for all keyboard 
97.      * devices supporting the boot protocol. 
98.      */  
99.     if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT &&  
100.             interface->desc.bInterfaceProtocol ==  
101.                 USB_INTERFACE_PROTOCOL_KEYBOARD) {  
102.         usbhid_set_leds(hid);  
103.         device_set_wakeup_enable(&dev->dev, 1);  
104.     }  
105.     return 0;  
106.   
107. fail:  
108.     usb_free_urb(usbhid->urbin);  
109.     usb_free_urb(usbhid->urbout);  
110.     usb_free_urb(usbhid->urbctrl);  
111.     usbhid->urbin = NULL;  
112.     usbhid->urbout = NULL;  
113.     usbhid->urbctrl = NULL;  
114.     hid_free_buffers(dev, hid);  
115.     return ret;  
116. }  

在这里主要是初始化了urb。

注意到有这么一行代码，这里使用这个函数提交USB_DIR_IN方向的reports.

         usb_fill_control_urb(usbhid->urbctrl,dev, 0, (void *) usbhid->cr,

                                 usbhid->ctrlbuf, 1, hid_ctrl, hid);

所以在提交完了之后会调用hid_ctrl函数。

[cpp]  view plain  copy

1. static void hid_ctrl(struct urb *urb)  
2. {  
3.     struct hid_device *hid = urb->context;  
4.     struct usbhid_device *usbhid = hid->driver_data;  
5.     int unplug = 0, status = urb->status;  
6.   
7.     spin_lock(&usbhid->lock);  
8.   
9.     switch (status) {  
10.     case 0:         /* success */  
11.         if (usbhid->ctrl[usbhid->ctrltail].dir == USB_DIR_IN)  
12.             hid_input_report(urb->context,  
13.                 usbhid->ctrl[usbhid->ctrltail].report->type,  
14.                 urb->transfer_buffer, urb->actual_length, 0);  
15.         break;  
16.     case -ESHUTDOWN:    /* unplug */  
17.         unplug = 1;  
18.     case -EILSEQ:       /* protocol error or unplug */  
19.     case -EPROTO:       /* protocol error or unplug */  
20.     case -ECONNRESET:   /* unlink */  
21.     case -ENOENT:  
22.     case -EPIPE:        /* report not available */  
23.         break;  
24.     default:        /* error */  
25.         hid_warn(urb->dev, "ctrl urb status %d received\n", status);  
26.     }  
27.   
28.     if (unplug)  
29.         usbhid->ctrltail = usbhid->ctrlhead;  
30.     else  
31.         usbhid->ctrltail = (usbhid->ctrltail + 1) & (HID_CONTROL_FIFO_SIZE - 1);  
32.   
33.     if (!ctrl_pump_restart(hid)) {  
34.         /* Successfully submitted next urb in queue */  
35.         spin_unlock(&usbhid->lock);  
36.         return;  
37.     }  
38.   
39.     clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);  
40.     spin_unlock(&usbhid->lock);  
41.     usb_autopm_put_interface_async(usbhid->intf);  
42.     wake_up(&usbhid->wait);  
43. }  

在这个函数里面对我们有用的是case 0的情况。

[cpp]  view plain  copy

1. case 0:         /* success */  
2.     if (usbhid->ctrl[usbhid->ctrltail].dir == USB_DIR_IN)  
3.         hid_input_report(urb->context,  
4.             usbhid->ctrl[usbhid->ctrltail].report->type,  
5.             urb->transfer_buffer, urb->actual_length, 0);  
6.     break;  

这里又去调用了hid_input_report函数。hid_input_report函数定义在drivers/hid/hid-core.c文件中，这样又再次回到了主目录下的hid-core中。在drivers/hid/hid-core.c函数中我们需要关注的是

[cpp]  view plain  copy

1. hid_report_raw_event(hid, type, data, size, interrupt);  

这里最终会用到下面几行代码

[cpp]  view plain  copy

1. for (a = 0; a < report->maxfield; a++)  
2.     hid_input_field(hid, report->field[a], cdata, interrupt);  
3.   
4. if (hid->claimed & HID_CLAIMED_INPUT)  
5.     hidinput_report_event(hid, report);  

其中for循环用于上报，hidinput_report_event发送上报结束标志EV_SYN。