Changes in / [78dbf5b:6c6a95d2] in mainline
- Location:
- uspace
- Files:
-
- 13 edited
-
drv/usbhid/generic/hiddev.c (modified) (4 diffs)
-
drv/usbhid/kbd/kbddev.c (modified) (3 diffs)
-
drv/usbhid/mouse/mousedev.c (modified) (14 diffs)
-
drv/usbhid/mouse/mousedev.h (modified) (1 diff)
-
drv/usbhid/subdrivers.c (modified) (2 diffs)
-
drv/usbhid/usbhid.c (modified) (4 diffs)
-
drv/usbhid/usbhid.h (modified) (2 diffs)
-
lib/usb/include/usb/classes/hiddescriptor.h (modified) (1 diff)
-
lib/usb/include/usb/classes/hidpath.h (modified) (1 diff)
-
lib/usb/include/usb/classes/hidtypes.h (modified) (1 diff)
-
lib/usb/src/hiddescriptor.c (modified) (17 diffs)
-
lib/usb/src/hidparser.c (modified) (1 diff)
-
lib/usb/src/hidpath.c (modified) (6 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/drv/usbhid/generic/hiddev.c
r78dbf5b r6c6a95d2 39 39 #include <errno.h> 40 40 #include <str_error.h> 41 #include <bool.h>42 41 43 42 #include <usbhid_iface.h> … … 65 64 size_t size, size_t *act_size, unsigned int flags); 66 65 67 static int usb_generic_hid_client_connected(ddf_fun_t *fun);68 69 66 /*----------------------------------------------------------------------------*/ 70 67 … … 75 72 76 73 static ddf_dev_ops_t usb_generic_hid_ops = { 77 .interfaces[USBHID_DEV_IFACE] = &usb_generic_iface, 78 .open = usb_generic_hid_client_connected 74 .interfaces[USBHID_DEV_IFACE] = &usb_generic_iface 79 75 }; 80 76 … … 108 104 109 105 /*! @todo This should probably be atomic. */ 110 if (usb_hid_report_ready()) { 111 memcpy(buffer, hid_dev->input_report, 112 hid_dev->input_report_size); 113 *act_size = hid_dev->input_report_size; 114 usb_hid_report_received(); 115 } 106 memcpy(buffer, hid_dev->input_report, hid_dev->input_report_size); 107 *act_size = hid_dev->input_report_size; 116 108 117 109 // clear the buffer so that it will not be received twice 118 //memset(hid_dev->input_report, 0, hid_dev->input_report_size);110 memset(hid_dev->input_report, 0, hid_dev->input_report_size); 119 111 120 // note that we already received this report121 // report_received = true;122 123 return EOK;124 }125 126 /*----------------------------------------------------------------------------*/127 128 static int usb_generic_hid_client_connected(ddf_fun_t *fun)129 {130 usb_hid_report_received();131 112 return EOK; 132 113 } -
uspace/drv/usbhid/kbd/kbddev.c
r78dbf5b r6c6a95d2 255 255 256 256 if (hid_dev == NULL || hid_dev->data == NULL) { 257 usb_log_debug("default_connection_handler: "258 "Missing parameter.\n");259 257 async_answer_0(icallid, EINVAL); 260 258 return; … … 269 267 270 268 if (kbd_dev->console_phone != -1) { 271 usb_log_debug("default_connection_handler: "272 "console phone already set\n");273 269 async_answer_0(icallid, ELIMIT); 274 270 return; … … 276 272 277 273 kbd_dev->console_phone = callback; 278 279 usb_log_debug("default_connection_handler: OK\n");280 274 async_answer_0(icallid, EOK); 281 275 return; 282 276 } 283 277 284 usb_log_debug("default_connection_handler: Wrong function.\n");285 278 async_answer_0(icallid, EINVAL); 286 279 } -
uspace/drv/usbhid/mouse/mousedev.c
r78dbf5b r6c6a95d2 43 43 #include <str_error.h> 44 44 #include <ipc/mouse.h> 45 #include <io/console.h>46 47 #include <ipc/kbd.h>48 #include <io/keycode.h>49 45 50 46 #include "mousedev.h" … … 65 61 66 62 const char *HID_MOUSE_FUN_NAME = "mouse"; 67 const char *HID_MOUSE_WHEEL_FUN_NAME = "mouse-wheel";68 63 const char *HID_MOUSE_CLASS_NAME = "mouse"; 69 const char *HID_MOUSE_WHEEL_CLASS_NAME = "keyboard";70 64 71 65 /** Default idle rate for mouses. */ … … 125 119 126 120 if (hid_dev == NULL || hid_dev->data == NULL) { 127 usb_log_debug("default_connection_handler: Missing "128 "parameters.\n");129 121 async_answer_0(icallid, EINVAL); 130 122 return; … … 135 127 usb_mouse_t *mouse_dev = (usb_mouse_t *)hid_dev->data; 136 128 137 int *phone = (str_cmp(fun->name, HID_MOUSE_FUN_NAME) == 0)138 ? &mouse_dev->mouse_phone : &mouse_dev->wheel_phone;139 140 129 if (method == IPC_M_CONNECT_TO_ME) { 141 130 int callback = IPC_GET_ARG5(*icall); 142 131 143 if (*phone != -1) { 144 usb_log_debug("default_connection_handler: Console " 145 "phone to mouse already set.\n"); 132 if (mouse_dev->console_phone != -1) { 146 133 async_answer_0(icallid, ELIMIT); 147 //async_answer_0(icallid, EOK);148 134 return; 149 135 } 150 136 151 *phone = callback;137 mouse_dev->console_phone = callback; 152 138 usb_log_debug("Console phone to mouse set ok (%d).\n", callback); 153 139 async_answer_0(icallid, EOK); … … 155 141 } 156 142 157 usb_log_debug("default_connection_handler: Invalid function.\n");158 143 async_answer_0(icallid, EINVAL); 159 144 } … … 167 152 return NULL; 168 153 } 169 mouse->mouse_phone = -1; 170 mouse->wheel_phone = -1; 154 mouse->console_phone = -1; 171 155 172 156 return mouse; … … 180 164 181 165 // hangup phone to the console 182 if ((*mouse_dev)->mouse_phone >= 0) { 183 async_hangup((*mouse_dev)->mouse_phone); 184 } 185 186 if ((*mouse_dev)->wheel_phone >= 0) { 187 async_hangup((*mouse_dev)->wheel_phone); 166 if ((*mouse_dev)->console_phone >= 0) { 167 async_hangup((*mouse_dev)->console_phone); 188 168 } 189 169 … … 194 174 /*----------------------------------------------------------------------------*/ 195 175 196 static void usb_mouse_send_wheel(const usb_mouse_t *mouse_dev, int wheel) 197 { 198 console_event_t ev; 199 200 ev.type = KEY_PRESS; 201 ev.key = (wheel > 0) ? KC_UP : (wheel < 0) ? KC_DOWN : 0; 202 ev.mods = 0; 203 ev.c = 0; 204 205 if (mouse_dev->wheel_phone < 0) { 206 usb_log_warning( 207 "Connection to console not ready, key discarded.\n"); 208 return; 209 } 210 211 int count = (wheel < 0) ? -wheel : wheel; 212 int i; 213 214 for (i = 0; i < count * 3; ++i) { 215 usb_log_debug2("Sending key %d to the console\n", ev.key); 216 async_msg_4(mouse_dev->wheel_phone, KBD_EVENT, ev.type, 217 ev.key, ev.mods, ev.c); 218 // send key release right away 219 async_msg_4(mouse_dev->wheel_phone, KBD_EVENT, KEY_RELEASE, 220 ev.key, ev.mods, ev.c); 221 } 222 } 223 224 /*----------------------------------------------------------------------------*/ 225 226 static bool usb_mouse_process_report(usb_hid_dev_t *hid_dev, uint8_t *buffer, 227 size_t buffer_size) 176 static bool usb_mouse_process_boot_report(usb_hid_dev_t *hid_dev, 177 uint8_t *buffer, size_t buffer_size) 228 178 { 229 179 usb_mouse_t *mouse_dev = (usb_mouse_t *)hid_dev->data; … … 232 182 usb_debug_str_buffer(buffer, buffer_size, 0)); 233 183 234 if (mouse_dev-> mouse_phone < 0) {184 if (mouse_dev->console_phone < 0) { 235 185 usb_log_error(NAME " No console phone.\n"); 236 186 return false; // ?? … … 302 252 303 253 if ((shift_x != 0) || (shift_y != 0)) { 304 async_req_2_0(mouse_dev-> mouse_phone,254 async_req_2_0(mouse_dev->console_phone, 305 255 MEVENT_MOVE, shift_x, shift_y); 306 256 } 307 308 /*309 * Wheel310 */311 int wheel;312 313 path = usb_hid_report_path();314 usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_GENERIC_DESKTOP,315 USB_HIDUT_USAGE_GENERIC_DESKTOP_WHEEL);316 317 usb_hid_report_path_set_report_id(path, report_id);318 319 field = usb_hid_report_get_sibling(320 hid_dev->report, NULL, path, USB_HID_PATH_COMPARE_END,321 USB_HID_REPORT_TYPE_INPUT);322 323 if (field != NULL) {324 usb_log_debug(NAME " VALUE(%X) USAGE(%X)\n", field->value,325 field->usage);326 wheel = field->value;327 }328 329 usb_hid_report_path_free(path);330 331 // send arrow up for positive direction and arrow down for negative332 // direction; three arrows for difference of 1333 usb_mouse_send_wheel(mouse_dev, wheel);334 335 257 336 258 /* … … 352 274 if (mouse_dev->buttons[field->usage - field->usage_minimum] == 0 353 275 && field->value != 0) { 354 async_req_2_0(mouse_dev-> mouse_phone,276 async_req_2_0(mouse_dev->console_phone, 355 277 MEVENT_BUTTON, field->usage, 1); 356 278 mouse_dev->buttons[field->usage - field->usage_minimum] … … 359 281 mouse_dev->buttons[field->usage - field->usage_minimum] != 0 360 282 && field->value == 0) { 361 async_req_2_0(mouse_dev-> mouse_phone,283 async_req_2_0(mouse_dev->console_phone, 362 284 MEVENT_BUTTON, field->usage, 0); 363 285 mouse_dev->buttons[field->usage - field->usage_minimum] … … 415 337 } 416 338 417 /*418 * Special function for acting as keyboard (wheel)419 */420 usb_log_debug("Creating DDF function %s...\n",421 HID_MOUSE_WHEEL_FUN_NAME);422 fun = ddf_fun_create(hid_dev->usb_dev->ddf_dev, fun_exposed,423 HID_MOUSE_WHEEL_FUN_NAME);424 if (fun == NULL) {425 usb_log_error("Could not create DDF function node.\n");426 return ENOMEM;427 }428 429 /*430 * Store the initialized HID device and HID ops431 * to the DDF function.432 */433 fun->ops = &hid_dev->ops;434 fun->driver_data = hid_dev; // TODO: maybe change to hid_dev->data435 436 rc = ddf_fun_bind(fun);437 if (rc != EOK) {438 usb_log_error("Could not bind DDF function: %s.\n",439 str_error(rc));440 ddf_fun_destroy(fun);441 return rc;442 }443 444 usb_log_debug("Adding DDF function to class %s...\n",445 HID_MOUSE_WHEEL_CLASS_NAME);446 rc = ddf_fun_add_to_class(fun, HID_MOUSE_WHEEL_CLASS_NAME);447 if (rc != EOK) {448 usb_log_error(449 "Could not add DDF function to class %s: %s.\n",450 HID_MOUSE_WHEEL_CLASS_NAME, str_error(rc));451 ddf_fun_destroy(fun);452 return rc;453 }454 455 339 return EOK; 456 340 } … … 523 407 } 524 408 525 return usb_mouse_process_ report(hid_dev, buffer, buffer_size);409 return usb_mouse_process_boot_report(hid_dev, buffer, buffer_size); 526 410 } 527 411 -
uspace/drv/usbhid/mouse/mousedev.h
r78dbf5b r6c6a95d2 48 48 //suseconds_t poll_interval_us; 49 49 /** IPC phone to console (consumer). */ 50 int mouse_phone; 51 int wheel_phone; 50 int console_phone; 52 51 53 52 int32_t *buttons; -
uspace/drv/usbhid/subdrivers.c
r78dbf5b r6c6a95d2 36 36 #include "subdrivers.h" 37 37 #include "usb/classes/hidut.h" 38 #include "usb/classes/hidpath.h"39 38 40 39 #include "lgtch-ultrax/lgtch-ultrax.h" 41 #include "mouse/mousedev.h"42 40 43 41 static usb_hid_subdriver_usage_t path_kbd[] = { 44 42 {USB_HIDUT_PAGE_KEYBOARD, 0}, 45 {0, 0}46 };47 48 static usb_hid_subdriver_usage_t path_mouse[] = {49 {USB_HIDUT_PAGE_GENERIC_DESKTOP, USB_HIDUT_USAGE_GENERIC_DESKTOP_MOUSE},50 {USB_HIDUT_PAGE_GENERIC_DESKTOP,51 USB_HIDUT_USAGE_GENERIC_DESKTOP_POINTER},52 {0, 0}53 };54 55 static usb_hid_subdriver_usage_t path_mouse2[] = {56 {USB_HIDUT_PAGE_GENERIC_DESKTOP, USB_HIDUT_USAGE_GENERIC_DESKTOP_X},57 43 {0, 0} 58 44 }; … … 93 79 } 94 80 }, 95 {96 path_mouse,97 -1,98 USB_HID_PATH_COMPARE_COLLECTION_ONLY,99 -1,100 -1,101 {102 .init = usb_mouse_init,103 .deinit = usb_mouse_deinit,104 .poll = usb_mouse_polling_callback,105 .poll_end = NULL106 }107 },108 {109 path_mouse2,110 -1,111 USB_HID_PATH_COMPARE_END112 | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,113 -1,114 -1,115 {116 .init = usb_mouse_init,117 .deinit = usb_mouse_deinit,118 .poll = usb_mouse_polling_callback,119 .poll_end = NULL120 }121 },122 81 {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL}} 123 82 }; -
uspace/drv/usbhid/usbhid.c
r78dbf5b r6c6a95d2 63 63 static const int USB_HID_MAX_SUBDRIVERS = 10; 64 64 65 static fibril_local bool report_received;66 67 65 /*----------------------------------------------------------------------------*/ 68 66 … … 414 412 } 415 413 416 if (fallback) { 414 // TODO: remove the mouse hack 415 if (hid_dev->poll_pipe_index == USB_HID_MOUSE_POLL_EP_NO || 416 fallback) { 417 417 // fall back to boot protocol 418 418 switch (hid_dev->poll_pipe_index) { … … 509 509 free(input_old); 510 510 } 511 usb_hid_new_report();512 511 } 513 512 } … … 590 589 /*----------------------------------------------------------------------------*/ 591 590 592 void usb_hid_new_report(void)593 {594 report_received = false;595 }596 597 /*----------------------------------------------------------------------------*/598 599 void usb_hid_report_received(void)600 {601 report_received = true;602 }603 604 /*----------------------------------------------------------------------------*/605 606 bool usb_hid_report_ready(void)607 {608 return !report_received;609 }610 611 /*----------------------------------------------------------------------------*/612 613 591 void usb_hid_free(usb_hid_dev_t **hid_dev) 614 592 { -
uspace/drv/usbhid/usbhid.h
r78dbf5b r6c6a95d2 44 44 #include <usb/devdrv.h> 45 45 #include <usb/classes/hid.h> 46 #include <bool.h>47 46 48 47 struct usb_hid_dev; … … 129 128 //const char *usb_hid_get_class_name(const usb_hid_dev_t *hid_dev); 130 129 131 void usb_hid_new_report(void);132 133 void usb_hid_report_received(void);134 135 bool usb_hid_report_ready(void);136 137 130 void usb_hid_free(usb_hid_dev_t **hid_dev); 138 131 -
uspace/lib/usb/include/usb/classes/hiddescriptor.h
r78dbf5b r6c6a95d2 78 78 uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size); 79 79 80 usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report, usb_hid_report_path_t *cmp_path);81 80 #endif 82 81 /** -
uspace/lib/usb/include/usb/classes/hidpath.h
r78dbf5b r6c6a95d2 43 43 * Description of path of usage pages and usages in report descriptor 44 44 */ 45 /** Wanted usage path must be exactly the same as the searched one */ 46 #define USB_HID_PATH_COMPARE_STRICT 0 47 /** Wanted usage path must be the suffix in the searched one */ 48 #define USB_HID_PATH_COMPARE_END 1 49 /** */ 50 #define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY 2 51 /** Searched usage page must be prefix of the other one */ 52 #define USB_HID_PATH_COMPARE_BEGIN 4 53 /** Searched couple of usage page and usage can be anywhere in usage path */ 54 #define USB_HID_PATH_COMPARE_ANYWHERE 8 45 #define USB_HID_PATH_COMPARE_STRICT 0 46 #define USB_HID_PATH_COMPARE_END 1 47 #define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY 4 48 #define USB_HID_PATH_COMPARE_COLLECTION_ONLY 2 /* porovnava jenom cestu z Kolekci */ 55 49 56 50 -
uspace/lib/usb/include/usb/classes/hidtypes.h
r78dbf5b r6c6a95d2 165 165 /** */ 166 166 link_t link; 167 168 int in_delimiter;169 167 } usb_hid_report_item_t; 170 168 -
uspace/lib/usb/src/hiddescriptor.c
r78dbf5b r6c6a95d2 41 41 #include <assert.h> 42 42 43 44 #define OUTSIDE_DELIMITER_SET 045 #define START_DELIMITER_SET 146 #define INSIDE_DELIMITER_SET 247 48 43 /** The new report item flag. Used to determine when the item is completly 49 44 * configured and should be added to the report structure … … 61 56 #define USB_HID_UNKNOWN_TAG -99 62 57 63 usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report, usb_hid_report_path_t *cmp_path) 64 { 58 59 /** 60 * Initialize the report descriptor parser structure 61 * 62 * @param parser Report descriptor parser structure 63 * @return Error code 64 */ 65 int usb_hid_report_init(usb_hid_report_t *report) 66 { 67 if(report == NULL) { 68 return EINVAL; 69 } 70 71 memset(report, 0, sizeof(usb_hid_report_t)); 72 list_initialize(&report->reports); 73 list_initialize(&report->collection_paths); 74 75 report->use_report_ids = 0; 76 return EOK; 77 } 78 79 int usb_hid_report_append_fields(usb_hid_report_t *report, usb_hid_report_item_t *report_item) 80 { 81 usb_hid_report_field_t *field; 82 int i; 83 84 65 85 /* find or append current collection path to the list */ 66 86 link_t *path_it = report->collection_paths.next; … … 69 89 path = list_get_instance(path_it, usb_hid_report_path_t, link); 70 90 71 if(usb_hid_report_compare_usage_path(path, cmp_path, USB_HID_PATH_COMPARE_STRICT) == EOK){91 if(usb_hid_report_compare_usage_path(path, report_item->usage_path, USB_HID_PATH_COMPARE_STRICT) == EOK){ 72 92 break; 73 93 } … … 75 95 } 76 96 if(path_it == &report->collection_paths) { 77 path = usb_hid_report_path_clone( cmp_path);97 path = usb_hid_report_path_clone(report_item->usage_path); 78 98 list_append(&path->link, &report->collection_paths); 79 99 report->collection_paths_count++; 80 81 return path; 82 } 83 else { 84 return list_get_instance(path_it, usb_hid_report_path_t, link); 85 } 86 } 87 88 /** 89 * Initialize the report descriptor parser structure 90 * 91 * @param parser Report descriptor parser structure 92 * @return Error code 93 */ 94 int usb_hid_report_init(usb_hid_report_t *report) 95 { 96 if(report == NULL) { 97 return EINVAL; 98 } 99 100 memset(report, 0, sizeof(usb_hid_report_t)); 101 list_initialize(&report->reports); 102 list_initialize(&report->collection_paths); 103 104 report->use_report_ids = 0; 105 return EOK; 106 } 107 108 109 /* 110 * 111 * 112 */ 113 int usb_hid_report_append_fields(usb_hid_report_t *report, usb_hid_report_item_t *report_item) 114 { 115 usb_hid_report_field_t *field; 116 int i; 100 } 117 101 118 102 for(i=0; i<report_item->usages_count; i++){ … … 120 104 } 121 105 122 usb_hid_report_path_t *path = report_item->usage_path;106 123 107 for(i=0; i<report_item->count; i++){ 124 108 … … 128 112 129 113 /* fill the attributes */ 114 field->collection_path = path; 130 115 field->logical_minimum = report_item->logical_minimum; 131 116 field->logical_maximum = report_item->logical_maximum; … … 144 129 if(report_item->usages_count > 0 && ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) { 145 130 uint32_t usage; 146 if(i < report_item->usages_count){ 147 usage = report_item->usages[i]; 131 if(report_item->type != USB_HID_REPORT_TYPE_OUTPUT) { 132 if(i < report_item->usages_count){ 133 usage = report_item->usages[i]; 134 } 135 else { 136 usage = report_item->usages[report_item->usages_count - 1]; 137 } 148 138 } 149 139 else { 150 usage = report_item->usages[report_item->usages_count - 1]; 140 if((report_item->count - i - 1) < report_item->usages_count){ 141 usage = report_item->usages[(report_item->count - i - 1)]; 142 } 143 else { 144 usage = report_item->usages[report_item->usages_count - 1]; 145 } 151 146 } 152 147 … … 164 159 165 160 if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) != 0) && (!((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0)))) { 166 field->usage = report_item->usage_minimum + i; 167 } 168 169 usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_GLOBAL, field->usage_page); 170 usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_LOCAL, field->usage); 171 172 field->collection_path = usb_hid_report_path_try_insert(report, path); 173 161 if(report_item->type == USB_HID_REPORT_TYPE_INPUT) { 162 field->usage = report_item->usage_maximum - i; 163 } 164 else { 165 field->usage = report_item->usage_minimum + i; 166 } 167 168 } 169 174 170 field->size = report_item->size; 175 176 size_t offset_byte = (report_item->offset + (i * report_item->size)) / 8; 177 size_t offset_bit = 8 - ((report_item->offset + (i * report_item->size)) % 8) - report_item->size; 178 179 field->offset = 8 * offset_byte + offset_bit; 171 field->offset = report_item->offset + (i * report_item->size); 180 172 if(report_item->id != 0) { 181 173 field->offset += 8; … … 272 264 return ENOMEM; 273 265 } 274 usb_hid_report_path_append_item(usage_path, 0, 0);275 266 276 267 while(i<size){ … … 358 349 tmp_usage_path = list_get_instance(report_item->usage_path->link.prev, usb_hid_report_usage_path_t, link); 359 350 360 usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL, tmp_usage_path->usage_page); 361 usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL, tmp_usage_path->usage); 351 usb_hid_report_set_last_item(usage_path, tmp_usage_path->usage_page, tmp_usage_path->usage); 362 352 363 353 usb_hid_report_path_free(report_item->usage_path); … … 437 427 int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size, 438 428 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) 439 { 440 usb_hid_report_usage_path_t *path_item; 441 429 { 442 430 switch(tag) 443 431 { … … 450 438 451 439 case USB_HID_REPORT_TAG_COLLECTION: 452 // store collection atributes 453 path_item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link); 454 path_item->flags = *data; 455 456 // set last item 457 usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL, report_item->usage_page); 458 usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL, report_item->usages[report_item->usages_count-1]); 459 460 // append the new one which will be set by common 461 // usage/usage page 462 usb_hid_report_path_append_item(usage_path, report_item->usage_page, report_item->usages[report_item->usages_count-1]); 440 // TODO usage_path->flags = *data; 441 usb_hid_report_path_append_item(usage_path, report_item->usage_page, report_item->usages[report_item->usages_count-1]); 463 442 usb_hid_report_reset_local_items (report_item); 464 443 return USB_HID_NO_ACTION; … … 551 530 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) 552 531 { 553 switch(tag) { 532 switch(tag) 533 { 554 534 case USB_HID_REPORT_TAG_USAGE: 555 switch(report_item->in_delimiter) { 556 case INSIDE_DELIMITER_SET: 557 // nothing to do 558 break; 559 case START_DELIMITER_SET: 560 report_item->in_delimiter = INSIDE_DELIMITER_SET; 561 case OUTSIDE_DELIMITER_SET: 562 report_item->usages[report_item->usages_count] = usb_hid_report_tag_data_uint32(data,item_size); 563 report_item->usages_count++; 564 break; 565 } 535 report_item->usages[report_item->usages_count] = usb_hid_report_tag_data_uint32(data,item_size); 536 report_item->usages_count++; 566 537 break; 567 538 case USB_HID_REPORT_TAG_USAGE_MINIMUM: … … 604 575 break; 605 576 case USB_HID_REPORT_TAG_DELIMITER: 606 report_item->in_delimiter = usb_hid_report_tag_data_uint32(data,item_size); 607 break; 608 577 //report_item->delimiter = usb_hid_report_tag_data_uint32(data,item_size); 578 //TODO: 579 // DELIMITER STUFF 580 break; 581 609 582 default: 610 583 return USB_HID_NO_ACTION; 611 584 } 612 585 613 586 return EOK; 614 587 } … … 656 629 657 630 usb_log_debug("\t\tOFFSET: %X\n", report_item->offset); 658 usb_log_debug("\t\tSIZE: % X\n", report_item->size);631 usb_log_debug("\t\tSIZE: %zu\n", report_item->size); 659 632 usb_log_debug("\t\tLOGMIN: %d\n", report_item->logical_minimum); 660 633 usb_log_debug("\t\tLOGMAX: %d\n", report_item->logical_maximum); … … 667 640 usb_log_debug("\t\ttUSAGE: %X\n", report_item->usage); 668 641 usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page); 669 670 //usb_hid_print_usage_path(report_item->collection_path); 671 672 usb_log_debug("\n"); 642 643 // usb_log_debug("\n"); 673 644 674 645 } … … 695 666 usb_log_debug("Report ID: %d\n", report_des->report_id); 696 667 usb_log_debug("\tType: %d\n", report_des->type); 697 usb_log_debug("\tLength: % d\n", report_des->bit_length);698 usb_log_debug("\tItems: % d\n", report_des->item_length);668 usb_log_debug("\tLength: %zu\n", report_des->bit_length); 669 usb_log_debug("\tItems: %zu\n", report_des->item_length); 699 670 700 671 usb_hid_descriptor_print_list(&report_des->report_items); -
uspace/lib/usb/src/hidparser.c
r78dbf5b r6c6a95d2 405 405 } 406 406 407 size_t shift = 8 - offset%8 - length;407 size_t shift = offset%8; 408 408 409 409 value = value << shift; -
uspace/lib/usb/src/hidpath.c
r78dbf5b r6c6a95d2 149 149 usb_log_debug("\tFLAGS: %d\n", path_item->flags); 150 150 151 151 item = item->next; 152 152 } 153 153 } … … 156 156 * Compares two usage paths structures 157 157 * 158 * 159 * @param report_path usage path structure to compare with @path 158 * If USB_HID_PATH_COMPARE_COLLECTION_ONLY flag is given, the last item in report_path structure is forgotten 159 * 160 * @param report_path usage path structure to compare 160 161 * @param path usage patrh structure to compare 161 162 * @param flags Flags determining the mode of comparison … … 178 179 } 179 180 180 // Empty path match all others181 181 if(path->depth == 0){ 182 182 return EOK; … … 189 189 190 190 switch(flags){ 191 /* path is somewhere in report_path */ 192 case USB_HID_PATH_COMPARE_ANYWHERE: 193 if(path->depth != 1){ 194 return 1; 195 } 196 197 // projit skrz cestu a kdyz nekde sedi tak vratim EOK 198 // dojduli az za konec tak nnesedi 199 report_link = report_path->head.next; 200 path_link = path->head.next; 201 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link); 202 203 while(report_link != &report_path->head) { 204 report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link); 205 if(report_item->usage_page == path_item->usage_page){ 206 if(only_page == 0){ 207 if(report_item->usage == path_item->usage) { 208 return EOK; 209 } 210 } 211 else { 212 return EOK; 213 } 214 } 215 216 report_link = report_link->next; 217 } 218 219 return 1; 220 break; 221 /* the paths must be identical */ 191 /* path must be completly identical */ 222 192 case USB_HID_PATH_COMPARE_STRICT: 223 193 if(report_path->depth != path->depth){ 224 194 return 1; 225 195 } 226 227 /* path is prefix of the report_path */ 228 case USB_HID_PATH_COMPARE_BEGIN: 229 196 230 197 report_link = report_path->head.next; 231 198 path_link = path->head.next; … … 254 221 } 255 222 256 if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) && (path_link == &path->head)) || 257 ((report_link == &report_path->head) && (path_link == &path->head))) { 223 if(((report_link == &report_path->head) && (path_link == &path->head)) || 224 (((flags & USB_HID_PATH_COMPARE_COLLECTION_ONLY) != 0) && 225 (path_link = &path->head) && 226 (report_link == report_path->head.prev))) { 258 227 return EOK; 259 228 } … … 263 232 break; 264 233 265 /* path is suffix of report_path*/234 /* compare with only the end of path*/ 266 235 case USB_HID_PATH_COMPARE_END: 267 236 268 report_link = report_path->head.prev; 237 if((flags & USB_HID_PATH_COMPARE_COLLECTION_ONLY) != 0) { 238 report_link = report_path->head.prev->prev; 239 } 240 else { 241 report_link = report_path->head.prev; 242 } 269 243 path_link = path->head.prev; 270 244
Note:
See TracChangeset
for help on using the changeset viewer.
