?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcrt: Add scheduler_resource_allocation_error class implementation.
[wine.git] / dlls / hid / hidp.c
blobd6d143e899e3d8f585e3c70cfab6dd627d61dad9
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 }
Windows API implementation