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 #include "config.h"
  22
  23 #include <stdarg.h>
  24
  25 #define NONAMELESSUNION
  26 #include "ntstatus.h"
  27 #define WIN32_NO_STATUS
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winternl.h"
  31 #include "winioctl.h"
  32 #include "ddk/wdm.h"
  33
  34 #include "hidusage.h"
  35 #include "ddk/hidpi.h"
  36 #include "parse.h"
  37 #include "wine/debug.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(hidp);
  40
  41 static NTSTATUS get_report_data(BYTE *report, INT reportLength, INT startBit, INT valueSize, PULONG value)
  42 {
  43
  44     if ((startBit + valueSize) / 8  > reportLength)
  45         return HIDP_STATUS_INVALID_REPORT_LENGTH;
  46
  47     if (valueSize == 1)
  48     {
  49         ULONG byte_index = startBit / 8;
  50         ULONG bit_index = startBit - (byte_index * 8);
  51         INT mask = (1 << bit_index);
  52         *value = !!(report[byte_index] & mask);
  53     }
  54     else
  55     {
  56         ULONG remaining_bits = valueSize;
  57         ULONG byte_index = startBit / 8;
  58         ULONG bit_index = startBit % 8;
  59         ULONG data = 0;
  60         ULONG shift = 0;
  61         while (remaining_bits)
  62         {
  63             ULONG copy_bits = 8 - bit_index;
  64             if (remaining_bits < copy_bits)
  65                 copy_bits = remaining_bits;
  66
  67             data |= ((report[byte_index] >> bit_index) & ((2 << copy_bits) - 1)) << shift;
  68
  69             shift += copy_bits;
  70             bit_index = 0;
  71             byte_index++;
  72             remaining_bits -= copy_bits;
  73         }
  74         *value = data;
  75     }
  76     return HIDP_STATUS_SUCCESS;
  77 }
  78
  79 static NTSTATUS set_report_data(BYTE *report, INT reportLength, INT startBit, INT valueSize, ULONG value)
  80 {
  81     if ((startBit + valueSize) / 8  > reportLength)
  82         return HIDP_STATUS_INVALID_REPORT_LENGTH;
  83
  84     if (valueSize == 1)
  85     {
  86         ULONG byte_index = startBit / 8;
  87         ULONG bit_index = startBit - (byte_index * 8);
  88         if (value)
  89             report[byte_index] |= (1 << bit_index);
  90         else
  91             report[byte_index] &= ~(1 << bit_index);
  92     }
  93     else
  94     {
  95         ULONG byte_index = (startBit + valueSize - 1) / 8;
  96         ULONG data = value;
  97         ULONG remainingBits = valueSize;
  98         while (remainingBits)
  99         {
 100             BYTE subvalue = data & 0xff;
 101
 102             data >>= 8;
 103
 104             if (remainingBits >= 8)
 105             {
 106                 report[byte_index] = subvalue;
 107                 byte_index --;
 108                 remainingBits -= 8;
 109             }
 110             else if (remainingBits > 0)
 111             {
 112                 BYTE mask = (0xff << (8-remainingBits)) & subvalue;
 113                 report[byte_index] |= mask;
 114                 remainingBits = 0;
 115             }
 116         }
 117     }
 118     return HIDP_STATUS_SUCCESS;
 119 }
 120
 121
 122 NTSTATUS WINAPI HidP_GetButtonCaps(HIDP_REPORT_TYPE ReportType, PHIDP_BUTTON_CAPS ButtonCaps,
 123                                    PUSHORT ButtonCapsLength, PHIDP_PREPARSED_DATA PreparsedData)
 124 {
 125     PWINE_HIDP_PREPARSED_DATA data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData;
 126     WINE_HID_ELEMENT *elems = HID_ELEMS(data);
 127     WINE_HID_REPORT *report = NULL;
 128     USHORT b_count = 0, r_count = 0;
 129     int i,j,u;
 130
 131     TRACE("(%i, %p, %p, %p)\n",ReportType, ButtonCaps, ButtonCapsLength, PreparsedData);
 132
 133     if (data->magic != HID_MAGIC)
 134         return HIDP_STATUS_INVALID_PREPARSED_DATA;
 135
 136     switch(ReportType)
 137     {
 138         case HidP_Input:
 139             b_count = data->caps.NumberInputButtonCaps;
 140             report = HID_INPUT_REPORTS(data);
 141             break;
 142         case HidP_Output:
 143             b_count = data->caps.NumberOutputButtonCaps;
 144             report = HID_OUTPUT_REPORTS(data);
 145             break;
 146         case HidP_Feature:
 147             b_count = data->caps.NumberFeatureButtonCaps;
 148             report = HID_FEATURE_REPORTS(data);
 149             break;
 150         default:
 151             return HIDP_STATUS_INVALID_REPORT_TYPE;
 152     }
 153     r_count = data->reportCount[ReportType];
 154
 155     if (!r_count || !b_count)
 156     {
 157         *ButtonCapsLength = 0;
 158         return HIDP_STATUS_SUCCESS;
 159     }
 160
 161     b_count = min(b_count, *ButtonCapsLength);
 162
 163     u = 0;
 164     for (j = 0; j < r_count && u < b_count; j++)
 165     {
 166         for (i = 0; i < report[j].elementCount && u < b_count; i++)
 167         {
 168             if (elems[report[j].elementIdx + i].ElementType == ButtonElement)
 169                 ButtonCaps[u++] = elems[report[j].elementIdx + i].caps.button;
 170         }
 171     }
 172
 173     *ButtonCapsLength = b_count;
 174     return HIDP_STATUS_SUCCESS;
 175 }
 176
 177
 178 NTSTATUS WINAPI HidP_GetCaps(PHIDP_PREPARSED_DATA PreparsedData,
 179     PHIDP_CAPS Capabilities)
 180 {
 181     PWINE_HIDP_PREPARSED_DATA data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData;
 182
 183     TRACE("(%p, %p)\n",PreparsedData, Capabilities);
 184
 185     if (data->magic != HID_MAGIC)
 186         return HIDP_STATUS_INVALID_PREPARSED_DATA;
 187
 188     *Capabilities = data->caps;
 189
 190     return HIDP_STATUS_SUCCESS;
 191 }
 192
 193 static NTSTATUS find_usage(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection,
 194                            USAGE Usage, PHIDP_PREPARSED_DATA PreparsedData, PCHAR Report,
 195                            WINE_ELEMENT_TYPE ElementType, WINE_HID_ELEMENT *element)
 196 {
 197     PWINE_HIDP_PREPARSED_DATA data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData;
 198     WINE_HID_ELEMENT *elems = HID_ELEMS(data);
 199     WINE_HID_REPORT *report = NULL;
 200     USHORT v_count = 0, r_count = 0;
 201     int i;
 202
 203     TRACE("(%i, %x, %i, %i, %p, %p)\n", ReportType, UsagePage, LinkCollection, Usage,
 204           PreparsedData, Report);
 205
 206     if (data->magic != HID_MAGIC)
 207         return HIDP_STATUS_INVALID_PREPARSED_DATA;
 208     switch(ReportType)
 209     {
 210         case HidP_Input:
 211             v_count = data->caps.NumberInputValueCaps;
 212             break;
 213         case HidP_Output:
 214             v_count = data->caps.NumberOutputValueCaps;
 215             break;
 216         case HidP_Feature:
 217             v_count = data->caps.NumberFeatureValueCaps;
 218             break;
 219         default:
 220             return HIDP_STATUS_INVALID_REPORT_TYPE;
 221     }
 222     r_count = data->reportCount[ReportType];
 223     report = &data->reports[data->reportIdx[ReportType][(BYTE)Report[0]]];
 224
 225     if (!r_count || !v_count)
 226         return HIDP_STATUS_USAGE_NOT_FOUND;
 227
 228     if (report->reportID && report->reportID != Report[0])
 229         return HIDP_STATUS_REPORT_DOES_NOT_EXIST;
 230
 231     for (i = 0; i < report->elementCount; i++)
 232     {
 233         HIDP_VALUE_CAPS *value = &elems[report->elementIdx + i].caps.value;
 234
 235         if (elems[report->elementIdx + i].ElementType != ElementType ||
 236             value->UsagePage != UsagePage)
 237             continue;
 238
 239         if (value->IsRange && value->u.Range.UsageMin <= Usage && Usage <= value->u.Range.UsageMax)
 240         {
 241             *element = elems[report->elementIdx + i];
 242             element->valueStartBit += value->BitSize * (Usage - value->u.Range.UsageMin);
 243             element->bitCount = elems[report->elementIdx + i].ElementType == ValueElement ? value->BitSize: 1;
 244             return HIDP_STATUS_SUCCESS;
 245         }
 246         else if (value->u.NotRange.Usage == Usage)
 247         {
 248             *element = elems[report->elementIdx + i];
 249             element->bitCount = elems[report->elementIdx + i].ElementType == ValueElement ? value->BitSize : 1;
 250             return HIDP_STATUS_SUCCESS;
 251         }
 252     }
 253
 254     return HIDP_STATUS_USAGE_NOT_FOUND;
 255 }
 256
 257 static LONG sign_extend(ULONG value, const WINE_HID_ELEMENT *element)
 258 {
 259     UINT bit_count = element->bitCount;
 260
 261     if ((value & (1 << (bit_count - 1)))
 262             && element->ElementType == ValueElement
 263             && element->caps.value.LogicalMin < 0)
 264     {
 265         value -= (1 << bit_count);
 266     }
 267     return value;
 268 }
 269
 270 static LONG logical_to_physical(LONG value, const WINE_HID_ELEMENT *element)
 271 {
 272     if (element->caps.value.PhysicalMin || element->caps.value.PhysicalMax)
 273     {
 274         value = (((ULONGLONG)(value - element->caps.value.LogicalMin)
 275                 * (element->caps.value.PhysicalMax - element->caps.value.PhysicalMin))
 276                 / (element->caps.value.LogicalMax - element->caps.value.LogicalMin))
 277                 + element->caps.value.PhysicalMin;
 278     }
 279     return value;
 280 }
 281
 282 NTSTATUS WINAPI HidP_GetScaledUsageValue(HIDP_REPORT_TYPE ReportType, USAGE UsagePage,
 283                                          USHORT LinkCollection, USAGE Usage, PLONG UsageValue,
 284                                          PHIDP_PREPARSED_DATA PreparsedData, PCHAR Report, ULONG ReportLength)
 285 {
 286     NTSTATUS rc;
 287     WINE_HID_ELEMENT element;
 288     TRACE("(%i, %x, %i, %i, %p, %p, %p, %i)\n", ReportType, UsagePage, LinkCollection, Usage, UsageValue,
 289           PreparsedData, Report, ReportLength);
 290
 291     rc = find_usage(ReportType, UsagePage, LinkCollection, Usage, PreparsedData, Report, ValueElement, &element);
 292
 293     if (rc == HIDP_STATUS_SUCCESS)
 294     {
 295         ULONG rawValue;
 296         rc = get_report_data((BYTE*)Report, ReportLength,
 297                              element.valueStartBit, element.bitCount, &rawValue);
 298         if (rc != HIDP_STATUS_SUCCESS)
 299             return rc;
 300         *UsageValue = logical_to_physical(sign_extend(rawValue, &element), &element);
 301     }
 302
 303     return rc;
 304 }
 305
 306
 307 NTSTATUS WINAPI HidP_GetUsageValue(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection,
 308                                    USAGE Usage, PULONG UsageValue, PHIDP_PREPARSED_DATA PreparsedData,
 309                                    PCHAR Report, ULONG ReportLength)
 310 {
 311     WINE_HID_ELEMENT element;
 312     NTSTATUS rc;
 313
 314     TRACE("(%i, %x, %i, %i, %p, %p, %p, %i)\n", ReportType, UsagePage, LinkCollection, Usage, UsageValue,
 315           PreparsedData, Report, ReportLength);
 316
 317     rc = find_usage(ReportType, UsagePage, LinkCollection, Usage, PreparsedData, Report, ValueElement, &element);
 318
 319     if (rc == HIDP_STATUS_SUCCESS)
 320     {
 321         return get_report_data((BYTE*)Report, ReportLength,
 322                                element.valueStartBit, element.bitCount, UsageValue);
 323     }
 324
 325     return rc;
 326 }
 327
 328
 329 NTSTATUS WINAPI HidP_GetUsages(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection,
 330                                PUSAGE UsageList, PULONG UsageLength, PHIDP_PREPARSED_DATA PreparsedData,
 331                                PCHAR Report, ULONG ReportLength)
 332 {
 333     PWINE_HIDP_PREPARSED_DATA data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData;
 334     WINE_HID_ELEMENT *elems = HID_ELEMS(data);
 335     WINE_HID_REPORT *report = NULL;
 336     BOOL found = FALSE;
 337     USHORT b_count = 0, r_count = 0;
 338     int i,uCount;
 339
 340     TRACE("(%i, %x, %i, %p, %p, %p, %p, %i)\n", ReportType, UsagePage, LinkCollection, UsageList,
 341           UsageLength, PreparsedData, Report, ReportLength);
 342
 343     if (data->magic != HID_MAGIC)
 344     {
 345         *UsageLength = 0;
 346         return HIDP_STATUS_INVALID_PREPARSED_DATA;
 347     }
 348
 349     switch(ReportType)
 350     {
 351         case HidP_Input:
 352             b_count = data->caps.NumberInputButtonCaps;
 353             break;
 354         case HidP_Output:
 355             b_count = data->caps.NumberOutputButtonCaps;
 356             break;
 357         case HidP_Feature:
 358             b_count = data->caps.NumberFeatureButtonCaps;
 359             break;
 360         default:
 361             return HIDP_STATUS_INVALID_REPORT_TYPE;
 362     }
 363     r_count = data->reportCount[ReportType];
 364     report = &data->reports[data->reportIdx[ReportType][(BYTE)Report[0]]];
 365
 366     if (!r_count || !b_count)
 367         return HIDP_STATUS_USAGE_NOT_FOUND;
 368
 369     if (report->reportID && report->reportID != Report[0])
 370         return HIDP_STATUS_REPORT_DOES_NOT_EXIST;
 371
 372     uCount = 0;
 373     for (i = 0; i < report->elementCount && uCount < *UsageLength; i++)
 374     {
 375         if (elems[report->elementIdx + i].ElementType == ButtonElement &&
 376             elems[report->elementIdx + i].caps.button.UsagePage == UsagePage)
 377         {
 378             int k;
 379             WINE_HID_ELEMENT *element = &elems[report->elementIdx + i];
 380             for (k=0; k < element->bitCount; k++)
 381             {
 382                 UINT v = 0;
 383                 NTSTATUS rc = get_report_data((BYTE*)Report, ReportLength,
 384                                 element->valueStartBit + k, 1, &v);
 385                 if (rc != HIDP_STATUS_SUCCESS)
 386                     return rc;
 387                 found = TRUE;
 388                 if (v)
 389                 {
 390                     if (uCount == *UsageLength)
 391                         return HIDP_STATUS_BUFFER_TOO_SMALL;
 392                     UsageList[uCount] = element->caps.button.u.Range.UsageMin + k;
 393                     uCount++;
 394                 }
 395             }
 396         }
 397     }
 398
 399     *UsageLength = uCount;
 400
 401     if (!found)
 402         return HIDP_STATUS_USAGE_NOT_FOUND;
 403
 404     return HIDP_STATUS_SUCCESS;
 405 }
 406
 407
 408 NTSTATUS WINAPI HidP_GetValueCaps(HIDP_REPORT_TYPE ReportType, PHIDP_VALUE_CAPS ValueCaps,
 409                                   PUSHORT ValueCapsLength, PHIDP_PREPARSED_DATA PreparsedData)
 410 {
 411     PWINE_HIDP_PREPARSED_DATA data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData;
 412     WINE_HID_ELEMENT *elems = HID_ELEMS(data);
 413     WINE_HID_REPORT *report = NULL;
 414     USHORT v_count = 0, r_count = 0;
 415     int i,j,u;
 416
 417     TRACE("(%i, %p, %p, %p)\n", ReportType, ValueCaps, ValueCapsLength, PreparsedData);
 418
 419     if (data->magic != HID_MAGIC)
 420         return HIDP_STATUS_INVALID_PREPARSED_DATA;
 421
 422     switch(ReportType)
 423     {
 424         case HidP_Input:
 425             v_count = data->caps.NumberInputValueCaps;
 426             report = HID_INPUT_REPORTS(data);
 427             break;
 428         case HidP_Output:
 429             v_count = data->caps.NumberOutputValueCaps;
 430             report = HID_OUTPUT_REPORTS(data);
 431             break;
 432         case HidP_Feature:
 433             v_count = data->caps.NumberFeatureValueCaps;
 434             report = HID_FEATURE_REPORTS(data);
 435             break;
 436         default:
 437             return HIDP_STATUS_INVALID_REPORT_TYPE;
 438     }
 439     r_count = data->reportCount[ReportType];
 440
 441     if (!r_count || !v_count)
 442     {
 443         *ValueCapsLength = 0;
 444         return HIDP_STATUS_SUCCESS;
 445     }
 446
 447     v_count = min(v_count, *ValueCapsLength);
 448
 449     u = 0;
 450     for (j = 0; j < r_count && u < v_count; j++)
 451     {
 452         for (i = 0; i < report[j].elementCount && u < v_count; i++)
 453         {
 454             if (elems[report->elementIdx + i].ElementType == ValueElement)
 455                 ValueCaps[u++] = elems[report->elementIdx + i].caps.value;
 456         }
 457     }
 458
 459     *ValueCapsLength = v_count;
 460     return HIDP_STATUS_SUCCESS;
 461 }
 462
 463 NTSTATUS WINAPI HidP_InitializeReportForID(HIDP_REPORT_TYPE ReportType, UCHAR ReportID,
 464                                            PHIDP_PREPARSED_DATA PreparsedData, PCHAR Report,
 465                                            ULONG ReportLength)
 466 {
 467     int size;
 468     PWINE_HIDP_PREPARSED_DATA data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData;
 469     WINE_HID_REPORT *report = NULL;
 470     int r_count;
 471
 472     TRACE("(%i, %i, %p, %p, %i)\n",ReportType, ReportID, PreparsedData, Report, ReportLength);
 473
 474     if (data->magic != HID_MAGIC)
 475         return HIDP_STATUS_INVALID_PREPARSED_DATA;
 476
 477     switch(ReportType)
 478     {
 479         case HidP_Input:
 480             size = data->caps.InputReportByteLength;
 481             break;
 482         case HidP_Output:
 483             size = data->caps.OutputReportByteLength;
 484             break;
 485         case HidP_Feature:
 486             size = data->caps.FeatureReportByteLength;
 487             break;
 488         default:
 489             return HIDP_STATUS_INVALID_REPORT_TYPE;
 490     }
 491     r_count = data->reportCount[ReportType];
 492     report = &data->reports[data->reportIdx[ReportType][(BYTE)Report[0]]];
 493
 494     if (!r_count || !size)
 495         return HIDP_STATUS_REPORT_DOES_NOT_EXIST;
 496
 497     if (size != ReportLength)
 498         return HIDP_STATUS_INVALID_REPORT_LENGTH;
 499
 500     if (report->reportID && report->reportID != Report[0])
 501         return HIDP_STATUS_REPORT_DOES_NOT_EXIST;
 502
 503     ZeroMemory(Report, size);
 504     Report[0] = ReportID;
 505     return HIDP_STATUS_SUCCESS;
 506 }
 507
 508 ULONG WINAPI HidP_MaxUsageListLength(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, PHIDP_PREPARSED_DATA PreparsedData)
 509 {
 510     PWINE_HIDP_PREPARSED_DATA data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData;
 511     WINE_HID_ELEMENT *elems = HID_ELEMS(data);
 512     WINE_HID_REPORT *report = NULL;
 513     int r_count;
 514     int i;
 515     int count = 0;
 516
 517     TRACE("(%i, %x, %p)\n", ReportType, UsagePage, PreparsedData);
 518
 519     if (data->magic != HID_MAGIC)
 520         return 0;
 521
 522     switch(ReportType)
 523     {
 524         case HidP_Input:
 525             report = HID_INPUT_REPORTS(data);
 526             break;
 527         case HidP_Output:
 528             report = HID_OUTPUT_REPORTS(data);
 529             break;
 530         case HidP_Feature:
 531             report = HID_FEATURE_REPORTS(data);
 532             break;
 533         default:
 534             return HIDP_STATUS_INVALID_REPORT_TYPE;
 535     }
 536     r_count = data->reportCount[ReportType];
 537
 538
 539     if (!r_count)
 540         return 0;
 541
 542     for (i = 0; i < r_count; i++)
 543     {
 544         int j;
 545         for (j = 0; j < report[i].elementCount; j++)
 546         {
 547             if (elems[report[i].elementIdx + j].ElementType == ButtonElement &&
 548                (UsagePage == 0 || elems[report[i].elementIdx + j].caps.button.UsagePage == UsagePage))
 549             {
 550                 if (elems[report[i].elementIdx + j].caps.button.IsRange)
 551                     count += (elems[report[i].elementIdx + j].caps.button.u.Range.UsageMax -
 552                              elems[report[i].elementIdx + j].caps.button.u.Range.UsageMin) + 1;
 553                 else
 554                     count++;
 555             }
 556         }
 557     }
 558     return count;
 559 }
 560
 561 NTSTATUS WINAPI HidP_SetUsageValue(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection,
 562                                    USAGE Usage, ULONG UsageValue, PHIDP_PREPARSED_DATA PreparsedData,
 563                                    CHAR *Report, ULONG ReportLength)
 564 {
 565     WINE_HID_ELEMENT element;
 566     NTSTATUS rc;
 567
 568     TRACE("(%i, %x, %i, %i, %i, %p, %p, %i)\n", ReportType, UsagePage, LinkCollection, Usage, UsageValue,
 569           PreparsedData, Report, ReportLength);
 570
 571     rc = find_usage(ReportType, UsagePage, LinkCollection, Usage, PreparsedData, Report, ValueElement, &element);
 572
 573     if (rc == HIDP_STATUS_SUCCESS)
 574     {
 575         return set_report_data((BYTE*)Report, ReportLength,
 576                                element.valueStartBit, element.bitCount, UsageValue);
 577     }
 578
 579     return rc;
 580 }
 581
 582
 583 NTSTATUS WINAPI HidP_SetUsages(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection,
 584                                PUSAGE UsageList, PULONG UsageLength, PHIDP_PREPARSED_DATA PreparsedData,
 585                                PCHAR Report, ULONG ReportLength)
 586 {
 587     WINE_HID_ELEMENT element;
 588     NTSTATUS rc;
 589     ULONG i;
 590
 591     TRACE("(%i, %x, %i, %p, %p, %p, %p, %i)\n", ReportType, UsagePage, LinkCollection, UsageList,
 592             UsageLength, PreparsedData, Report, ReportLength);
 593
 594     for (i = 0; i < *UsageLength; i++)
 595     {
 596         rc = find_usage(ReportType, UsagePage, LinkCollection,
 597                 UsageList[i], PreparsedData, Report, ButtonElement, &element);
 598         if (rc == HIDP_STATUS_SUCCESS)
 599         {
 600             rc = set_report_data((BYTE*)Report, ReportLength,
 601                     element.valueStartBit, element.bitCount, -1);
 602         }
 603
 604         if (rc != HIDP_STATUS_SUCCESS)
 605         {
 606             *UsageLength = i;
 607             return rc;
 608         }
 609     }
 610
 611     return HIDP_STATUS_SUCCESS;
 612 }
 613
 614
 615 NTSTATUS WINAPI HidP_TranslateUsagesToI8042ScanCodes(USAGE *ChangedUsageList,
 616     ULONG UsageListLength, HIDP_KEYBOARD_DIRECTION KeyAction,
 617     HIDP_KEYBOARD_MODIFIER_STATE *ModifierState,
 618     PHIDP_INSERT_SCANCODES InsertCodesProcedure, VOID *InsertCodesContext)
 619 {
 620     FIXME("stub: %p, %i, %i, %p, %p, %p\n", ChangedUsageList, UsageListLength,
 621         KeyAction, ModifierState, InsertCodesProcedure, InsertCodesContext);
 622
 623     return STATUS_NOT_IMPLEMENTED;
 624 }
 625
 626 NTSTATUS WINAPI HidP_GetSpecificButtonCaps(HIDP_REPORT_TYPE ReportType,
 627     USAGE UsagePage, USHORT LinkCollection, USAGE Usage,
 628     HIDP_BUTTON_CAPS *ButtonCaps, USHORT *ButtonCapsLength, PHIDP_PREPARSED_DATA PreparsedData)
 629 {
 630     WINE_HIDP_PREPARSED_DATA *data = (WINE_HIDP_PREPARSED_DATA*)PreparsedData;
 631     WINE_HID_ELEMENT *elems = HID_ELEMS(data);
 632     WINE_HID_REPORT *report = NULL;
 633     USHORT b_count = 0, r_count = 0;
 634     int i,j,u;
 635
 636     TRACE("(%i, 0x%x, %i, 0x%x, %p %p %p)\n", ReportType, UsagePage, LinkCollection,
 637         Usage, ButtonCaps, ButtonCapsLength, PreparsedData);
 638
 639     if (data->magic != HID_MAGIC)
 640         return HIDP_STATUS_INVALID_PREPARSED_DATA;
 641
 642     switch(ReportType)
 643     {
 644         case HidP_Input:
 645             b_count = data->caps.NumberInputButtonCaps;
 646             report = HID_INPUT_REPORTS(data);
 647             break;
 648         case HidP_Output:
 649             b_count = data->caps.NumberOutputButtonCaps;
 650             report = HID_OUTPUT_REPORTS(data);
 651             break;
 652         case HidP_Feature:
 653             b_count = data->caps.NumberFeatureButtonCaps;
 654             report = HID_FEATURE_REPORTS(data);
 655             break;
 656         default:
 657             return HIDP_STATUS_INVALID_REPORT_TYPE;
 658     }
 659     r_count = data->reportCount[ReportType];
 660
 661     if (!r_count || !b_count)
 662     {
 663         *ButtonCapsLength = 0;
 664         return HIDP_STATUS_SUCCESS;
 665     }
 666
 667     b_count = min(b_count, *ButtonCapsLength);
 668
 669     u = 0;
 670     for (j = 0; j < r_count && u < b_count; j++)
 671     {
 672         for (i = 0; i < report[j].elementCount && u < b_count; i++)
 673         {
 674             if (elems[report[j].elementIdx + i].ElementType == ButtonElement &&
 675                 (UsagePage == 0 || UsagePage == elems[report[j].elementIdx + i].caps.button.UsagePage) &&
 676                 (LinkCollection == 0 || LinkCollection == elems[report[j].elementIdx + i].caps.button.LinkCollection) &&
 677                 (Usage == 0 || (
 678                   (!elems[report[j].elementIdx + i].caps.button.IsRange &&
 679                     Usage == elems[report[j].elementIdx + i].caps.button.u.NotRange.Usage)) ||
 680                   (elems[report[j].elementIdx + i].caps.button.IsRange &&
 681                     Usage >= elems[report[j].elementIdx + i].caps.button.u.Range.UsageMin &&
 682                     Usage <= elems[report[j].elementIdx + i].caps.button.u.Range.UsageMax)))
 683             {
 684                 ButtonCaps[u++] = elems[report[j].elementIdx + i].caps.button;
 685             }
 686         }
 687     }
 688     TRACE("Matched %i usages\n", u);
 689
 690     *ButtonCapsLength = u;
 691
 692     return HIDP_STATUS_SUCCESS;
 693 }
 694
 695
 696 NTSTATUS WINAPI HidP_GetSpecificValueCaps(HIDP_REPORT_TYPE ReportType,
 697     USAGE UsagePage, USHORT LinkCollection, USAGE Usage,
 698     HIDP_VALUE_CAPS *ValueCaps, USHORT *ValueCapsLength, PHIDP_PREPARSED_DATA PreparsedData)
 699 {
 700     WINE_HIDP_PREPARSED_DATA *data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData;
 701     WINE_HID_ELEMENT *elems = HID_ELEMS(data);
 702     WINE_HID_REPORT *report = NULL;
 703     USHORT v_count = 0, r_count = 0;
 704     int i,j,u;
 705
 706     TRACE("(%i, 0x%x, %i, 0x%x, %p %p %p)\n", ReportType, UsagePage, LinkCollection,
 707         Usage, ValueCaps, ValueCapsLength, PreparsedData);
 708
 709     if (data->magic != HID_MAGIC)
 710         return HIDP_STATUS_INVALID_PREPARSED_DATA;
 711
 712     switch(ReportType)
 713     {
 714         case HidP_Input:
 715             v_count = data->caps.NumberInputValueCaps;
 716             report = HID_INPUT_REPORTS(data);
 717             break;
 718         case HidP_Output:
 719             v_count = data->caps.NumberOutputValueCaps;
 720             report = HID_OUTPUT_REPORTS(data);
 721             break;
 722         case HidP_Feature:
 723             v_count = data->caps.NumberFeatureValueCaps;
 724             report = HID_FEATURE_REPORTS(data);
 725             break;
 726         default:
 727             return HIDP_STATUS_INVALID_REPORT_TYPE;
 728     }
 729     r_count = data->reportCount[ReportType];
 730
 731     if (!r_count || !v_count)
 732     {
 733         *ValueCapsLength = 0;
 734         return HIDP_STATUS_SUCCESS;
 735     }
 736
 737     v_count = min(v_count, *ValueCapsLength);
 738
 739     u = 0;
 740     for (j = 0; j < r_count && u < v_count; j++)
 741     {
 742         for (i = 0; i < report[j].elementCount && u < v_count; i++)
 743         {
 744             if (elems[report[j].elementIdx + i].ElementType == ValueElement &&
 745                 (UsagePage == 0 || UsagePage == elems[report[j].elementIdx + i].caps.value.UsagePage) &&
 746                 (LinkCollection == 0 || LinkCollection == elems[report[j].elementIdx + i].caps.value.LinkCollection) &&
 747                 (Usage == 0 || Usage == elems[report[j].elementIdx + i].caps.value.u.NotRange.Usage))
 748             {
 749                 ValueCaps[u++] = elems[report[j].elementIdx + i].caps.value;
 750             }
 751         }
 752     }
 753     TRACE("Matched %i usages\n", u);
 754
 755     *ValueCapsLength = u;
 756
 757     return HIDP_STATUS_SUCCESS;
 758 }
 759
 760 NTSTATUS WINAPI HidP_GetUsagesEx(HIDP_REPORT_TYPE ReportType, USHORT LinkCollection, USAGE_AND_PAGE *ButtonList,
 761     ULONG *UsageLength, PHIDP_PREPARSED_DATA PreparsedData, CHAR *Report, ULONG ReportLength)
 762 {
 763     WINE_HIDP_PREPARSED_DATA *data = (WINE_HIDP_PREPARSED_DATA*)PreparsedData;
 764     WINE_HID_ELEMENT *elems = HID_ELEMS(data);
 765     WINE_HID_REPORT *report = NULL;
 766     USHORT b_count = 0, r_count = 0;
 767     int i,uCount = 0;
 768     NTSTATUS rc;
 769
 770     TRACE("(%i, %i, %p, %p(%i), %p, %p, %i)\n", ReportType, LinkCollection, ButtonList,
 771         UsageLength, *UsageLength, PreparsedData, Report, ReportLength);
 772
 773     if (data->magic != HID_MAGIC)
 774         return HIDP_STATUS_INVALID_PREPARSED_DATA;
 775
 776     switch(ReportType)
 777     {
 778         case HidP_Input:
 779             b_count = data->caps.NumberInputButtonCaps;
 780             break;
 781         case HidP_Output:
 782             b_count = data->caps.NumberOutputButtonCaps;
 783             break;
 784         case HidP_Feature:
 785             b_count = data->caps.NumberFeatureButtonCaps;
 786             break;
 787         default:
 788             return HIDP_STATUS_INVALID_REPORT_TYPE;
 789     }
 790     r_count = data->reportCount[ReportType];
 791     report = &data->reports[data->reportIdx[ReportType][(BYTE)Report[0]]];
 792
 793     if (!r_count || !b_count)
 794         return HIDP_STATUS_USAGE_NOT_FOUND;
 795
 796     if (report->reportID && report->reportID != Report[0])
 797         return HIDP_STATUS_REPORT_DOES_NOT_EXIST;
 798
 799     for (i = 0; i < report->elementCount; i++)
 800     {
 801         if (elems[report->elementIdx + i].ElementType == ButtonElement)
 802         {
 803             int k;
 804             WINE_HID_ELEMENT *element = &elems[report->elementIdx + i];
 805             for (k=0; k < element->bitCount; k++)
 806             {
 807                 UINT v = 0;
 808                 NTSTATUS rc = get_report_data((BYTE*)Report, ReportLength,
 809                                 element->valueStartBit + k, 1, &v);
 810                 if (rc != HIDP_STATUS_SUCCESS)
 811                     return rc;
 812                 if (v)
 813                 {
 814                     if (uCount < *UsageLength)
 815                     {
 816                         ButtonList[uCount].Usage = element->caps.button.u.Range.UsageMin + k;
 817                         ButtonList[uCount].UsagePage = element->caps.button.UsagePage;
 818                     }
 819                     uCount++;
 820                 }
 821             }
 822         }
 823     }
 824
 825     TRACE("Returning %i usages\n", uCount);
 826
 827     if (*UsageLength < uCount)
 828         rc = HIDP_STATUS_BUFFER_TOO_SMALL;
 829     else
 830         rc = HIDP_STATUS_SUCCESS;
 831
 832     *UsageLength = uCount;
 833
 834     return rc;
 835 }
 836
 837 ULONG WINAPI HidP_MaxDataListLength(HIDP_REPORT_TYPE ReportType, PHIDP_PREPARSED_DATA PreparsedData)
 838 {
 839     WINE_HIDP_PREPARSED_DATA *data = (WINE_HIDP_PREPARSED_DATA *)PreparsedData;
 840     TRACE("(%i, %p)\n", ReportType, PreparsedData);
 841     if (data->magic != HID_MAGIC)
 842         return 0;
 843
 844     switch(ReportType)
 845     {
 846         case HidP_Input:
 847             return data->caps.NumberInputDataIndices;
 848         case HidP_Output:
 849             return data->caps.NumberOutputDataIndices;
 850         case HidP_Feature:
 851             return data->caps.NumberFeatureDataIndices;
 852         default:
 853             return 0;
 854     }
 855 }
 856
 857 NTSTATUS WINAPI HidP_GetData(HIDP_REPORT_TYPE ReportType, HIDP_DATA *DataList, ULONG *DataLength,
 858     PHIDP_PREPARSED_DATA PreparsedData,CHAR *Report, ULONG ReportLength)
 859 {
 860     WINE_HIDP_PREPARSED_DATA *data = (WINE_HIDP_PREPARSED_DATA*)PreparsedData;
 861     WINE_HID_ELEMENT *elems = HID_ELEMS(data);
 862     WINE_HID_REPORT *report = NULL;
 863     USHORT r_count = 0;
 864     int i,uCount = 0;
 865     NTSTATUS rc;
 866
 867     TRACE("(%i, %p, %p(%i), %p, %p, %i)\n", ReportType, DataList, DataLength,
 868     DataLength?*DataLength:0, PreparsedData, Report, ReportLength);
 869
 870     if (data->magic != HID_MAGIC)
 871         return 0;
 872
 873     if (ReportType != HidP_Input && ReportType != HidP_Output && ReportType != HidP_Feature)
 874         return HIDP_STATUS_INVALID_REPORT_TYPE;
 875
 876     r_count = data->reportCount[ReportType];
 877     report = &data->reports[data->reportIdx[ReportType][(BYTE)Report[0]]];
 878
 879     if (!r_count || (report->reportID && report->reportID != Report[0]))
 880         return HIDP_STATUS_REPORT_DOES_NOT_EXIST;
 881
 882     for (i = 0; i < report->elementCount; i++)
 883     {
 884         WINE_HID_ELEMENT *element = &elems[report->elementIdx + i];
 885         if (element->ElementType == ButtonElement)
 886         {
 887             int k;
 888             for (k=0; k < element->bitCount; k++)
 889             {
 890                 UINT v = 0;
 891                 NTSTATUS rc = get_report_data((BYTE*)Report, ReportLength,
 892                                 element->valueStartBit + k, 1, &v);
 893                 if (rc != HIDP_STATUS_SUCCESS)
 894                     return rc;
 895                 if (v)
 896                 {
 897                     if (uCount < *DataLength)
 898                     {
 899                         DataList[uCount].DataIndex = element->caps.button.u.Range.DataIndexMin + k;
 900                         DataList[uCount].u.On = v;
 901                     }
 902                     uCount++;
 903                 }
 904             }
 905         }
 906         else
 907         {
 908             if (uCount < *DataLength)
 909             {
 910                 UINT v;
 911                 NTSTATUS rc = get_report_data((BYTE*)Report, ReportLength,
 912                                      element->valueStartBit, element->bitCount, &v);
 913                 if (rc != HIDP_STATUS_SUCCESS)
 914                     return rc;
 915                 DataList[uCount].DataIndex = element->caps.value.u.NotRange.DataIndex;
 916                 DataList[uCount].u.RawValue = v;
 917             }
 918             uCount++;
 919         }
 920     }
 921
 922     if (*DataLength < uCount)
 923         rc = HIDP_STATUS_BUFFER_TOO_SMALL;
 924     else
 925         rc = HIDP_STATUS_SUCCESS;
 926
 927     *DataLength = uCount;
 928
 929     return rc;
 930 }