Re: [4/13](resend)hidclass.sys: Add USB Descriptor parsing

[Andrew Eikum]

A couple small notes inline below.

On Wed, Sep 02, 2015 at 07:01:51AM -0500, Aric Stewart wrote:
> diff --git a/dlls/hidclass.sys/Makefile.in b/dlls/hidclass.sys/Makefile.in
> index 8ed51e6..6e79486 100644
> --- a/dlls/hidclass.sys/Makefile.in
> +++ b/dlls/hidclass.sys/Makefile.in
> @@ -5,6 +5,7 @@ DELAYIMPORTS = setupapi hid
>
> C_SRCS = \
>    buffer.c \
> - descriptor.c \
> device.c \
> main.c \
> pnp.c
>
> diff --git a/dlls/hidclass.sys/descriptor.c b/dlls/hidclass.sys/descriptor.c
> new file mode 100644
> index 0000000..c277dec
> --- /dev/null
> +++ b/dlls/hidclass.sys/descriptor.c
> @@ -0,0 +1,1106 @@
> +/*
> -
> - HID descriptor parsing
> -
> -
> -
> - Copyright (C) 2015 Aric Stewart
> -
> -
> -
> - This library is free software; you can redistribute it and/or
> -
> - modify it under the terms of the GNU Lesser General Public
> -
> - License as published by the Free Software Foundation; either
> -
> - version 2.1 of the License, or (at your option) any later version.
> -
> -
> -
> - This library is distributed in the hope that it will be useful,
> -
> - but WITHOUT ANY WARRANTY; without even the implied warranty of
> -
> - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> -
> - Lesser General Public License for more details.
> -
> -
> -
> - You should have received a copy of the GNU Lesser General Public
> -
> - License along with this library; if not, write to the Free Software
> -
> - Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
> - */
> -
>
> +#include "config.h"
> -
>
> +#include <stdarg.h>
> +#include <stdlib.h>
> +#define NONAMELESSUNION
> +#include "hid.h"
> -
>
> +#include "wine/debug.h"
> +#include "wine/list.h"
> -
>
> +WINE_DEFAULT_DEBUG_CHANNEL(hid);
> -
>
> +#define USAGE_MAX 10
> -
>
> +static const char* feature_string[] =
> - { "Input", "Output", "Feature" };
> -
>
> +struct caps {
> - USAGE UsagePage;
> - LONG LogicalMin;
> - LONG LogicalMax;
> - LONG PhysicalMin;
> - LONG PhysicalMax;
> - ULONG UnitsExp;
> - ULONG Units;
> - USHORT BitSize;
> - UCHAR ReportID;
> - USHORT ReportCount;
> -
> - BOOLEAN  IsRange;
> - BOOLEAN  IsStringRange;
> - BOOLEAN  IsDesignatorRange;
> - int usage_count;
> - union {
> -
>    struct {
> -
>        USAGE UsageMin;
> -
>        USAGE UsageMax;
> -
>        USHORT StringMin;
> -
>        USHORT StringMax;
> -
>        USHORT DesignatorMin;
> -
>        USHORT DesignatorMax;
> -
>    } Range;
> -
>    struct  {
> -
>        USAGE Usage[USAGE_MAX];
> -
>        USAGE Reserved1;
> -
>        USHORT StringIndex;
> -
>        USHORT Reserved2;
> -
>        USHORT DesignatorIndex;
> -
>        USHORT Reserved3;
> -
>    } NotRange;
> - } DUMMYUNIONNAME;
> -
> - int Delim;
>
> +};
> -
>
> +struct feature {
> - struct list entry;
> - struct list col_entry;
> - struct caps caps;
> -
> - HIDP_REPORT_TYPE type;
> - BOOLEAN isData;
> - BOOLEAN isArray;
> - BOOLEAN IsAbsolute;
> - BOOLEAN Wrap;
> - BOOLEAN Linear;
> - BOOLEAN prefState;
> - BOOLEAN HasNull;
> - BOOLEAN Volatile;
> - BOOLEAN BitField;
> -
> - int index;
> - struct collection *collection;
>
> +};
> -
>
> +static const char* collection_string[] = {
> - "Physical",
> - "Application",
> - "Logical",
> - "Report",
> - "Named Array",
> - "Usage Switch",
> - "Usage Modifier",
>
> +};
> -
>
> +struct collection {
> - struct list entry;
> - struct caps caps;
> - int index;
> - int type;
> - struct collection *parent;
> - struct list features;
> - struct list collections;
>
> +};
> -
>
> +static const char* debugstr_usages(struct caps *caps)
> +{
> - if (!caps->IsRange)
> - {
> -
>    static char out[30];
> -
>    int i;
> -
>    strcpy(out, "[ ");
> -
>    for (i = 0; i < caps->usage_count; i++)
> -
>        strcat(out, wine_dbg_sprintf("%x ", caps->u.NotRange.Usage[i]));
> -
>    strcat(out,"]");
> -
>    return out;
> - }
> - else
> -
>    return wine_dbg_sprintf("[%x - %x]", caps->u.Range.UsageMin, caps->u.Range.UsageMax);
>
> +}
> -
>
> +static const char* debugstr_stringindex(struct caps *caps)
> +{
> - if (!caps->IsStringRange)
> -
>    return wine_dbg_sprintf("%i", caps->u.NotRange.StringIndex);
> - else
> -
>    return wine_dbg_sprintf("[%i - %i]", caps->u.Range.StringMin, caps->u.Range.StringMax);
>
> +}
> -
>
> +static const char* debugstr_designatorindex(struct caps *caps)
> +{
> - if (!caps->IsDesignatorRange)
> -
>    return wine_dbg_sprintf("%i", caps->u.NotRange.DesignatorIndex);
> - else
> -
>    return wine_dbg_sprintf("[%i - %i]", caps->u.Range.DesignatorMin, caps->u.Range.DesignatorMax);
>
> +}
> -
>
> +static const char* debugstr_caps(struct caps *caps)
> +{
> - if (!caps)
> -
>    return "";
> - return wine_dbg_sprintf("(UsagePage %x; LogicalMin %i; LogicalMax %i; PhysicalMin %i; PhysicalMax %i; UnitsExp %i; Units %i; BitSize %i; ReportID %i; ReportCount %i; Usage %s; StringIndex %s; DesignatorIndex %s; Delim %i;)",
> - caps->UsagePage,
> - caps->LogicalMin,
> - caps->LogicalMax,
> - caps->PhysicalMin,
> - caps->PhysicalMax,
> - caps->UnitsExp,
> - caps->Units,
> - caps->BitSize,
> - caps->ReportID,
> - caps->ReportCount,
> - debugstr_usages(caps),
> - debugstr_stringindex(caps),
> - debugstr_designatorindex(caps),
> - caps->Delim);
>
> +}
> -
>
> +static void debug_feature(struct feature *feature)
> +{
> - if (!feature)
> -
>    return;
> - TRACE("[\n\t type %s [%i]; %s; %s; %s; %s; %s; %s; %s; %s; %s\n\t %s\n]\n",
> - feature_string[feature->type],
> - feature->index,
> - (feature->isData)?"Data":"Const",
> - (feature->isArray)?"Array":"Var",
> - (feature->IsAbsolute)?"Abs":"Rel",
> - (feature->Wrap)?"Wrap":"NoWrap",
> - (feature->Linear)?"Linear":"NonLinear",
> - (feature->prefState)?"PrefStat":"NoPrefState",
> - (feature->HasNull)?"HasNull":"NoNull",
> - (feature->Volatile)?"Volatile":"NonVolatile",
> - (feature->BitField)?"BitField":"Buffered",
> - debugstr_caps(&feature->caps));
>
> +}
> -
>
> +static void debug_collection(struct collection *collection)
> +{
> - struct feature *fentry;
> - struct collection *centry;
> - if (TRACE_ON(hid))
> - {
> -
>    TRACE("{ %s[%i], %p, %i features, %i collections\n\t %s\n", collection_string[collection->type], collection->index, collection->parent, list_count(&collection->features), list_count(&collection->collections), debugstr_caps(&collection->caps));
> -
>    LIST_FOR_EACH_ENTRY(fentry, &collection->features, struct feature, col_entry)
> -
>        debug_feature(fentry);
> -
>    LIST_FOR_EACH_ENTRY(centry, &collection->collections, struct collection, entry)
> -
>        debug_collection(centry);
> -
>    TRACE("}\n");
> - }
>
> +}
> -
>
> +static void debug_print_button_cap(const CHAR * type, WINE_HID_ELEMENT *wine_element)
> +{
> - if (!wine_element->caps.button.IsRange)
> -
>    TRACE("%s Button: %x/%04x: ReportId %i, startBit %i/1\n" , type,
> -
>        wine_element->caps.button.UsagePage,
> -
>        wine_element->caps.button.u.NotRange.Usage,
> -
>        wine_element->caps.value.ReportID,
> -
>        wine_element->valueStartBit);
> - else
> -
>    TRACE("%s Button: %x/[%04x-%04x]: ReportId %i, startBit %i/%i\n" ,type,
> -
>           wine_element->caps.button.UsagePage,
> -
>           wine_element->caps.button.u.Range.UsageMin,
> -
>           wine_element->caps.button.u.Range.UsageMax,
> -
>           wine_element->caps.value.ReportID,
> -
>           wine_element->valueStartBit,
> -
>           wine_element->bitCount);
>
> +}
> -
>
> +static void debug_print_value_cap(const CHAR * type, WINE_HID_ELEMENT *wine_element)
> +{
> - TRACE("%s Value: %x/%x: ReportId %i, IsAbsolute %i, HasNull %i, "
> -
>      "Bit Size %i, ReportCount %i, UnitsExp %i, Units %i, "
> -
>      "LogicalMin %i, Logical Max %i, PhysicalMin %i, "
> -
>      "PhysicalMax %i -- StartBit %i/%i\n", type,
> -
>        wine_element->caps.value.UsagePage,
> -
>        wine_element->caps.value.u.NotRange.Usage,
> -
>        wine_element->caps.value.ReportID,
> -
>        wine_element->caps.value.IsAbsolute,
> -
>        wine_element->caps.value.HasNull,
> -
>        wine_element->caps.value.BitSize,
> -
>        wine_element->caps.value.ReportCount,
> -
>        wine_element->caps.value.UnitsExp,
> -
>        wine_element->caps.value.Units,
> -
>        wine_element->caps.value.LogicalMin,
> -
>        wine_element->caps.value.LogicalMax,
> -
>        wine_element->caps.value.PhysicalMin,
> -
>        wine_element->caps.value.PhysicalMax,
> -
>        wine_element->valueStartBit,
> -
>        wine_element->bitCount);
>
> +}
> -
>
> +static void debug_print_element(const CHAR* type, WINE_HID_ELEMENT *wine_element)
> +{
> - if (wine_element->ElementType == ButtonElement)
> -
>    debug_print_button_cap(type, wine_element);
> - else if (wine_element->ElementType == ValueElement)
> -
>    debug_print_value_cap(type, wine_element);
> - else
> -
>    TRACE("%s: UNKNOWN\n", type);
>
> +}
> -
>
> +static void debug_print_report(const char* type, WINE_HID_REPORT *report)
> +{
> - int i;
> - TRACE("%s REPORT:\n"
> -
>    "\tReportID: %i\n"
> -
>    "\tdwSize: %i\n"
> -
>    "\telementCount: %i\n",
> -
>    type,
> -
>    report->reportID,
> -
>    report->dwSize,
> -
>    report->elementCount);
> - for (i = 0; i < report->elementCount; i++)
> -
>    debug_print_element(type, &report->Elements[i]);
>
> +}
> -
>
> +static void debug_print_preparsed(WINE_HIDP_PREPARSED_DATA *data)
> +{
> - int i;
> - WINE_HID_REPORT *r;
> - if (TRACE_ON(hid))
> - {
> -
>    TRACE("PREPARSED Data:\n"
> -
>         "\tdwSize: %i\n"
> -
>         "\tCaps:\n"
> -
>         "\t\tUsage: %i\n"
> -
>         "\t\tUsagePage: %i\n"
> -
>         "\t\tInputReportByteLength: %i\n"
> -
>         "\t\tOutputReportByteLength: %i\n"
> -
>         "\t\tFeatureReportByteLength: %i\n"
> -
>         "\t\tNumberLinkCollectionNodes: %i\n"
> -
>         "\t\tNumberInputButtonCaps: %i\n"
> -
>         "\t\tNumberInputValueCaps: %i\n"
> -
>         "\t\tNumberInputDataIndices: %i\n"
> -
>         "\t\tNumberOutputButtonCaps: %i\n"
> -
>         "\t\tNumberOutputValueCaps: %i\n"
> -
>         "\t\tNumberOutputDataIndices: %i\n"
> -
>         "\t\tNumberFeatureButtonCaps: %i\n"
> -
>         "\t\tNumberFeatureValueCaps: %i\n"
> -
>         "\t\tNumberFeatureDataIndices: %i\n"
> -
>         "\tdwInputReportCount: %i\n"
> -
>         "\tdwOutputReportCount: %i\n"
> -
>         "\tdwFeatureReportCount: %i\n"
> -
>         "\tdwOutputReportOffset: %i\n"
> -
>         "\tdwFeatureReportOffset: %i\n",
> -
>    data->dwSize,
> -
>    data->caps.Usage,
> -
>    data->caps.UsagePage,
> -
>    data->caps.InputReportByteLength,
> -
>    data->caps.OutputReportByteLength,
> -
>    data->caps.FeatureReportByteLength,
> -
>    data->caps.NumberLinkCollectionNodes,
> -
>    data->caps.NumberInputButtonCaps,
> -
>    data->caps.NumberInputValueCaps,
> -
>    data->caps.NumberInputDataIndices,
> -
>    data->caps.NumberOutputButtonCaps,
> -
>    data->caps.NumberOutputValueCaps,
> -
>    data->caps.NumberOutputDataIndices,
> -
>    data->caps.NumberFeatureButtonCaps,
> -
>    data->caps.NumberFeatureValueCaps,
> -
>    data->caps.NumberFeatureDataIndices,
> -
>    data->dwInputReportCount,
> -
>    data->dwOutputReportCount,
> -
>    data->dwFeatureReportCount,
> -
>    data->dwOutputReportOffset,
> -
>    data->dwFeatureReportOffset);
> -
> -
>    r = HID_INPUT_REPORTS(data);
> -
>    for (i = 0; i < data->dwInputReportCount; i++)
> -
>    {
> -
>        debug_print_report("INPUT", r);
> -
>        r = HID_NEXT_REPORT(data, r);
> -
>    }
> -
>    r = HID_OUTPUT_REPORTS(data);
> -
>    for (i = 0; i < data->dwOutputReportCount; i++)
> -
>    {
> -
>        debug_print_report("OUTPUT", r);
> -
>        r = HID_NEXT_REPORT(data, r);
> -
>    }
> -
>    r = HID_FEATURE_REPORTS(data);
> -
>    for (i = 0; i < data->dwFeatureReportCount; i++)
> -
>    {
> -
>        debug_print_report("FEATURE", r);
> -
>        r = HID_NEXT_REPORT(data, r);
> -
>    }
> - }
>
> +}
> -
>
> +static int getValue(int bsize, int source)
> +{
> - int mask = 0xff;
> - int negative = 0x80;
> - int outofrange = 0x100;
> - int value;
> - int i;
> -
> - if (bsize == 4)
> -
>    return source;
> -
> - for (i = 1; i < bsize; i++)
> - {
> -
>    mask = (mask<<8) + 0xff;
> -
>    negative = (negative<<8);
> -
>    outofrange = (outofrange<<8);
> - }
> - value = (source&mask);
> - if (value&negative)
> -
>    value = -1 * (outofrange - value);
> - return value;
>
> +}
> -
>
> +void parse_io_feature(int bSize, int itemVal, int bTag, int *feature_index, struct feature *feature)
> +{
> - if (bSize <= 0)
> - {
> -
>    return;
> - }
> - else
> - {
> -
>    if ((itemVal & 0x01) == 0)
> -
>        feature->isData = TRUE;
> -
>    else
> -
>        feature->isData = FALSE; //Const
> -
>    if ((itemVal & 0x02) == 0)
> -
>        feature->isArray= TRUE;
> -
>    else
> -
>        feature->isArray= TRUE; //Var
> -
>    if ((itemVal & 0x04) == 0)
> -
>        feature->IsAbsolute = TRUE;
> -
>    else
> -
>        feature->IsAbsolute = FALSE; //Rel
> -
>    if ((itemVal & 0x08) == 0)
> -
>        feature->Wrap = FALSE;
> -
>    else
> -
>        feature->Wrap = TRUE;
> -
>    if ((itemVal & 0x10) == 0)
> -
>        feature->Linear = TRUE;
> -
>    else
> -
>        feature->Linear = FALSE;
> -
>    if ((itemVal & 0x20) == 0)
> -
>        feature->prefState = TRUE;
> -
>    else
> -
>        feature->prefState = FALSE;
> -
>    if ((itemVal & 0x40) == 0)
> -
>        feature->HasNull = FALSE;
> -
>    else
> -
>        feature->HasNull = TRUE;
> -
> -
>    if (bTag != 0x08)
> -
>    {
> -
>        if ((itemVal & 0x80) == 0)
> -
>            feature->Volatile = FALSE;
> -
>        else
> -
>            feature->Volatile = TRUE;
> -
>    }
> -
>    if (bSize > 1)
> -
>    {
> -
>        if ((itemVal & 0x100) == 0)
> -
>            feature->BitField = TRUE;
> -
>        else
> -
>            feature->BitField = FALSE; //Buffered Bytes
> -
>    }
> -
>    feature->index = *feature_index;
> -
>    *feature_index = *feature_index + 1;
> - }
>
> +}
> -
>
> +void parse_collection(int bSize, int itemVal, struct collection *collection)
> +{
> - if (bSize <= 0)
> -
>    return;
> - else
> -
> {
> -
>    collection->type = itemVal;
> -
> -
>    if (itemVal >= 0x07 && itemVal <= 0x7F) {
> -
>        ERR(" (Reserved %x )\n", itemVal);
> -
>    }
> -
>    else if (itemVal >= 0x80 && itemVal <= 0xFF) {
> -
>        ERR(" (Vendor Defined %x )\n", itemVal);
> -
>    }
> - }
>
> +}
> -
>
> +static void new_caps(struct caps *caps)
> +{
> - caps->IsRange = 0;
> - caps->IsStringRange = 0;
> - caps->IsDesignatorRange = 0;
> - caps->usage_count = 0;
>
> +}
> -
>
> +int parse_descriptor(BYTE *descriptor, INT index, INT length, INT *feature_index, INT *collection_index, struct collection *collection, struct caps *caps, struct list *features)
> +{
> - int i;
> - for (i = index; i < length;)
> - {
> -
>    BYTE b0 = descriptor[i++];
> -
>    int bSize = b0 & 0x03;
> -
>    int bType = (b0 >> 2) & 0x03;
> -
>    int bTag = (b0 >> 4) & 0x0F;
> -
> -
>    bSize = (bSize == 3) ? 4 : bSize;
> -
>    if (bType == 0x03 && bTag == 0x0F && bSize == 2 && i + 2 < length)
> -
>    {
> -
>        /* Long data items: Should be unused */
> -
>        ERR("Long Data Item, should be unused\n");

This confused me. Is this a malformed report from the HID or something
Wine doesn't yet support?
> -
>    }
> -
>    else
> -
>    {
> -
>        int bSizeActual = 0;
> -
>        int itemVal = 0;
> -
>        int j;
> -
> -
>        for (j = 0; j < bSize; j++)
> -
>        {
> -
>            if (i + j < length)
> -
>            {
> -
>                itemVal += descriptor[i + j] << (8 * j);
> -
>                bSizeActual++;
> -
>            }
> -
>        }
> -
>        TRACE(" %x[%i], type %i , tag %i, size %i, val %i\n",b0,i-1,bType, bTag, bSize, itemVal );
> -
> -
>        if (bType == 0x00)
> -
>        {
> -
>            struct feature *feature;
> -
>            switch(bTag)
> -
>            {
> -
>                case 0x08:

Here and elsewhere, there's a lot of magic numbers. Do these have
names in the standard? Could you make up names for them? TAG_INPUT or
something. Or is it more useful to have the raw numbers?
> -
>                    feature = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*feature));
> -
>                    list_add_tail(&collection->features, &feature->col_entry);
> -
>                    list_add_tail(features, &feature->entry);
> -
>                    feature->type = HidP_Input;
> -
>                    parse_io_feature(bSize, itemVal, bTag, feature_index, feature);
> -
>                    feature->caps = *caps;
> -
>                    feature->collection = collection;
> -
>                    new_caps(caps);
> -
>                    break;
> -
>                case 0x09:
> -
>                    feature = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*feature));
> -
>                    list_add_tail(&collection->features, &feature->col_entry);
> -
>                    list_add_tail(features, &feature->entry);
> -
>                    feature->type = HidP_Output;
> -
>                    parse_io_feature(bSize, itemVal, bTag, feature_index, feature);
> -
>                    feature->caps = *caps;
> -
>                    feature->collection = collection;
> -
>                    new_caps(caps);
> -
>                    break;
> -
>                case 0x0B:
> -
>                    feature = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*feature));
> -
>                    list_add_tail(&collection->features, &feature->col_entry);
> -
>                    list_add_tail(features, &feature->entry);
> -
>                    feature->type = HidP_Feature;
> -
>                    parse_io_feature(bSize, itemVal, bTag, feature_index, feature);
> -
>                    feature->caps = *caps;
> -
>                    feature->collection = collection;
> -
>                    new_caps(caps);
> -
>                    break;
> -
>                case 0x0A:

