Index: uspace/lib/usb/include/usb/classes/hid/utled.h =================================================================== --- uspace/lib/usb/include/usb/classes/hid/utled.h (revision 8e7d724e2db8b57d2c79ffdc0e5467e61abcae0b) +++ uspace/lib/usb/include/usb/classes/hid/utled.h (revision 8e7d724e2db8b57d2c79ffdc0e5467e61abcae0b) @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2010 Lubos Slovak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * @brief USB HID Usage Tables - LED page. + */ +#ifndef LIBUSB_UTLED_H_ +#define LIBUSB_UTLED_H_ + +typedef enum { + USB_HID_LED_UNDEFINED = 0, + USB_HID_LED_NUM_LOCK, + USB_HID_LED_CAPS_LOCK, + USB_HID_LED_SCROLL_LOCK, + USB_HID_LED_COMPOSE, + USB_HID_LED_KANA, + USB_HID_LED_POWER, + USB_HID_LED_SHIFT, + USB_HID_LED_DND, + USB_HID_LED_MUTE, + USB_HID_LED_TONE_ENABLE, + USB_HID_LED_HIGH_CUT_FILTER, + USB_HID_LED_LOW_CUT_FILTER, + USB_HID_LED_EQ_ENABLE, + USB_HID_LED_SOUND_FIELD_ON, + USB_HID_LED_SURROUND_ON, + USB_HID_LED_REPEAT, + USB_HID_LED_STEREO, + USB_HID_LED_SAMPLING_RATE_DETECT, + USB_HID_LED_SPINNING, + USB_HID_LED_CAV, + USB_HID_LED_CLV, + USB_HID_LED_RECORDING_FORMAT_DETECT, + USB_HID_LED_OFF_HOOK, + USB_HID_LED_RING, + USB_HID_LED_MESSAGE_WAITING, + USB_HID_LED_DATA_MODE, + USB_HID_LED_BATTERY_OPERATION, + USB_HID_LED_BATTERY_OK, + USB_HID_LED_BATTERY_LOW, + USB_HID_LED_SPEAKER, + USB_HID_LED_HEAD_SET, + USB_HID_LED_HOLD, + USB_HID_LED_MICRO, + USB_HID_LED_COVERAGE, + USB_HID_LED_NIGHT_MODE, + USB_HID_LED_SEND_CALLS, + USB_HID_LED_CALL_PICKUP, + USB_HID_LED_CONFERENCE, + USB_HID_LED_STAND_BY, + USB_HID_LED_CAMERA_ON, + USB_HID_LED_CAMERA_OFF, + USB_HID_LED_ON_LINE, + USB_HID_LED_OFF_LINE, + USB_HID_LED_BUSY, + USB_HID_LED_READY, + USB_HID_LED_PAPER_OUT, + USB_HID_LED_PAPER_JAM, + USB_HID_LED_REMOTE, + USB_HID_LED_FORWARD, + USB_HID_LED_REVERSE, + USB_HID_LED_STOP, + USB_HID_LED_REWIND, + USB_HID_LED_FAST_FORWARD, + USB_HID_LED_PLAY, + USB_HID_LED_PAUSE, + USB_HID_LED_RECORD, + USB_HID_LED_ERROR, + USB_HID_LED_USAGE_SELECTED_IND, + USB_HID_LED_USAGE_IN_USE_IND, + USB_HID_LED_USAGE_MULTI_MODE_IND, + USB_HID_LED_IND_ON, + USB_HID_LED_IND_FLASH, + USB_HID_LED_IND_SLOW_BLINK, + USB_HID_LED_IND_FAST_BLINK, + USB_HID_LED_IND_OFF, + USB_HID_LED_FLASH_ON_TIME, + USB_HID_LED_SLOW_BLINK_ON_TIME, + USB_HID_LED_SLOW_BLINK_OFF_TIME, + USB_HID_LED_FAST_BLINK_ON_TIME, + USB_HID_LED_FAST_BLINK_OFF_TIME, + USB_HID_LED_USAGE_IND_COLOR, + USB_HID_LED_IND_RED, + USB_HID_LED_IND_GREEN, + USB_HID_LED_IND_AMBER, + USB_HID_LED_GENERIC_IND, + USB_HID_LED_SYSTEM_SUSPEND, + USB_HID_LED_EXTERNAL_POWER +} usb_hid_usage_led_t; + +#endif /* LIBUSB_UTLED_H_ */ +/** + * @} + */ Index: uspace/lib/usb/include/usb/classes/hidparser.h =================================================================== --- uspace/lib/usb/include/usb/classes/hidparser.h (revision 66a54cca9f5cd9c1ecc9a96ea5ec1ab1c05590e5) +++ uspace/lib/usb/include/usb/classes/hidparser.h (revision 8e7d724e2db8b57d2c79ffdc0e5467e61abcae0b) @@ -31,5 +31,5 @@ */ /** @file - * @brief USB HID parser. + * USB HID report descriptor and report data parser */ #ifndef LIBUSB_HIDPARSER_H_ @@ -74,13 +74,20 @@ #define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY 4 +/** */ typedef struct { + /** */ int32_t usage_page; + /** */ int32_t usage; - + /** */ link_t link; } usb_hid_report_usage_path_t; +/** */ typedef struct { + /** */ int depth; + + /** */ link_t link; } usb_hid_report_path_t; @@ -90,32 +97,50 @@ */ typedef struct { + /** */ int32_t id; + /** */ int32_t usage_minimum; + /** */ int32_t usage_maximum; + /** */ int32_t logical_minimum; + /** */ int32_t logical_maximum; + /** */ int32_t size; + /** */ int32_t count; + /** */ size_t offset; + /** */ int32_t delimiter; - + /** */ int32_t unit_exponent; + /** */ int32_t unit; - /* - * some not yet used fields - */ + /** */ int32_t string_index; + /** */ int32_t string_minimum; + /** */ int32_t string_maximum; + /** */ int32_t designator_index; + /** */ int32_t designator_minimum; + /** */ int32_t designator_maximum; + /** */ int32_t physical_minimum; + /** */ int32_t physical_maximum; + /** */ uint8_t item_flags; + /** */ usb_hid_report_path_t *usage_path; + /** */ link_t link; } usb_hid_report_item_t; @@ -124,6 +149,9 @@ /** HID report parser structure. */ typedef struct { + /** */ link_t input; + /** */ link_t output; + /** */ link_t feature; } usb_hid_report_parser_t; @@ -154,12 +182,12 @@ } usb_hid_modifiers_t; -typedef enum { - USB_HID_LED_NUM_LOCK = 0x1, - USB_HID_LED_CAPS_LOCK = 0x2, - USB_HID_LED_SCROLL_LOCK = 0x4, - USB_HID_LED_COMPOSE = 0x8, - USB_HID_LED_KANA = 0x10, - USB_HID_LED_COUNT = 5 -} usb_hid_led_t; +//typedef enum { +// USB_HID_LED_NUM_LOCK = 0x1, +// USB_HID_LED_CAPS_LOCK = 0x2, +// USB_HID_LED_SCROLL_LOCK = 0x4, +// USB_HID_LED_COMPOSE = 0x8, +// USB_HID_LED_KANA = 0x10, +// USB_HID_LED_COUNT = 5 +//} usb_hid_led_t; static const usb_hid_modifiers_t @@ -190,16 +218,34 @@ /* - * modifiers definitions - */ - + * Descriptor parser functions + */ +/** */ +int usb_hid_parser_init(usb_hid_report_parser_t *parser); + +/** */ +int usb_hid_parse_report_descriptor(usb_hid_report_parser_t *parser, + const uint8_t *data, size_t size); + +/** */ +void usb_hid_free_report_parser(usb_hid_report_parser_t *parser); + +/** */ +void usb_hid_descriptor_print(usb_hid_report_parser_t *parser); + +/* + * Boot protocol functions + */ +/** */ int usb_hid_boot_keyboard_input_report(const uint8_t *data, size_t size, const usb_hid_report_in_callbacks_t *callbacks, void *arg); +/** */ int usb_hid_boot_keyboard_output_report(uint8_t leds, uint8_t *data, size_t size); -int usb_hid_parser_init(usb_hid_report_parser_t *parser); -int usb_hid_parse_report_descriptor(usb_hid_report_parser_t *parser, - const uint8_t *data, size_t size); - + +/* + * Input report parser functions + */ +/** */ int usb_hid_parse_report(const usb_hid_report_parser_t *parser, const uint8_t *data, size_t size, @@ -207,28 +253,56 @@ const usb_hid_report_in_callbacks_t *callbacks, void *arg); -int usb_hid_report_input_length(const usb_hid_report_parser_t *parser, +/** */ +size_t usb_hid_report_input_length(const usb_hid_report_parser_t *parser, usb_hid_report_path_t *path, int flags); -void usb_hid_free_report_parser(usb_hid_report_parser_t *parser); - -void usb_hid_descriptor_print(usb_hid_report_parser_t *parser); - -/* usage path functions */ + +/* + * usage path functions + */ +/** */ usb_hid_report_path_t *usb_hid_report_path(void); + +/** */ void usb_hid_report_path_free(usb_hid_report_path_t *path); + +/** */ int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, int32_t usage_page, int32_t usage); + +/** */ void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path); + +/** */ void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path); + +/** */ void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data); + +/** */ int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, usb_hid_report_path_t *path, int flags); -int usb_hid_report_path_clone(usb_hid_report_path_t *new_usage_path, usb_hid_report_path_t *usage_path); - - -// output -// - funkce co vrati cesty poli v output reportu -// - funkce co pro danou cestu nastavi data -// - finalize - + +/** */ +usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path); + + +/* + * Output report parser functions + */ +/** Allocates output report buffer*/ +uint8_t *usb_hid_report_output(usb_hid_report_parser_t *parser, size_t *size); + +/** Frees output report buffer*/ +void usb_hid_report_output_free(uint8_t *output); + +/** Returns size of output for given usage path */ +size_t usb_hid_report_output_size(usb_hid_report_parser_t *parser, + usb_hid_report_path_t *path, int flags); + +/** Updates the output report buffer by translated given data */ +int usb_hid_report_output_translate(usb_hid_report_parser_t *parser, + usb_hid_report_path_t *path, int flags, + uint8_t *buffer, size_t size, + int32_t *data, size_t data_size); #endif /** Index: uspace/lib/usb/src/hidparser.c =================================================================== --- uspace/lib/usb/src/hidparser.c (revision 66a54cca9f5cd9c1ecc9a96ea5ec1ab1c05590e5) +++ uspace/lib/usb/src/hidparser.c (revision 8e7d724e2db8b57d2c79ffdc0e5467e61abcae0b) @@ -31,5 +31,5 @@ */ /** @file - * @brief HID parser implementation. + * HID report descriptor and report data parser implementation. */ #include @@ -40,10 +40,16 @@ #include +/** */ #define USB_HID_NEW_REPORT_ITEM 1 + +/** */ #define USB_HID_NO_ACTION 2 + +/** */ #define USB_HID_UNKNOWN_TAG -99 -#define BAD_HACK_USAGE_PAGE 0x07 - +/* + * Private descriptor parser functions + */ int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size, usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); @@ -58,10 +64,15 @@ int usb_hid_report_reset_local_items(); void usb_hid_free_report_list(link_t *head); + +/* + * Data translation private functions + */ int32_t usb_hid_report_tag_data_int32(const uint8_t *data, size_t size); inline size_t usb_hid_count_item_offset(usb_hid_report_item_t * report_item, size_t offset); int usb_hid_translate_data(usb_hid_report_item_t *item, const uint8_t *data, size_t j); +int32_t usb_hid_translate_data_reverse(usb_hid_report_item_t *item, int32_t value); int usb_pow(int a, int b); - +// TODO: tohle ma bejt asi jinde int usb_pow(int a, int b) { @@ -80,13 +91,16 @@ /** - * + * Initialize the report descriptor parser structure + * + * @param parser Report descriptor parser structure + * @return Error code */ int usb_hid_parser_init(usb_hid_report_parser_t *parser) { - if(parser == NULL) { - return EINVAL; - } - - list_initialize(&(parser->input)); + if(parser == NULL) { + return EINVAL; + } + + list_initialize(&(parser->input)); list_initialize(&(parser->output)); list_initialize(&(parser->feature)); @@ -164,10 +178,7 @@ // store current usage path report_item->usage_path = usage_path; - - // new current usage path - tmp_usage_path = usb_hid_report_path(); - // copy old path to the new one - usb_hid_report_path_clone(tmp_usage_path, usage_path); + // clone path to the new one + tmp_usage_path = usb_hid_report_path_clone(usage_path); // swap @@ -304,4 +315,5 @@ /** + * Parse one tag of the report descriptor * * @param Tag to parse @@ -391,5 +403,4 @@ * @return Error code */ - int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size, usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) @@ -520,5 +531,5 @@ * Prints content of given list of report items. * - * @param List of report items + * @param List of report items (usb_hid_report_item_t) * @return void */ @@ -552,8 +563,5 @@ path = path->next; } - - -// usb_log_debug("\tUSAGE: %X\n", report_item->usage); -// usb_log_debug("\tUSAGE PAGE: %X\n", report_item->usage_page); + usb_log_debug("\tLOGMIN: %X\n", report_item->logical_minimum); usb_log_debug("\tLOGMAX: %X\n", report_item->logical_maximum); @@ -570,7 +578,7 @@ } /** - * Prints content of given descriptor in human readable format. - * - * @param Parsed descriptor to print + * Prints content of given report descriptor in human readable format. + * + * @param parser Parsed descriptor to print * @return void */ @@ -595,5 +603,6 @@ * Releases whole linked list of report items * - * + * @param head Head of list of report descriptor items (usb_hid_report_item_t) + * @return void */ void usb_hid_free_report_list(link_t *head) @@ -627,8 +636,8 @@ } -/** Free the HID report parser structure +/** Frees the HID report descriptor parser structure * * @param parser Opaque HID report parser structure - * @return Error code + * @return void */ void usb_hid_free_report_parser(usb_hid_report_parser_t *parser) @@ -660,9 +669,4 @@ const usb_hid_report_in_callbacks_t *callbacks, void *arg) { - /* - * - * only key codes (usage page 0x07) will be processed - * other usages will be ignored - */ link_t *list_item; usb_hid_report_item_t *item; @@ -676,7 +680,6 @@ return EINVAL; } - - - // get the size of result keycodes array + + /* get the size of result array */ key_count = usb_hid_report_input_length(parser, path, flags); @@ -685,5 +688,5 @@ } - // read data + /* read data */ list_item = parser->input.next; while(list_item != &(parser->input)) { @@ -719,5 +722,12 @@ } - +/** + * Translate data from the report as specified in report descriptor + * + * @param item Report descriptor item with definition of translation + * @param data Data to translate + * @param j Index of processed field in report descriptor item + * @return Translated data + */ int usb_hid_translate_data(usb_hid_report_item_t *item, const uint8_t *data, size_t j) { @@ -796,16 +806,24 @@ } -int usb_hid_report_input_length(const usb_hid_report_parser_t *parser, +/** + * + * + * @param parser + * @param path + * @param flags + * @return + */ +size_t usb_hid_report_input_length(const usb_hid_report_parser_t *parser, usb_hid_report_path_t *path, int flags) { - int ret = 0; + size_t ret = 0; link_t *item; usb_hid_report_item_t *report_item; if(parser == NULL) { - return EINVAL; - } - - item = (&parser->input)->next; + return 0; + } + + item = parser->input.next; while(&parser->input != item) { report_item = list_get_instance(item, usb_hid_report_item_t, link); @@ -824,4 +842,8 @@ /** * + * @param usage_path + * @param usage_page + * @param usage + * @return */ int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, @@ -845,4 +867,6 @@ /** * + * @param usage_path + * @return */ void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path) @@ -860,4 +884,6 @@ /** * + * @param usage_path + * @return */ void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path) @@ -873,4 +899,8 @@ /** * + * @param usage_path + * @param tag + * @param data + * @return */ void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data) @@ -894,5 +924,10 @@ /** - * + * + * + * @param report_path + * @param path + * @param flags + * @return */ int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, @@ -949,5 +984,5 @@ break; - /* given path must be the end of the report one*/ + /* compare with only the end of path*/ case USB_HID_PATH_COMPARE_END: report_link = report_path->link.prev; @@ -992,4 +1027,5 @@ /** * + * @return */ usb_hid_report_path_t *usb_hid_report_path(void) @@ -1009,4 +1045,6 @@ /** * + * @param path + * @return void */ void usb_hid_report_path_free(usb_hid_report_path_t *path) @@ -1019,14 +1057,21 @@ /** - * - */ -int usb_hid_report_path_clone(usb_hid_report_path_t *new_usage_path, usb_hid_report_path_t *usage_path) + * Clone content of given usage path to the new one + * + * @param usage_path + * @return + */ +usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path) { usb_hid_report_usage_path_t *path_item; link_t *path_link; - + usb_hid_report_path_t *new_usage_path = usb_hid_report_path (); + + if(new_usage_path == NULL){ + return NULL; + } if(list_empty(&usage_path->link)){ - return EOK; + return new_usage_path; } @@ -1039,7 +1084,242 @@ } + return new_usage_path; +} + + +/*** OUTPUT API **/ + +/** Allocates output report buffer + * + * @param parser + * @param size + * @return + */ +uint8_t *usb_hid_report_output(usb_hid_report_parser_t *parser, size_t *size) +{ + if(parser == NULL) { + *size = 0; + return NULL; + } + + // read the last output report item + usb_hid_report_item_t *last; + link_t *link; + + link = parser->output.prev; + if(link != &parser->output) { + last = list_get_instance(link, usb_hid_report_item_t, link); + *size = (last->offset + (last->size * last->count)) / 8; + + uint8_t *buffer = malloc(sizeof(uint8_t) * (*size)); + memset(buffer, 0, sizeof(uint8_t) * (*size)); + usb_log_debug("output buffer: %s\n", usb_debug_str_buffer(buffer, *size, 0)); + + return buffer; + } + else { + *size = 0; + return NULL; + } +} + + +/** Frees output report buffer + * + * @param output Output report buffer + * @return + */ +void usb_hid_report_output_free(uint8_t *output) + +{ + if(output != NULL) { + free (output); + } +} + +/** Returns size of output for given usage path + * + * @param parser + * @param path + * @param flags + * @return + */ +size_t usb_hid_report_output_size(usb_hid_report_parser_t *parser, + usb_hid_report_path_t *path, int flags) +{ + size_t ret = 0; + link_t *item; + usb_hid_report_item_t *report_item; + + if(parser == NULL) { + return 0; + } + + item = parser->output.next; + while(&parser->output != item) { + report_item = list_get_instance(item, usb_hid_report_item_t, link); + if(!USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags) && + (usb_hid_report_compare_usage_path(report_item->usage_path, path, flags) == EOK)) { + ret += report_item->count; + } + + item = item->next; + } + + return ret; + +} + +/** Updates the output report buffer by translated given data + * + * @param parser + * @param path + * @param flags + * @param buffer + * @param size + * @param data + * @param data_size + * @return + */ +int usb_hid_report_output_translate(usb_hid_report_parser_t *parser, + usb_hid_report_path_t *path, int flags, + uint8_t *buffer, size_t size, + int32_t *data, size_t data_size) +{ + usb_hid_report_item_t *report_item; + link_t *item; + size_t idx=0; + int i=0; + int32_t value=0; + int offset; + int length; + int32_t tmp_value; + + if(parser == NULL) { + return EINVAL; + } + + usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0)); + usb_log_debug("OUTPUT DATA[0]: %d, DATA[1]: %d, DATA[2]: %d\n", data[0], data[1], data[2]); + + item = parser->output.next; + while(item != &parser->output) { + report_item = list_get_instance(item, usb_hid_report_item_t, link); + + for(i=0; icount; i++) { + + if(idx >= data_size) { + break; + } + + if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) || + ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) { + +// // variable item + value = usb_hid_translate_data_reverse(report_item, data[idx++]); + offset = report_item->offset + (i * report_item->size); + length = report_item->size; + } + else { + //bitmap + value += usb_hid_translate_data_reverse(report_item, data[idx++]); + offset = report_item->offset; + length = report_item->size * report_item->count; + } + + if((offset/8) == ((offset+length-1)/8)) { + // je to v jednom bytu + if(((size_t)(offset/8) >= size) || ((size_t)(offset+length-1)/8) >= size) { + break; // TODO ErrorCode + } + + size_t shift = offset%8; + + value = value << shift; + value = value & (((1 << length)-1) << shift); + + uint8_t mask = 0; + mask = 0xff - (((1 << length) - 1) << shift); + buffer[offset/8] = (buffer[offset/8] & mask) | value; + } + else { + // je to ve dvou!! FIXME: melo by to umet delsi jak 2 + + // konec prvniho -- dolni x bitu + tmp_value = value; + tmp_value = tmp_value & ((1 << (8-(offset%8)))-1); + tmp_value = tmp_value << (offset%8); + + uint8_t mask = 0; + mask = ~(((1 << (8-(offset%8)))-1) << (offset%8)); + buffer[offset/8] = (buffer[offset/8] & mask) | tmp_value; + + // a ted druhej -- hornich length-x bitu + value = value >> (8 - (offset % 8)); + value = value & ((1 << (length - (8 - (offset % 8)))) - 1); + + mask = ((1 << (length - (8 - (offset % 8)))) - 1); + buffer[(offset+length-1)/8] = (buffer[(offset+length-1)/8] & mask) | value; + } + + } + + item = item->next; + } + + usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0)); + return EOK; } +/** + * + * @param item + * @param value + * @return + */ +int32_t usb_hid_translate_data_reverse(usb_hid_report_item_t *item, int value) +{ + int ret=0; + int resolution; + + if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags)) { + ret = item->logical_minimum; + } + + if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0)) { + + // variable item + if((item->physical_minimum == 0) && (item->physical_maximum == 0)) { + item->physical_minimum = item->logical_minimum; + item->physical_maximum = item->logical_maximum; + } + + if(item->physical_maximum == item->physical_minimum){ + resolution = 1; + } + else { + resolution = (item->logical_maximum - item->logical_minimum) / + ((item->physical_maximum - item->physical_minimum) * + (usb_pow(10,(item->unit_exponent)))); + } + + ret = ((value - item->physical_minimum) * resolution) + item->logical_minimum; + } + else { + // bitmapa + if(value == 0) { + ret = 0; + } + else { + size_t bitmap_idx = (value - item->usage_minimum); + ret = 1 << bitmap_idx; + } + } + + + return ret; +} + /**