LINUX下USB1.1设备学习小记(6)_hid与input子系统(1)

static int __init hid_init(void)
{
    int retval;
    //怪癖检测初始化
    retval = usbhid_quirks_init(quirks_param);
    if (retval)
        goto usbhid_quirks_init_fail;
    //注册hiddev_driver为usb总线驱动
    retval = hiddev_init();
    if (retval)
        goto hiddev_init_fail;
    //注册hid_driver为usb总线驱动
    retval = usb_register(&hid_driver);
    if (retval)
        goto usb_register_fail;
    info(DRIVER_VERSION ":" DRIVER_DESC);
    return 0;
usb_register_fail:
    hiddev_exit();
hiddev_init_fail:
    usbhid_quirks_exit();
usbhid_quirks_init_fail:
    return retval;
}

static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
    struct hid_device *hid;
    char path[64];
    int i;
    char *c;
    dbg_hid("HID probe called for ifnum %d\n",intf->altsetting->desc.bInterfaceNumber);
    //进行hid_device结构的配置
    if (!(hid = usb_hid_configure(intf)))
        return -ENODEV;
    //初始化报告
    usbhid_init_reports(hid);
    hid_dump_device(hid);
    if (hid->quirks & HID_QUIRK_RESET_LEDS)
        usbhid_set_leds(hid);
    //检测是否匹配input设备
    if (!hidinput_connect(hid))
        hid->claimed |= HID_CLAIMED_INPUT;
    //检测是否匹配hiddev设备
    if (!hiddev_connect(hid))
        hid->claimed |= HID_CLAIMED_HIDDEV;
    //检测是否匹配hidraw设备
    if (!hidraw_connect(hid))
        hid->claimed |= HID_CLAIMED_HIDRAW;
    usb_set_intfdata(intf, hid);
    if (!hid->claimed)
    {
        printk ("HID device claimed by neither input, hiddev nor hidraw\n");
        hid_disconnect(intf);
        return -ENODEV;
    }
    if ((hid->claimed & HID_CLAIMED_INPUT))
        hid_ff_init(hid);
    //检测是否为PS3手柄,泪流满面
    if (hid->quirks & HID_QUIRK_SONY_PS3_CONTROLLER)
        hid_fixup_sony_ps3_controller(interface_to_usbdev(intf),
            intf->cur_altsetting->desc.bInterfaceNumber);
    //输出匹配信息
    printk(KERN_INFO);
    if (hid->claimed & HID_CLAIMED_INPUT)
        printk("input");
    if ((hid->claimed & HID_CLAIMED_INPUT) && ((hid->claimed & HID_CLAIMED_HIDDEV) ||
                hid->claimed & HID_CLAIMED_HIDRAW))
        printk(",");
    if (hid->claimed & HID_CLAIMED_HIDDEV)
        printk("hiddev%d", hid->minor);
    if ((hid->claimed & HID_CLAIMED_INPUT) && (hid->claimed & HID_CLAIMED_HIDDEV) &&
            (hid->claimed & HID_CLAIMED_HIDRAW))
        printk(",");
    if (hid->claimed & HID_CLAIMED_HIDRAW)
        printk("hidraw%d", ((struct hidraw*)hid->hidraw)->minor);
    c = "Device";
    for (i = 0; i < hid->maxcollection; i++)
    {
        if (hid->collection[i].type == HID_COLLECTION_APPLICATION &&
         (hid->collection[i].usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&
         (hid->collection[i].usage & 0xffff) < ARRAY_SIZE(hid_types))
        {
            c = hid_types[hid->collection[i].usage & 0xffff];
            break;
        }
    }
    usb_make_path(interface_to_usbdev(intf), path, 63);
    printk(": USB HID v%x.%02x %s [%s] on %s\n",
        hid->version >> 8, hid->version & 0xff, c, hid->name, path);
    return 0;
}

