Changeset 095b2017 in mainline for uspace/lib/usb/src
- Timestamp:
- 2011-03-25T17:13:02Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- b8d453ec, fa3de85
- Parents:
- da88eb82 (diff), da3dafc (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)links above to see all the changes relative to each parent. - Location:
- uspace/lib/usb/src
- Files:
-
- 1 added
- 1 edited
- 1 moved
-
hidparser.c (modified) (25 diffs)
-
hidreport.c (added)
-
hidreq.c (moved) (moved from uspace/drv/usbhid/hidreq.c ) (14 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/usb/src/hidparser.c
rda88eb82 r095b2017 47 47 48 48 int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size, 49 usb_hid_report_item_t *report_item );49 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); 50 50 int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size, 51 usb_hid_report_item_t *report_item );51 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); 52 52 int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size, 53 usb_hid_report_item_t *report_item );53 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); 54 54 int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size, 55 usb_hid_report_item_t *report_item );55 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); 56 56 57 57 void usb_hid_descriptor_print_list(link_t *head); … … 63 63 int usb_pow(int a, int b); 64 64 65 65 66 int usb_pow(int a, int b) 66 67 { … … 84 85 { 85 86 if(parser == NULL) { 86 return -1;87 return EINVAL; 87 88 } 88 89 … … 110 111 int ret; 111 112 usb_hid_report_item_t *report_item=0; 112 usb_hid_report_item_t *new_report_item; 113 usb_hid_report_item_t *new_report_item; 114 usb_hid_report_path_t *usage_path; 115 usb_hid_report_path_t *tmp_usage_path; 113 116 114 117 size_t offset_input=0; … … 117 120 118 121 122 /* parser structure initialization*/ 123 if(usb_hid_parser_init(parser) != EOK) { 124 return EINVAL; 125 } 126 127 128 /*report item initialization*/ 119 129 if(!(report_item=malloc(sizeof(usb_hid_report_item_t)))){ 120 130 return ENOMEM; 121 131 } 122 132 memset(report_item, 0, sizeof(usb_hid_report_item_t)); 123 124 link_initialize(&(report_item->link)); 125 133 list_initialize(&(report_item->link)); 134 135 /* usage path context initialization */ 136 if(!(usage_path=usb_hid_report_path())){ 137 return ENOMEM; 138 } 139 126 140 while(i<size){ 127 141 if(!USB_HID_ITEM_IS_LONG(data[i])){ 128 142 129 143 if((i+USB_HID_ITEM_SIZE(data[i]))>= size){ 130 return -1; // TODO ERROR CODE144 return EINVAL; // TODO ERROR CODE 131 145 } 132 146 … … 141 155 142 156 ret = usb_hid_report_parse_tag(tag,class,data+i+1, 143 item_size,report_item);157 item_size,report_item, usage_path); 144 158 usb_log_debug2("ret: %u\n", ret); 145 159 switch(ret){ 146 160 case USB_HID_NEW_REPORT_ITEM: 147 161 // store report item to report and create the new one 148 usb_log_debug("\nNEW REPORT ITEM: %X",tag); 162 usb_log_debug("\nNEW REPORT ITEM: %X",ret); 163 164 // store current usage path 165 report_item->usage_path = usage_path; 166 167 // new current usage path 168 tmp_usage_path = usb_hid_report_path(); 169 170 // copy old path to the new one 171 usb_hid_report_path_clone(tmp_usage_path, usage_path); 172 173 // swap 174 usage_path = tmp_usage_path; 175 tmp_usage_path = NULL; 176 149 177 150 178 switch(tag) { … … 184 212 link_initialize(&(new_report_item->link)); 185 213 report_item = new_report_item; 186 214 187 215 break; 188 216 case USB_HID_REPORT_TAG_PUSH: … … 284 312 */ 285 313 int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size, 286 usb_hid_report_item_t *report_item )314 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) 287 315 { 288 316 int ret; … … 291 319 case USB_HID_TAG_CLASS_MAIN: 292 320 293 if((ret=usb_hid_report_parse_main_tag(tag,data,item_size,report_item )) == EOK) {321 if((ret=usb_hid_report_parse_main_tag(tag,data,item_size,report_item, usage_path)) == EOK) { 294 322 return USB_HID_NEW_REPORT_ITEM; 295 323 } … … 301 329 302 330 case USB_HID_TAG_CLASS_GLOBAL: 303 return usb_hid_report_parse_global_tag(tag,data,item_size,report_item );331 return usb_hid_report_parse_global_tag(tag,data,item_size,report_item, usage_path); 304 332 break; 305 333 306 334 case USB_HID_TAG_CLASS_LOCAL: 307 return usb_hid_report_parse_local_tag(tag,data,item_size,report_item );335 return usb_hid_report_parse_local_tag(tag,data,item_size,report_item, usage_path); 308 336 break; 309 337 default: … … 323 351 324 352 int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size, 325 usb_hid_report_item_t *report_item )326 { 353 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) 354 { 327 355 switch(tag) 328 356 { … … 335 363 336 364 case USB_HID_REPORT_TAG_COLLECTION: 337 // TODO 365 usb_hid_report_path_append_item(usage_path, 0, 0); 366 338 367 return USB_HID_NO_ACTION; 339 368 break; 340 369 341 370 case USB_HID_REPORT_TAG_END_COLLECTION: 342 /* should be ignored */ 371 // TODO 372 // znici posledni uroven ve vsech usage paths 373 // otazka jestli nema nicit dve, respektive novou posledni vynulovat? 374 usb_hid_report_remove_last_item(usage_path); 343 375 return USB_HID_NO_ACTION; 344 376 break; … … 361 393 362 394 int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size, 363 usb_hid_report_item_t *report_item )395 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) 364 396 { 365 397 // TODO take care about the bit length of data … … 367 399 { 368 400 case USB_HID_REPORT_TAG_USAGE_PAGE: 369 report_item->usage_page = usb_hid_report_tag_data_int32(data,item_size); 401 // zmeni to jenom v poslednim poli aktualni usage path 402 usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL, 403 usb_hid_report_tag_data_int32(data,item_size)); 370 404 break; 371 405 case USB_HID_REPORT_TAG_LOGICAL_MINIMUM: … … 418 452 */ 419 453 int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size, 420 usb_hid_report_item_t *report_item )454 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path) 421 455 { 422 456 switch(tag) 423 457 { 424 458 case USB_HID_REPORT_TAG_USAGE: 425 report_item->usage = usb_hid_report_tag_data_int32(data,item_size); 459 usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL, 460 usb_hid_report_tag_data_int32(data,item_size)); 426 461 break; 427 462 case USB_HID_REPORT_TAG_USAGE_MINIMUM: … … 491 526 { 492 527 usb_hid_report_item_t *report_item; 528 usb_hid_report_usage_path_t *path_item; 529 link_t *path; 493 530 link_t *item; 494 531 … … 507 544 usb_log_debug("\tCONSTANT/VAR: %X\n", USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags)); 508 545 usb_log_debug("\tVARIABLE/ARRAY: %X\n", USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags)); 509 usb_log_debug("\tUSAGE: %X\n", report_item->usage); 510 usb_log_debug("\tUSAGE PAGE: %X\n", report_item->usage_page); 546 usb_log_debug("\tUSAGE PATH:\n"); 547 548 path = report_item->usage_path->link.next; 549 while(path != &report_item->usage_path->link) { 550 path_item = list_get_instance(path, usb_hid_report_usage_path_t, link); 551 usb_log_debug("\t\tUSAGE PAGE: %X, USAGE: %X\n", path_item->usage_page, path_item->usage); 552 path = path->next; 553 } 554 555 556 // usb_log_debug("\tUSAGE: %X\n", report_item->usage); 557 // usb_log_debug("\tUSAGE PAGE: %X\n", report_item->usage_page); 511 558 usb_log_debug("\tLOGMIN: %X\n", report_item->logical_minimum); 512 559 usb_log_debug("\tLOGMAX: %X\n", report_item->logical_maximum); … … 530 577 void usb_hid_descriptor_print(usb_hid_report_parser_t *parser) 531 578 { 579 if(parser == NULL) { 580 return; 581 } 582 532 583 usb_log_debug("INPUT:\n"); 533 584 usb_hid_descriptor_print_list(&parser->input); … … 561 612 562 613 report_item = list_get_instance(next, usb_hid_report_item_t, link); 614 615 while(!list_empty(&report_item->usage_path->link)) { 616 usb_hid_report_remove_last_item(report_item->usage_path); 617 } 618 619 563 620 next = next->next; 564 621 … … 600 657 int usb_hid_parse_report(const usb_hid_report_parser_t *parser, 601 658 const uint8_t *data, size_t size, 659 usb_hid_report_path_t *path, int flags, 602 660 const usb_hid_report_in_callbacks_t *callbacks, void *arg) 603 661 { … … 615 673 size_t j=0; 616 674 675 if(parser == NULL) { 676 return EINVAL; 677 } 678 679 617 680 // get the size of result keycodes array 618 usb_hid_report_path_t path; 619 path.usage_page = BAD_HACK_USAGE_PAGE; 620 key_count = usb_hid_report_input_length(parser, &path); 681 key_count = usb_hid_report_input_length(parser, path, flags); 621 682 622 683 if(!(keys = malloc(sizeof(uint8_t) * key_count))){ … … 629 690 630 691 item = list_get_instance(list_item, usb_hid_report_item_t, link); 631 if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) && 632 ( item->usage_page == path.usage_page)) {692 if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) && 693 (usb_hid_report_compare_usage_path(item->usage_path, path, flags) == EOK)) { 633 694 for(j=0; j<(size_t)(item->count); j++) { 634 695 if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) || … … 640 701 // bitmapa 641 702 if((item_value = usb_hid_translate_data(item, data, j)) != 0) { 642 keys[i++] = j+ item->usage_minimum;703 keys[i++] = (item->count - 1 - j) + item->usage_minimum; 643 704 } 644 705 else { … … 736 797 737 798 int usb_hid_report_input_length(const usb_hid_report_parser_t *parser, 738 const usb_hid_report_path_t *path)739 { 799 usb_hid_report_path_t *path, int flags) 800 { 740 801 int ret = 0; 741 802 link_t *item; 742 803 usb_hid_report_item_t *report_item; 743 804 805 if(parser == NULL) { 806 return EINVAL; 807 } 808 744 809 item = (&parser->input)->next; 745 810 while(&parser->input != item) { 746 811 report_item = list_get_instance(item, usb_hid_report_item_t, link); 747 812 if(!USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags) && 748 ( report_item->usage_page == path->usage_page)) {813 (usb_hid_report_compare_usage_path(report_item->usage_path, path, flags) == EOK)) { 749 814 ret += report_item->count; 750 815 } … … 757 822 758 823 824 /** 825 * 826 */ 827 int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, 828 int32_t usage_page, int32_t usage) 829 { 830 usb_hid_report_usage_path_t *item; 831 832 if(!(item=malloc(sizeof(usb_hid_report_usage_path_t)))) { 833 return ENOMEM; 834 } 835 list_initialize(&item->link); 836 837 item->usage = usage; 838 item->usage_page = usage_page; 839 840 list_append (&usage_path->link, &item->link); 841 usage_path->depth++; 842 return EOK; 843 } 844 845 /** 846 * 847 */ 848 void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path) 849 { 850 usb_hid_report_usage_path_t *item; 851 852 if(!list_empty(&usage_path->link)){ 853 item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link); 854 list_remove(usage_path->link.prev); 855 usage_path->depth--; 856 free(item); 857 } 858 } 859 860 /** 861 * 862 */ 863 void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path) 864 { 865 usb_hid_report_usage_path_t *item; 866 867 if(!list_empty(&usage_path->link)){ 868 item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link); 869 memset(item, 0, sizeof(usb_hid_report_usage_path_t)); 870 } 871 } 872 873 /** 874 * 875 */ 876 void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data) 877 { 878 usb_hid_report_usage_path_t *item; 879 880 if(!list_empty(&usage_path->link)){ 881 item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link); 882 883 switch(tag) { 884 case USB_HID_TAG_CLASS_GLOBAL: 885 item->usage_page = data; 886 break; 887 case USB_HID_TAG_CLASS_LOCAL: 888 item->usage = data; 889 break; 890 } 891 } 892 893 } 894 895 /** 896 * 897 */ 898 int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, 899 usb_hid_report_path_t *path, 900 int flags) 901 { 902 usb_hid_report_usage_path_t *report_item; 903 usb_hid_report_usage_path_t *path_item; 904 905 link_t *report_link; 906 link_t *path_link; 907 908 int only_page; 909 910 if(path->depth == 0){ 911 return EOK; 912 } 913 914 915 if((only_page = flags & USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY) != 0){ 916 flags -= USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY; 917 } 918 919 switch(flags){ 920 /* path must be completly identical */ 921 case USB_HID_PATH_COMPARE_STRICT: 922 if(report_path->depth != path->depth){ 923 return 1; 924 } 925 926 report_link = report_path->link.next; 927 path_link = path->link.next; 928 929 while((report_link != &report_path->link) && (path_link != &path->link)) { 930 report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link); 931 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link); 932 933 if((report_item->usage_page != path_item->usage_page) || 934 ((only_page == 0) && (report_item->usage != path_item->usage))) { 935 return 1; 936 } else { 937 report_link = report_link->next; 938 path_link = path_link->next; 939 } 940 941 } 942 943 if((report_link == &report_path->link) && (path_link == &path->link)) { 944 return EOK; 945 } 946 else { 947 return 1; 948 } 949 break; 950 951 /* given path must be the end of the report one*/ 952 case USB_HID_PATH_COMPARE_END: 953 report_link = report_path->link.prev; 954 path_link = path->link.prev; 955 956 if(list_empty(&path->link)){ 957 return EOK; 958 } 959 960 while((report_link != &report_path->link) && (path_link != &path->link)) { 961 report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link); 962 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link); 963 964 if((report_item->usage_page != path_item->usage_page) || 965 ((only_page == 0) && (report_item->usage != path_item->usage))) { 966 return 1; 967 } else { 968 report_link = report_link->prev; 969 path_link = path_link->prev; 970 } 971 972 } 973 974 if(path_link == &path->link) { 975 return EOK; 976 } 977 else { 978 return 1; 979 } 980 981 break; 982 983 default: 984 return EINVAL; 985 } 986 987 988 989 990 } 991 992 /** 993 * 994 */ 995 usb_hid_report_path_t *usb_hid_report_path(void) 996 { 997 usb_hid_report_path_t *path; 998 path = malloc(sizeof(usb_hid_report_path_t)); 999 if(!path){ 1000 return NULL; 1001 } 1002 else { 1003 path->depth = 0; 1004 list_initialize(&path->link); 1005 return path; 1006 } 1007 } 1008 1009 /** 1010 * 1011 */ 1012 void usb_hid_report_path_free(usb_hid_report_path_t *path) 1013 { 1014 while(!list_empty(&path->link)){ 1015 usb_hid_report_remove_last_item(path); 1016 } 1017 } 1018 1019 1020 /** 1021 * 1022 */ 1023 int usb_hid_report_path_clone(usb_hid_report_path_t *new_usage_path, usb_hid_report_path_t *usage_path) 1024 { 1025 usb_hid_report_usage_path_t *path_item; 1026 link_t *path_link; 1027 1028 1029 if(list_empty(&usage_path->link)){ 1030 return EOK; 1031 } 1032 1033 path_link = usage_path->link.next; 1034 while(path_link != &usage_path->link) { 1035 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link); 1036 usb_hid_report_path_append_item (new_usage_path, path_item->usage_page, path_item->usage); 1037 1038 path_link = path_link->next; 1039 } 1040 1041 return EOK; 1042 } 1043 759 1044 760 1045 /** -
uspace/lib/usb/src/hidreq.c
rda88eb82 r095b2017 41 41 #include <usb/debug.h> 42 42 #include <usb/request.h> 43 44 #include "hidreq.h" 45 #include "hiddev.h"43 #include <usb/pipes.h> 44 45 #include <usb/classes/hidreq.h> 46 46 47 47 /*----------------------------------------------------------------------------*/ … … 60 60 * usb_control_request_set(). 61 61 */ 62 int usbhid_req_set_report(usb hid_dev_t *hid_dev,62 int usbhid_req_set_report(usb_pipe_t *ctrl_pipe, int iface_no, 63 63 usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size) 64 64 { 65 if (hid_dev == NULL) { 66 usb_log_error("usbhid_req_set_report(): no HID device structure" 67 " given.\n"); 68 return EINVAL; 69 } 70 71 /* 72 * No need for checking other parameters, as they are checked in 73 * the called function (usb_control_request_set()). 74 */ 75 76 int rc, sess_rc; 77 78 sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe); 65 if (ctrl_pipe == NULL) { 66 usb_log_warning("usbhid_req_set_report(): no pipe given.\n"); 67 return EINVAL; 68 } 69 70 if (iface_no < 0) { 71 usb_log_warning("usbhid_req_set_report(): no interface given." 72 "\n"); 73 return EINVAL; 74 } 75 76 /* 77 * No need for checking other parameters, as they are checked in 78 * the called function (usb_control_request_set()). 79 */ 80 81 int rc, sess_rc; 82 83 sess_rc = usb_pipe_start_session(ctrl_pipe); 79 84 if (sess_rc != EOK) { 80 85 usb_log_warning("Failed to start a session: %s.\n", … … 88 93 usb_log_debug("Sending Set_Report request to the device.\n"); 89 94 90 rc = usb_control_request_set( &hid_dev->ctrl_pipe,91 USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 92 USB_HIDREQ_SET_REPORT, value, hid_dev->iface, buffer, buf_size);93 94 sess_rc = usb_pipe_end_session( &hid_dev->ctrl_pipe);95 rc = usb_control_request_set(ctrl_pipe, 96 USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 97 USB_HIDREQ_SET_REPORT, value, iface_no, buffer, buf_size); 98 99 sess_rc = usb_pipe_end_session(ctrl_pipe); 95 100 96 101 if (rc != EOK) { … … 122 127 * usb_control_request_set(). 123 128 */ 124 int usbhid_req_set_protocol(usbhid_dev_t *hid_dev, usb_hid_protocol_t protocol) 125 { 126 if (hid_dev == NULL) { 127 usb_log_error("usbhid_req_set_protocol(): no HID device " 128 "structure given.\n"); 129 return EINVAL; 130 } 131 132 /* 133 * No need for checking other parameters, as they are checked in 134 * the called function (usb_control_request_set()). 135 */ 136 137 int rc, sess_rc; 138 139 sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe); 129 int usbhid_req_set_protocol(usb_pipe_t *ctrl_pipe, int iface_no, 130 usb_hid_protocol_t protocol) 131 { 132 if (ctrl_pipe == NULL) { 133 usb_log_warning("usbhid_req_set_report(): no pipe given.\n"); 134 return EINVAL; 135 } 136 137 if (iface_no < 0) { 138 usb_log_warning("usbhid_req_set_report(): no interface given." 139 "\n"); 140 return EINVAL; 141 } 142 143 /* 144 * No need for checking other parameters, as they are checked in 145 * the called function (usb_control_request_set()). 146 */ 147 148 int rc, sess_rc; 149 150 sess_rc = usb_pipe_start_session(ctrl_pipe); 140 151 if (sess_rc != EOK) { 141 152 usb_log_warning("Failed to start a session: %s.\n", … … 145 156 146 157 usb_log_debug("Sending Set_Protocol request to the device (" 147 "protocol: %d, iface: %d).\n", protocol, hid_dev->iface);148 149 rc = usb_control_request_set( &hid_dev->ctrl_pipe,150 USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 151 USB_HIDREQ_SET_PROTOCOL, protocol, hid_dev->iface, NULL, 0);152 153 sess_rc = usb_pipe_end_session( &hid_dev->ctrl_pipe);158 "protocol: %d, iface: %d).\n", protocol, iface_no); 159 160 rc = usb_control_request_set(ctrl_pipe, 161 USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 162 USB_HIDREQ_SET_PROTOCOL, protocol, iface_no, NULL, 0); 163 164 sess_rc = usb_pipe_end_session(ctrl_pipe); 154 165 155 166 if (rc != EOK) { … … 182 193 * usb_control_request_set(). 183 194 */ 184 int usbhid_req_set_idle(usbhid_dev_t *hid_dev, uint8_t duration) 185 { 186 if (hid_dev == NULL) { 187 usb_log_error("usbhid_req_set_idle(): no HID device " 188 "structure given.\n"); 189 return EINVAL; 190 } 191 192 /* 193 * No need for checking other parameters, as they are checked in 194 * the called function (usb_control_request_set()). 195 */ 196 197 int rc, sess_rc; 198 199 sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe); 195 int usbhid_req_set_idle(usb_pipe_t *ctrl_pipe, int iface_no, uint8_t duration) 196 { 197 if (ctrl_pipe == NULL) { 198 usb_log_warning("usbhid_req_set_report(): no pipe given.\n"); 199 return EINVAL; 200 } 201 202 if (iface_no < 0) { 203 usb_log_warning("usbhid_req_set_report(): no interface given." 204 "\n"); 205 return EINVAL; 206 } 207 208 /* 209 * No need for checking other parameters, as they are checked in 210 * the called function (usb_control_request_set()). 211 */ 212 213 int rc, sess_rc; 214 215 sess_rc = usb_pipe_start_session(ctrl_pipe); 200 216 if (sess_rc != EOK) { 201 217 usb_log_warning("Failed to start a session: %s.\n", … … 205 221 206 222 usb_log_debug("Sending Set_Idle request to the device (" 207 "duration: %u, iface: %d).\n", duration, hid_dev->iface);223 "duration: %u, iface: %d).\n", duration, iface_no); 208 224 209 225 uint16_t value = duration << 8; 210 226 211 rc = usb_control_request_set( &hid_dev->ctrl_pipe,212 USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 213 USB_HIDREQ_SET_IDLE, value, hid_dev->iface, NULL, 0);214 215 sess_rc = usb_pipe_end_session( &hid_dev->ctrl_pipe);227 rc = usb_control_request_set(ctrl_pipe, 228 USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 229 USB_HIDREQ_SET_IDLE, value, iface_no, NULL, 0); 230 231 sess_rc = usb_pipe_end_session(ctrl_pipe); 216 232 217 233 if (rc != EOK) { … … 247 263 * usb_control_request_set(). 248 264 */ 249 int usbhid_req_get_report(usbhid_dev_t *hid_dev, usb_hid_report_type_t type, 250 uint8_t *buffer, size_t buf_size, size_t *actual_size) 251 { 252 if (hid_dev == NULL) { 253 usb_log_error("usbhid_req_set_report(): no HID device structure" 254 " given.\n"); 255 return EINVAL; 256 } 257 258 /* 259 * No need for checking other parameters, as they are checked in 260 * the called function (usb_control_request_set()). 261 */ 262 263 int rc, sess_rc; 264 265 sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe); 265 int usbhid_req_get_report(usb_pipe_t *ctrl_pipe, int iface_no, 266 usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size, 267 size_t *actual_size) 268 { 269 if (ctrl_pipe == NULL) { 270 usb_log_warning("usbhid_req_set_report(): no pipe given.\n"); 271 return EINVAL; 272 } 273 274 if (iface_no < 0) { 275 usb_log_warning("usbhid_req_set_report(): no interface given." 276 "\n"); 277 return EINVAL; 278 } 279 280 /* 281 * No need for checking other parameters, as they are checked in 282 * the called function (usb_control_request_set()). 283 */ 284 285 int rc, sess_rc; 286 287 sess_rc = usb_pipe_start_session(ctrl_pipe); 266 288 if (sess_rc != EOK) { 267 289 usb_log_warning("Failed to start a session: %s.\n", … … 275 297 usb_log_debug("Sending Get_Report request to the device.\n"); 276 298 277 rc = usb_control_request_get( &hid_dev->ctrl_pipe,278 USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 279 USB_HIDREQ_GET_REPORT, value, hid_dev->iface, buffer, buf_size,299 rc = usb_control_request_get(ctrl_pipe, 300 USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 301 USB_HIDREQ_GET_REPORT, value, iface_no, buffer, buf_size, 280 302 actual_size); 281 303 282 sess_rc = usb_pipe_end_session( &hid_dev->ctrl_pipe);304 sess_rc = usb_pipe_end_session(ctrl_pipe); 283 305 284 306 if (rc != EOK) { … … 310 332 * usb_control_request_set(). 311 333 */ 312 int usbhid_req_get_protocol(usbhid_dev_t *hid_dev, usb_hid_protocol_t *protocol) 313 { 314 if (hid_dev == NULL) { 315 usb_log_error("usbhid_req_set_protocol(): no HID device " 316 "structure given.\n"); 317 return EINVAL; 318 } 319 320 /* 321 * No need for checking other parameters, as they are checked in 322 * the called function (usb_control_request_set()). 323 */ 324 325 int rc, sess_rc; 326 327 sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe); 334 int usbhid_req_get_protocol(usb_pipe_t *ctrl_pipe, int iface_no, 335 usb_hid_protocol_t *protocol) 336 { 337 if (ctrl_pipe == NULL) { 338 usb_log_warning("usbhid_req_set_report(): no pipe given.\n"); 339 return EINVAL; 340 } 341 342 if (iface_no < 0) { 343 usb_log_warning("usbhid_req_set_report(): no interface given." 344 "\n"); 345 return EINVAL; 346 } 347 348 /* 349 * No need for checking other parameters, as they are checked in 350 * the called function (usb_control_request_set()). 351 */ 352 353 int rc, sess_rc; 354 355 sess_rc = usb_pipe_start_session(ctrl_pipe); 328 356 if (sess_rc != EOK) { 329 357 usb_log_warning("Failed to start a session: %s.\n", … … 333 361 334 362 usb_log_debug("Sending Get_Protocol request to the device (" 335 "iface: %d).\n", hid_dev->iface);363 "iface: %d).\n", iface_no); 336 364 337 365 uint8_t buffer[1]; 338 366 size_t actual_size = 0; 339 367 340 rc = usb_control_request_get( &hid_dev->ctrl_pipe,341 USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 342 USB_HIDREQ_GET_PROTOCOL, 0, hid_dev->iface, buffer, 1, &actual_size);343 344 sess_rc = usb_pipe_end_session( &hid_dev->ctrl_pipe);368 rc = usb_control_request_get(ctrl_pipe, 369 USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 370 USB_HIDREQ_GET_PROTOCOL, 0, iface_no, buffer, 1, &actual_size); 371 372 sess_rc = usb_pipe_end_session(ctrl_pipe); 345 373 346 374 if (rc != EOK) { … … 381 409 * usb_control_request_set(). 382 410 */ 383 int usbhid_req_get_idle(usbhid_dev_t *hid_dev, uint8_t *duration) 384 { 385 if (hid_dev == NULL) { 386 usb_log_error("usbhid_req_set_idle(): no HID device " 387 "structure given.\n"); 388 return EINVAL; 389 } 390 391 /* 392 * No need for checking other parameters, as they are checked in 393 * the called function (usb_control_request_set()). 394 */ 395 396 int rc, sess_rc; 397 398 sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe); 411 int usbhid_req_get_idle(usb_pipe_t *ctrl_pipe, int iface_no, uint8_t *duration) 412 { 413 if (ctrl_pipe == NULL) { 414 usb_log_warning("usbhid_req_set_report(): no pipe given.\n"); 415 return EINVAL; 416 } 417 418 if (iface_no < 0) { 419 usb_log_warning("usbhid_req_set_report(): no interface given." 420 "\n"); 421 return EINVAL; 422 } 423 424 /* 425 * No need for checking other parameters, as they are checked in 426 * the called function (usb_control_request_set()). 427 */ 428 429 int rc, sess_rc; 430 431 sess_rc = usb_pipe_start_session(ctrl_pipe); 399 432 if (sess_rc != EOK) { 400 433 usb_log_warning("Failed to start a session: %s.\n", … … 404 437 405 438 usb_log_debug("Sending Get_Idle request to the device (" 406 "iface: %d).\n", hid_dev->iface);439 "iface: %d).\n", iface_no); 407 440 408 441 uint16_t value = 0; … … 410 443 size_t actual_size = 0; 411 444 412 rc = usb_control_request_get( &hid_dev->ctrl_pipe,413 USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 414 USB_HIDREQ_GET_IDLE, value, hid_dev->iface, buffer, 1,445 rc = usb_control_request_get(ctrl_pipe, 446 USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 447 USB_HIDREQ_GET_IDLE, value, iface_no, buffer, 1, 415 448 &actual_size); 416 449 417 sess_rc = usb_pipe_end_session( &hid_dev->ctrl_pipe);450 sess_rc = usb_pipe_end_session(ctrl_pipe); 418 451 419 452 if (rc != EOK) {
Note:
See TracChangeset
for help on using the changeset viewer.
