Changes in / [1ce4189:45a2688] in mainline


Ignore:
Location:
uspace/lib/usb
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/usb/include/usb/classes/hidpath.h

    r1ce4189 r45a2688  
    4444 */
    4545/** Wanted usage path must be exactly the same as the searched one */
    46 #define USB_HID_PATH_COMPARE_STRICT                             0
     46#define USB_HID_PATH_COMPARE_STRICT             0
    4747/** Wanted usage path must be the suffix in the searched one */
    48 #define USB_HID_PATH_COMPARE_END                        1
     48#define USB_HID_PATH_COMPARE_END                1
    4949/** */
    50 #define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY    4
    51 #define USB_HID_PATH_COMPARE_COLLECTION_ONLY    2 /* porovnava jenom cestu z Kolekci */
     50#define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY    2
    5251/** Searched usage page must be prefix of the other one */
    53 #define USB_HID_PATH_COMPARE_BEGIN              8
     52#define USB_HID_PATH_COMPARE_BEGIN              4
    5453/** Searched couple of usage page and usage can be anywhere in usage path */
    55 #define USB_HID_PATH_COMPARE_WHERE              16
    56 /**
    57  * TODO
    58  *  * porovnani zacatek - neni to to samy jako COLLECTION ONLY?? -- TEST
    59  *  * porovnani kdekoliv (jenom s delkou 1 at si to moc nekomplikujem)
    60  */
     54#define USB_HID_PATH_COMPARE_ANYWHERE           8
    6155
    6256

  • uspace/lib/usb/src/hiddescriptor.c

    r1ce4189 r45a2688  
    437437int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    438438                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
    439 {               
     439{
     440        usb_hid_report_usage_path_t *path_item;
     441       
    440442        switch(tag)
    441443        {
    … …  
    448450                       
    449451                case USB_HID_REPORT_TAG_COLLECTION:
    450                         //TODO: usage_path->flags = *data;
     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;       
    451455                       
    452                         usb_log_debug("APPENDED ITEM TO USAGE PATH (PAGE %d, USAGE %d\n", report_item->usage_page, report_item->usages[report_item->usages_count-1]);
    453                         usb_hid_print_usage_path(usage_path);
    454 
    455456                        // set last item
    456457                        usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL, report_item->usage_page);
    457458                        usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL, report_item->usages[report_item->usages_count-1]);
     459                       
    458460                        // append the new one which will be set by common
    459461                        // usage/usage page
    460462                        usb_hid_report_path_append_item(usage_path, report_item->usage_page, report_item->usages[report_item->usages_count-1]);
    461                         usb_hid_print_usage_path(usage_path);
    462 
    463463                        usb_hid_report_reset_local_items (report_item);
    464464                        return USB_HID_NO_ACTION;
    … …  
    551551                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
    552552{
    553         switch(tag)
    554         {
     553        switch(tag) {
    555554                case USB_HID_REPORT_TAG_USAGE:
    556                         report_item->usages[report_item->usages_count] = usb_hid_report_tag_data_uint32(data,item_size);
    557                         report_item->usages_count++;
     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                        }
    558566                        break;
    559567                case USB_HID_REPORT_TAG_USAGE_MINIMUM:
    … …  
    596604                        break;                 
    597605                case USB_HID_REPORT_TAG_DELIMITER:
    598                         if (report_item->in_delimiter == OUTSIDE_DELIMITER_SET) {
    599                                 report_item->in_delimiter = START_DELIMITER_SET;
    600                         }
    601                         else {
    602                                 report_item->in_delimiter = OUTSIDE_DELIMITER_SET;
    603                         }
    604                        
    605                         break;
    606                
     606                        report_item->in_delimiter = usb_hid_report_tag_data_uint32(data,item_size);
     607                        break;
     608
    607609                default:
    608610                        return USB_HID_NO_ACTION;
    609611        }
    610        
     612
    611613        return EOK;
    612614}

  • uspace/lib/usb/src/hidpath.c

    r1ce4189 r45a2688  
    149149                usb_log_debug("\tFLAGS: %d\n", path_item->flags);               
    150150               
    151                 item = item->next;
     151                item = item->next;
    152152        }
    153153}
    … …  
    156156 * Compares two usage paths structures
    157157 *
    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
     158 *
     159 * @param report_path usage path structure to compare with @path
    161160 * @param path usage patrh structure to compare
    162161 * @param flags Flags determining the mode of comparison
    … …  
    179178        }
    180179
     180        // Empty path match all others
    181181        if(path->depth == 0){
    182182                return EOK;
    … …  
    189189       
    190190        switch(flags){
    191                 /* path must be completly identical */
     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 */
    192222                case USB_HID_PATH_COMPARE_STRICT:
    193223                                if(report_path->depth != path->depth){
    194224                                        return 1;
    195225                                }
    196 
     226               
     227                /* path is prefix of the report_path */
     228                case USB_HID_PATH_COMPARE_BEGIN:
     229       
    197230                                report_link = report_path->head.next;
    198231                                path_link = path->head.next;
    … …  
    221254                                }
    222255
    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))) {
     256                                if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) && (path_link == &path->head)) ||
     257                                   ((report_link == &report_path->head) && (path_link == &path->head))) {
    227258                                        return EOK;
    228259                                }
    … …  
    232263                        break;
    233264
    234                 /* compare with only the end of path*/
     265                /* path is suffix of report_path */
    235266                case USB_HID_PATH_COMPARE_END:
    236267
    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                                 }
     268                                report_link = report_path->head.prev;
    243269                                path_link = path->head.prev;
    244270
Note: See TracChangeset for help on using the changeset viewer.