static struct hid_device *usb_hid_configure(struct usb_interface *intf)
{
    //获得usb设备的接口结构
    struct usb_host_interface *interface = intf->cur_altsetting;
    //获得usb设备
    struct usb_device *dev = interface_to_usbdev (intf);
    struct hid_descriptor *hdesc;
    struct hid_device *hid;
    u32 quirks = 0;
    unsigned int insize = 0, rsize = 0;
    char *rdesc;
    int n, len;
    struct usbhid_device *usbhid;
    //根据厂商和产品id检测怪癖
    quirks = usbhid_lookup_quirk(le16_to_cpu(dev->descriptor.idVendor),
            le16_to_cpu(dev->descriptor.idProduct));
    /* Many keyboards and mice don't like to be polled for reports,
     * so we will always set the HID_QUIRK_NOGET flag for them. */
     //检测接口描述符中的子类别是否为引导启动设备
    if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT)
    {
        //检测是否为鼠标或者键盘
        if (interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_KEYBOARD ||
            interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE)
                quirks |= HID_QUIRK_NOGET;
    }
    //检测该设备的怪癖是否需要忽略
    if (quirks & HID_QUIRK_IGNORE)
        return NULL;
    if ((quirks & HID_QUIRK_IGNORE_MOUSE) &&
        (interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE))
            return NULL;
    //检测接口描述符的下一个描述符是否为HID
    //接口描述符中的端点数是否不为1
    //0号端点描述符的下一个描述符是否为HID
    if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) &&
     (!interface->desc.bNumEndpoints ||
     usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc)))
    {
        dbg_hid("class descriptor not present\n");
        return NULL;
    }
    //历遍HID描述符的下级描述符
    for (n = 0; n < hdesc->bNumDescriptors; n++)
        //检测下级描述符的种类是否为报告描述符
        if (hdesc->desc[n].bDescriptorType == HID_DT_REPORT)
            //取得下级描述符的长度
            rsize = le16_to_cpu(hdesc->desc[n].wDescriptorLength);
    //检测报告描述符长度是否为0
    //检测报告描述符的长度是否超长
    if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE)
    {
        dbg_hid("weird size of report descriptor (%u)\n", rsize);
        return NULL;
    }
    //为报告描述符指针分配空间
    if (!(rdesc = kmalloc(rsize, GFP_KERNEL)))
    {
        dbg_hid("couldn't allocate rdesc memory\n");
        return NULL;
    }
    //设置设备为空闲状态
    hid_set_idle(dev, interface->desc.bInterfaceNumber, 0, 0);
    //取得报告描述符
    if ((n = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber, HID_DT_REPORT, rdesc, rsize)) < 0)
    {
        dbg_hid("reading report descriptor failed\n");
        kfree(rdesc);
        return NULL;
    }
    //检测报告描述符是否需要修复
    usbhid_fixup_report_descriptor(le16_to_cpu(dev->descriptor.idVendor),
                                le16_to_cpu(dev->descriptor.idProduct), rdesc,
                                rsize, rdesc_quirks_param);
    dbg_hid("report descriptor (size %u, read %d) = ", rsize, n);
    //打印报告描述符中所有的字节
    for (n = 0; n < rsize; n++)
        dbg_hid_line(" %02x", (unsigned char) rdesc[n]);
    dbg_hid_line("\n");
    //分析报告描述符
    if (!(hid = hid_parse_report(rdesc, n)))
    {
        dbg_hid("parsing report descriptor failed\n");
        kfree(rdesc);
        return NULL;
    }
    kfree(rdesc);
    hid->quirks = quirks;
    //分配一个usbhid_device结构
    if (!(usbhid = kzalloc(sizeof(struct usbhid_device), GFP_KERNEL)))
        goto fail_no_usbhid;
    //连接usbhid_device到hid_device
    hid->driver_data = usbhid;
    //连接hid_device到usbhid_device
    usbhid->hid = hid;
    //设置所使用的urb缓冲的大小
    usbhid->bufsize = HID_MIN_BUFFER_SIZE;
    hid_find_max_report(hid, HID_INPUT_REPORT, &usbhid->bufsize);
    hid_find_max_report(hid, HID_OUTPUT_REPORT, &usbhid->bufsize);
    hid_find_max_report(hid, HID_FEATURE_REPORT, &usbhid->bufsize);
    if (usbhid->bufsize > HID_MAX_BUFFER_SIZE)
        usbhid->bufsize = HID_MAX_BUFFER_SIZE;
    hid_find_max_report(hid, HID_INPUT_REPORT, &insize);
    if (insize > HID_MAX_BUFFER_SIZE)
        insize = HID_MAX_BUFFER_SIZE;
    //分配缓冲
    if (hid_alloc_buffers(dev, hid))
    {
        hid_free_buffers(dev, hid);
        goto fail;
    }
    hid->name[0] = 0;
    //有厂商信息则拷贝
    if (dev->manufacturer)
        strlcpy(hid->name, dev->manufacturer, sizeof(hid->name));
    //有产品信息则拷贝
    if (dev->product)
    {
        if (dev->manufacturer)
            strlcat(hid->name, " ", sizeof(hid->name));
        strlcat(hid->name, dev->product, sizeof(hid->name));
    }
    //检测设备的名字是否存在
    if (!strlen(hid->name))
        //不存在则以"HID厂商:产品"来命名
        snprintf(hid->name, sizeof(hid->name), "HID %04x:%04x",
             le16_to_cpu(dev->descriptor.idVendor),
             le16_to_cpu(dev->descriptor.idProduct));
    //历遍端点
    for (n = 0; n < interface->desc.bNumEndpoints; n++)
    {
        struct usb_endpoint_descriptor *endpoint;
        int pipe;
        int interval;
        //获得端点描述符
        endpoint = &interface->endpoint[n].desc;
        //检测端点类型是都为中断传输
        if ((endpoint->bmAttributes & 3) != 3)        /* Not an interrupt endpoint */
            continue;
        //获得中断间隔查询时间
        interval = endpoint->bInterval;
        /* Some vendors give fullspeed interval on highspeed devides */
        if (quirks & HID_QUIRK_FULLSPEED_INTERVAL &&
         dev->speed == USB_SPEED_HIGH)
        {
            interval = fls(endpoint->bInterval*8);
            printk(KERN_INFO "%s: Fixing fullspeed to highspeed interval: %d -> %d\n",
             hid->name, endpoint->bInterval, interval);
        }
        /* Change the polling interval of mice. */
        if (hid->collection->usage == HID_GD_MOUSE && hid_mousepoll_interval > 0)
            interval = hid_mousepoll_interval;
        //检测端点是否为传入类型
        if (usb_endpoint_dir_in(endpoint))
        {
            if (usbhid->urbin)
                continue;
            //分配一个urb给in传输
            if (!(usbhid->urbin = usb_alloc_urb(0, GFP_KERNEL)))
                goto fail;
            //创建一个中断传输的管道
            pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
            usb_fill_int_urb(usbhid->urbin, dev, pipe, usbhid->inbuf, insize,hid_irq_in, hid, interval);
            usbhid->urbin->transfer_dma = usbhid->inbuf_dma;
            usbhid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
        }
        else
        {
            if (usbhid->urbout)
                continue;
            //分配一个urb给out传输
            if (!(usbhid->urbout = usb_alloc_urb(0, GFP_KERNEL)))
                goto fail;
            //创建一个中断传输的管道
            pipe = usb_sndintpipe(dev, endpoint->bEndpointAddress);
            usb_fill_int_urb(usbhid->urbout, dev, pipe, usbhid->outbuf, 0,hid_irq_out, hid, interval);
            
            usbhid->urbout->transfer_dma = usbhid->outbuf_dma;
            usbhid->urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
        }
    }
    if (!usbhid->urbin)
    {
        err_hid("couldn't find an input interrupt endpoint");
        goto fail;
    }
    init_waitqueue_head(&usbhid->wait);
    INIT_WORK(&usbhid->reset_work, hid_reset);
    setup_timer(&usbhid->io_retry, hid_retry_timeout, (unsigned long) hid);
    spin_lock_init(&usbhid->inlock);
    spin_lock_init(&usbhid->outlock);
    spin_lock_init(&usbhid->ctrllock);
    hid->version = le16_to_cpu(hdesc->bcdHID);
    hid->country = hdesc->bCountryCode;
    hid->dev = &intf->dev;
    usbhid->intf = intf;
    usbhid->ifnum = interface->desc.bInterfaceNumber;
    hid->bus = BUS_USB;
    hid->vendor = le16_to_cpu(dev->descriptor.idVendor);
    hid->product = le16_to_cpu(dev->descriptor.idProduct);
    usb_make_path(dev, hid->phys, sizeof(hid->phys));
    strlcat(hid->phys, "/input", sizeof(hid->phys));
    len = strlen(hid->phys);
    if (len < sizeof(hid->phys) - 1)
        snprintf(hid->phys + len, sizeof(hid->phys) - len,
             "%d", intf->altsetting[0].desc.bInterfaceNumber);
    if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)
        hid->uniq[0] = 0;
    //分配一个urb给控制传输
    usbhid->urbctrl = usb_alloc_urb(0, GFP_KERNEL);
    if (!usbhid->urbctrl)
        goto fail;
    //填充该urb
    usb_fill_control_urb(usbhid->urbctrl, dev, 0, (void *) usbhid->cr,
             usbhid->ctrlbuf, 1, hid_ctrl, hid);
    usbhid->urbctrl->setup_dma = usbhid->cr_dma;
    usbhid->urbctrl->transfer_dma = usbhid->ctrlbuf_dma;
    usbhid->urbctrl->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP);
    hid->hidinput_input_event = usb_hidinput_input_event;
    hid->hid_open = usbhid_open;
    hid->hid_close = usbhid_close;
