source: mainline/uspace/lib/usb/src/hidparser.c@ 3a6e423

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 3a6e423 was 3a6e423, checked in by Matej Klonfar <maklf@…>, 14 years ago

Parsing of usages in case of array items repaired
  • Property mode set to 100644
File size: 14.5 KB
Line 
1/*
2 * Copyright (c) 2011 Matej Klonfar
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup libusb
30 * @{
31 */
32/** @file
33 * HID report descriptor and report data parser implementation.
34 */
35#include <usb/classes/hidparser.h>
36#include <errno.h>
37#include <stdio.h>
38#include <malloc.h>
39#include <mem.h>
40#include <usb/debug.h>
41#include <assert.h>
42
43
44/*
45 * Data translation private functions
46 */
47uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size);
48inline size_t usb_hid_count_item_offset(usb_hid_report_item_t * report_item, size_t offset);
49int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data);
50uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int32_t value);
51int usb_pow(int a, int b);
52
53
54// TODO: tohle ma bejt asi jinde
55int usb_pow(int a, int b)
56{
57 switch(b) {
58 case 0:
59 return 1;
60 break;
61 case 1:
62 return a;
63 break;
64 default:
65 return a * usb_pow(a, b-1);
66 break;
67 }
68}
69
70
71/** Returns size of report of specified report id and type in items
72 *
73 * @param parser Opaque report parser structure
74 * @param report_id
75 * @param type
76 * @return Number of items in specified report
77 */
78size_t usb_hid_report_size(usb_hid_report_t *report, uint8_t report_id,
79 usb_hid_report_type_t type)
80{
81 usb_hid_report_description_t *report_des;
82
83 if(report == NULL) {
84 return 0;
85 }
86
87 report_des = usb_hid_report_find_description (report, report_id, type);
88 if(report_des == NULL){
89 return 0;
90 }
91 else {
92 return report_des->item_length;
93 }
94}
95
96
97/** Parse and act upon a HID report.
98 *
99 * @see usb_hid_parse_report_descriptor
100 *
101 * @param parser Opaque HID report parser structure.
102 * @param data Data for the report.
103 * @return Error code.
104 */
105int usb_hid_parse_report(const usb_hid_report_t *report,
106 const uint8_t *data, size_t size, uint8_t *report_id)
107{
108 link_t *list_item;
109 usb_hid_report_field_t *item;
110
111 usb_hid_report_description_t *report_des;
112 usb_hid_report_type_t type = USB_HID_REPORT_TYPE_INPUT;
113
114 if(report == NULL) {
115 return EINVAL;
116 }
117
118 if(report->use_report_ids != 0) {
119 *report_id = data[0];
120 }
121 else {
122 *report_id = 0;
123 }
124
125
126 report_des = usb_hid_report_find_description(report, *report_id, type);
127
128 /* read data */
129 list_item = report_des->report_items.next;
130 while(list_item != &(report_des->report_items)) {
131
132 item = list_get_instance(list_item, usb_hid_report_field_t, link);
133
134 if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) {
135
136 if(USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) {
137
138 // array
139 item->value = usb_hid_translate_data(item, data);
140
141 item->usage = USB_HID_EXTENDED_USAGE(item->usages[item->value - item->physical_minimum]);
142 item->usage_page = USB_HID_EXTENDED_USAGE_PAGE(item->usages[item->value - item->physical_minimum]);
143
144 usb_hid_report_set_last_item (item->collection_path,
145 USB_HID_TAG_CLASS_GLOBAL,
146 item->usage_page);
147 usb_hid_report_set_last_item (item->collection_path,
148 USB_HID_TAG_CLASS_LOCAL,
149 item->usage);
150
151 }
152 else {
153 // variable item
154 item->value = usb_hid_translate_data(item, data);
155 }
156 }
157 list_item = list_item->next;
158 }
159
160 return EOK;
161
162}
163
164/**
165 * Translate data from the report as specified in report descriptor item
166 *
167 * @param item Report descriptor item with definition of translation
168 * @param data Data to translate
169 * @param j Index of processed field in report descriptor item
170 * @return Translated data
171 */
172int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data)
173{
174 int resolution;
175 int offset;
176 int part_size;
177
178 int32_t value=0;
179 int32_t mask;
180 const uint8_t *foo;
181
182 // now only shot tags are allowed
183 if(item->size > 32) {
184 return 0;
185 }
186
187 if((item->physical_minimum == 0) && (item->physical_maximum == 0)){
188 item->physical_minimum = item->logical_minimum;
189 item->physical_maximum = item->logical_maximum;
190 }
191
192
193 if(item->physical_maximum == item->physical_minimum){
194 resolution = 1;
195 }
196 else {
197 resolution = (item->logical_maximum - item->logical_minimum) /
198 ((item->physical_maximum - item->physical_minimum) *
199 (usb_pow(10,(item->unit_exponent))));
200 }
201
202 offset = item->offset;
203 // FIXME
204 if((size_t)(offset/8) != (size_t)((offset+item->size-1)/8)) {
205
206 part_size = ((offset+item->size)%8);
207
208 size_t i=0;
209 for(i=(size_t)(offset/8); i<=(size_t)(offset+item->size-1)/8; i++){
210 if(i == (size_t)(offset/8)) {
211 // the higher one
212 foo = data + i;
213 mask = ((1 << (item->size-part_size))-1);
214 value = (*foo & mask) << part_size;
215 }
216 else if(i == ((offset+item->size-1)/8)){
217 // the lower one
218 foo = data + i;
219 mask = ((1 << part_size)-1) << (8-part_size);
220 value += ((*foo & mask) >> (8-part_size));
221 }
222 else {
223 value = value << 8;
224 value += *(data + 1);
225 }
226 }
227 }
228 else {
229 foo = data+(offset/8);
230 mask = ((1 << item->size)-1) << (8-((offset%8)+item->size));
231 value = (*foo & mask) >> (8-((offset%8)+item->size));
232 }
233
234 if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
235 value = USB_HID_UINT32_TO_INT32(value, item->size);
236 }
237
238 return (int)(((value - item->logical_minimum) / resolution) + item->physical_minimum);
239
240}
241
242/*** OUTPUT API **/
243
244/**
245 * Allocates output report buffer for output report
246 *
247 * @param parser Report parsed structure
248 * @param size Size of returned buffer
249 * @param report_id Report id of created output report
250 * @return Returns allocated output buffer for specified output
251 */
252uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, uint8_t report_id)
253{
254 if(report == NULL) {
255 *size = 0;
256 return NULL;
257 }
258
259 link_t *report_it = report->reports.next;
260 usb_hid_report_description_t *report_des = NULL;
261 while(report_it != &report->reports) {
262 report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
263 if((report_des->report_id == report_id) && (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)){
264 break;
265 }
266
267 report_it = report_it->next;
268 }
269
270 if(report_des == NULL){
271 *size = 0;
272 return NULL;
273 }
274 else {
275 *size = (report_des->bit_length + (8 - 1))/8;
276 uint8_t *ret = malloc((*size) * sizeof(uint8_t));
277 memset(ret, 0, (*size) * sizeof(uint8_t));
278 return ret;
279 }
280}
281
282
283/** Frees output report buffer
284 *
285 * @param output Output report buffer
286 * @return void
287 */
288void usb_hid_report_output_free(uint8_t *output)
289
290{
291 if(output != NULL) {
292 free (output);
293 }
294}
295
296/** Makes the output report buffer for data given in the report structure
297 *
298 * @param parser Opaque report parser structure
299 * @param path Usage path specifing which parts of output will be set
300 * @param flags Usage path structure comparison flags
301 * @param buffer Output buffer
302 * @param size Size of output buffer
303 * @return Error code
304 */
305int usb_hid_report_output_translate(usb_hid_report_t *report, uint8_t report_id,
306 uint8_t *buffer, size_t size)
307{
308 link_t *item;
309 int32_t value=0;
310 int offset;
311 int length;
312 int32_t tmp_value;
313
314 if(report == NULL) {
315 return EINVAL;
316 }
317
318 if(report->use_report_ids != 0) {
319 buffer[0] = report_id;
320 }
321
322 usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));
323
324 usb_hid_report_description_t *report_des;
325 report_des = usb_hid_report_find_description (report, report_id, USB_HID_REPORT_TYPE_OUTPUT);
326 if(report_des == NULL){
327 return EINVAL;
328 }
329
330 usb_hid_report_field_t *report_item;
331 item = report_des->report_items.next;
332 while(item != &report_des->report_items) {
333 report_item = list_get_instance(item, usb_hid_report_field_t, link);
334
335 usb_log_debug("OUTPUT ITEM usage(%x), value(%x)\n", report_item->usage, report_item->value);
336
337 if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) {
338
339 // array
340 value = usb_hid_translate_data_reverse(report_item, report_item->value);
341 offset = report_item->offset;
342 length = report_item->size;
343 }
344 else {
345 // variable item
346 value = usb_hid_translate_data_reverse(report_item, report_item->value);
347 offset = report_item->offset;
348 length = report_item->size;
349 }
350
351 if((offset/8) == ((offset+length-1)/8)) {
352 // je to v jednom bytu
353 if(((size_t)(offset/8) >= size) || ((size_t)(offset+length-1)/8) >= size) {
354 break; // TODO ErrorCode
355 }
356
357 size_t shift = 8 - offset%8 - length;
358
359 value = value << shift;
360 value = value & (((1 << length)-1) << shift);
361
362 uint8_t mask = 0;
363 mask = 0xff - (((1 << length) - 1) << shift);
364 buffer[offset/8] = (buffer[offset/8] & mask) | value;
365 }
366 else {
367 int i = 0;
368 uint8_t mask = 0;
369 for(i = (offset/8); i <= ((offset+length-1)/8); i++) {
370 if(i == (offset/8)) {
371 tmp_value = value;
372 tmp_value = tmp_value & ((1 << (8-(offset%8)))-1);
373 tmp_value = tmp_value << (offset%8);
374
375 mask = ~(((1 << (8-(offset%8)))-1) << (offset%8));
376 buffer[i] = (buffer[i] & mask) | tmp_value;
377 }
378 else if (i == ((offset + length -1)/8)) {
379
380 value = value >> (length - ((offset + length) % 8));
381 value = value & ((1 << (length - ((offset + length) % 8))) - 1);
382
383 mask = (1 << (length - ((offset + length) % 8))) - 1;
384 buffer[i] = (buffer[i] & mask) | value;
385 }
386 else {
387 buffer[i] = value & (0xFF << i);
388 }
389 }
390 }
391
392
393 // reset value
394 report_item->value = 0;
395
396 item = item->next;
397 }
398
399 usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));
400
401 return EOK;
402}
403
404/**
405 * Translate given data for putting them into the outoput report
406 * @param item Report item structure
407 * @param value Value to translate
408 * @return ranslated value
409 */
410uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int value)
411{
412 int ret=0;
413 int resolution;
414
415 if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags)) {
416 ret = item->logical_minimum;
417 }
418
419 if((item->physical_minimum == 0) && (item->physical_maximum == 0)){
420 item->physical_minimum = item->logical_minimum;
421 item->physical_maximum = item->logical_maximum;
422 }
423
424
425 if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0)) {
426
427 // variable item
428 if(item->physical_maximum == item->physical_minimum){
429 resolution = 1;
430 }
431 else {
432 resolution = (item->logical_maximum - item->logical_minimum) /
433 ((item->physical_maximum - item->physical_minimum) *
434 (usb_pow(10,(item->unit_exponent))));
435 }
436
437 ret = ((value - item->physical_minimum) * resolution) + item->logical_minimum;
438 }
439 else {
440 // bitmapa
441 if(value == 0) {
442 ret = 0;
443 }
444 else {
445 size_t bitmap_idx = (value - item->usage_minimum);
446 ret = 1 << bitmap_idx;
447 }
448 }
449
450 if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
451 return USB_HID_INT32_TO_UINT32(ret, item->size);
452 }
453 return (int32_t)ret;
454}
455
456usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item)
457{
458 usb_hid_report_item_t *new_report_item;
459
460 if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) {
461 return NULL;
462 }
463 memcpy(new_report_item,item, sizeof(usb_hid_report_item_t));
464 link_initialize(&(new_report_item->link));
465
466 return new_report_item;
467}
468
469
470usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report,
471 usb_hid_report_field_t *field,
472 usb_hid_report_path_t *path, int flags,
473 usb_hid_report_type_t type)
474{
475 usb_hid_report_description_t *report_des = usb_hid_report_find_description (report, path->report_id, type);
476 link_t *field_it;
477
478 if(report_des == NULL){
479 return NULL;
480 }
481
482 if(field == NULL){
483 // vezmu prvni co mathuje podle path!!
484 field_it = report_des->report_items.next;
485 }
486 else {
487 field_it = field->link.next;
488 }
489
490 while(field_it != &report_des->report_items) {
491 field = list_get_instance(field_it, usb_hid_report_field_t, link);
492
493 if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) {
494 usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage);
495 if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK){
496 usb_hid_report_remove_last_item (field->collection_path);
497 return field;
498 }
499 usb_hid_report_remove_last_item (field->collection_path);
500 }
501 field_it = field_it->next;
502 }
503
504 return NULL;
505}
506
507uint8_t usb_hid_report_get_report_id(usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type)
508{
509 if(report == NULL){
510 return 0;
511 }
512
513 usb_hid_report_description_t *report_des;
514 link_t *report_it;
515
516 if(report_id == 0) {
517 report_it = usb_hid_report_find_description (report, report_id, type)->link.next;
518 }
519 else {
520 report_it = report->reports.next;
521 }
522
523 while(report_it != &report->reports) {
524 report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
525 if(report_des->type == type){
526 return report_des->report_id;
527 }
528 }
529
530 return 0;
531}
532
533void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item)
534{
535 if(report_item == NULL) {
536 return;
537 }
538
539 report_item->usages_count = 0;
540 memset(report_item->usages, 0, USB_HID_MAX_USAGES);
541
542 report_item->extended_usage_page = 0;
543 report_item->usage_minimum = 0;
544 report_item->usage_maximum = 0;
545 report_item->designator_index = 0;
546 report_item->designator_minimum = 0;
547 report_item->designator_maximum = 0;
548 report_item->string_index = 0;
549 report_item->string_minimum = 0;
550 report_item->string_maximum = 0;
551
552 return;
553}
554/**
555 * @}
556 */
Note: See TracBrowser for help on using the repository browser.