dlls/hid/hidp.c

   1 /*
   2  * Human Input Devices
   3  *
   4  * Copyright (C) 2015 Aric Stewart
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21
  22 #include <stdarg.h>
  23
  24 #include "ntstatus.h"
  25 #define WIN32_NO_STATUS
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winternl.h"
  29 #include "winioctl.h"
  30 #include "ddk/wdm.h"
  31
  32 #include "hidusage.h"
  33 #include "ddk/hidpi.h"
  34 #include "wine/hid.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(hid);
  38
  39 static NTSTATUS get_value_caps_range( struct hid_preparsed_data *preparsed, HIDP_REPORT_TYPE report_type, ULONG report_len,
  40                                       const struct hid_value_caps **caps, const struct hid_value_caps **caps_end )
  41 {
  42     if (!preparsed || memcmp( preparsed->magic, "HidP KDR", 8 )) return HIDP_STATUS_INVALID_PREPARSED_DATA;
  43
  44     switch (report_type)
  45     {
  46     case HidP_Input:
  47         if (report_len && report_len != preparsed->input_report_byte_length)
  48             return HIDP_STATUS_INVALID_REPORT_LENGTH;
  49         *caps = HID_INPUT_VALUE_CAPS( preparsed );
  50         *caps_end = *caps + preparsed->input_caps_count;
  51         break;
  52     case HidP_Output:
  53         if (report_len && report_len != preparsed->output_report_byte_length)
  54             return HIDP_STATUS_INVALID_REPORT_LENGTH;
  55         *caps = HID_OUTPUT_VALUE_CAPS( preparsed );
  56         *caps_end = *caps + preparsed->output_caps_count;
  57         break;
  58     case HidP_Feature:
  59         if (report_len && report_len != preparsed->feature_report_byte_length)
  60             return HIDP_STATUS_INVALID_REPORT_LENGTH;
  61         *caps = HID_FEATURE_VALUE_CAPS( preparsed );
  62         *caps_end = *caps + preparsed->feature_caps_count;
  63         break;
  64     default:
  65         return HIDP_STATUS_INVALID_REPORT_TYPE;
  66     }
  67
  68     return HIDP_STATUS_SUCCESS;
  69 }
  70
  71 #define USAGE_MASK  0xffff
  72 #define USAGE_ANY  0x10000
  73
  74 struct caps_filter
  75 {
  76     BOOLEAN buttons;
  77     BOOLEAN values;
  78     BOOLEAN array;
  79     DWORD   usage_page;
  80     USHORT  collection;
  81     DWORD   usage;
  82     UCHAR   report_id;
  83 };
  84
  85 static BOOL match_value_caps( const struct hid_value_caps *caps, const struct caps_filter *filter )
  86 {
  87     if (!caps->usage_min && !caps->usage_max) return FALSE;
  88     if (filter->buttons && !(caps->flags & HID_VALUE_CAPS_IS_BUTTON)) return FALSE;
  89     if (filter->values && (caps->flags & HID_VALUE_CAPS_IS_BUTTON)) return FALSE;
  90     if (filter->usage_page != USAGE_ANY && (filter->usage_page & USAGE_MASK) != caps->usage_page) return FALSE;
  91     if (filter->collection && filter->collection != caps->link_collection) return FALSE;
  92     if (filter->usage == USAGE_ANY) return TRUE;
  93     return caps->usage_min <= (filter->usage & USAGE_MASK) && caps->usage_max >= (filter->usage & USAGE_MASK);
  94 }
  95
  96 typedef NTSTATUS (*enum_value_caps_callback)( const struct hid_value_caps *caps, void *user );
  97
  98 static NTSTATUS enum_value_caps( struct hid_preparsed_data *preparsed, HIDP_REPORT_TYPE report_type,
  99                                  ULONG report_len, const struct caps_filter *filter,
 100                                  enum_value_caps_callback callback, void *user, USHORT *count )
 101 {
 102     const struct hid_value_caps *caps, *caps_end;
 103     BOOL is_range, incompatible = FALSE;
 104     LONG remaining = *count;
 105     NTSTATUS status;
 106
 107     for (status = get_value_caps_range( preparsed, report_type, report_len, &caps, &caps_end );
 108          status == HIDP_STATUS_SUCCESS && caps != caps_end; caps++)
 109     {
 110         is_range = caps->flags & HID_VALUE_CAPS_IS_RANGE;
 111         if (!match_value_caps( caps, filter )) continue;
 112         if (filter->report_id && caps->report_id != filter->report_id) incompatible = TRUE;
 113         else if (filter->array && (is_range || caps->report_count <= 1)) return HIDP_STATUS_NOT_VALUE_ARRAY;
 114         else if (remaining-- > 0) status = callback( caps, user );
 115     }
 116
 117     if (status == HIDP_STATUS_NULL) status = HIDP_STATUS_SUCCESS;
 118     if (status != HIDP_STATUS_SUCCESS) return status;
 119
 120     *count -= remaining;
 121     if (*count == 0) return incompatible ? HIDP_STATUS_INCOMPATIBLE_REPORT_ID : HIDP_STATUS_USAGE_NOT_FOUND;
 122     if (remaining < 0) return HIDP_STATUS_BUFFER_TOO_SMALL;
 123     return HIDP_STATUS_SUCCESS;
 124 }
 125
 126 /* copy count bits from src, starting at (-shift) bit if < 0, to dst starting at (shift) bit if > 0 */
 127 static void copy_bits( unsigned char *dst, const unsigned char *src, int count, int shift )
 128 {
 129     unsigned char bits, mask;
 130     size_t src_shift = shift < 0 ? (-shift & 7) : 0;
 131     size_t dst_shift = shift > 0 ? (shift & 7) : 0;
 132     if (shift < 0) src += -shift / 8;
 133     if (shift > 0) dst += shift / 8;
 134
 135     if (src_shift == 0 && dst_shift == 0)
 136     {
 137         memcpy( dst, src, count / 8 );
 138         dst += count / 8;
 139         src += count / 8;
 140         count &= 7;
 141     }
 142
 143     if (!count) return;
 144
 145     bits = *dst << (8 - dst_shift);
 146     count += dst_shift;
 147
 148     while (count > 8)
 149     {
 150         *dst = bits >> (8 - dst_shift);
 151         bits = *(unsigned short *)src++ >> src_shift;
 152         *dst++ |= bits << dst_shift;
 153         count -= 8;
 154     }
 155
 156     bits >>= (8 - dst_shift);
 157     if (count <= 8 - src_shift) bits |= (*src >> src_shift) << dst_shift;
 158     else bits |= (*(unsigned short *)src >> src_shift) << dst_shift;
 159
 160     mask = (1 << count) - 1;
 161     *dst = (bits & mask) | (*dst & ~mask);
 162 }
 163
 164 NTSTATUS WINAPI HidP_GetButtonCaps( HIDP_REPORT_TYPE report_type, HIDP_BUTTON_CAPS *caps, USHORT *caps_count,
 165                                     PHIDP_PREPARSED_DATA preparsed_data )
 166 {
 167     return HidP_GetSpecificButtonCaps( report_type, 0, 0, 0, caps, caps_count, preparsed_data );
 168 }
 169
 170 NTSTATUS WINAPI HidP_GetCaps( PHIDP_PREPARSED_DATA preparsed_data, HIDP_CAPS *caps )
 171 {
 172     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 173     struct hid_value_caps *it, *end;
 174
 175     TRACE( "preparsed_data %p, caps %p.\n", preparsed_data, caps );
 176
 177     if (!preparsed || memcmp( preparsed->magic, "HidP KDR", 8 )) return HIDP_STATUS_INVALID_PREPARSED_DATA;
 178
 179     caps->Usage = preparsed->usage;
 180     caps->UsagePage = preparsed->usage_page;
 181     caps->InputReportByteLength = preparsed->input_report_byte_length;
 182     caps->OutputReportByteLength = preparsed->output_report_byte_length;
 183     caps->FeatureReportByteLength = preparsed->feature_report_byte_length;
 184     caps->NumberLinkCollectionNodes = preparsed->number_link_collection_nodes;
 185     caps->NumberInputButtonCaps = 0;
 186     caps->NumberInputValueCaps = 0;
 187     caps->NumberInputDataIndices = 0;
 188     caps->NumberOutputButtonCaps = 0;
 189     caps->NumberOutputValueCaps = 0;
 190     caps->NumberOutputDataIndices = 0;
 191     caps->NumberFeatureButtonCaps = 0;
 192     caps->NumberFeatureValueCaps = 0;
 193     caps->NumberFeatureDataIndices = 0;
 194
 195     for (it = HID_INPUT_VALUE_CAPS( preparsed ), end = it + preparsed->input_caps_count;
 196          it != end; ++it)
 197     {
 198         if (!it->usage_min && !it->usage_max) continue;
 199         if (it->flags & HID_VALUE_CAPS_IS_BUTTON) caps->NumberInputButtonCaps++;
 200         else caps->NumberInputValueCaps++;
 201         if (!(it->flags & HID_VALUE_CAPS_IS_RANGE)) caps->NumberInputDataIndices++;
 202         else caps->NumberInputDataIndices += it->data_index_max - it->data_index_min + 1;
 203     }
 204
 205     for (it = HID_OUTPUT_VALUE_CAPS( preparsed ), end = it + preparsed->output_caps_count;
 206          it != end; ++it)
 207     {
 208         if (!it->usage_min && !it->usage_max) continue;
 209         if (it->flags & HID_VALUE_CAPS_IS_BUTTON) caps->NumberOutputButtonCaps++;
 210         else caps->NumberOutputValueCaps++;
 211         if (!(it->flags & HID_VALUE_CAPS_IS_RANGE)) caps->NumberOutputDataIndices++;
 212         else caps->NumberOutputDataIndices += it->data_index_max - it->data_index_min + 1;
 213     }
 214
 215     for (it = HID_FEATURE_VALUE_CAPS( preparsed ), end = it + preparsed->feature_caps_count;
 216          it != end; ++it)
 217     {
 218         if (!it->usage_min && !it->usage_max) continue;
 219         if (it->flags & HID_VALUE_CAPS_IS_BUTTON) caps->NumberFeatureButtonCaps++;
 220         else caps->NumberFeatureValueCaps++;
 221         if (!(it->flags & HID_VALUE_CAPS_IS_RANGE)) caps->NumberFeatureDataIndices++;
 222         else caps->NumberFeatureDataIndices += it->data_index_max - it->data_index_min + 1;
 223     }
 224
 225     return HIDP_STATUS_SUCCESS;
 226 }
 227
 228 struct usage_value_params
 229 {
 230     BOOL array;
 231     USAGE usage;
 232     void *value_buf;
 233     USHORT value_len;
 234     void *report_buf;
 235 };
 236
 237 static LONG sign_extend( ULONG value, const struct hid_value_caps *caps )
 238 {
 239     UINT sign = 1 << (caps->bit_size - 1);
 240     if (sign <= 1 || caps->logical_min >= 0) return value;
 241     return value - ((value & sign) << 1);
 242 }
 243
 244 static NTSTATUS get_usage_value( const struct hid_value_caps *caps, void *user )
 245 {
 246     unsigned char *report_buf, start_bit = caps->start_bit;
 247     ULONG bit_count = caps->bit_size, bit_offset = 0;
 248     struct usage_value_params *params = user;
 249
 250     if (params->array) bit_count *= caps->report_count;
 251     else bit_offset = (params->usage - caps->usage_min) * caps->bit_size;
 252
 253     if ((bit_count + 7) / 8 > params->value_len) return HIDP_STATUS_BUFFER_TOO_SMALL;
 254     memset( params->value_buf, 0, params->value_len );
 255
 256     report_buf = (unsigned char *)params->report_buf + caps->start_byte + bit_offset / 8;
 257     copy_bits( params->value_buf, report_buf, bit_count, -(start_bit + bit_offset % 8) );
 258
 259     return HIDP_STATUS_NULL;
 260 }
 261
 262 static NTSTATUS get_scaled_usage_value( const struct hid_value_caps *caps, void *user )
 263 {
 264     struct usage_value_params *params = user;
 265     LONG signed_value, *value = params->value_buf;
 266     ULONG unsigned_value = 0;
 267     NTSTATUS status;
 268
 269     params->value_buf = &unsigned_value;
 270     params->value_len = sizeof(unsigned_value);
 271     if ((status = get_usage_value( caps, params )) != HIDP_STATUS_NULL) return status;
 272
 273     if (sizeof(LONG) > params->value_len) return HIDP_STATUS_BUFFER_TOO_SMALL;
 274     signed_value = sign_extend( unsigned_value, caps );
 275
 276     if (caps->logical_min > caps->logical_max || caps->physical_min > caps->physical_max)
 277         return HIDP_STATUS_BAD_LOG_PHY_VALUES;
 278     if (caps->logical_min > signed_value || caps->logical_max < signed_value)
 279         return HIDP_STATUS_VALUE_OUT_OF_RANGE;
 280
 281     if (!caps->physical_min && !caps->physical_max) *value = signed_value;
 282     else *value = caps->physical_min + MulDiv( signed_value - caps->logical_min, caps->physical_max - caps->physical_min,
 283                                                caps->logical_max - caps->logical_min );
 284     return HIDP_STATUS_NULL;
 285 }
 286
 287 NTSTATUS WINAPI HidP_GetScaledUsageValue( HIDP_REPORT_TYPE report_type, USAGE usage_page, USHORT collection,
 288                                           USAGE usage, LONG *value, PHIDP_PREPARSED_DATA preparsed_data,
 289                                           char *report_buf, ULONG report_len )
 290 {
 291     struct usage_value_params params = {.usage = usage, .value_buf = value, .value_len = sizeof(*value), .report_buf = report_buf};
 292     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 293     struct caps_filter filter = {.values = TRUE, .usage_page = usage_page, .collection = collection, .usage = usage };
 294     USHORT count = 1;
 295
 296     TRACE( "report_type %d, usage_page %u, collection %u, usage %u, value %p, preparsed_data %p, report_buf %p, report_len %lu.\n",
 297            report_type, usage_page, collection, usage, value, preparsed_data, report_buf, report_len );
 298
 299     *value = 0;
 300     if (!report_len) return HIDP_STATUS_INVALID_REPORT_LENGTH;
 301
 302     filter.report_id = report_buf[0];
 303     return enum_value_caps( preparsed, report_type, report_len, &filter, get_scaled_usage_value, &params, &count );
 304 }
 305
 306 NTSTATUS WINAPI HidP_GetUsageValue( HIDP_REPORT_TYPE report_type, USAGE usage_page, USHORT collection, USAGE usage,
 307                                     ULONG *value, PHIDP_PREPARSED_DATA preparsed_data, char *report_buf, ULONG report_len )
 308 {
 309     struct usage_value_params params = {.usage = usage, .value_buf = value, .value_len = sizeof(*value), .report_buf = report_buf};
 310     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 311     struct caps_filter filter = {.values = TRUE, .usage_page = usage_page, .collection = collection, .usage = usage};
 312     USHORT count = 1;
 313
 314     TRACE( "report_type %d, usage_page %u, collection %u, usage %u, value %p, preparsed_data %p, report_buf %p, report_len %lu.\n",
 315            report_type, usage_page, collection, usage, value, preparsed_data, report_buf, report_len );
 316
 317     if (!report_len) return HIDP_STATUS_INVALID_REPORT_LENGTH;
 318
 319     filter.report_id = report_buf[0];
 320     return enum_value_caps( preparsed, report_type, report_len, &filter, get_usage_value, &params, &count );
 321 }
 322
 323 NTSTATUS WINAPI HidP_GetUsageValueArray( HIDP_REPORT_TYPE report_type, USAGE usage_page, USHORT collection,
 324                                          USAGE usage, char *value_buf, USHORT value_len,
 325                                          PHIDP_PREPARSED_DATA preparsed_data, char *report_buf, ULONG report_len )
 326 {
 327     struct usage_value_params params = {.array = TRUE, .usage = usage, .value_buf = value_buf, .value_len = value_len, .report_buf = report_buf};
 328     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 329     struct caps_filter filter = {.values = TRUE, .array = TRUE, .usage_page = usage_page, .collection = collection, .usage = usage};
 330     USHORT count = 1;
 331
 332     TRACE( "report_type %d, usage_page %u, collection %u, usage %u, value_buf %p, value_len %u, "
 333            "preparsed_data %p, report_buf %p, report_len %lu.\n",
 334            report_type, usage_page, collection, usage, value_buf, value_len, preparsed_data, report_buf, report_len );
 335
 336     if (!report_len) return HIDP_STATUS_INVALID_REPORT_LENGTH;
 337
 338     filter.report_id = report_buf[0];
 339     return enum_value_caps( preparsed, report_type, report_len, &filter, get_usage_value, &params, &count );
 340 }
 341
 342
 343 struct get_usage_params
 344 {
 345     USAGE *usages;
 346     USAGE *usages_end;
 347     char *report_buf;
 348 };
 349
 350 static NTSTATUS get_usage( const struct hid_value_caps *caps, void *user )
 351 {
 352     const struct hid_value_caps *end = caps;
 353     ULONG index_min, index_max, bit, last;
 354     struct get_usage_params *params = user;
 355     unsigned char *report_buf;
 356     BYTE index;
 357
 358     report_buf = (unsigned char *)params->report_buf + caps->start_byte;
 359
 360     if (HID_VALUE_CAPS_IS_ARRAY( caps ))
 361     {
 362         while (end->flags & HID_VALUE_CAPS_ARRAY_HAS_MORE) end++;
 363         index_min = end - caps + 1;
 364         index_max = index_min + caps->usage_max - caps->usage_min;
 365
 366         for (bit = caps->start_bit, last = bit + caps->report_count * caps->bit_size - 1; bit <= last; bit += 8)
 367         {
 368             if (!(index = report_buf[bit / 8]) || index < index_min || index > index_max) continue;
 369             if (params->usages < params->usages_end) *params->usages = caps->usage_min + index - index_min;
 370             params->usages++;
 371         }
 372         return HIDP_STATUS_SUCCESS;
 373     }
 374
 375     for (bit = caps->start_bit, last = bit + caps->usage_max - caps->usage_min; bit <= last; ++bit)
 376     {
 377         if (!(report_buf[bit / 8] & (1 << (bit % 8)))) continue;
 378         if (params->usages < params->usages_end) *params->usages = caps->usage_min + bit - caps->start_bit;
 379         params->usages++;
 380     }
 381
 382     return HIDP_STATUS_SUCCESS;
 383 }
 384
 385 NTSTATUS WINAPI HidP_GetUsages( HIDP_REPORT_TYPE report_type, USAGE usage_page, USHORT collection, USAGE *usages,
 386                                 ULONG *usages_len, PHIDP_PREPARSED_DATA preparsed_data, char *report_buf, ULONG report_len )
 387 {
 388     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 389     struct get_usage_params params = {.usages = usages, .usages_end = usages + *usages_len, .report_buf = report_buf};
 390     struct caps_filter filter = {.buttons = TRUE, .usage_page = usage_page, .collection = collection, .usage = USAGE_ANY};
 391     NTSTATUS status;
 392     USHORT limit = -1;
 393
 394     TRACE( "report_type %d, usage_page %u, collection %u, usages %p, usages_len %p, preparsed_data %p, "
 395            "report_buf %p, report_len %lu.\n",
 396            report_type, usage_page, collection, usages, usages_len, preparsed_data, report_buf, report_len );
 397
 398     if (!report_len) return HIDP_STATUS_INVALID_REPORT_LENGTH;
 399
 400     filter.report_id = report_buf[0];
 401     status = enum_value_caps( preparsed, report_type, report_len, &filter, get_usage, &params, &limit );
 402     *usages_len = params.usages - usages;
 403     if (status != HIDP_STATUS_SUCCESS) return status;
 404
 405     if (params.usages > params.usages_end) return HIDP_STATUS_BUFFER_TOO_SMALL;
 406     return status;
 407 }
 408
 409 NTSTATUS WINAPI HidP_GetValueCaps( HIDP_REPORT_TYPE report_type, HIDP_VALUE_CAPS *caps, USHORT *caps_count,
 410                                    PHIDP_PREPARSED_DATA preparsed_data )
 411 {
 412     return HidP_GetSpecificValueCaps( report_type, 0, 0, 0, caps, caps_count, preparsed_data );
 413 }
 414
 415 NTSTATUS WINAPI HidP_InitializeReportForID( HIDP_REPORT_TYPE report_type, UCHAR report_id,
 416                                             PHIDP_PREPARSED_DATA preparsed_data, char *report_buf, ULONG report_len )
 417 {
 418     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 419     const struct hid_value_caps *caps, *end;
 420     NTSTATUS status;
 421
 422     TRACE( "report_type %d, report_id %u, preparsed_data %p, report_buf %p, report_len %lu.\n", report_type,
 423            report_id, preparsed_data, report_buf, report_len );
 424
 425     if (!report_len) return HIDP_STATUS_INVALID_REPORT_LENGTH;
 426
 427     status = get_value_caps_range( preparsed, report_type, report_len, &caps, &end );
 428     if (status != HIDP_STATUS_SUCCESS) return status;
 429
 430     while (caps != end && (caps->report_id != report_id || (!caps->usage_min && !caps->usage_max))) caps++;
 431     if (caps == end) return HIDP_STATUS_REPORT_DOES_NOT_EXIST;
 432
 433     memset( report_buf, 0, report_len );
 434     report_buf[0] = report_id;
 435     return HIDP_STATUS_SUCCESS;
 436 }
 437
 438 static NTSTATUS get_usage_list_length( const struct hid_value_caps *caps, void *data )
 439 {
 440     *(ULONG *)data += caps->report_count;
 441     return HIDP_STATUS_SUCCESS;
 442 }
 443
 444 ULONG WINAPI HidP_MaxUsageListLength( HIDP_REPORT_TYPE report_type, USAGE usage_page, PHIDP_PREPARSED_DATA preparsed_data )
 445 {
 446     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 447     struct caps_filter filter = {.buttons = TRUE, .usage_page = usage_page | USAGE_ANY, .usage = USAGE_ANY};
 448     USHORT limit = -1;
 449     ULONG count = 0;
 450
 451     TRACE( "report_type %d, usage_page %u, preparsed_data %p.\n", report_type, usage_page, preparsed_data );
 452
 453     enum_value_caps( preparsed, report_type, 0, &filter, get_usage_list_length, &count, &limit );
 454     return count;
 455 }
 456
 457 static NTSTATUS set_usage_value( const struct hid_value_caps *caps, void *user )
 458 {
 459     unsigned char *report_buf, start_bit = caps->start_bit;
 460     ULONG bit_count = caps->bit_size, bit_offset = 0;
 461     struct usage_value_params *params = user;
 462
 463     if (params->array) bit_count *= caps->report_count;
 464     else bit_offset = (params->usage - caps->usage_min) * caps->bit_size;
 465
 466     if ((bit_count + 7) / 8 > params->value_len) return HIDP_STATUS_BUFFER_TOO_SMALL;
 467
 468     report_buf = (unsigned char *)params->report_buf + caps->start_byte + bit_offset / 8;
 469     copy_bits( report_buf, params->value_buf, bit_count, start_bit + bit_offset % 8 );
 470
 471     return HIDP_STATUS_NULL;
 472 }
 473
 474 static NTSTATUS set_scaled_usage_value( const struct hid_value_caps *caps, void *user )
 475 {
 476     struct usage_value_params *params = user;
 477     LONG value, log_range, phy_range;
 478
 479     if (caps->logical_min > caps->logical_max) return HIDP_STATUS_BAD_LOG_PHY_VALUES;
 480     if (caps->physical_min > caps->physical_max) return HIDP_STATUS_BAD_LOG_PHY_VALUES;
 481
 482     if (sizeof(LONG) > params->value_len) return HIDP_STATUS_BUFFER_TOO_SMALL;
 483     value = *(LONG *)params->value_buf;
 484
 485     if (caps->physical_min || caps->physical_max)
 486     {
 487         /* testing shows that this is what the function does, including all
 488          * the overflows and rounding errors... */
 489         log_range = (caps->logical_max - caps->logical_min + 1) / 2;
 490         phy_range = (caps->physical_max - caps->physical_min + 1) / 2;
 491         value = value - caps->physical_min;
 492         value = (log_range * value) / phy_range;
 493         value = caps->logical_min + value;
 494     }
 495
 496     params->value_buf = &value;
 497     params->value_len = sizeof(value);
 498     return set_usage_value( caps, params );
 499 }
 500
 501 NTSTATUS WINAPI HidP_SetScaledUsageValue( HIDP_REPORT_TYPE report_type, USAGE usage_page, USHORT collection,
 502                                           USAGE usage, LONG value, PHIDP_PREPARSED_DATA preparsed_data,
 503                                           char *report_buf, ULONG report_len )
 504 {
 505     struct usage_value_params params = {.usage = usage, .value_buf = &value, .value_len = sizeof(value), .report_buf = report_buf};
 506     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 507     struct caps_filter filter = {.values = TRUE, .usage_page = usage_page, .collection = collection, .usage = usage };
 508     USHORT count = 1;
 509
 510     TRACE( "report_type %d, usage_page %u, collection %u, usage %u, value %ld, preparsed_data %p, report_buf %p, report_len %lu.\n",
 511            report_type, usage_page, collection, usage, value, preparsed_data, report_buf, report_len );
 512
 513     if (!report_len) return HIDP_STATUS_INVALID_REPORT_LENGTH;
 514
 515     filter.report_id = report_buf[0];
 516     return enum_value_caps( preparsed, report_type, report_len, &filter, set_scaled_usage_value, &params, &count );
 517 }
 518
 519 NTSTATUS WINAPI HidP_SetUsageValue( HIDP_REPORT_TYPE report_type, USAGE usage_page, USHORT collection, USAGE usage,
 520                                     ULONG value, PHIDP_PREPARSED_DATA preparsed_data, char *report_buf, ULONG report_len )
 521 {
 522     struct usage_value_params params = {.usage = usage, .value_buf = &value, .value_len = sizeof(value), .report_buf = report_buf};
 523     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 524     struct caps_filter filter = {.values = TRUE, .usage_page = usage_page, .collection = collection, .usage = usage};
 525     USHORT count = 1;
 526
 527     TRACE( "report_type %d, usage_page %u, collection %u, usage %u, value %lu, preparsed_data %p, report_buf %p, report_len %lu.\n",
 528            report_type, usage_page, collection, usage, value, preparsed_data, report_buf, report_len );
 529
 530     if (!report_len) return HIDP_STATUS_INVALID_REPORT_LENGTH;
 531
 532     filter.report_id = report_buf[0];
 533     return enum_value_caps( preparsed, report_type, report_len, &filter, set_usage_value, &params, &count );
 534 }
 535
 536 NTSTATUS WINAPI HidP_SetUsageValueArray( HIDP_REPORT_TYPE report_type, USAGE usage_page, USHORT collection,
 537                                          USAGE usage, char *value_buf, USHORT value_len,
 538                                          PHIDP_PREPARSED_DATA preparsed_data, char *report_buf, ULONG report_len )
 539 {
 540     struct usage_value_params params = {.array = TRUE, .usage = usage, .value_buf = value_buf, .value_len = value_len, .report_buf = report_buf};
 541     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 542     struct caps_filter filter = {.values = TRUE, .array = TRUE, .usage_page = usage_page, .collection = collection, .usage = usage};
 543     USHORT count = 1;
 544
 545     TRACE( "report_type %d, usage_page %u, collection %u, usage %u, value_buf %p, value_len %u, "
 546            "preparsed_data %p, report_buf %p, report_len %lu.\n",
 547            report_type, usage_page, collection, usage, value_buf, value_len, preparsed_data, report_buf, report_len );
 548
 549     if (!report_len) return HIDP_STATUS_INVALID_REPORT_LENGTH;
 550
 551     filter.report_id = report_buf[0];
 552     return enum_value_caps( preparsed, report_type, report_len, &filter, set_usage_value, &params, &count );
 553 }
 554
 555 struct set_usage_params
 556 {
 557     USAGE usage;
 558     char *report_buf;
 559 };
 560
 561 static NTSTATUS set_usage( const struct hid_value_caps *caps, void *user )
 562 {
 563     const struct hid_value_caps *end = caps;
 564     struct set_usage_params *params = user;
 565     ULONG index_min, bit, last;
 566     unsigned char *report_buf;
 567
 568     report_buf = (unsigned char *)params->report_buf + caps->start_byte;
 569
 570     if (HID_VALUE_CAPS_IS_ARRAY( caps ))
 571     {
 572         while (end->flags & HID_VALUE_CAPS_ARRAY_HAS_MORE) end++;
 573         index_min = end - caps + 1;
 574
 575         for (bit = caps->start_bit, last = bit + caps->report_count * caps->bit_size - 1; bit <= last; bit += 8)
 576         {
 577             if (report_buf[bit / 8]) continue;
 578             report_buf[bit / 8] = index_min + params->usage - caps->usage_min;
 579             break;
 580         }
 581
 582         if (bit > last) return HIDP_STATUS_BUFFER_TOO_SMALL;
 583         return HIDP_STATUS_NULL;
 584     }
 585
 586     bit = caps->start_bit + params->usage - caps->usage_min;
 587     report_buf[bit / 8] |= (1 << (bit % 8));
 588     return HIDP_STATUS_NULL;
 589 }
 590
 591 NTSTATUS WINAPI HidP_SetUsages( HIDP_REPORT_TYPE report_type, USAGE usage_page, USHORT collection, USAGE *usages,
 592                                 ULONG *usage_count, PHIDP_PREPARSED_DATA preparsed_data, char *report_buf, ULONG report_len )
 593 {
 594     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 595     struct set_usage_params params = {.report_buf = report_buf};
 596     struct caps_filter filter = {.buttons = TRUE, .usage_page = usage_page, .collection = collection, .usage = USAGE_ANY};
 597     NTSTATUS status;
 598     USHORT limit = 1;
 599     ULONG i, count = *usage_count;
 600
 601     TRACE( "report_type %d, usage_page %u, collection %u, usages %p, usage_count %p, preparsed_data %p, "
 602            "report_buf %p, report_len %lu.\n",
 603            report_type, usage_page, collection, usages, usage_count, preparsed_data, report_buf, report_len );
 604
 605     if (!report_len) return HIDP_STATUS_INVALID_REPORT_LENGTH;
 606
 607     filter.report_id = report_buf[0];
 608     for (i = 0; i < count; ++i)
 609     {
 610         params.usage = filter.usage = usages[i];
 611         status = enum_value_caps( preparsed, report_type, report_len, &filter, set_usage, &params, &limit );
 612         if (status != HIDP_STATUS_SUCCESS) return status;
 613     }
 614
 615     return HIDP_STATUS_SUCCESS;
 616 }
 617
 618 struct unset_usage_params
 619 {
 620     USAGE usage;
 621     char *report_buf;
 622     BOOL found;
 623 };
 624
 625 static NTSTATUS unset_usage( const struct hid_value_caps *caps, void *user )
 626 {
 627     ULONG index, index_min, index_max, bit, last;
 628     const struct hid_value_caps *end = caps;
 629     struct unset_usage_params *params = user;
 630     unsigned char *report_buf;
 631
 632     report_buf = (unsigned char *)params->report_buf + caps->start_byte;
 633
 634     if (HID_VALUE_CAPS_IS_ARRAY( caps ))
 635     {
 636         while (end->flags & HID_VALUE_CAPS_ARRAY_HAS_MORE) end++;
 637         index_min = end - caps + 1;
 638         index_max = index_min + caps->usage_max - caps->usage_min;
 639
 640         for (bit = caps->start_bit, last = bit + caps->report_count * caps->bit_size - 1; bit <= last; bit += 8)
 641         {
 642             if (!(index = report_buf[bit / 8]) || index < index_min || index > index_max) continue;
 643             report_buf[bit / 8] = 0;
 644             params->found = TRUE;
 645             break;
 646         }
 647
 648         return HIDP_STATUS_NULL;
 649     }
 650
 651     bit = caps->start_bit + params->usage - caps->usage_min;
 652     if (report_buf[bit / 8] & (1 << (bit % 8))) params->found = TRUE;
 653     report_buf[bit / 8] &= ~(1 << (bit % 8));
 654     return HIDP_STATUS_NULL;
 655 }
 656
 657 NTSTATUS WINAPI HidP_UnsetUsages( HIDP_REPORT_TYPE report_type, USAGE usage_page, USHORT collection, USAGE *usages,
 658                                   ULONG *usage_count, PHIDP_PREPARSED_DATA preparsed_data, char *report_buf, ULONG report_len )
 659 {
 660     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 661     struct unset_usage_params params = {.report_buf = report_buf, .found = FALSE};
 662     struct caps_filter filter = {.buttons = TRUE, .usage_page = usage_page, .collection = collection, .usage = USAGE_ANY};
 663     NTSTATUS status;
 664     USHORT limit = 1;
 665     ULONG i, count = *usage_count;
 666
 667     TRACE( "report_type %d, usage_page %u, collection %u, usages %p, usage_count %p, preparsed_data %p, "
 668            "report_buf %p, report_len %lu.\n",
 669            report_type, usage_page, collection, usages, usage_count, preparsed_data, report_buf, report_len );
 670
 671     if (!report_len) return HIDP_STATUS_INVALID_REPORT_LENGTH;
 672
 673     filter.report_id = report_buf[0];
 674     for (i = 0; i < count; ++i)
 675     {
 676         params.usage = filter.usage = usages[i];
 677         status = enum_value_caps( preparsed, report_type, report_len, &filter, unset_usage, &params, &limit );
 678         if (status != HIDP_STATUS_SUCCESS) return status;
 679     }
 680
 681     if (!params.found) return HIDP_STATUS_BUTTON_NOT_PRESSED;
 682     return HIDP_STATUS_SUCCESS;
 683 }
 684
 685 NTSTATUS WINAPI HidP_TranslateUsagesToI8042ScanCodes(USAGE *ChangedUsageList,
 686     ULONG UsageListLength, HIDP_KEYBOARD_DIRECTION KeyAction,
 687     HIDP_KEYBOARD_MODIFIER_STATE *ModifierState,
 688     PHIDP_INSERT_SCANCODES InsertCodesProcedure, VOID *InsertCodesContext)
 689 {
 690     FIXME( "ChangedUsageList %p, UsageListLength %lu, KeyAction %u, ModifierState %p, InsertCodesProcedure %p, InsertCodesContext %p stub!\n",
 691            ChangedUsageList, UsageListLength, KeyAction, ModifierState, InsertCodesProcedure, InsertCodesContext );
 692
 693     return STATUS_NOT_IMPLEMENTED;
 694 }
 695
 696 static NTSTATUS get_button_caps( const struct hid_value_caps *caps, void *user )
 697 {
 698     HIDP_BUTTON_CAPS **iter = user, *dst = *iter;
 699     dst->UsagePage = caps->usage_page;
 700     dst->ReportID = caps->report_id;
 701     dst->LinkCollection = caps->link_collection;
 702     dst->LinkUsagePage = caps->link_usage_page;
 703     dst->LinkUsage = caps->link_usage;
 704     dst->BitField = caps->bit_field;
 705     dst->IsAlias = FALSE;
 706     dst->IsAbsolute = (caps->flags & HID_VALUE_CAPS_IS_ABSOLUTE) ? 1 : 0;
 707     dst->IsRange = (caps->flags & HID_VALUE_CAPS_IS_RANGE) ? 1 : 0;
 708     if (!dst->IsRange)
 709     {
 710         dst->NotRange.Usage = caps->usage_min;
 711         dst->NotRange.DataIndex = caps->data_index_min;
 712     }
 713     else
 714     {
 715         dst->Range.UsageMin = caps->usage_min;
 716         dst->Range.UsageMax = caps->usage_max;
 717         dst->Range.DataIndexMin = caps->data_index_min;
 718         dst->Range.DataIndexMax = caps->data_index_max;
 719     }
 720     dst->IsStringRange = (caps->flags & HID_VALUE_CAPS_IS_STRING_RANGE) ? 1 : 0;
 721     if (!dst->IsStringRange)
 722         dst->NotRange.StringIndex = caps->string_min;
 723     else
 724     {
 725         dst->Range.StringMin = caps->string_min;
 726         dst->Range.StringMax = caps->string_max;
 727     }
 728     dst->IsDesignatorRange = (caps->flags & HID_VALUE_CAPS_IS_DESIGNATOR_RANGE) ? 1 : 0;
 729     if (!dst->IsDesignatorRange)
 730         dst->NotRange.DesignatorIndex = caps->designator_min;
 731     else
 732     {
 733         dst->Range.DesignatorMin = caps->designator_min;
 734         dst->Range.DesignatorMax = caps->designator_max;
 735     }
 736     *iter += 1;
 737     return HIDP_STATUS_SUCCESS;
 738 }
 739
 740 NTSTATUS WINAPI HidP_GetSpecificButtonCaps( HIDP_REPORT_TYPE report_type, USAGE usage_page, USHORT collection,
 741                                             USAGE usage, HIDP_BUTTON_CAPS *caps, USHORT *caps_count,
 742                                             PHIDP_PREPARSED_DATA preparsed_data )
 743 {
 744     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 745     const struct caps_filter filter = {.buttons = TRUE, .usage_page = usage_page | USAGE_ANY, .collection = collection, .usage = usage | USAGE_ANY};
 746
 747     TRACE( "report_type %d, usage_page %u, collection %u, usage %u, caps %p, caps_count %p, preparsed_data %p.\n",
 748            report_type, usage_page, collection, usage, caps, caps_count, preparsed_data );
 749
 750     return enum_value_caps( preparsed, report_type, 0, &filter, get_button_caps, &caps, caps_count );
 751 }
 752
 753 static NTSTATUS get_value_caps( const struct hid_value_caps *caps, void *user )
 754 {
 755     HIDP_VALUE_CAPS **iter = user, *dst = *iter;
 756     dst->UsagePage = caps->usage_page;
 757     dst->ReportID = caps->report_id;
 758     dst->LinkCollection = caps->link_collection;
 759     dst->LinkUsagePage = caps->link_usage_page;
 760     dst->LinkUsage = caps->link_usage;
 761     dst->BitField = caps->bit_field;
 762     dst->IsAlias = FALSE;
 763     dst->IsAbsolute = (caps->flags & HID_VALUE_CAPS_IS_ABSOLUTE) ? 1 : 0;
 764     dst->HasNull = HID_VALUE_CAPS_HAS_NULL( caps );
 765     dst->BitSize = caps->bit_size;
 766     dst->UnitsExp = caps->units_exp;
 767     dst->Units = caps->units;
 768     dst->LogicalMin = caps->logical_min;
 769     dst->LogicalMax = caps->logical_max;
 770     dst->PhysicalMin = caps->physical_min;
 771     dst->PhysicalMax = caps->physical_max;
 772     dst->IsRange = (caps->flags & HID_VALUE_CAPS_IS_RANGE) ? 1 : 0;
 773     if (!dst->IsRange)
 774     {
 775         dst->ReportCount = caps->report_count;
 776         dst->NotRange.Usage = caps->usage_min;
 777         dst->NotRange.DataIndex = caps->data_index_min;
 778     }
 779     else
 780     {
 781         dst->ReportCount = 1;
 782         dst->Range.UsageMin = caps->usage_min;
 783         dst->Range.UsageMax = caps->usage_max;
 784         dst->Range.DataIndexMin = caps->data_index_min;
 785         dst->Range.DataIndexMax = caps->data_index_max;
 786     }
 787     dst->IsStringRange = (caps->flags & HID_VALUE_CAPS_IS_STRING_RANGE) ? 1 : 0;
 788     if (!dst->IsStringRange)
 789         dst->NotRange.StringIndex = caps->string_min;
 790     else
 791     {
 792         dst->Range.StringMin = caps->string_min;
 793         dst->Range.StringMax = caps->string_max;
 794     }
 795     dst->IsDesignatorRange = (caps->flags & HID_VALUE_CAPS_IS_DESIGNATOR_RANGE) ? 1 : 0;
 796     if (!dst->IsDesignatorRange)
 797         dst->NotRange.DesignatorIndex = caps->designator_min;
 798     else
 799     {
 800         dst->Range.DesignatorMin = caps->designator_min;
 801         dst->Range.DesignatorMax = caps->designator_max;
 802     }
 803     *iter += 1;
 804     return HIDP_STATUS_SUCCESS;
 805 }
 806
 807 NTSTATUS WINAPI HidP_GetSpecificValueCaps( HIDP_REPORT_TYPE report_type, USAGE usage_page, USHORT collection,
 808                                            USAGE usage, HIDP_VALUE_CAPS *caps, USHORT *caps_count,
 809                                            PHIDP_PREPARSED_DATA preparsed_data )
 810 {
 811     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 812     const struct caps_filter filter = {.values = TRUE, .usage_page = usage_page | USAGE_ANY, .collection = collection, .usage = usage | USAGE_ANY};
 813
 814     TRACE( "report_type %d, usage_page %u, collection %u, usage %u, caps %p, caps_count %p, preparsed_data %p.\n",
 815            report_type, usage_page, collection, usage, caps, caps_count, preparsed_data );
 816
 817     return enum_value_caps( preparsed, report_type, 0, &filter, get_value_caps, &caps, caps_count );
 818 }
 819
 820 struct get_usage_and_page_params
 821 {
 822     USAGE_AND_PAGE *usages;
 823     USAGE_AND_PAGE *usages_end;
 824     char *report_buf;
 825 };
 826
 827 static NTSTATUS get_usage_and_page( const struct hid_value_caps *caps, void *user )
 828 {
 829     struct get_usage_and_page_params *params = user;
 830     const struct hid_value_caps *end = caps;
 831     ULONG index_min, index_max, bit, last;
 832     unsigned char *report_buf;
 833     BYTE index;
 834
 835     report_buf = (unsigned char *)params->report_buf + caps->start_byte;
 836
 837     if (HID_VALUE_CAPS_IS_ARRAY( caps ))
 838     {
 839         while (end->flags & HID_VALUE_CAPS_ARRAY_HAS_MORE) end++;
 840         index_min = end - caps + 1;
 841         index_max = index_min + caps->usage_max - caps->usage_min;
 842
 843         for (bit = caps->start_bit, last = bit + caps->report_count * caps->bit_size - 1; bit <= last; bit += 8)
 844         {
 845             if (!(index = report_buf[bit / 8]) || index < index_min || index > index_max) continue;
 846             if (params->usages < params->usages_end)
 847             {
 848                 params->usages->UsagePage = caps->usage_page;
 849                 params->usages->Usage = caps->usage_min + index - index_min;
 850             }
 851             params->usages++;
 852         }
 853         return HIDP_STATUS_SUCCESS;
 854     }
 855
 856     for (bit = caps->start_bit, last = bit + caps->usage_max - caps->usage_min; bit <= last; bit++)
 857     {
 858         if (!(report_buf[bit / 8] & (1 << (bit % 8)))) continue;
 859         if (params->usages < params->usages_end)
 860         {
 861             params->usages->UsagePage = caps->usage_page;
 862             params->usages->Usage = caps->usage_min + bit - caps->start_bit;
 863         }
 864         params->usages++;
 865     }
 866
 867     return HIDP_STATUS_SUCCESS;
 868 }
 869
 870 NTSTATUS WINAPI HidP_GetUsagesEx( HIDP_REPORT_TYPE report_type, USHORT collection, USAGE_AND_PAGE *usages,
 871                                   ULONG *usages_len, PHIDP_PREPARSED_DATA preparsed_data, char *report_buf, ULONG report_len )
 872 {
 873     struct get_usage_and_page_params params = {.usages = usages, .usages_end = usages + *usages_len, .report_buf = report_buf};
 874     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 875     struct caps_filter filter = {.buttons = TRUE, .usage_page = USAGE_ANY, .collection = collection, .usage = USAGE_ANY};
 876     NTSTATUS status;
 877     USHORT limit = -1;
 878
 879     TRACE( "report_type %d, collection %u, usages %p, usages_len %p, preparsed_data %p, report_buf %p, report_len %lu.\n",
 880            report_type, collection, usages, usages_len, preparsed_data, report_buf, report_len );
 881
 882     if (!report_len) return HIDP_STATUS_INVALID_REPORT_LENGTH;
 883
 884     filter.report_id = report_buf[0];
 885     status = enum_value_caps( preparsed, report_type, report_len, &filter, get_usage_and_page, &params, &limit );
 886     *usages_len = params.usages - usages;
 887     if (status != HIDP_STATUS_SUCCESS) return status;
 888
 889     if (params.usages > params.usages_end) return HIDP_STATUS_BUFFER_TOO_SMALL;
 890     return status;
 891 }
 892
 893 static NTSTATUS count_data( const struct hid_value_caps *caps, void *user )
 894 {
 895     BOOL is_button = caps->flags & HID_VALUE_CAPS_IS_BUTTON;
 896     BOOL is_range = caps->flags & HID_VALUE_CAPS_IS_RANGE;
 897     if (is_range || is_button) *(ULONG *)user += caps->report_count;
 898     else *(ULONG *)user += 1;
 899     return HIDP_STATUS_SUCCESS;
 900 }
 901
 902 ULONG WINAPI HidP_MaxDataListLength( HIDP_REPORT_TYPE report_type, PHIDP_PREPARSED_DATA preparsed_data )
 903 {
 904     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 905     struct caps_filter filter = {.usage_page = USAGE_ANY, .usage = USAGE_ANY};
 906     USHORT limit = -1;
 907     ULONG count = 0;
 908
 909     TRACE( "report_type %d, preparsed_data %p.\n", report_type, preparsed_data );
 910
 911     enum_value_caps( preparsed, report_type, 0, &filter, count_data, &count, &limit );
 912     return count;
 913 }
 914
 915 struct find_all_data_params
 916 {
 917     HIDP_DATA *data;
 918     HIDP_DATA *data_end;
 919     char *report_buf;
 920 };
 921
 922 static NTSTATUS find_all_data( const struct hid_value_caps *caps, void *user )
 923 {
 924     struct find_all_data_params *params = user;
 925     HIDP_DATA *data = params->data, *data_end = params->data_end;
 926     ULONG index_min, index_max, bit, last, bit_count;
 927     const struct hid_value_caps *end = caps;
 928     unsigned char *report_buf;
 929     BYTE index;
 930
 931     if (!caps->bit_size) return HIDP_STATUS_SUCCESS;
 932
 933     report_buf = (unsigned char *)params->report_buf + caps->start_byte;
 934
 935     if (HID_VALUE_CAPS_IS_ARRAY( caps ))
 936     {
 937         while (end->flags & HID_VALUE_CAPS_ARRAY_HAS_MORE) end++;
 938         index_min = end - caps + 1;
 939         index_max = index_min + caps->usage_max - caps->usage_min;
 940
 941         for (bit = caps->start_bit, last = bit + caps->report_count * caps->bit_size - 1; bit <= last; bit += 8)
 942         {
 943             if (!(index = report_buf[bit / 8]) || index < index_min || index > index_max) continue;
 944             if (data < data_end)
 945             {
 946                 data->DataIndex = caps->data_index_min + index - index_min;
 947                 data->On = 1;
 948             }
 949             data++;
 950         }
 951     }
 952     else if (caps->flags & HID_VALUE_CAPS_IS_BUTTON)
 953     {
 954         for (bit = caps->start_bit, last = bit + caps->usage_max - caps->usage_min; bit <= last; bit++)
 955         {
 956             if (!(report_buf[bit / 8] & (1 << (bit % 8)))) continue;
 957             if (data < data_end)
 958             {
 959                 data->DataIndex = caps->data_index_min + bit - caps->start_bit;
 960                 data->On = 1;
 961             }
 962             data++;
 963         }
 964     }
 965     else if (caps->report_count == 1)
 966     {
 967         if (data < data_end)
 968         {
 969             data->DataIndex = caps->data_index_min;
 970             data->RawValue = 0;
 971             bit_count = caps->bit_size * caps->report_count;
 972             if ((bit_count + 7) / 8 > sizeof(data->RawValue)) return HIDP_STATUS_BUFFER_TOO_SMALL;
 973             copy_bits( (void *)&data->RawValue, report_buf, bit_count, -caps->start_bit );
 974         }
 975         data++;
 976     }
 977
 978     params->data = data;
 979     return HIDP_STATUS_SUCCESS;
 980 }
 981
 982 NTSTATUS WINAPI HidP_GetData( HIDP_REPORT_TYPE report_type, HIDP_DATA *data, ULONG *data_len,
 983                               PHIDP_PREPARSED_DATA preparsed_data, char *report_buf, ULONG report_len )
 984 {
 985     struct find_all_data_params params = {.data = data, .data_end = data + *data_len, .report_buf = report_buf};
 986     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
 987     struct caps_filter filter = {.usage_page = USAGE_ANY, .usage = USAGE_ANY};
 988     NTSTATUS status;
 989     USHORT limit = -1;
 990
 991     TRACE( "report_type %d, data %p, data_len %p, preparsed_data %p, report_buf %p, report_len %lu.\n",
 992            report_type, data, data_len, preparsed_data, report_buf, report_len );
 993
 994     if (!report_len) return HIDP_STATUS_INVALID_REPORT_LENGTH;
 995
 996     filter.report_id = report_buf[0];
 997     status = enum_value_caps( preparsed, report_type, report_len, &filter, find_all_data, &params, &limit );
 998     *data_len = params.data - data;
 999     if (status != HIDP_STATUS_SUCCESS) return status;
1000
1001     if (params.data > params.data_end) return HIDP_STATUS_BUFFER_TOO_SMALL;
1002     return HIDP_STATUS_SUCCESS;
1003 }
1004
1005 NTSTATUS WINAPI HidP_GetLinkCollectionNodes( HIDP_LINK_COLLECTION_NODE *nodes, ULONG *nodes_len, PHIDP_PREPARSED_DATA preparsed_data )
1006 {
1007     struct hid_preparsed_data *preparsed = (struct hid_preparsed_data *)preparsed_data;
1008     struct hid_collection_node *collections = HID_COLLECTION_NODES( preparsed );
1009     ULONG i, count, capacity = *nodes_len;
1010
1011     TRACE( "nodes %p, nodes_len %p, preparsed_data %p.\n", nodes, nodes_len, preparsed_data );
1012
1013     if (!preparsed || memcmp( preparsed->magic, "HidP KDR", 8 )) return HIDP_STATUS_INVALID_PREPARSED_DATA;
1014
1015     count = *nodes_len = preparsed->number_link_collection_nodes;
1016     if (capacity < count) return HIDP_STATUS_BUFFER_TOO_SMALL;
1017
1018     for (i = 0; i < count; ++i)
1019     {
1020         nodes[i].LinkUsagePage = collections[i].usage_page;
1021         nodes[i].LinkUsage = collections[i].usage;
1022         nodes[i].Parent = collections[i].parent;
1023         nodes[i].CollectionType = collections[i].collection_type;
1024         nodes[i].FirstChild = collections[i].first_child;
1025         nodes[i].NextSibling = collections[i].next_sibling;
1026         nodes[i].NumberOfChildren = collections[i].number_of_children;
1027         nodes[i].IsAlias = 0;
1028     }
1029
1030     return HIDP_STATUS_SUCCESS;
1031 }