#ifdef CONFIG_USB_HIDDEV
    hid->hiddev_hid_event = hiddev_hid_event;
    hid->hiddev_report_event = hiddev_report_event;
#endif
    hid->hid_output_raw_report = usbhid_output_raw_report;
    return hid;
fail:
    usb_free_urb(usbhid->urbin);
    usb_free_urb(usbhid->urbout);
    usb_free_urb(usbhid->urbctrl);
    hid_free_buffers(dev, hid);
    kfree(usbhid);
fail_no_usbhid:
    hid_free_device(hid);
    return NULL;
}

struct hid_device *hid_parse_report(__u8 *start, unsigned size)
{
    struct hid_device *device;
    struct hid_parser *parser;
    struct hid_item item;
    __u8 *end;
    unsigned i;
    //用于分析主区域,全局区域和局部区域的函数组
    static int (*dispatch_type[])(struct hid_parser *parser,
                 struct hid_item *item) = {
        hid_parser_main,
        hid_parser_global,
        hid_parser_local,
        hid_parser_reserved
    };
    //分配一个hid_device结构
    if (!(device = kzalloc(sizeof(struct hid_device), GFP_KERNEL)))
        return NULL;
    //分配一个hid_collection结构
    if (!(device->collection = kzalloc(sizeof(struct hid_collection) *
                 HID_DEFAULT_NUM_COLLECTIONS, GFP_KERNEL)))
    {
        kfree(device);
        return NULL;
    }
    //设置收集最大数为16
    device->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
    for (i = 0; i < HID_REPORT_TYPES; i++)
        INIT_LIST_HEAD(&device->report_enum[i].report_list);
    //分配报告描述符所需要的空间,并让rdesc指向他
    if (!(device->rdesc = kmalloc(size, GFP_KERNEL)))
    {
        kfree(device->collection);
        kfree(device);
        return NULL;
    }
    //将报告描述符拷贝进刚分配的空间里
    memcpy(device->rdesc, start, size);
    //设置报告描述符的大小
    device->rsize = size;
    //分配一个hid_parser结构
    if (!(parser = vmalloc(sizeof(struct hid_parser))))
    {
        kfree(device->rdesc);
        kfree(device->collection);
        kfree(device);
        return NULL;
    }
    //用0初始化hid_parser结构
    memset(parser, 0, sizeof(struct hid_parser));
    //连接hid_device
    parser->device = device;
    //取得报告描述符的结束地址
    end = start + size;
    while ((start = fetch_item(start, end, &item)) != NULL)
    {
        //不支持长类型的描述格式
        if (item.format != HID_ITEM_FORMAT_SHORT)
        {
            dbg_hid("unexpected long global item\n");
            hid_free_device(device);
            vfree(parser);
            return NULL;
        }
        //使用相应的函数处理描述项
        if (dispatch_type[item.type](parser, &item))
        {
            dbg_hid("item %u %u %u %u parsing failed\n",
                item.format, (unsigned)item.size, (unsigned)item.type, (unsigned)item.tag);
            hid_free_device(device);
            vfree(parser);
            return NULL;
        }
        //判断是否分析完毕
        if (start == end)
        {
            if (parser->collection_stack_ptr)
            {
                dbg_hid("unbalanced collection at end of report description\n");
                hid_free_device(device);
                vfree(parser);
                return NULL;
            }
            if (parser->local.delimiter_depth)
            {
                dbg_hid("unbalanced delimiter at end of report description\n");
                hid_free_device(device);
                vfree(parser);
                return NULL;
            }
            vfree(parser);
            return device;
        }
    }
    dbg_hid("item fetching failed at offset %d\n", (int)(end - start));
    hid_free_device(device);
    vfree(parser);
    return NULL;
}

