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