source: mainline/uspace/lib/usbhid/src/hiddescriptor.c@ b72efe8

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since b72efe8 was b72efe8, checked in by Jiri Svoboda <jiri@…>, 14 years ago

Separate list_t typedef from link_t (user-space part).

  • list_t represents lists
  • Use list_first(), list_last(), list_empty() where appropriate
  • Use list_foreach() where possible
  • assert_link_not_used()
  • usb_hid_report_path_free() shall not unlink the path, caller must do it
  • Property mode set to 100644
File size: 27.1 KB
RevLine 
[9d05599]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
[160b75e]29/** @addtogroup libusbhid
[9d05599]30 * @{
31 */
32/** @file
33 * HID report descriptor and report data parser implementation.
34 */
[faa44e58]35#include <usb/hid/hidparser.h>
[9d05599]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
[f3b39b4]43/*---------------------------------------------------------------------------*/
44/*
45 * Constants defining current parsing mode for correct parsing of the set of
46 * local tags (usage) enclosed in delimter tags.
47 */
48/**
49 * Second delimiter tag was read. The set of local items (usage) ended.
50 */
[22ded10]51#define OUTSIDE_DELIMITER_SET 0
[f3b39b4]52
53/**
54 * First delimiter tag was read. The set of local items (usage) started.
55 */
[22ded10]56#define START_DELIMITER_SET 1
[f3b39b4]57
58/**
59 * Parser is in the set of local items.
60 */
[22ded10]61#define INSIDE_DELIMITER_SET 2
[f3b39b4]62
63/*---------------------------------------------------------------------------*/
[22ded10]64
[9d05599]65/** The new report item flag. Used to determine when the item is completly
66 * configured and should be added to the report structure
67 */
68#define USB_HID_NEW_REPORT_ITEM 1
69
70/** No special action after the report descriptor tag is processed should be
71 * done
72 */
73#define USB_HID_NO_ACTION 2
74
75#define USB_HID_RESET_OFFSET 3
76
77/** Unknown tag was founded in report descriptor data*/
78#define USB_HID_UNKNOWN_TAG -99
79
[f3b39b4]80/*---------------------------------------------------------------------------*/
81/**
82 * Checks if given collection path is already present in report structure and
83 * inserts it if not.
84 *
85 * @param report Report structure
86 * @param cmp_path The collection path
87 * @return Pointer to the result collection path in report structure.
88 * @retval NULL If some error occurs
89 */
[b72efe8]90usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report,
91 usb_hid_report_path_t *cmp_path)
92{
93 link_t *path_it = report->collection_paths.head.next;
[1519b91]94 usb_hid_report_path_t *path = NULL;
[3a6e423]95
[f3b39b4]96 if((report == NULL) || (cmp_path == NULL)) {
97 return NULL;
98 }
[3a6e423]99
[b72efe8]100 while(path_it != &report->collection_paths.head) {
[f3b39b4]101 path = list_get_instance(path_it, usb_hid_report_path_t,
[b72efe8]102 cpath_link);
[1519b91]103
[f3b39b4]104 if(usb_hid_report_compare_usage_path(path, cmp_path,
105 USB_HID_PATH_COMPARE_STRICT) == EOK){
[1519b91]106 break;
[b72efe8]107 }
[1519b91]108 path_it = path_it->next;
109 }
[b72efe8]110 if(path_it == &report->collection_paths.head) {
[f3b39b4]111 path = usb_hid_report_path_clone(cmp_path);
112 if(path == NULL) {
113 return NULL;
114 }
[b72efe8]115 list_append(&path->cpath_link, &report->collection_paths);
[1519b91]116 report->collection_paths_count++;
[b9d7965]117
118 return path;
119 }
120 else {
[f3b39b4]121 return list_get_instance(path_it, usb_hid_report_path_t,
[b72efe8]122 cpath_link);
[1519b91]123 }
124}
[9d05599]125
[f3b39b4]126/*---------------------------------------------------------------------------*/
[9d05599]127/**
128 * Initialize the report descriptor parser structure
129 *
130 * @param parser Report descriptor parser structure
131 * @return Error code
[f3b39b4]132 * @retval EINVAL If no report structure was given
133 * @retval EOK If report structure was successfully initialized
[9d05599]134 */
135int usb_hid_report_init(usb_hid_report_t *report)
136{
137 if(report == NULL) {
138 return EINVAL;
139 }
140
141 memset(report, 0, sizeof(usb_hid_report_t));
142 list_initialize(&report->reports);
143 list_initialize(&report->collection_paths);
144
145 report->use_report_ids = 0;
146 return EOK;
147}
148
[f3b39b4]149/*---------------------------------------------------------------------------*/
[3b5d5b9d]150
[f3b39b4]151/**
[3b5d5b9d]152 *
153 *
[f3b39b4]154 * @param report Report structure in which the new report items should be
155 * stored
156 * @param report_item Current report descriptor's parsing state table
157 * @return Error code
158 * @retval EOK If all fields were successfully append to report
159 * @retval EINVAL If invalid parameters (NULL) was given
160 * @retval ENOMEM If there is no memmory to store new report description
161 *
[3b5d5b9d]162 */
[f3b39b4]163int usb_hid_report_append_fields(usb_hid_report_t *report,
164 usb_hid_report_item_t *report_item) {
165
[9d05599]166 usb_hid_report_field_t *field;
167 int i;
168
[3a6e423]169 uint32_t *usages;
170 int usages_used=0;
[f3b39b4]171
172 if((report == NULL) || (report_item == NULL)) {
173 return EINVAL;
174 }
175
[3a6e423]176 if(report_item->usages_count > 0){
177 usages = malloc(sizeof(int32_t) * report_item->usages_count);
[f3b39b4]178 memcpy(usages, report_item->usages, sizeof(int32_t) *
179 report_item->usages_count);
[9d05599]180 }
[3a6e423]181 else {
182 usages = NULL;
183 }
184
[1519b91]185 usb_hid_report_path_t *path = report_item->usage_path;
[9d05599]186 for(i=0; i<report_item->count; i++){
187
188 field = malloc(sizeof(usb_hid_report_field_t));
[574f276]189 if(field == NULL) {
190 return ENOMEM;
191 }
192
[9d05599]193 memset(field, 0, sizeof(usb_hid_report_field_t));
[b72efe8]194 link_initialize(&field->ritems_link);
[9d05599]195
196 /* fill the attributes */
197 field->logical_minimum = report_item->logical_minimum;
198 field->logical_maximum = report_item->logical_maximum;
199 field->physical_minimum = report_item->physical_minimum;
200 field->physical_maximum = report_item->physical_maximum;
201
[3a6e423]202 if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0){
203 /*
[f3b39b4]204 Store usage array. The Correct Usage Page and Usage is
205 depending on data in report and will be filled later
[3a6e423]206 */
207 field->usage = 0;
208 field->usage_page = 0; //report_item->usage_page;
209
210 field->usages_count = report_item->usages_count;
211 field->usages = usages;
212 usages_used = 1;
[9d05599]213 }
214 else {
215
[3a6e423]216 /* Fill the correct Usage and Usage Page */
217 int32_t usage;
218 if(i < report_item->usages_count) {
[3b5d5b9d]219 usage = report_item->usages[i];
[9d05599]220 }
221 else {
[ee7e7c93]222 usage = report_item->usages[
[f3b39b4]223 report_item->usages_count- 1];
[9d05599]224 }
225
[3a6e423]226 if(USB_HID_IS_EXTENDED_USAGE(usage)){
227 field->usage = USB_HID_EXTENDED_USAGE(usage);
[f3b39b4]228 field->usage_page =
229 USB_HID_EXTENDED_USAGE_PAGE(usage);
[9d05599]230 }
231 else {
[3a6e423]232 // should not occur
[9d05599]233 field->usage = usage;
[3a6e423]234 field->usage_page = report_item->usage_page;
[9d05599]235 }
236 }
237
[f3b39b4]238 usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_GLOBAL,
239 field->usage_page);
240 usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_LOCAL,
241 field->usage);
[1519b91]242
[f3b39b4]243 field->collection_path =
244 usb_hid_report_path_try_insert(report, path);
[1519b91]245
[9d05599]246 field->size = report_item->size;
[ee7e7c93]247
[574f276]248 if(report_item->type == USB_HID_REPORT_TYPE_INPUT) {
[ee7e7c93]249 int offset = report_item->offset + report_item->size * i;
250 int field_offset = (offset/8)*8 + (offset/8 + 1) * 8 -
251 offset - report_item->size;
252 if(field_offset < 0) {
253 field->offset = 0;
254 }
255 else {
256 field->offset = field_offset;
257 }
[574f276]258 }
259 else {
260 field->offset = report_item->offset + (i * report_item->size);
261 }
[3b5d5b9d]262
[ee7e7c93]263
[574f276]264 if(report->use_report_ids != 0) {
[9d05599]265 field->offset += 8;
266 report->use_report_ids = 1;
267 }
[ee7e7c93]268
[9d05599]269 field->item_flags = report_item->item_flags;
270
271 /* find the right report list*/
272 usb_hid_report_description_t *report_des;
[f3b39b4]273 report_des = usb_hid_report_find_description(report,
274 report_item->id, report_item->type);
275
[9d05599]276 if(report_des == NULL){
[f3b39b4]277 report_des = malloc(
278 sizeof(usb_hid_report_description_t));
279 if(report_des == NULL) {
280 return ENOMEM;
281 }
282
283 memset(report_des, 0,
284 sizeof(usb_hid_report_description_t));
[9d05599]285
286 report_des->type = report_item->type;
287 report_des->report_id = report_item->id;
[1432fcf3]288 if(report_des->report_id != 0) {
289 /* set up the bit length by report_id field */
290 report_des->bit_length = 8;
291 }
292
[b72efe8]293 link_initialize (&report_des->reports_link);
[9d05599]294 list_initialize (&report_des->report_items);
295
[b72efe8]296 list_append(&report_des->reports_link, &report->reports);
[9d05599]297 report->report_count++;
298 }
299
300 /* append this field to the end of founded report list */
[b72efe8]301 list_append(&field->ritems_link, &report_des->report_items);
[9d05599]302
303 /* update the sizes */
304 report_des->bit_length += field->size;
305 report_des->item_length++;
306
307 }
308
[3a6e423]309 // free only when not used!!!
310 if(usages && usages_used == 0) {
311 free(usages);
312 }
[9d05599]313
314 return EOK;
315}
[f3b39b4]316/*---------------------------------------------------------------------------*/
317/**
318 * Finds description of report with given report_id and of given type in
319 * opaque report structure.
320 *
321 * @param report Opaque structure containing the parsed report descriptor
322 * @param report_id ReportId of report we are searching
323 * @param type Type of report we are searching
324 * @return Pointer to the particular report description
325 * @retval NULL If no description is founded
326 */
327usb_hid_report_description_t * usb_hid_report_find_description(
328 const usb_hid_report_t *report, uint8_t report_id,
329 usb_hid_report_type_t type) {
[9d05599]330
[0dd3e49]331 if(report == NULL) {
332 return NULL;
333 }
334
[9d05599]335 usb_hid_report_description_t *report_des = NULL;
336
[b72efe8]337 list_foreach(report->reports, report_it) {
[f3b39b4]338 report_des = list_get_instance(report_it,
[b72efe8]339 usb_hid_report_description_t, reports_link);
[9d05599]340
[dcb7d7cd]341 // if report id not set, return the first of the type
342 if(((report_des->report_id == report_id) || (report_id == 0)) &&
[f3b39b4]343 (report_des->type == type)) {
[9d05599]344 return report_des;
345 }
346 }
347
348 return NULL;
349}
[f3b39b4]350/*---------------------------------------------------------------------------*/
[9d05599]351
352/** Parse HID report descriptor.
353 *
354 * @param parser Opaque HID report parser structure.
355 * @param data Data describing the report.
356 * @return Error code.
[f3b39b4]357 * @retval ENOMEM If no more memmory is available
358 * @retval EINVAL If invalid data are founded
359 * @retval EOK If report descriptor is successfully parsed
[9d05599]360 */
361int usb_hid_parse_report_descriptor(usb_hid_report_t *report,
362 const uint8_t *data, size_t size)
363{
364 size_t i=0;
365 uint8_t tag=0;
366 uint8_t item_size=0;
367 int class=0;
368 int ret;
369 usb_hid_report_item_t *report_item=0;
370 usb_hid_report_item_t *new_report_item;
371 usb_hid_report_path_t *usage_path;
372
373 size_t offset_input=0;
374 size_t offset_output=0;
375 size_t offset_feature=0;
[b72efe8]376
377 link_t *item_link;
[9d05599]378
[b72efe8]379 list_t stack;
380 list_initialize(&stack);
[9d05599]381
382 /* parser structure initialization*/
383 if(usb_hid_report_init(report) != EOK) {
384 return EINVAL;
385 }
386
387 /*report item initialization*/
388 if(!(report_item=malloc(sizeof(usb_hid_report_item_t)))){
389 return ENOMEM;
390 }
391 memset(report_item, 0, sizeof(usb_hid_report_item_t));
[b72efe8]392 link_initialize(&(report_item->link));
[9d05599]393
394 /* usage path context initialization */
395 if(!(usage_path=usb_hid_report_path())){
396 return ENOMEM;
397 }
[22ded10]398 usb_hid_report_path_append_item(usage_path, 0, 0);
[9d05599]399
400 while(i<size){
401 if(!USB_HID_ITEM_IS_LONG(data[i])){
402
403 if((i+USB_HID_ITEM_SIZE(data[i]))>= size){
404 return EINVAL;
405 }
406
407 tag = USB_HID_ITEM_TAG(data[i]);
408 item_size = USB_HID_ITEM_SIZE(data[i]);
409 class = USB_HID_ITEM_TAG_CLASS(data[i]);
410
411 ret = usb_hid_report_parse_tag(tag,class,data+i+1,
[f3b39b4]412 item_size,report_item, usage_path);
413
[9d05599]414 switch(ret){
[f3b39b4]415 case USB_HID_NEW_REPORT_ITEM:
416 /* store report item to report and create the
417 * new one store current collection path
418 */
419 report_item->usage_path = usage_path;
[9d05599]420
[f3b39b4]421 usb_hid_report_path_set_report_id(
422 report_item->usage_path, report_item->id);
423
424 if(report_item->id != 0){
425 report->use_report_ids = 1;
426 }
[9d05599]427
[f3b39b4]428 switch(tag) {
429 case USB_HID_REPORT_TAG_INPUT:
430 report_item->type =
431 USB_HID_REPORT_TYPE_INPUT;
432
433 report_item->offset = offset_input;
434 offset_input += report_item->count *
435 report_item->size;
436 break;
437
438 case USB_HID_REPORT_TAG_OUTPUT:
439 report_item->type =
440 USB_HID_REPORT_TYPE_OUTPUT;
[9d05599]441
[f3b39b4]442 report_item->offset = offset_output;
443 offset_output += report_item->count *
444 report_item->size;
[9d05599]445 break;
[f3b39b4]446
447 case USB_HID_REPORT_TAG_FEATURE:
448 report_item->type =
449 USB_HID_REPORT_TYPE_FEATURE;
[9d05599]450
[f3b39b4]451 report_item->offset = offset_feature;
452 offset_feature += report_item->count *
453 report_item->size;
[9d05599]454 break;
[f3b39b4]455
456 default:
457 usb_log_debug2(
458 "\tjump over - tag %X\n", tag);
459 break;
460 }
461
462 /*
463 * append new fields to the report structure
464 */
465 usb_hid_report_append_fields(report,
466 report_item);
467
468 /* reset local items */
469 usb_hid_report_reset_local_items (report_item);
470 break;
471
472 case USB_HID_RESET_OFFSET:
473 offset_input = 0;
474 offset_output = 0;
475 offset_feature = 0;
476 usb_hid_report_path_set_report_id (usage_path,
477 report_item->id);
478 break;
479
480 case USB_HID_REPORT_TAG_PUSH:
481 // push current state to stack
482 new_report_item = usb_hid_report_item_clone(
483 report_item);
484
485 usb_hid_report_path_t *tmp_path =
486 usb_hid_report_path_clone(usage_path);
[9d05599]487
[f3b39b4]488 new_report_item->usage_path = tmp_path;
[9d05599]489
[f3b39b4]490 list_prepend (&new_report_item->link, &stack);
491 break;
492 case USB_HID_REPORT_TAG_POP:
493 // restore current state from stack
[b72efe8]494 item_link = list_first(&stack);
495 if (item_link == NULL) {
[f3b39b4]496 return EINVAL;
497 }
498 free(report_item);
[b72efe8]499
500 report_item = list_get_instance(item_link,
[f3b39b4]501 usb_hid_report_item_t, link);
[b72efe8]502
[f3b39b4]503 usb_hid_report_usage_path_t *tmp_usage_path;
504 tmp_usage_path = list_get_instance(
[b72efe8]505 report_item->usage_path->cpath_link.prev,
506 usb_hid_report_usage_path_t, rpath_items_link);
507
[f3b39b4]508 usb_hid_report_set_last_item(usage_path,
509 USB_HID_TAG_CLASS_GLOBAL, tmp_usage_path->usage_page);
510
511 usb_hid_report_set_last_item(usage_path,
512 USB_HID_TAG_CLASS_LOCAL, tmp_usage_path->usage);
[9d05599]513
[f3b39b4]514 usb_hid_report_path_free(report_item->usage_path);
[b72efe8]515 list_remove (item_link);
[9d05599]516
[f3b39b4]517 break;
[9d05599]518
[f3b39b4]519 default:
520 // nothing special to do
521 break;
[9d05599]522 }
523
524 /* jump over the processed block */
525 i += 1 + USB_HID_ITEM_SIZE(data[i]);
526 }
527 else{
528 // TBD
529 i += 3 + USB_HID_ITEM_SIZE(data[i+1]);
530 }
531
532
533 }
534
535 return EOK;
536}
537
[f3b39b4]538/*---------------------------------------------------------------------------*/
[9d05599]539
540/**
541 * Parse one tag of the report descriptor
542 *
543 * @param Tag to parse
544 * @param Report descriptor buffer
545 * @param Size of data belongs to this tag
546 * @param Current report item structe
547 * @return Code of action to be done next
548 */
[f3b39b4]549int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data,
550 size_t item_size, usb_hid_report_item_t *report_item,
551 usb_hid_report_path_t *usage_path) {
552
[9d05599]553 int ret;
554
555 switch(class){
[f3b39b4]556 case USB_HID_TAG_CLASS_MAIN:
[9d05599]557
[f3b39b4]558 if((ret=usb_hid_report_parse_main_tag(tag, data, item_size,
559 report_item, usage_path)) == EOK) {
[9d05599]560
[f3b39b4]561 return USB_HID_NEW_REPORT_ITEM;
562 }
563 else {
564 return ret;
565 }
566 break;
[9d05599]567
[f3b39b4]568 case USB_HID_TAG_CLASS_GLOBAL:
569 return usb_hid_report_parse_global_tag(tag, data, item_size,
570 report_item, usage_path);
571 break;
572
573 case USB_HID_TAG_CLASS_LOCAL:
574 return usb_hid_report_parse_local_tag(tag, data, item_size,
575 report_item, usage_path);
576 break;
577
578 default:
579 return USB_HID_NO_ACTION;
[9d05599]580 }
581}
582
583/**
584 * Parse main tags of report descriptor
585 *
586 * @param Tag identifier
587 * @param Data buffer
588 * @param Length of data buffer
589 * @param Current state table
590 * @return Error code
591 */
592
[f3b39b4]593int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data,
594 size_t item_size, usb_hid_report_item_t *report_item,
595 usb_hid_report_path_t *usage_path)
[674cf89]596{
597 usb_hid_report_usage_path_t *path_item;
598
[9d05599]599 switch(tag)
600 {
[f3b39b4]601 case USB_HID_REPORT_TAG_INPUT:
602 case USB_HID_REPORT_TAG_OUTPUT:
603 case USB_HID_REPORT_TAG_FEATURE:
604 report_item->item_flags = *data;
605 return EOK;
606 break;
[9d05599]607
[f3b39b4]608 case USB_HID_REPORT_TAG_COLLECTION:
[3a6e423]609
[f3b39b4]610 /* store collection atributes */
[b72efe8]611 path_item = list_get_instance(list_first(&usage_path->items),
612 usb_hid_report_usage_path_t, rpath_items_link);
613 path_item->flags = *data;
[22ded10]614
[f3b39b4]615 /* set last item */
616 usb_hid_report_set_last_item(usage_path,
617 USB_HID_TAG_CLASS_GLOBAL,
618 USB_HID_EXTENDED_USAGE_PAGE(report_item->usages[
619 report_item->usages_count-1]));
620
621 usb_hid_report_set_last_item(usage_path,
622 USB_HID_TAG_CLASS_LOCAL,
623 USB_HID_EXTENDED_USAGE(report_item->usages[
624 report_item->usages_count-1]));
[674cf89]625
[f3b39b4]626 /* append the new one which will be set by common usage/usage
627 * page */
628 usb_hid_report_path_append_item(usage_path,
629 report_item->usage_page,
630 report_item->usages[report_item->usages_count-1]);
631
632 usb_hid_report_reset_local_items (report_item);
633 return USB_HID_NO_ACTION;
634 break;
[9d05599]635
[f3b39b4]636 case USB_HID_REPORT_TAG_END_COLLECTION:
637 usb_hid_report_remove_last_item(usage_path);
638 return USB_HID_NO_ACTION;
639 break;
640
641 default:
642 return USB_HID_NO_ACTION;
[9d05599]643 }
644
645 return EOK;
646}
647
648/**
649 * Parse global tags of report descriptor
650 *
651 * @param Tag identifier
652 * @param Data buffer
653 * @param Length of data buffer
654 * @param Current state table
655 * @return Error code
656 */
[f3b39b4]657int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data,
658 size_t item_size, usb_hid_report_item_t *report_item,
659 usb_hid_report_path_t *usage_path) {
660
[9d05599]661 switch(tag)
662 {
[f3b39b4]663 case USB_HID_REPORT_TAG_USAGE_PAGE:
664 report_item->usage_page =
665 usb_hid_report_tag_data_uint32(data, item_size);
666 break;
667
668 case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
669 report_item->logical_minimum = USB_HID_UINT32_TO_INT32(
670 usb_hid_report_tag_data_uint32(data,item_size),
671 item_size * 8);
672 break;
673
674 case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM:
675 report_item->logical_maximum = USB_HID_UINT32_TO_INT32(
676 usb_hid_report_tag_data_uint32(data,item_size),
677 item_size * 8);
678 break;
679
680 case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM:
681 report_item->physical_minimum = USB_HID_UINT32_TO_INT32(
682 usb_hid_report_tag_data_uint32(data,item_size),
683 item_size * 8);
684 break;
685
686 case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM:
687 report_item->physical_maximum = USB_HID_UINT32_TO_INT32(
688 usb_hid_report_tag_data_uint32(data,item_size),
689 item_size * 8);
690 break;
691
692 case USB_HID_REPORT_TAG_UNIT_EXPONENT:
693 report_item->unit_exponent = usb_hid_report_tag_data_uint32(
694 data,item_size);
695 break;
696
697 case USB_HID_REPORT_TAG_UNIT:
698 report_item->unit = usb_hid_report_tag_data_uint32(
699 data,item_size);
700 break;
701
702 case USB_HID_REPORT_TAG_REPORT_SIZE:
703 report_item->size = usb_hid_report_tag_data_uint32(
704 data,item_size);
705 break;
706
707 case USB_HID_REPORT_TAG_REPORT_COUNT:
708 report_item->count = usb_hid_report_tag_data_uint32(
709 data,item_size);
710 break;
711
712 case USB_HID_REPORT_TAG_REPORT_ID:
713 report_item->id = usb_hid_report_tag_data_uint32(data,
714 item_size);
715 return USB_HID_RESET_OFFSET;
716 break;
717
718 case USB_HID_REPORT_TAG_PUSH:
719 case USB_HID_REPORT_TAG_POP:
720 /*
721 * stack operations are done in top level parsing
722 * function
723 */
724 return tag;
725 break;
[9d05599]726
[f3b39b4]727 default:
728 return USB_HID_NO_ACTION;
[9d05599]729 }
730
731 return EOK;
732}
733
734/**
735 * Parse local tags of report descriptor
736 *
737 * @param Tag identifier
738 * @param Data buffer
739 * @param Length of data buffer
740 * @param Current state table
741 * @return Error code
742 */
[f3b39b4]743int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data,
744 size_t item_size, usb_hid_report_item_t *report_item,
745 usb_hid_report_path_t *usage_path)
[9d05599]746{
[3a6e423]747 int32_t extended_usage;
748
[1be39e9]749 switch(tag) {
[f3b39b4]750 case USB_HID_REPORT_TAG_USAGE:
751 switch(report_item->in_delimiter) {
752 case INSIDE_DELIMITER_SET:
753 /* nothing to do
754 * we catch only the first one
755 */
[1be39e9]756 break;
[f3b39b4]757
758 case START_DELIMITER_SET:
759 report_item->in_delimiter = INSIDE_DELIMITER_SET;
760 case OUTSIDE_DELIMITER_SET:
761 extended_usage = ((report_item->usage_page) << 16);
762 extended_usage += usb_hid_report_tag_data_uint32(
763 data,item_size);
[3a6e423]764
[f3b39b4]765 report_item->usages[report_item->usages_count] =
766 extended_usage;
767
768 report_item->usages_count++;
769 break;
770 }
771 break;
772
773 case USB_HID_REPORT_TAG_USAGE_MINIMUM:
774 if (item_size == 3) {
775 // usage extended usages
776 report_item->extended_usage_page =
777 USB_HID_EXTENDED_USAGE_PAGE(
778 usb_hid_report_tag_data_uint32(data,item_size));
779
780
781 report_item->usage_minimum =
782 USB_HID_EXTENDED_USAGE(
783 usb_hid_report_tag_data_uint32(data,item_size));
784 }
785 else {
786 report_item->usage_minimum =
787 usb_hid_report_tag_data_uint32(data,item_size);
788 }
789 break;
790
791 case USB_HID_REPORT_TAG_USAGE_MAXIMUM:
792 if (item_size == 3) {
793 if(report_item->extended_usage_page !=
794 USB_HID_EXTENDED_USAGE_PAGE(
795 usb_hid_report_tag_data_uint32(data,item_size))) {
[3a6e423]796
[f3b39b4]797 return EINVAL;
[1be39e9]798 }
[f3b39b4]799
800 // usage extended usages
801 report_item->extended_usage_page =
802 USB_HID_EXTENDED_USAGE_PAGE(
803 usb_hid_report_tag_data_uint32(data,item_size));
804
805 report_item->usage_maximum =
806 USB_HID_EXTENDED_USAGE(
807 usb_hid_report_tag_data_uint32(data,item_size));
808 }
809 else {
810 report_item->usage_maximum =
811 usb_hid_report_tag_data_uint32(data,item_size);
812 }
[3a6e423]813
[f3b39b4]814 // vlozit zaznamy do pole usages
815 int32_t i;
816 for(i = report_item->usage_minimum;
817 i <= report_item->usage_maximum; i++) {
818
819 if(report_item->extended_usage_page) {
820 report_item->usages[report_item->usages_count++] =
821 (report_item->extended_usage_page << 16) + i;
[3a6e423]822 }
[f3b39b4]823 else {
824 report_item->usages[report_item->usages_count++] =
825 (report_item->usage_page << 16) + i;
826 }
827 }
828 report_item->extended_usage_page = 0;
[3a6e423]829
[f3b39b4]830 break;
831
832 case USB_HID_REPORT_TAG_DESIGNATOR_INDEX:
833 report_item->designator_index =
834 usb_hid_report_tag_data_uint32(data,item_size);
835 break;
836
837 case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM:
838 report_item->designator_minimum =
839 usb_hid_report_tag_data_uint32(data,item_size);
840 break;
841
842 case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM:
843 report_item->designator_maximum =
844 usb_hid_report_tag_data_uint32(data,item_size);
845 break;
846
847 case USB_HID_REPORT_TAG_STRING_INDEX:
848 report_item->string_index =
849 usb_hid_report_tag_data_uint32(data,item_size);
850 break;
851
852 case USB_HID_REPORT_TAG_STRING_MINIMUM:
853 report_item->string_minimum =
854 usb_hid_report_tag_data_uint32(data,item_size);
855 break;
856
857 case USB_HID_REPORT_TAG_STRING_MAXIMUM:
858 report_item->string_maximum =
859 usb_hid_report_tag_data_uint32(data,item_size);
860 break;
861
862 case USB_HID_REPORT_TAG_DELIMITER:
863 report_item->in_delimiter =
864 usb_hid_report_tag_data_uint32(data,item_size);
865 break;
866
867 default:
868 return USB_HID_NO_ACTION;
[9d05599]869 }
[1be39e9]870
[9d05599]871 return EOK;
872}
[f3b39b4]873/*---------------------------------------------------------------------------*/
[9d05599]874
875/**
876 * Converts raw data to uint32 (thats the maximum length of short item data)
877 *
878 * @param Data buffer
879 * @param Size of buffer
880 * @return Converted int32 number
881 */
882uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size)
883{
884 unsigned int i;
885 uint32_t result;
886
887 result = 0;
888 for(i=0; i<size; i++) {
889 result = (result | (data[i]) << (i*8));
890 }
891
892 return result;
893}
[f3b39b4]894/*---------------------------------------------------------------------------*/
[9d05599]895
896/**
897 * Prints content of given list of report items.
898 *
899 * @param List of report items (usb_hid_report_item_t)
900 * @return void
901 */
[b72efe8]902void usb_hid_descriptor_print_list(list_t *list)
[9d05599]903{
904 usb_hid_report_field_t *report_item;
905
[b72efe8]906 if(list == NULL || list_empty(list)) {
[9d05599]907 usb_log_debug("\tempty\n");
908 return;
909 }
[b72efe8]910
911 list_foreach(*list, item) {
912 report_item = list_get_instance(item, usb_hid_report_field_t,
913 ritems_link);
[9d05599]914
915 usb_log_debug("\t\tOFFSET: %X\n", report_item->offset);
[f3b39b4]916 usb_log_debug("\t\tSIZE: %zu\n", report_item->size);
[b72efe8]917 usb_log_debug("\t\tLOGMIN: %d\n",
[f3b39b4]918 report_item->logical_minimum);
[b72efe8]919 usb_log_debug("\t\tLOGMAX: %d\n",
920 report_item->logical_maximum);
921 usb_log_debug("\t\tPHYMIN: %d\n",
922 report_item->physical_minimum);
923 usb_log_debug("\t\tPHYMAX: %d\n",
924 report_item->physical_maximum);
925 usb_log_debug("\t\ttUSAGEMIN: %X\n",
[f3b39b4]926 report_item->usage_minimum);
927 usb_log_debug("\t\tUSAGEMAX: %X\n",
928 report_item->usage_maximum);
[b72efe8]929 usb_log_debug("\t\tUSAGES COUNT: %zu\n",
[f3b39b4]930 report_item->usages_count);
[9d05599]931
932 usb_log_debug("\t\tVALUE: %X\n", report_item->value);
933 usb_log_debug("\t\ttUSAGE: %X\n", report_item->usage);
934 usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page);
[b72efe8]935
[3a6e423]936 usb_hid_print_usage_path(report_item->collection_path);
[b9d7965]937
[b72efe8]938 usb_log_debug("\n");
[9d05599]939
940 }
941
942}
[f3b39b4]943/*---------------------------------------------------------------------------*/
944
[9d05599]945/**
946 * Prints content of given report descriptor in human readable format.
947 *
948 * @param parser Parsed descriptor to print
949 * @return void
950 */
951void usb_hid_descriptor_print(usb_hid_report_t *report)
952{
953 if(report == NULL) {
954 return;
955 }
956
957 usb_hid_report_description_t *report_des;
958
[b72efe8]959 list_foreach(report->reports, report_it) {
960 report_des = list_get_instance(report_it,
961 usb_hid_report_description_t, reports_link);
[9d05599]962 usb_log_debug("Report ID: %d\n", report_des->report_id);
963 usb_log_debug("\tType: %d\n", report_des->type);
[b72efe8]964 usb_log_debug("\tLength: %zu\n", report_des->bit_length);
[d861c22]965 usb_log_debug("\tB Size: %zu\n",
[b72efe8]966 usb_hid_report_byte_size(report,
967 report_des->report_id,
[d861c22]968 report_des->type));
[b72efe8]969 usb_log_debug("\tItems: %zu\n", report_des->item_length);
[9d05599]970
971 usb_hid_descriptor_print_list(&report_des->report_items);
972 }
973}
[f3b39b4]974/*---------------------------------------------------------------------------*/
[9d05599]975
976/**
977 * Releases whole linked list of report items
978 *
[b72efe8]979 * @param list List of report descriptor items (usb_hid_report_item_t)
[9d05599]980 * @return void
981 */
[b72efe8]982void usb_hid_free_report_list(list_t *list)
[9d05599]983{
[b72efe8]984 return; /* XXX What's this? */
[9d05599]985
[b72efe8]986/* usb_hid_report_item_t *report_item;
[9d05599]987 link_t *next;
988
[b72efe8]989 if(list == NULL || list_empty(list)) {
[9d05599]990 return;
991 }
992
[b72efe8]993 next = list->head.next;
994 while (next != &list->head) {
995 report_item = list_get_instance(next, usb_hid_report_item_t,
996 rpath_items_link);
[9d05599]997
998 while(!list_empty(&report_item->usage_path->link)) {
[b72efe8]999 usb_hid_report_remove_last_item(report_item->usage_path);
[9d05599]1000 }
1001
1002
1003 next = next->next;
1004
1005 free(report_item);
1006 }
1007
1008 return;
[b72efe8]1009 */
[9d05599]1010}
[f3b39b4]1011/*---------------------------------------------------------------------------*/
[9d05599]1012
1013/** Frees the HID report descriptor parser structure
1014 *
1015 * @param parser Opaque HID report parser structure
1016 * @return void
1017 */
1018void usb_hid_free_report(usb_hid_report_t *report)
1019{
1020 if(report == NULL){
1021 return;
1022 }
1023
1024 // free collection paths
[b72efe8]1025 link_t *path_link;
[9d05599]1026 usb_hid_report_path_t *path;
1027 while(!list_empty(&report->collection_paths)) {
[b72efe8]1028 path_link = list_first(&report->collection_paths);
1029 path = list_get_instance(path_link,
1030 usb_hid_report_path_t, cpath_link);
[f3b39b4]1031
[b72efe8]1032 list_remove(path_link);
1033 usb_hid_report_path_free(path);
[9d05599]1034 }
1035
1036 // free report items
1037 usb_hid_report_description_t *report_des;
1038 usb_hid_report_field_t *field;
1039 while(!list_empty(&report->reports)) {
[b72efe8]1040 report_des = list_get_instance(list_first(&report->reports),
1041 usb_hid_report_description_t, reports_link);
[f3b39b4]1042
[b72efe8]1043 list_remove(&report_des->reports_link);
[9d05599]1044
1045 while(!list_empty(&report_des->report_items)) {
[f3b39b4]1046 field = list_get_instance(
[b72efe8]1047 list_first(&report_des->report_items),
1048 usb_hid_report_field_t, ritems_link);
[f3b39b4]1049
[b72efe8]1050 list_remove(&field->ritems_link);
[9d05599]1051
1052 free(field);
1053 }
1054
1055 free(report_des);
1056 }
1057
1058 return;
1059}
[f3b39b4]1060/*---------------------------------------------------------------------------*/
[9d05599]1061
1062/**
1063 * @}
1064 */
Note: See TracBrowser for help on using the repository browser.