static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
{
    u8 b;
    //检测是否分析完所有的项目了
    if ((end - start) <= 0)
        return NULL;
    //取得start的字节后start自加
    b = *start++;
    //取得type字段
    item->type = (b >> 2) & 3;
    //取得tag字段
    item->tag = (b >> 4) & 15;
    //检测tag的类型是否为长类型
    if (item->tag == HID_ITEM_TAG_LONG)
    {
        //项的类型为长类型
        item->format = HID_ITEM_FORMAT_LONG;
        //检测剩余空间是否过短
        if ((end - start) < 2)
            return NULL;
        //取得长类型项的大小
        item->size = *start++;
        //取得长类型项的标签
        item->tag = *start++;
        //检测剩余大小是否满足长类型项的数据大小
        if ((end - start) < item->size)
            return NULL;
        //取得长类型项的数据起始地址
        item->data.longdata = start;
        //一个长类型项分析完成,start定位到下一个项的起始位置
        start += item->size;
        return start;
    }
    //项的类型为短类型
    item->format = HID_ITEM_FORMAT_SHORT;
    //取得短类型项的数据大小
    item->size = b & 3;
    //判断数据的大小
    switch (item->size)
    {
        //数据大小为0个字节
        case 0:
            return start;
        //数据大小为1个字节
        case 1:
            if ((end - start) < 1)
                return NULL;
            item->data.u8 = *start++;
            return start;
        //数据大小为2个字节
        case 2:
            if ((end - start) < 2)
                return NULL;
            item->data.u16 = get_unaligned_le16(start);
            start = (__u8 *)((__le16 *)start + 1);
            return start;
        //数据大小为4个字节
        case 3:
            item->size++;
            if ((end - start) < 4)
                return NULL;
            item->data.u32 = get_unaligned_le32(start);
            start = (__u8 *)((__le32 *)start + 1);
            return start;
    }
    return NULL;
}