Here, the cases are in a different order. That wouldn't matter with
symbols, but it struck me with the raw numbers.
> -
>                {
> -
>                    struct collection *subcollection = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct collection));
> -
>                    list_add_tail(&collection->collections, &subcollection->entry);
> -
>                    subcollection->parent = collection;
> -
>                    /* Only set our collection once...
> -
>                       We do not properly handle composite devices yet. */
> -
>                    if (*collection_index == 0)
> -
>                        collection->caps = *caps;
> -
>                    subcollection->caps = *caps;
> -
>                    subcollection->index = *collection_index;
> -
>                    *collection_index = *collection_index + 1;
> -
>                    list_init(&subcollection->features);
> -
>                    list_init(&subcollection->collections);
> -
>                    new_caps(caps);
> -
> -
>                    parse_collection(bSize, itemVal, subcollection);
> -
> -
>                    i = parse_descriptor(descriptor, i+1, length, feature_index, collection_index, subcollection, caps, features);
> -
>                    continue;
> -
>                }
> -
>                case 0x0C:
> -
>                    return i;
> -
>                default:
> -
>                    ERR("Unknown Tag\n");

Would it be useful to print the tag value here?
> -
>            }
> -
>        }
> -
>        else if (bType == 0x01)
> -
>        {
> -
>            switch(bTag)
> -
>            {
> -
>                case 0x00:
> -
>                    caps->UsagePage = getValue(bSize, itemVal);
> -
>                    break;
> -
>                case 0x01:
> -
>                    caps->LogicalMin = getValue(bSize, itemVal);
> -
>                    break;
> -
>                case 0x02:
> -
>                    caps->LogicalMax = getValue(bSize, itemVal);
> -
>                    break;
> -
>                case 0x03:
> -
>                    caps->PhysicalMin = getValue(bSize, itemVal);
> -
>                    break;
> -
>                case 0x04:
> -
>                    caps->PhysicalMax = getValue(bSize, itemVal);
> -
>                    break;
> -
>                case 0x05:
> -
>                    caps->UnitsExp = getValue(bSize, itemVal);
> -
>                    break;
> -
>                case 0x06:
> -
>                    caps->Units = getValue(bSize, itemVal);
> -
>                    break;
> -
>                case 0x07:
> -
>                    caps->BitSize = getValue(bSize, itemVal);
> -
>                    break;
> -
>                case 0x08:
> -
>                    caps->ReportID = getValue(bSize, itemVal);
> -
>                    break;
> -
>                case 0x09:
> -
>                    caps->ReportCount = getValue(bSize, itemVal);
> -
>                    break;
> -
>                case 0x0A:
> -
>                    ERR("Push\n");
> -
>                    break;
> -
>                case 0x0B:
> -
>                    ERR("Pop\n");
> -
>                    break;

Are these invalid messages from the HID device, or things wine doesn't
yet support? Should they be FIXMEs?
> -
>                default:
> -
>                    ERR("Unknown (bTag: %x, bType: %x)\n", bTag, bType);
> -
>            }
> -
>        }
> -
>        else if (bType == 0x02)
> -
>        {
> -
>            switch(bTag)
> -
>            {
> -
>                case 0x00:
> -
>                    if (caps->usage_count >= USAGE_MAX)
> -
>                        FIXME("More than %i individual usages defined\n",USAGE_MAX);
> -
>                    else
> -
>                    {
> -
>                        caps->u.NotRange.Usage[caps->usage_count++] = getValue(bSize, itemVal);
> -
>                        caps->IsRange = FALSE;
> -
>                    }
> -
>                    break;
> -
>                case 0x01:
> -
>                    caps->usage_count = 1;
> -
>                    caps->u.Range.UsageMin = getValue(bSize, itemVal);
> -
>                    caps->IsRange = TRUE;
> -
>                    break;
> -
>                case 0x02:
> -
>                    caps->usage_count = 1;
> -
>                    caps->u.Range.UsageMax = getValue(bSize, itemVal);
> -
>                    caps->IsRange = TRUE;
> -
>                    break;
> -
>                case 0x03:
> -
>                    caps->u.NotRange.DesignatorIndex = getValue(bSize, itemVal);
> -
>                    caps->IsDesignatorRange = FALSE;
> -
>                    break;
> -
>                case 0x04:
> -
>                    caps->u.Range.DesignatorMin = getValue(bSize, itemVal);
> -
>                    caps->IsDesignatorRange = TRUE;
> -
>                    break;
> -
>                case 0x05:
> -
>                    caps->u.Range.DesignatorMax = getValue(bSize, itemVal);
> -
>                    caps->IsDesignatorRange = TRUE;
> -
>                    break;
> -
>                case 0x07:
> -
>                    caps->u.NotRange.StringIndex = getValue(bSize, itemVal);
> -
>                    caps->IsStringRange = FALSE;
> -
>                    break;
> -
>                case 0x08:
> -
>                    caps->u.Range.StringMin = getValue(bSize, itemVal);
> -
>                    caps->IsStringRange = TRUE;
> -
>                    break;
> -
>                case 0x09:
> -
>                    caps->u.Range.StringMax = getValue(bSize, itemVal);
> -
>                    caps->IsStringRange = TRUE;
> -
>                    break;
> -
>                case 0x0A:
> -
>                    caps->Delim = getValue(bSize, itemVal);
> -
>                    break;
> -
>                default:
> -
>                    ERR("Unknown (bTag: %x, bType: %x)\n", bTag, bType);
> -
>            }
> -
>        }
> -
>        else
> -
>            ERR("Unknown (bTag: %x, bType: %x)\n", bTag, bType);
> -
> -
>        i += bSize;
> -
>    }
> - }
> - return i;
>
> +}
> -
>
> +static inline void new_report(WINE_HID_REPORT *wine_report, struct feature* feature)
> +{
> - wine_report->reportID = feature->caps.ReportID;
> - wine_report->dwSize = sizeof(*wine_report) - sizeof(WINE_HID_ELEMENT);
> - wine_report->elementCount = 0;
>
> +}
> -
>
> +static void build_elements(WINE_HID_REPORT *wine_report, struct feature* feature, DWORD *bitOffset)
> +{
> - int i;
> -
> - if (!feature->isData)
> - {
> -
>    *bitOffset = *bitOffset + (feature->caps.BitSize * feature->caps.ReportCount);
> -
>    return;
> - }
> -
> - for (i = 0; i < feature->caps.usage_count; i++)
> - {
> -
>    WINE_HID_ELEMENT *wine_element = &wine_report->Elements[wine_report->elementCount];
> -
> -
>    wine_element->valueStartBit = *bitOffset;
> -
>    if (feature->caps.UsagePage == HID_USAGE_PAGE_BUTTON)
> -
>    {
> -
>        wine_element->ElementType = ButtonElement;
> -
>        wine_element->caps.button.UsagePage = feature->caps.UsagePage;
> -
>        wine_element->caps.button.ReportID = feature->caps.ReportID;
> -
>        wine_element->caps.button.BitField = feature->BitField;
> -
>        wine_element->caps.button.IsRange = feature->caps.IsRange;
> -
>        wine_element->caps.button.IsStringRange = feature->caps.IsStringRange;
> -
>        wine_element->caps.button.IsDesignatorRange = feature->caps.IsDesignatorRange;
> -
>        wine_element->caps.button.IsAbsolute = feature->IsAbsolute;
> -
>        if (wine_element->caps.button.IsRange)
> -
>        {
> -
>            wine_element->bitCount = (feature->caps.u.Range.UsageMax - feature->caps.u.Range.UsageMin) + 1;
> -
>            *bitOffset = *bitOffset + wine_element->bitCount;
> -
>            wine_element->caps.button.u.Range.UsageMin = feature->caps.u.Range.UsageMin;
> -
>            wine_element->caps.button.u.Range.UsageMax = feature->caps.u.Range.UsageMax;
> -
>            wine_element->caps.button.u.Range.StringMin = feature->caps.u.Range.StringMin;
> -
>            wine_element->caps.button.u.Range.StringMax = feature->caps.u.Range.StringMax;
> -
>            wine_element->caps.button.u.Range.DesignatorMin = feature->caps.u.Range.DesignatorMin;
> -
>            wine_element->caps.button.u.Range.DesignatorMax = feature->caps.u.Range.DesignatorMax;
> -
>        }
> -
>        else
> -
>        {
> -
>            *bitOffset = *bitOffset + 1;
> -
>            wine_element->bitCount = 1;
> -
>            wine_element->caps.button.u.NotRange.Usage = feature->caps.u.NotRange.Usage[i];
> -
>            wine_element->caps.button.u.NotRange.StringIndex = feature->caps.u.NotRange.StringIndex;
> -
>            wine_element->caps.button.u.NotRange.DesignatorIndex = feature->caps.u.NotRange.DesignatorIndex;
> -
>        }
> -
>    }
> -
>    else
> -
>    {
> -
>        wine_element->ElementType = ValueElement;
> -
>        wine_element->caps.value.UsagePage = feature->caps.UsagePage;
> -
>        wine_element->caps.value.ReportID = feature->caps.ReportID;
> -
>        wine_element->caps.value.BitField = feature->BitField;
> -
>        wine_element->caps.value.IsRange = feature->caps.IsRange;
> -
>        wine_element->caps.value.IsStringRange = feature->caps.IsStringRange;
> -
>        wine_element->caps.value.IsDesignatorRange = feature->caps.IsDesignatorRange;
> -
>        wine_element->caps.value.IsAbsolute = feature->IsAbsolute;
> -
>        wine_element->caps.value.HasNull = feature->HasNull;
> -
>        wine_element->caps.value.BitSize = feature->caps.BitSize;
> -
>        if (feature->caps.usage_count > 1)
> -
>            wine_element->caps.value.ReportCount = 1;
> -
>        else
> -
>            wine_element->caps.value.ReportCount = feature->caps.ReportCount;
> -
>        wine_element->bitCount = (feature->caps.BitSize * wine_element->caps.value.ReportCount);
> -
>        *bitOffset = *bitOffset + wine_element->bitCount;
> -
>        wine_element->caps.value.UnitsExp = feature->caps.UnitsExp;
> -
>        wine_element->caps.value.Units = feature->caps.Units;
> -
>        wine_element->caps.value.LogicalMin = feature->caps.LogicalMin;
> -
>        wine_element->caps.value.LogicalMax = feature->caps.LogicalMax;
> -
>        wine_element->caps.value.PhysicalMin = feature->caps.PhysicalMin;
> -
>        wine_element->caps.value.PhysicalMax = feature->caps.PhysicalMax;
> -
>        if (wine_element->caps.value.IsRange)
> -
>        {
> -
>            wine_element->caps.value.u.Range.UsageMin = feature->caps.u.Range.UsageMin;
> -
>            wine_element->caps.value.u.Range.UsageMax = feature->caps.u.Range.UsageMax;
> -
>            wine_element->caps.value.u.Range.StringMin = feature->caps.u.Range.StringMin;
> -
>            wine_element->caps.value.u.Range.StringMax = feature->caps.u.Range.StringMax;
> -
>            wine_element->caps.value.u.Range.DesignatorMin = feature->caps.u.Range.DesignatorMin;
> -
>            wine_element->caps.value.u.Range.DesignatorMax = feature->caps.u.Range.DesignatorMax;
> -
>        }
> -
>        else
> -
>        {
> -
>            wine_element->caps.value.u.NotRange.Usage = feature->caps.u.NotRange.Usage[i];
> -
>            wine_element->caps.value.u.NotRange.StringIndex = feature->caps.u.NotRange.StringIndex;
> -
>            wine_element->caps.value.u.NotRange.DesignatorIndex = feature->caps.u.NotRange.DesignatorIndex;
> -
>        }
> -
>    }
> -
> -
>    wine_report->elementCount++;
> - }
>
> +}
> -
>
> +static void count_elements(struct feature* feature, USHORT *buttons, USHORT *values)
> +{
> - if (feature->caps.UsagePage == HID_USAGE_PAGE_BUTTON)
> - {
> -
>    if (feature->caps.IsRange)
> -
>        *buttons = *buttons + 1;
> -
>    else
> -
>        *buttons = *buttons + feature->caps.usage_count;
> - }
> - else
> - {
> -
>    if (feature->caps.IsRange)
> -
>        *values = *values + 1;
> -
>    else
> -
>        *values = *values + feature->caps.usage_count;
> - }
>
> +}
> -
>
> +WINE_HIDP_PREPARSED_DATA* build_PreparseData(
> -
>                   struct feature **features, int feature_count,
> -
>                   struct feature **input_features, int i_count,
> -
>                   struct feature **output_features, int o_count,
> -
>                   struct feature **feature_features, int f_count,
> -
>                   struct collection *base_collection)
>
> +{
> - WINE_HIDP_PREPARSED_DATA *data;
> - WINE_HID_REPORT *wine_report = NULL;
> - DWORD bitOffset, bitLength;
> - int report_count = 1;
> - int i;
> - int element_count;
> - int size = 0;
> -
> - if (features[0]->caps.ReportID != 0)
> - {
> -
>    int *report_ids;
> -
>    int cnt = max(i_count, o_count);
> -
>    cnt = max(cnt, f_count);
> -
>    report_ids = HeapAlloc(GetProcessHeap(), 0 , sizeof(*report_ids) * cnt);
> -
> -
>    if (i_count)
> -
>    {
> -
>        report_ids[0] = input_features[0]->caps.ReportID;
> -
>        for (i = 1; i < i_count; i++)
> -
>        {
> -
>            int j;
> -
>            int found = FALSE;
> -
>            for (j = 0; !found && j < i_count; j++)
> -
>            {
> -
>                if (report_ids[j] == input_features[i]->caps.ReportID)
> -
>                    found = TRUE;
> -
>            }
> -
>            if (!found)
> -
>            {
> -
>                report_ids[report_count] = input_features[i]->caps.ReportID;
> -
>                report_count++;
> -
>            }
> -
>        }
> -
>    }
> -
>    if (o_count)
> -
>    {
> -
>        report_count++;
> -
>        report_ids[0] = output_features[0]->caps.ReportID;
> -
>        for (i = 1; i < o_count; i++)
> -
>        {
> -
>            int j;
> -
>            int found = FALSE;
> -
>            for (j = 0; !found && j < o_count; j++)
> -
>            {
> -
>                if (report_ids[j] == output_features[i]->caps.ReportID)
> -
>                    found = TRUE;
> -
>            }
> -
>            if (!found)
> -
>            {
> -
>                report_ids[report_count] = output_features[i]->caps.ReportID;
> -
>                report_count++;
> -
>            }
> -
>        }
> -
>    }
> -
>    if (f_count)
> -
>    {
> -
>        report_count++;
> -
>        report_ids[0] = feature_features[0]->caps.ReportID;
> -
>        for (i = 1; i < f_count; i++)
> -
>        {
> -
>            int j;
> -
>            int found = FALSE;
> -
>            for (j = 0; !found && j < f_count; j++)
> -
>            {
> -
>                if (report_ids[j] == feature_features[i]->caps.ReportID)
> -
>                    found = TRUE;
> -
>            }
> -
>            if (!found)
> -
>            {
> -
>                report_ids[report_count] = feature_features[i]->caps.ReportID;
> -
>                report_count++;
> -
>            }
> -
>        }
> -
>    }
> -
>    HeapFree(GetProcessHeap(), 0, report_ids);
> - }
> - else
> - {
> -
>    if (o_count) report_count++;
> -
>    if (f_count) report_count++;
> - }
> -
> - element_count = 0;
> - for (i = 0; i < feature_count; i++)
> -
>    element_count += features[i]->caps.usage_count;
> -
> - size = sizeof(WINE_HIDP_PREPARSED_DATA) +
> -
>        (element_count * sizeof(WINE_HID_ELEMENT)) +
> -
>        (report_count * sizeof(WINE_HID_REPORT));
> -
> - TRACE("%i reports %i elements -> size %i\n",report_count, element_count, size);
> -
> - data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
> - data->magic = HID_MAGIC;
> - data->dwSize = size;
> - data->caps.Usage = base_collection->caps.u.NotRange.Usage[0];
> - data->caps.UsagePage = base_collection->caps.UsagePage;
> -
> - wine_report = data->InputReports;
> - if (i_count)
> - {
> -
>    bitLength = 0;
> -
>    new_report(wine_report, input_features[0]);
> -
>    data->dwInputReportCount ++;
> -
> -
>    if (input_features[0]->caps.ReportID != 0)
> -
>        bitOffset = 8;
> -
>    else
> -
>        bitOffset = 0;
> -
> -
>    for (i = 0; i < i_count; i++)
> -
>    {
> -
>        if (input_features[i]->caps.ReportID != wine_report->reportID)
> -
>        {
> -
>            wine_report->dwSize += (sizeof(WINE_HID_ELEMENT) * wine_report->elementCount);
> -
>            wine_report = (WINE_HID_REPORT*)(((BYTE*)wine_report)+wine_report->dwSize);
> -
>            new_report(wine_report, input_features[i]);
> -
>            data->dwInputReportCount ++;
> -
>            bitLength = max(bitOffset, bitLength);
> -
>            if (input_features[i]->caps.ReportID != 0)
> -
>                bitOffset = 8;
> -
>            else
> -
>                bitOffset = 0;
> -
>        }
> -
>        build_elements(wine_report, input_features[i], &bitOffset);
> -
>        count_elements(input_features[i], &data->caps.NumberInputButtonCaps,
> -
>            &data->caps.NumberInputValueCaps);
> -
>    }
> -
>    wine_report->dwSize += (sizeof(WINE_HID_ELEMENT) * wine_report->elementCount);
> -
>    bitLength = max(bitOffset, bitLength);
> -
>    data->caps.InputReportByteLength = ((bitLength + 7) & ~7)/8;
> - }
> -
> - if (o_count)
> - {
> -
>    bitLength = 0;
> -
>    wine_report = (WINE_HID_REPORT*)(((BYTE*)wine_report)+wine_report->dwSize);
> -
>    data->dwOutputReportOffset = (BYTE*)wine_report - (BYTE*)data->InputReports;
> -
>    new_report(wine_report, output_features[0]);
> -
>    data->dwOutputReportCount ++;
> -
>    if (output_features[0]->caps.ReportID != 0)
> -
>        bitOffset = 8;
> -
>    else
> -
>        bitOffset = 0;
> -
> -
>    for (i = 0; i < o_count; i++)
> -
>    {
> -
>        if (output_features[i]->caps.ReportID != wine_report->reportID)
> -
>        {
> -
>            wine_report->dwSize += (sizeof(WINE_HID_ELEMENT) * wine_report->elementCount);
> -
>            wine_report = (WINE_HID_REPORT*)(((BYTE*)wine_report)+wine_report->dwSize);
> -
>            new_report(wine_report, output_features[i]);
> -
>            data->dwOutputReportCount ++;
> -
>            bitLength = max(bitOffset, bitLength);
> -
>            if (output_features[0]->caps.ReportID != 0)
> -
>                bitOffset = 8;
> -
>            else
> -
>                bitOffset = 0;
> -
>        }
> -
>        build_elements(wine_report, output_features[i], &bitOffset);
> -
>        count_elements(output_features[i], &data->caps.NumberOutputButtonCaps,
> -
>            &data->caps.NumberOutputValueCaps);
> -
>    }
> -
>    wine_report->dwSize += (sizeof(WINE_HID_ELEMENT) * wine_report->elementCount);
> -
>    bitLength = max(bitOffset, bitLength);
> -
>    data->caps.OutputReportByteLength = ((bitLength + 7) & ~7)/8;
> - }
> -
> - if (f_count)
> - {
> -
>    bitLength = 0;
> -
>    wine_report = (WINE_HID_REPORT*)(((BYTE*)wine_report)+wine_report->dwSize);
> -
>    data->dwFeatureReportOffset = (BYTE*)wine_report - (BYTE*)data->InputReports;
> -
>    new_report(wine_report, feature_features[0]);
> -
>    data->dwFeatureReportCount ++;
> -
>    if (feature_features[0]->caps.ReportID != 0)
> -
>        bitOffset = 8;
> -
>    else
> -
>        bitOffset = 0;
> -
> -
>    for (i = 0; i < f_count; i++)
> -
>    {
> -
>        if (feature_features[i]->caps.ReportID != wine_report->reportID)
> -
>        {
> -
>            wine_report->dwSize += (sizeof(WINE_HID_ELEMENT) * wine_report->elementCount);
> -
>            wine_report = (WINE_HID_REPORT*)((BYTE*)wine_report)+wine_report->dwSize;
> -
>            new_report(wine_report, feature_features[i]);
> -
>            data->dwFeatureReportCount ++;
> -
>            bitLength = max(bitOffset, bitLength);
> -
>            if (feature_features[0]->caps.ReportID != 0)
> -
>                bitOffset = 8;
> -
>            else
> -
>                bitOffset = 0;
> -
>        }
> -
>        build_elements(wine_report, feature_features[i], &bitOffset);
> -
>        count_elements(feature_features[i], &data->caps.NumberFeatureButtonCaps,
> -
>            &data->caps.NumberFeatureValueCaps);
> -
>    }
> -
>    bitLength = max(bitOffset, bitLength);
> -
>    data->caps.FeatureReportByteLength = ((bitLength + 7) & ~7)/8;
> - }
> -
> - return data;
>
> +}
> -
>
> +static void free_collection(struct collection *collection)
> +{
> - struct feature *fentry, *fnext;
> - struct collection *centry, *cnext;
> - LIST_FOR_EACH_ENTRY_SAFE(centry, cnext, &collection->collections, struct collection, entry)
> - {
> -
>    list_remove(&centry->entry);
> -
>    free_collection(centry);
> - }
> - LIST_FOR_EACH_ENTRY_SAFE(fentry, fnext, &collection->features, struct feature, col_entry)
> - {
> -
>    list_remove(&fentry->col_entry);
> -
>    HeapFree(GetProcessHeap(), 0, fentry);
> - }
> - HeapFree(GetProcessHeap(), 0, collection);
>
> +}
> -
>
> +static int compare_reports(const void *a, const void* b)
> +{
> - struct feature *f1 = *(struct feature **)a;
> - struct feature *f2 = *(struct feature **)b;
> - int c = (f1->caps.ReportID - f2->caps.ReportID);
> - if (c) return c;
> - return (f1->index - f2->index);
>
> +}
> -
>
> +WINE_HIDP_PREPARSED_DATA* ParseDescriptor(BYTE *descriptor, INT length)
> +{
> - WINE_HIDP_PREPARSED_DATA *data = NULL;
> - struct collection *base;
> - struct caps caps;
> -
> - struct list features;
> -
> - int feature_count = 0;
> - int cidx;
> -
> - if (TRACE_ON(hid))
> - {
> -
>    TRACE("Descriptor[%i]: ", length);
> -
>    for (cidx = 0; cidx < length; cidx++)
> -
>        TRACE("%x ",descriptor[cidx]);
> -
>    TRACE("\n");
> - }
> -
> - list_init(&features);
> -
> - base = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*base));
> - base->index = 1;
> - list_init(&base->features);
> - list_init(&base->collections);
> - memset(&caps, 0, sizeof(caps));
> -
> - cidx = 0;
> - parse_descriptor(descriptor, 0, length, &feature_count, &cidx, base, &caps, &features);
> -
> - debug_collection(base);
> -
> - cidx = 2;
> - if (feature_count)
> - {
> -
>    struct feature *entry;
> -
>    struct feature** sorted_features;
> -
>    struct feature** input_features;
> -
>    struct feature** output_features;
> -
>    struct feature** feature_features;
> -
>    int i_count, o_count, f_count;
> -
>    int i;
> -
> -
>    i_count = o_count = f_count = 0;
> -
> -
>    sorted_features = HeapAlloc(GetProcessHeap(), 0, sizeof(*sorted_features) * feature_count);
> -
>    input_features = HeapAlloc(GetProcessHeap(), 0, sizeof(*input_features) * feature_count);
> -
>    output_features = HeapAlloc(GetProcessHeap(), 0, sizeof(*output_features) * feature_count);
> -
>    feature_features = HeapAlloc(GetProcessHeap(), 0, sizeof(*feature_features) * feature_count);
> -
> -
>    i = 0;
> -
>    LIST_FOR_EACH_ENTRY(entry, &features, struct feature, entry)
> -
>        sorted_features[i++] = entry;
> -
> -
>    /* Sort features base on report if there are multiple reports */
> -
>    if (sorted_features[0]->caps.ReportID != 0)
> -
>        qsort(sorted_features, feature_count, sizeof(struct feature*), compare_reports);
> -
> -
>    for (i = 0; i < feature_count; i++)
> -
>    {
> -
>        switch (sorted_features[i]->type)
> -
>        {
> -
>            case HidP_Input:
> -
>                input_features[i_count] = sorted_features[i];
> -
>                i_count++;
> -
>                break;
> -
>            case HidP_Output:
> -
>                output_features[o_count] = sorted_features[i];
> -
>                o_count++;
> -
>                break;
> -
>            case HidP_Feature:
> -
>                feature_features[f_count] = sorted_features[i];
> -
>                f_count++;
> -
>                break;
> -
>            default:
> -
>                ERR("Unknown type %i\n",sorted_features[i]->type);
> -
>        }
> -
>    }
> -
> -
>    if (TRACE_ON(hid))
> -
>    {
> -
>        TRACE("DUMP FEATURES:\n");
> -
>        TRACE("----INPUT----\n");
> -
>        for (cidx = 0; cidx < i_count; cidx++)
> -
>            debug_feature(input_features[cidx]);
> -
>        TRACE("----OUTPUT----\n");
> -
>        for (cidx = 0; cidx < o_count; cidx++)
> -
>            debug_feature(output_features[cidx]);
> -
>        TRACE("----FEATURE----\n");
> -
>        for (cidx = 0; cidx < f_count; cidx++)
> -
>            debug_feature(feature_features[cidx]);
> -
>    }
> -
> -
>    data = build_PreparseData(sorted_features, feature_count, input_features, i_count, output_features, o_count, feature_features, f_count, base);
> -
> -
>    debug_print_preparsed(data);
> -
> -
>    HeapFree(GetProcessHeap(), 0, sorted_features);
> -
>    HeapFree(GetProcessHeap(), 0, input_features);
> -
>    HeapFree(GetProcessHeap(), 0, output_features);
> -
>    HeapFree(GetProcessHeap(), 0, feature_features);
> - }
> -
> - free_collection(base);
> - /* We do not have to free the list as free_collection does all the work */
> -
> - return data;
>
> +}
> diff --git a/dlls/hidclass.sys/hid.h b/dlls/hidclass.sys/hid.h
> index 8f9e56f..c8cee69 100644
> --- a/dlls/hidclass.sys/hid.h
> +++ b/dlls/hidclass.sys/hid.h
> @@ -81,3 +81,6 @@ void HID_DeleteDevice(HID_MINIDRIVER_REGISTRATION *driver, DEVICE_OBJECT *device
>  /* Pseudo-Plug and Play support*/
>  NTSTATUS WINAPI PNP_AddDevice(DRIVER_OBJECT *driver, void* native) DECLSPEC_HIDDEN;
>  void PNP_CleanupPNP() DECLSPEC_HIDDEN;
> -
>
> +/* Parsing HID Report Descriptors into preparsed data */
> +WINE_HIDP_PREPARSED_DATA* ParseDescriptor(BYTE *descriptor, INT length) DECLSPEC_HIDDEN;
> diff --git a/dlls/hidclass.sys/pnp.c b/dlls/hidclass.sys/pnp.c
> index ca85cb7..5694b8a 100644
> --- a/dlls/hidclass.sys/pnp.c
> +++ b/dlls/hidclass.sys/pnp.c
> @@ -53,6 +53,9 @@ NTSTATUS WINAPI PNP_AddDevice(DRIVER_OBJECT *driver, void *native)
>      DWORD index = HID_STRING_ID_ISERIALNUMBER;
>      NATIVE_DEVICE *tracked_device, *ptr;
>      INT interface_index = 1;
> -
>
> HID_DESCRIPTOR descriptor;
> -
>
> BYTE *reportDescriptor;
> -
>
> INT i;
>
> static const WCHAR ig_fmtW[] = {'I','G','_','%','i',0};
> static const WCHAR im_fmtW[] = {'I','M','_','%','i',0};
>
> @@ -104,6 +107,40 @@ NTSTATUS WINAPI PNP_AddDevice(DRIVER_OBJECT *driver, void *native)
>  list_add_tail(&tracked_devices, &tracked_device->entry);
>
> - status = call_minidriver(IOCTL_HID_GET_DEVICE_DESCRIPTOR, device, NULL, 0,
> -
>    &descriptor, sizeof(descriptor));
> - if (status != STATUS_SUCCESS)
> - {
> -
>    ERR("Cannot get Device Descriptor(%x)\n",status);
> -
>    HID_DeleteDevice(&minidriver->minidriver, device);
> -
>    return status;
> - }
> - for (i = 0; i < descriptor.bNumDescriptors; i++)
> -
>    if (descriptor.DescriptorList[i].bReportType == HID_REPORT_DESCRIPTOR_TYPE)
> -
>        break;
> -
> - if (i >= descriptor.bNumDescriptors)
> - {
> -
>    ERR("No Report Descriptor found in reply\n");
> -
>    HID_DeleteDevice(&minidriver->minidriver, device);
> -
>    return status;
> - }
> -
> - reportDescriptor = HeapAlloc(GetProcessHeap(), 0, descriptor.DescriptorList[i].wReportLength);
> - status = call_minidriver(IOCTL_HID_GET_REPORT_DESCRIPTOR, device, NULL, 0,
> -
>    reportDescriptor, descriptor.DescriptorList[i].wReportLength);
> - if (status != STATUS_SUCCESS)
> - {
> -
>    ERR("Cannot get Report Descriptor(%x)\n",status);
> -
>    HID_DeleteDevice(&minidriver->minidriver, device);
> -
>    HeapFree(GetProcessHeap(), 0, reportDescriptor);
> -
>    return status;
> - }
> -
> - ext->preparseData = ParseDescriptor(reportDescriptor, descriptor.DescriptorList[0].wReportLength);
> - ext->information.DescriptorSize = ext->preparseData->dwSize;
> - HeapFree(GetProcessHeap(), 0, reportDescriptor);
> - status = call_minidriver(IOCTL_HID_GET_STRING, device,
>       (void*)index, sizeof(DWORD), serial, sizeof(serial));
>