| /* |
| * Human Input Devices |
| * |
| * Copyright (C) 2015 Aric Stewart |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include "config.h" |
| |
| #include <stdarg.h> |
| |
| #define NONAMELESSUNION |
| #include "ntstatus.h" |
| #define WIN32_NO_STATUS |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winternl.h" |
| #include "winioctl.h" |
| #include "ddk/wdm.h" |
| |
| #include "hidusage.h" |
| #include "ddk/hidpi.h" |
| #include "parse.h" |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(hidp); |
| |
| static NTSTATUS get_report_data(BYTE *report, INT reportLength, INT startBit, INT valueSize, PULONG value) |
| { |
| |
| if ((startBit + valueSize) / 8 > reportLength) |
| return HIDP_STATUS_INVALID_REPORT_LENGTH; |
| |
| if (valueSize == 1) |
| { |
| ULONG byte_index = startBit / 8; |
| ULONG bit_index = startBit - (byte_index * 8); |
| INT mask = (1 << bit_index); |
| *value = (report[byte_index] & mask); |
| } |
| else |
| { |
| ULONG byte_index = startBit / 8; |
| ULONG data = 0; |
| ULONG remainingBits = valueSize; |
| ULONG shift = 0; |
| ULONG begin_offset = startBit % 8; |
| while (remainingBits) |
| { |
| if (remainingBits >= 8) |
| { |
| BYTE mask = 0xff << begin_offset; |
| data |= (report[byte_index] & mask) << shift; |
| byte_index ++; |
| remainingBits -= (8-begin_offset); |
| shift += (8-begin_offset); |
| begin_offset = 0; |
| } |
| else if (remainingBits > 0) |
| { |
| BYTE mask = (0xff >> (8-remainingBits)) << begin_offset; |
| data |= (report[byte_index] & mask) << shift; |
| remainingBits = 0; |
| } |
| } |
| *value = data; |
| } |
| return HIDP_STATUS_SUCCESS; |
| } |
| |
| NTSTATUS WINAPI HidP_GetButtonCaps(HIDP_REPORT_TYPE ReportType, PHIDP_BUTTON_CAPS ButtonCaps, |
| PUSHORT ButtonCapsLength, PHIDP_PREPARSED_DATA PreparsedData) |
| { |
| PWINE_HIDP_PREPARSED_DATA data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData; |
| WINE_HID_REPORT *report = NULL; |
| USHORT b_count = 0, r_count = 0; |
| int i,j,u; |
| |
| TRACE("(%i, %p, %p, %p)\n",ReportType, ButtonCaps, ButtonCapsLength, PreparsedData); |
| |
| if (data->magic != HID_MAGIC) |
| return HIDP_STATUS_INVALID_PREPARSED_DATA; |
| |
| switch(ReportType) |
| { |
| case HidP_Input: |
| b_count = data->caps.NumberInputButtonCaps; |
| r_count = data->dwInputReportCount; |
| report = HID_INPUT_REPORTS(data); |
| break; |
| case HidP_Output: |
| b_count = data->caps.NumberOutputButtonCaps; |
| r_count = data->dwOutputReportCount; |
| report = HID_OUTPUT_REPORTS(data); |
| break; |
| case HidP_Feature: |
| b_count = data->caps.NumberFeatureButtonCaps; |
| r_count = data->dwFeatureReportCount; |
| report = HID_FEATURE_REPORTS(data); |
| break; |
| default: |
| return HIDP_STATUS_INVALID_REPORT_TYPE; |
| } |
| |
| if (!r_count || !b_count || !report) |
| { |
| *ButtonCapsLength = 0; |
| return HIDP_STATUS_SUCCESS; |
| } |
| |
| b_count = min(b_count, *ButtonCapsLength); |
| |
| u = 0; |
| for (j = 0; j < r_count && u < b_count; j++) |
| { |
| for (i = 0; i < report->elementCount && u < b_count; i++) |
| { |
| if (report->Elements[i].ElementType == ButtonElement) |
| ButtonCaps[u++] = report->Elements[i].caps.button; |
| } |
| report = HID_NEXT_REPORT(data, report); |
| } |
| |
| *ButtonCapsLength = b_count; |
| return HIDP_STATUS_SUCCESS; |
| } |
| |
| |
| NTSTATUS WINAPI HidP_GetCaps(PHIDP_PREPARSED_DATA PreparsedData, |
| PHIDP_CAPS Capabilities) |
| { |
| PWINE_HIDP_PREPARSED_DATA data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData; |
| |
| TRACE("(%p, %p)\n",PreparsedData, Capabilities); |
| |
| if (data->magic != HID_MAGIC) |
| return HIDP_STATUS_INVALID_PREPARSED_DATA; |
| |
| *Capabilities = data->caps; |
| |
| return HIDP_STATUS_SUCCESS; |
| } |
| |
| static NTSTATUS find_value(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection, |
| USAGE Usage, PHIDP_PREPARSED_DATA PreparsedData, PCHAR Report, |
| WINE_HID_ELEMENT **element) |
| { |
| PWINE_HIDP_PREPARSED_DATA data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData; |
| WINE_HID_REPORT *report = NULL; |
| USHORT v_count = 0, r_count = 0; |
| int i; |
| |
| TRACE("(%i, %x, %i, %i, %p, %p)\n", ReportType, UsagePage, LinkCollection, Usage, |
| PreparsedData, Report); |
| |
| if (data->magic != HID_MAGIC) |
| return HIDP_STATUS_INVALID_PREPARSED_DATA; |
| switch(ReportType) |
| { |
| case HidP_Input: |
| v_count = data->caps.NumberInputValueCaps; |
| r_count = data->dwInputReportCount; |
| report = HID_INPUT_REPORTS(data); |
| break; |
| case HidP_Output: |
| v_count = data->caps.NumberOutputValueCaps; |
| r_count = data->dwOutputReportCount; |
| report = HID_OUTPUT_REPORTS(data); |
| break; |
| case HidP_Feature: |
| v_count = data->caps.NumberFeatureValueCaps; |
| r_count = data->dwFeatureReportCount; |
| report = HID_FEATURE_REPORTS(data); |
| break; |
| default: |
| return HIDP_STATUS_INVALID_REPORT_TYPE; |
| } |
| |
| if (!r_count || !v_count || !report) |
| return HIDP_STATUS_USAGE_NOT_FOUND; |
| |
| for (i = 0; i < r_count; i++) |
| { |
| if (!report->reportID || report->reportID == Report[0]) |
| break; |
| report = HID_NEXT_REPORT(data, report); |
| } |
| |
| if (i == r_count) |
| return HIDP_STATUS_REPORT_DOES_NOT_EXIST; |
| |
| for (i = 0; i < report->elementCount; i++) |
| { |
| if (report->Elements[i].ElementType == ValueElement && |
| report->Elements[i].caps.value.UsagePage == UsagePage && |
| report->Elements[i].caps.value.u.NotRange.Usage == Usage) |
| { |
| *element = &report->Elements[i]; |
| return HIDP_STATUS_SUCCESS; |
| } |
| } |
| |
| return HIDP_STATUS_USAGE_NOT_FOUND; |
| } |
| |
| NTSTATUS WINAPI HidP_GetScaledUsageValue(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, |
| USHORT LinkCollection, USAGE Usage, PLONG UsageValue, |
| PHIDP_PREPARSED_DATA PreparsedData, PCHAR Report, ULONG ReportLength) |
| { |
| NTSTATUS rc; |
| WINE_HID_ELEMENT *element; |
| TRACE("(%i, %x, %i, %i, %p, %p, %p, %i)\n", ReportType, UsagePage, LinkCollection, Usage, UsageValue, |
| PreparsedData, Report, ReportLength); |
| |
| rc = find_value(ReportType, UsagePage, LinkCollection, Usage, PreparsedData, Report, &element); |
| |
| if (rc == HIDP_STATUS_SUCCESS) |
| { |
| ULONG rawValue; |
| rc = get_report_data((BYTE*)Report, ReportLength, |
| element->valueStartBit, element->bitCount, &rawValue); |
| if (rc != HIDP_STATUS_SUCCESS) |
| return rc; |
| if (element->caps.value.BitSize == 16) |
| rawValue = (short)rawValue; |
| *UsageValue = rawValue; |
| } |
| |
| return rc; |
| } |
| |
| |
| NTSTATUS WINAPI HidP_GetUsageValue(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection, |
| USAGE Usage, PULONG UsageValue, PHIDP_PREPARSED_DATA PreparsedData, |
| PCHAR Report, ULONG ReportLength) |
| { |
| WINE_HID_ELEMENT *element; |
| NTSTATUS rc; |
| |
| TRACE("(%i, %x, %i, %i, %p, %p, %p, %i)\n", ReportType, UsagePage, LinkCollection, Usage, UsageValue, |
| PreparsedData, Report, ReportLength); |
| |
| rc = find_value(ReportType, UsagePage, LinkCollection, Usage, PreparsedData, Report, &element); |
| |
| if (rc == HIDP_STATUS_SUCCESS) |
| { |
| return get_report_data((BYTE*)Report, ReportLength, |
| element->valueStartBit, element->bitCount, UsageValue); |
| } |
| |
| return rc; |
| } |
| |
| |
| NTSTATUS WINAPI HidP_GetUsages(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection, |
| PUSAGE UsageList, PULONG UsageLength, PHIDP_PREPARSED_DATA PreparsedData, |
| PCHAR Report, ULONG ReportLength) |
| { |
| PWINE_HIDP_PREPARSED_DATA data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData; |
| WINE_HID_REPORT *report = NULL; |
| BOOL found = FALSE; |
| USHORT b_count = 0, r_count = 0; |
| int i,uCount; |
| |
| TRACE("(%i, %x, %i, %p, %p, %p, %p, %i)\n", ReportType, UsagePage, LinkCollection, UsageList, |
| UsageLength, PreparsedData, Report, ReportLength); |
| |
| if (data->magic != HID_MAGIC) |
| { |
| *UsageLength = 0; |
| return HIDP_STATUS_INVALID_PREPARSED_DATA; |
| } |
| |
| switch(ReportType) |
| { |
| case HidP_Input: |
| b_count = data->caps.NumberInputButtonCaps; |
| r_count = data->dwInputReportCount; |
| report = HID_INPUT_REPORTS(data); |
| break; |
| case HidP_Output: |
| b_count = data->caps.NumberOutputButtonCaps; |
| r_count = data->dwOutputReportCount; |
| report = HID_OUTPUT_REPORTS(data); |
| break; |
| case HidP_Feature: |
| b_count = data->caps.NumberFeatureButtonCaps; |
| r_count = data->dwFeatureReportCount; |
| report = HID_FEATURE_REPORTS(data); |
| break; |
| default: |
| return HIDP_STATUS_INVALID_REPORT_TYPE; |
| } |
| |
| if (!r_count || !b_count || !report) |
| return HIDP_STATUS_USAGE_NOT_FOUND; |
| |
| for (i = 0; i < r_count; i++) |
| { |
| if (!report->reportID || report->reportID == Report[0]) |
| break; |
| report = HID_NEXT_REPORT(data, report); |
| } |
| |
| if (i == r_count) |
| return HIDP_STATUS_REPORT_DOES_NOT_EXIST; |
| |
| uCount = 0; |
| for (i = 0; i < report->elementCount && uCount < *UsageLength; i++) |
| { |
| if (report->Elements[i].ElementType == ButtonElement && |
| report->Elements[i].caps.button.UsagePage == UsagePage) |
| { |
| int k; |
| WINE_HID_ELEMENT *element = &report->Elements[i]; |
| for (k=0; k < element->bitCount; k++) |
| { |
| UINT v = 0; |
| NTSTATUS rc = get_report_data((BYTE*)Report, ReportLength, |
| element->valueStartBit + k, 1, &v); |
| if (rc != HIDP_STATUS_SUCCESS) |
| return rc; |
| found = TRUE; |
| if (v) |
| { |
| if (uCount == *UsageLength) |
| return HIDP_STATUS_BUFFER_TOO_SMALL; |
| UsageList[uCount] = element->caps.button.u.Range.UsageMin + k; |
| uCount++; |
| } |
| } |
| } |
| } |
| |
| *UsageLength = uCount; |
| |
| if (!found) |
| return HIDP_STATUS_USAGE_NOT_FOUND; |
| |
| return HIDP_STATUS_SUCCESS; |
| } |
| |
| |
| NTSTATUS WINAPI HidP_GetValueCaps(HIDP_REPORT_TYPE ReportType, PHIDP_VALUE_CAPS ValueCaps, |
| PUSHORT ValueCapsLength, PHIDP_PREPARSED_DATA PreparsedData) |
| { |
| PWINE_HIDP_PREPARSED_DATA data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData; |
| WINE_HID_REPORT *report = NULL; |
| USHORT v_count = 0, r_count = 0; |
| int i,j,u; |
| |
| TRACE("(%i, %p, %p, %p)\n", ReportType, ValueCaps, ValueCapsLength, PreparsedData); |
| |
| if (data->magic != HID_MAGIC) |
| return HIDP_STATUS_INVALID_PREPARSED_DATA; |
| |
| switch(ReportType) |
| { |
| case HidP_Input: |
| v_count = data->caps.NumberInputValueCaps; |
| r_count = data->dwInputReportCount; |
| report = HID_INPUT_REPORTS(data); |
| break; |
| case HidP_Output: |
| v_count = data->caps.NumberOutputValueCaps; |
| r_count = data->dwOutputReportCount; |
| report = HID_OUTPUT_REPORTS(data); |
| break; |
| case HidP_Feature: |
| v_count = data->caps.NumberFeatureValueCaps; |
| r_count = data->dwFeatureReportCount; |
| report = HID_FEATURE_REPORTS(data); |
| break; |
| default: |
| return HIDP_STATUS_INVALID_REPORT_TYPE; |
| } |
| |
| if (!r_count || !v_count || !report) |
| { |
| *ValueCapsLength = 0; |
| return HIDP_STATUS_SUCCESS; |
| } |
| |
| v_count = min(v_count, *ValueCapsLength); |
| |
| u = 0; |
| for (j = 0; j < r_count && u < v_count; j++) |
| { |
| for (i = 0; i < report->elementCount && u < v_count; i++) |
| { |
| if (report->Elements[i].ElementType == ValueElement) |
| ValueCaps[u++] = report->Elements[i].caps.value; |
| } |
| report = HID_NEXT_REPORT(data, report); |
| } |
| |
| *ValueCapsLength = v_count; |
| return HIDP_STATUS_SUCCESS; |
| } |
| |
| NTSTATUS WINAPI HidP_InitializeReportForID(HIDP_REPORT_TYPE ReportType, UCHAR ReportID, |
| PHIDP_PREPARSED_DATA PreparsedData, PCHAR Report, |
| ULONG ReportLength) |
| { |
| int size; |
| PWINE_HIDP_PREPARSED_DATA data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData; |
| WINE_HID_REPORT *report = NULL; |
| BOOL found=FALSE; |
| int r_count; |
| int i; |
| |
| TRACE("(%i, %i, %p, %p, %i)\n",ReportType, ReportID, PreparsedData, Report, ReportLength); |
| |
| if (data->magic != HID_MAGIC) |
| return HIDP_STATUS_INVALID_PREPARSED_DATA; |
| |
| switch(ReportType) |
| { |
| case HidP_Input: |
| size = data->caps.InputReportByteLength; |
| report = HID_INPUT_REPORTS(data); |
| r_count = data->dwInputReportCount; |
| break; |
| case HidP_Output: |
| size = data->caps.OutputReportByteLength; |
| report = HID_OUTPUT_REPORTS(data); |
| r_count = data->dwOutputReportCount; |
| break; |
| case HidP_Feature: |
| size = data->caps.FeatureReportByteLength; |
| report = HID_FEATURE_REPORTS(data); |
| r_count = data->dwFeatureReportCount; |
| break; |
| default: |
| return HIDP_STATUS_INVALID_REPORT_TYPE; |
| } |
| |
| if (!r_count || !size || !report) |
| return HIDP_STATUS_REPORT_DOES_NOT_EXIST; |
| |
| if (size != ReportLength) |
| return HIDP_STATUS_INVALID_REPORT_LENGTH; |
| |
| ZeroMemory(Report, size); |
| |
| for (i = 0; i < r_count; i++) |
| { |
| if (report->reportID == ReportID) |
| { |
| found = TRUE; |
| if (report->reportID) |
| Report[0] = ReportID; |
| /* TODO: Handle null and default values */ |
| } |
| report = HID_NEXT_REPORT(data, report); |
| } |
| |
| if (!found) |
| return HIDP_STATUS_REPORT_DOES_NOT_EXIST; |
| |
| return HIDP_STATUS_SUCCESS; |
| } |
| |
| ULONG WINAPI HidP_MaxUsageListLength(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, PHIDP_PREPARSED_DATA PreparsedData) |
| { |
| PWINE_HIDP_PREPARSED_DATA data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData; |
| WINE_HID_REPORT *report = NULL; |
| int r_count; |
| int i; |
| int count = 0; |
| |
| TRACE("(%i, %x, %p)\n", ReportType, UsagePage, PreparsedData); |
| |
| if (data->magic != HID_MAGIC) |
| return 0; |
| |
| switch(ReportType) |
| { |
| case HidP_Input: |
| report = HID_INPUT_REPORTS(data); |
| r_count = data->dwInputReportCount; |
| break; |
| case HidP_Output: |
| report = HID_OUTPUT_REPORTS(data); |
| r_count = data->dwOutputReportCount; |
| break; |
| case HidP_Feature: |
| report = HID_FEATURE_REPORTS(data); |
| r_count = data->dwFeatureReportCount; |
| break; |
| default: |
| return HIDP_STATUS_INVALID_REPORT_TYPE; |
| } |
| |
| if (!r_count || !report) |
| return 0; |
| |
| for (i = 0; i < r_count; i++) |
| { |
| int j; |
| for (j = 0; j < report->elementCount; j++) |
| { |
| if (report->Elements[j].ElementType == ButtonElement && |
| (UsagePage == 0 || report->Elements[j].caps.button.UsagePage == UsagePage)) |
| { |
| if (report->Elements[j].caps.button.IsRange) |
| count += (report->Elements[j].caps.button.u.Range.UsageMax - |
| report->Elements[j].caps.button.u.Range.UsageMin) + 1; |
| else |
| count++; |
| } |
| } |
| report = HID_NEXT_REPORT(data, report); |
| } |
| return count; |
| } |
| |
| NTSTATUS WINAPI HidP_TranslateUsagesToI8042ScanCodes(USAGE *ChangedUsageList, |
| ULONG UsageListLength, HIDP_KEYBOARD_DIRECTION KeyAction, |
| HIDP_KEYBOARD_MODIFIER_STATE *ModifierState, |
| PHIDP_INSERT_SCANCODES InsertCodesProcedure, VOID *InsertCodesContext) |
| { |
| FIXME("stub: %p, %i, %i, %p, %p, %p\n", ChangedUsageList, UsageListLength, |
| KeyAction, ModifierState, InsertCodesProcedure, InsertCodesContext); |
| |
| return STATUS_NOT_IMPLEMENTED; |
| } |
| |
| NTSTATUS WINAPI HidP_GetSpecificButtonCaps(HIDP_REPORT_TYPE ReportType, |
| USAGE UsagePage, USHORT LinkCollection, USAGE Usage, |
| HIDP_BUTTON_CAPS *ButtonCaps, USHORT *ButtonCapsLength, PHIDP_PREPARSED_DATA PreparsedData) |
| { |
| WINE_HIDP_PREPARSED_DATA *data = (WINE_HIDP_PREPARSED_DATA*)PreparsedData; |
| WINE_HID_REPORT *report = NULL; |
| USHORT b_count = 0, r_count = 0; |
| int i,j,u; |
| |
| TRACE("(%i, 0x%x, %i, 0x%x, %p %p %p)\n", ReportType, UsagePage, LinkCollection, |
| Usage, ButtonCaps, ButtonCapsLength, PreparsedData); |
| |
| if (data->magic != HID_MAGIC) |
| return HIDP_STATUS_INVALID_PREPARSED_DATA; |
| |
| switch(ReportType) |
| { |
| case HidP_Input: |
| b_count = data->caps.NumberInputButtonCaps; |
| r_count = data->dwInputReportCount; |
| report = HID_INPUT_REPORTS(data); |
| break; |
| case HidP_Output: |
| b_count = data->caps.NumberOutputButtonCaps; |
| r_count = data->dwOutputReportCount; |
| report = HID_OUTPUT_REPORTS(data); |
| break; |
| case HidP_Feature: |
| b_count = data->caps.NumberFeatureButtonCaps; |
| r_count = data->dwFeatureReportCount; |
| report = HID_FEATURE_REPORTS(data); |
| break; |
| default: |
| return HIDP_STATUS_INVALID_REPORT_TYPE; |
| } |
| |
| if (!r_count || !b_count || !report) |
| { |
| *ButtonCapsLength = 0; |
| return HIDP_STATUS_SUCCESS; |
| } |
| |
| b_count = min(b_count, *ButtonCapsLength); |
| |
| u = 0; |
| for (j = 0; j < r_count && u < b_count; j++) |
| { |
| for (i = 0; i < report->elementCount && u < b_count; i++) |
| { |
| if (report->Elements[i].ElementType == ButtonElement && |
| (UsagePage == 0 || UsagePage == report->Elements[i].caps.button.UsagePage) && |
| (LinkCollection == 0 || LinkCollection == report->Elements[i].caps.button.LinkCollection) && |
| (Usage == 0 || ( |
| (!report->Elements[i].caps.button.IsRange && |
| Usage == report->Elements[i].caps.button.u.NotRange.Usage)) || |
| (report->Elements[i].caps.button.IsRange && |
| Usage >=report->Elements[i].caps.button.u.Range.UsageMin && |
| Usage <= report->Elements[i].caps.button.u.Range.UsageMax))) |
| { |
| ButtonCaps[u++] = report->Elements[i].caps.button; |
| } |
| } |
| report = HID_NEXT_REPORT(data, report); |
| } |
| TRACE("Matched %i usages\n", u); |
| |
| *ButtonCapsLength = u; |
| |
| return HIDP_STATUS_SUCCESS; |
| } |
| |
| |
| NTSTATUS WINAPI HidP_GetSpecificValueCaps(HIDP_REPORT_TYPE ReportType, |
| USAGE UsagePage, USHORT LinkCollection, USAGE Usage, |
| HIDP_VALUE_CAPS *ValueCaps, USHORT *ValueCapsLength, PHIDP_PREPARSED_DATA PreparsedData) |
| { |
| WINE_HIDP_PREPARSED_DATA *data = (PWINE_HIDP_PREPARSED_DATA)PreparsedData; |
| WINE_HID_REPORT *report = NULL; |
| USHORT v_count = 0, r_count = 0; |
| int i,j,u; |
| |
| TRACE("(%i, 0x%x, %i, 0x%x, %p %p %p)\n", ReportType, UsagePage, LinkCollection, |
| Usage, ValueCaps, ValueCapsLength, PreparsedData); |
| |
| if (data->magic != HID_MAGIC) |
| return HIDP_STATUS_INVALID_PREPARSED_DATA; |
| |
| switch(ReportType) |
| { |
| case HidP_Input: |
| v_count = data->caps.NumberInputValueCaps; |
| r_count = data->dwInputReportCount; |
| report = HID_INPUT_REPORTS(data); |
| break; |
| case HidP_Output: |
| v_count = data->caps.NumberOutputValueCaps; |
| r_count = data->dwOutputReportCount; |
| report = HID_OUTPUT_REPORTS(data); |
| break; |
| case HidP_Feature: |
| v_count = data->caps.NumberFeatureValueCaps; |
| r_count = data->dwFeatureReportCount; |
| report = HID_FEATURE_REPORTS(data); |
| break; |
| default: |
| return HIDP_STATUS_INVALID_REPORT_TYPE; |
| } |
| |
| if (!r_count || !v_count || !report) |
| { |
| *ValueCapsLength = 0; |
| return HIDP_STATUS_SUCCESS; |
| } |
| |
| v_count = min(v_count, *ValueCapsLength); |
| |
| u = 0; |
| for (j = 0; j < r_count && u < v_count; j++) |
| { |
| for (i = 0; i < report->elementCount && u < v_count; i++) |
| { |
| if (report->Elements[i].ElementType == ValueElement && |
| (UsagePage == 0 || UsagePage == report->Elements[i].caps.value.UsagePage) && |
| (LinkCollection == 0 || LinkCollection == report->Elements[i].caps.value.LinkCollection) && |
| (Usage == 0 || Usage == report->Elements[i].caps.value.u.NotRange.Usage)) |
| { |
| ValueCaps[u++] = report->Elements[i].caps.value; |
| } |
| } |
| report = HID_NEXT_REPORT(data, report); |
| } |
| TRACE("Matched %i usages\n", u); |
| |
| *ValueCapsLength = u; |
| |
| return HIDP_STATUS_SUCCESS; |
| } |
| |
| NTSTATUS WINAPI HidP_GetUsagesEx(HIDP_REPORT_TYPE ReportType, USHORT LinkCollection, USAGE_AND_PAGE *ButtonList, |
| ULONG *UsageLength, PHIDP_PREPARSED_DATA PreparsedData, CHAR *Report, ULONG ReportLength) |
| { |
| WINE_HIDP_PREPARSED_DATA *data = (WINE_HIDP_PREPARSED_DATA*)PreparsedData; |
| WINE_HID_REPORT *report = NULL; |
| USHORT b_count = 0, r_count = 0; |
| int i,uCount = 0; |
| NTSTATUS rc; |
| |
| TRACE("(%i, %i, %p, %p(%i), %p, %p, %i)\n", ReportType, LinkCollection, ButtonList, |
| UsageLength, *UsageLength, PreparsedData, Report, ReportLength); |
| |
| if (data->magic != HID_MAGIC) |
| return HIDP_STATUS_INVALID_PREPARSED_DATA; |
| |
| switch(ReportType) |
| { |
| case HidP_Input: |
| b_count = data->caps.NumberInputButtonCaps; |
| r_count = data->dwInputReportCount; |
| report = HID_INPUT_REPORTS(data); |
| break; |
| case HidP_Output: |
| b_count = data->caps.NumberOutputButtonCaps; |
| r_count = data->dwOutputReportCount; |
| report = HID_OUTPUT_REPORTS(data); |
| break; |
| case HidP_Feature: |
| b_count = data->caps.NumberFeatureButtonCaps; |
| r_count = data->dwFeatureReportCount; |
| report = HID_FEATURE_REPORTS(data); |
| break; |
| default: |
| return HIDP_STATUS_INVALID_REPORT_TYPE; |
| } |
| |
| if (!r_count || !b_count || !report) |
| return HIDP_STATUS_USAGE_NOT_FOUND; |
| |
| for (i = 0; i < r_count; i++) |
| { |
| if (!report->reportID || report->reportID == Report[0]) |
| break; |
| report = HID_NEXT_REPORT(data, report); |
| } |
| |
| if (i == r_count) |
| return HIDP_STATUS_REPORT_DOES_NOT_EXIST; |
| |
| for (i = 0; i < report->elementCount; i++) |
| { |
| if (report->Elements[i].ElementType == ButtonElement) |
| { |
| int k; |
| WINE_HID_ELEMENT *element = &report->Elements[i]; |
| for (k=0; k < element->bitCount; k++) |
| { |
| UINT v = 0; |
| NTSTATUS rc = get_report_data((BYTE*)Report, ReportLength, |
| element->valueStartBit + k, 1, &v); |
| if (rc != HIDP_STATUS_SUCCESS) |
| return rc; |
| if (v) |
| { |
| if (uCount < *UsageLength) |
| { |
| ButtonList[uCount].Usage = element->caps.button.u.Range.UsageMin + k; |
| ButtonList[uCount].UsagePage = element->caps.button.UsagePage; |
| } |
| uCount++; |
| } |
| } |
| } |
| } |
| |
| TRACE("Returning %i usages\n", uCount); |
| |
| if (*UsageLength < uCount) |
| rc = HIDP_STATUS_BUFFER_TOO_SMALL; |
| else |
| rc = HIDP_STATUS_SUCCESS; |
| |
| *UsageLength = uCount; |
| |
| return rc; |
| } |
| |
| ULONG WINAPI HidP_MaxDataListLength(HIDP_REPORT_TYPE ReportType, PHIDP_PREPARSED_DATA PreparsedData) |
| { |
| WINE_HIDP_PREPARSED_DATA *data = (WINE_HIDP_PREPARSED_DATA *)PreparsedData; |
| TRACE("(%i, %p)\n", ReportType, PreparsedData); |
| if (data->magic != HID_MAGIC) |
| return 0; |
| |
| switch(ReportType) |
| { |
| case HidP_Input: |
| return data->caps.NumberInputDataIndices; |
| case HidP_Output: |
| return data->caps.NumberOutputDataIndices; |
| case HidP_Feature: |
| return data->caps.NumberFeatureDataIndices; |
| default: |
| return 0; |
| } |
| } |
| |
| NTSTATUS WINAPI HidP_GetData(HIDP_REPORT_TYPE ReportType, HIDP_DATA *DataList, ULONG *DataLength, |
| PHIDP_PREPARSED_DATA PreparsedData,CHAR *Report, ULONG ReportLength) |
| { |
| WINE_HIDP_PREPARSED_DATA *data = (WINE_HIDP_PREPARSED_DATA*)PreparsedData; |
| WINE_HID_REPORT *report = NULL; |
| USHORT r_count = 0; |
| int i,uCount = 0; |
| NTSTATUS rc; |
| |
| TRACE("(%i, %p, %p(%i), %p, %p, %i)\n", ReportType, DataList, DataLength, |
| DataLength?*DataLength:0, PreparsedData, Report, ReportLength); |
| |
| if (data->magic != HID_MAGIC) |
| return 0; |
| |
| switch(ReportType) |
| { |
| case HidP_Input: |
| r_count = data->dwInputReportCount; |
| report = HID_INPUT_REPORTS(data); |
| break; |
| case HidP_Output: |
| r_count = data->dwOutputReportCount; |
| report = HID_OUTPUT_REPORTS(data); |
| break; |
| case HidP_Feature: |
| r_count = data->dwFeatureReportCount; |
| report = HID_FEATURE_REPORTS(data); |
| break; |
| default: |
| return HIDP_STATUS_INVALID_REPORT_TYPE; |
| } |
| |
| for (i = 0; i < r_count; i++) |
| { |
| if (!report->reportID || report->reportID == Report[0]) |
| break; |
| report = HID_NEXT_REPORT(data, report); |
| } |
| |
| if (i == r_count) |
| return HIDP_STATUS_REPORT_DOES_NOT_EXIST; |
| |
| for (i = 0; i < report->elementCount; i++) |
| { |
| WINE_HID_ELEMENT *element = &report->Elements[i]; |
| if (element->ElementType == ButtonElement) |
| { |
| int k; |
| for (k=0; k < element->bitCount; k++) |
| { |
| UINT v = 0; |
| NTSTATUS rc = get_report_data((BYTE*)Report, ReportLength, |
| element->valueStartBit + k, 1, &v); |
| if (rc != HIDP_STATUS_SUCCESS) |
| return rc; |
| if (v) |
| { |
| if (uCount < *DataLength) |
| { |
| DataList[uCount].DataIndex = element->caps.button.u.Range.DataIndexMin + k; |
| DataList[uCount].u.On = v; |
| } |
| uCount++; |
| } |
| } |
| } |
| else |
| { |
| if (uCount < *DataLength) |
| { |
| UINT v; |
| NTSTATUS rc = get_report_data((BYTE*)Report, ReportLength, |
| element->valueStartBit, element->bitCount, &v); |
| if (rc != HIDP_STATUS_SUCCESS) |
| return rc; |
| if (element->caps.value.BitSize == 16) |
| v = (short)v; |
| DataList[uCount].DataIndex = element->caps.value.u.NotRange.DataIndex; |
| DataList[uCount].u.RawValue = v; |
| } |
| uCount++; |
| } |
| } |
| |
| if (*DataLength < uCount) |
| rc = HIDP_STATUS_BUFFER_TOO_SMALL; |
| else |
| rc = HIDP_STATUS_SUCCESS; |
| |
| *DataLength = uCount; |
| |
| return rc; |
| } |