static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
{
    switch (item->tag) {

        case HID_GLOBAL_ITEM_TAG_PUSH:

            if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
                dbg_hid("global enviroment stack overflow\n");
                return -1;
            }
            memcpy(parser->global_stack + parser->global_stack_ptr++,
                &parser->global, sizeof(struct hid_global));
            return 0;
        case HID_GLOBAL_ITEM_TAG_POP:

            if (!parser->global_stack_ptr) {
                dbg_hid("global enviroment stack underflow\n");
                return -1;
            }
            memcpy(&parser->global, parser->global_stack + --parser->global_stack_ptr,
                sizeof(struct hid_global));
            return 0;
        //为使用用途页
        case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
            parser->global.usage_page = item_udata(item);
            return 0;
        //设置逻辑最小值
        case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
            parser->global.logical_minimum = item_sdata(item);
            return 0;
        //设置逻辑最大值
        case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
            //检测是否需要符号来表示负数
            if (parser->global.logical_minimum < 0)
                parser->global.logical_maximum = item_sdata(item);
            else
                parser->global.logical_maximum = item_udata(item);
            return 0;
        //设置物理最小值
        case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
            parser->global.physical_minimum = item_sdata(item);
            return 0;
        //设置物理最大值
        case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
            //检测是否需要符号来表示负数
            if (parser->global.physical_minimum < 0)
                parser->global.physical_maximum = item_sdata(item);
            else
                parser->global.physical_maximum = item_udata(item);
            return 0;
        case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
            parser->global.unit_exponent = item_sdata(item);
            return 0;
        case HID_GLOBAL_ITEM_TAG_UNIT:
            parser->global.unit = item_udata(item);
            return 0;
        //设置需要的bit数目
        case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
            //检测是否超过32个bit,也就是4个字节
            if ((parser->global.report_size = item_udata(item)) > 32) {
                dbg_hid("invalid report_size %d\n", parser->global.report_size);
                return -1;
            }
            return 0;
        //设置个数
        case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
            //检测是否超越最大个数
            if ((parser->global.report_count = item_udata(item)) > HID_MAX_USAGES) {
                dbg_hid("invalid report_count %d\n", parser->global.report_count);
                return -1;
            }
            return 0;
        case HID_GLOBAL_ITEM_TAG_REPORT_ID:
            if ((parser->global.report_id = item_udata(item)) == 0) {
                dbg_hid("report_id 0 is invalid\n");
                return -1;
            }
            return 0;
        default:
            dbg_hid("unknown global tag 0x%x\n", item->tag);
            return -1;
    }
}

static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
{
    __u32 data;
    unsigned n;
    if (item->size == 0)
    {
        dbg_hid("item data expected for local item\n");
        return -1;
    }
    //取得数据
    data = item_udata(item);
    switch (item->tag) {
        case HID_LOCAL_ITEM_TAG_DELIMITER:
            if (data) {
                /*
                 * We treat items before the first delimiter
                 * as global to all usage sets (branch 0).
                 * In the moment we process only these global
                 * items and the first delimiter set.
                 */
                if (parser->local.delimiter_depth != 0) {
                    dbg_hid("nested delimiters\n");
                    return -1;
                }
                parser->local.delimiter_depth++;
                parser->local.delimiter_branch++;
            } else {
                if (parser->local.delimiter_depth < 1) {
                    dbg_hid("bogus close delimiter\n");
                    return -1;
                }
                parser->local.delimiter_depth--;
            }
            return 1;
        //为使用用途页
        case HID_LOCAL_ITEM_TAG_USAGE:
            if (parser->local.delimiter_branch > 1) {
                dbg_hid("alternative usage ignored\n");
                return 0;
            }
            //检测数据的大小是否小于或者等于2字节
            if (item->size <= 2)
                //加上作用标记
                data = (parser->global.usage_page << 16) + data;
            return hid_add_usage(parser, data);
        //设置开始设置的最小项
        case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:

            if (parser->local.delimiter_branch > 1) {
                dbg_hid("alternative usage ignored\n");
                return 0;
            }
            //检测数据的大小是否小于或者等于2字节
            if (item->size <= 2)
                //加上作用标记
                data = (parser->global.usage_page << 16) + data;

            parser->local.usage_minimum = data;
            return 0;
        //设置开始设置的最大项
        case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:

            if (parser->local.delimiter_branch > 1) {
                dbg_hid("alternative usage ignored\n");
                return 0;
            }
            //检测数据的大小是否小于或者等于2字节
            if (item->size <= 2)
                //加上作用标记
                data = (parser->global.usage_page << 16) + data;
            //添加要求的项
            for (n = parser->local.usage_minimum; n <= data; n++)
                if (hid_add_usage(parser, n)) {
                    dbg_hid("hid_add_usage failed\n");
                    return -1;
                }
            return 0;
        default:
            dbg_hid("unknown local item tag 0x%x\n", item->tag);
            return 0;
    }
    return 0;
}

static int hid_add_usage(struct hid_parser *parser, unsigned usage)
{
    if (parser->local.usage_index >= HID_MAX_USAGES)
    {
        dbg_hid("usage index exceeded\n");
        return -1;
    }
    parser->local.usage[parser->local.usage_index] = usage;
    parser->local.collection_index[parser->local.usage_index] =
        parser->collection_stack_ptr ?
        parser->collection_stack[parser->collection_stack_ptr - 1] : 0;
    parser->local.usage_index++;
    return 0;
}

static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
{
    __u32 data;
    int ret;
    //取得项的数据
    data = item_udata(item);
    //检测项的标签项
    switch (item->tag) {
        //开始主项目的收集
        case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
            ret = open_collection(parser, data & 0xff);
            break;
        //结束主项目的收集
        case HID_MAIN_ITEM_TAG_END_COLLECTION:
            ret = close_collection(parser);
            break;
        //为input项
        case HID_MAIN_ITEM_TAG_INPUT:
            ret = hid_add_field(parser, HID_INPUT_REPORT, data);
            break;
        //为output项
        case HID_MAIN_ITEM_TAG_OUTPUT:
            ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
            break;
        //为feature项
        case HID_MAIN_ITEM_TAG_FEATURE:
            ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
            break;
        default:
            dbg_hid("unknown main item tag 0x%x\n", item->tag);
            ret = 0;
    }
    //清空局域解析结构
    memset(&parser->local, 0, sizeof(parser->local));    /* Reset the local parser environment */
    return ret;
}

static int open_collection(struct hid_parser *parser, unsigned type)
{
    struct hid_collection *collection;
    unsigned usage;
    usage = parser->local.usage[0];
    //检测收集堆栈是否已经满了
    if (parser->collection_stack_ptr == HID_COLLECTION_STACK_SIZE)
    {
        dbg_hid("collection stack overflow\n");
        return -1;
    }
    //检测已分析收集数是否达到最大分配的数目
    if (parser->device->maxcollection == parser->device->collection_size)
    {
        collection = kmalloc(sizeof(struct hid_collection) *
                parser->device->collection_size * 2, GFP_KERNEL);
        if (collection == NULL)
        {
            dbg_hid("failed to reallocate collection array\n");
            return -1;
        }
        memcpy(collection, parser->device->collection,
            sizeof(struct hid_collection) *
            parser->device->collection_size);
        memset(collection + parser->device->collection_size, 0,
            sizeof(struct hid_collection) *
            parser->device->collection_size);
        kfree(parser->device->collection);
        parser->device->collection = collection;
        parser->device->collection_size *= 2;
    }
    parser->collection_stack[parser->collection_stack_ptr++] =
        parser->device->maxcollection;
    //指向相应的收集结构
    collection = parser->device->collection + parser->device->maxcollection++;
    //设置类型
    collection->type = type;
    //设置用途
    collection->usage = usage;
    //设置层次
    collection->level = parser->collection_stack_ptr - 1;
    //检测类型是否为应用
    if (type == HID_COLLECTION_APPLICATION)
        //增加应用计数器
        parser->device->maxapplication++;
    return 0;
}