Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/usbhid/src/hidpath.c

    r5499a8b r160b75e  
    4141#include <assert.h>
    4242
    43 /*---------------------------------------------------------------------------*/
    44 /**
    45  * Compares two usages if they are same or not or one of the usages is not
    46  * set.
    47  *
    48  * @param usage1
    49  * @param usage2
    50  * @return boolean
    51  */
    52 #define USB_HID_SAME_USAGE(usage1, usage2)              \
    53         ((usage1 == usage2) || (usage1 == 0) || (usage2 == 0))
    54 
    55 /**
    56  * Compares two usage pages if they are same or not or one of them is not set.
    57  *
    58  * @param page1
    59  * @param page2
    60  * @return boolean
    61  */
    62 #define USB_HID_SAME_USAGE_PAGE(page1, page2)   \
    63         ((page1 == page2) || (page1 == 0) || (page2 == 0))
    64 
    65 /*---------------------------------------------------------------------------*/
     43
    6644/**
    6745 * Appends one item (couple of usage_path and usage) into the usage path
     
    9270}
    9371
    94 /*---------------------------------------------------------------------------*/
    9572/**
    9673 * Removes last item from the usage path structure
     
    11188}
    11289
    113 /*---------------------------------------------------------------------------*/
    11490/**
    11591 * Nulls last item of the usage path structure.
     
    12399       
    124100        if(!list_empty(&usage_path->head)){     
    125                 item = list_get_instance(usage_path->head.prev,
    126                         usb_hid_report_usage_path_t, link);
    127 
     101                item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link);
    128102                memset(item, 0, sizeof(usb_hid_report_usage_path_t));
    129103        }
    130104}
    131105
    132 /*---------------------------------------------------------------------------*/
    133106/**
    134107 * Modifies last item of usage path structure by given usage page or usage
     
    161134}
    162135
    163 /*---------------------------------------------------------------------------*/
    164 /**
    165  *
    166  *
    167  *
    168  *
    169  */
     136
    170137void usb_hid_print_usage_path(usb_hid_report_path_t *path)
    171138{
     
    177144        while(item != &path->head) {
    178145
    179                 path_item = list_get_instance(item, usb_hid_report_usage_path_t,
    180                         link);
    181 
     146                path_item = list_get_instance(item, usb_hid_report_usage_path_t, link);
    182147                usb_log_debug("\tUSAGE_PAGE: %X\n", path_item->usage_page);
    183148                usb_log_debug("\tUSAGE: %X\n", path_item->usage);
    184149                usb_log_debug("\tFLAGS: %d\n", path_item->flags);               
    185150               
    186         item = item->next;
    187         }
    188 }
    189 
    190 /*---------------------------------------------------------------------------*/
     151                item = item->next;
     152        }
     153}
     154
    191155/**
    192156 * Compares two usage paths structures
     
    231195                        }
    232196
     197                        // projit skrz cestu a kdyz nekde sedi tak vratim EOK
     198                        // dojduli az za konec tak nnesedi
    233199                        report_link = report_path->head.next;
    234200                        path_link = path->head.next;
    235                         path_item = list_get_instance(path_link,
    236                                 usb_hid_report_usage_path_t, link);
     201                        path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);
    237202
    238203                        while(report_link != &report_path->head) {
    239                                 report_item = list_get_instance(report_link,
    240                                         usb_hid_report_usage_path_t, link);
    241                                
    242                                 if(USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
    243                                         path_item->usage_page)){
    244                                        
     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){
    245206                                        if(only_page == 0){
    246                                                 if(USB_HID_SAME_USAGE(report_item->usage,
    247                                                         path_item->usage)) {
    248                                                        
     207                                                if(report_item->usage == path_item->usage) {
    249208                                                        return EOK;
    250209                                                }
     
    276235                                                 
    277236                                        report_item = list_get_instance(report_link,
    278                         usb_hid_report_usage_path_t, link);
     237                                                                        usb_hid_report_usage_path_t,
     238                                                                        link);
    279239                                                 
    280240                                        path_item = list_get_instance(path_link,
    281                         usb_hid_report_usage_path_t, link);             
    282 
    283                                         if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
    284                                                 path_item->usage_page) || ((only_page == 0) &&
    285                                             !USB_HID_SAME_USAGE(report_item->usage,
    286                                                 path_item->usage))) {
     241                                                                      usb_hid_report_usage_path_t,
     242                                                                      link);           
     243
     244                                        if((report_item->usage_page != path_item->usage_page) ||
     245                                           ((only_page == 0) &&
     246                                            (report_item->usage != path_item->usage))) {
    287247                                                       
    288248                                                   return 1;
     
    294254                                }
    295255
    296                                 if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) &&
    297                                         (path_link == &path->head)) ||
    298                                    ((report_link == &report_path->head) &&
    299                                         (path_link == &path->head))) {
    300                                        
     256                                if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) && (path_link == &path->head)) ||
     257                                   ((report_link == &report_path->head) && (path_link == &path->head))) {
    301258                                        return EOK;
    302259                                }
     
    320277                                                 
    321278                                        report_item = list_get_instance(report_link,
    322                                                 usb_hid_report_usage_path_t, link);
    323 
     279                                                                        usb_hid_report_usage_path_t,
     280                                                                        link);
    324281                                        path_item = list_get_instance(path_link,
    325                                                 usb_hid_report_usage_path_t, link);             
    326                                                  
    327                                         if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
    328                                                 path_item->usage_page) || ((only_page == 0) &&
    329                                             !USB_HID_SAME_USAGE(report_item->usage,
    330                                                 path_item->usage))) {
    331                                                
    332                                                         return 1;
     282                                                                      usb_hid_report_usage_path_t,
     283                                                                      link);           
     284
     285                                        if((report_item->usage_page != path_item->usage_page) ||
     286                                           ((only_page == 0) &&
     287                                            (report_item->usage != path_item->usage))) {
     288                                                   return 1;
    333289                                        } else {
    334290                                                report_link = report_link->prev;
     
    352308}
    353309
    354 /*---------------------------------------------------------------------------*/
    355310/**
    356311 * Allocates and initializes new usage path structure.
     
    374329}
    375330
    376 /*---------------------------------------------------------------------------*/
    377331/**
    378332 * Releases given usage path structure.
     
    391345}
    392346
    393 /*---------------------------------------------------------------------------*/
     347
    394348/**
    395349 * Clone content of given usage path to the new one
     
    398352 * @return New copy of given usage path structure
    399353 */
    400 usb_hid_report_path_t *usb_hid_report_path_clone(
    401         usb_hid_report_path_t *usage_path)
     354usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path)
    402355{
    403356        link_t *path_link;
     
    418371        path_link = usage_path->head.next;
    419372        while(path_link != &usage_path->head) {
    420                 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t,
     373                path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, 
    421374                                              link);
    422375                new_path_item = malloc(sizeof(usb_hid_report_usage_path_t));
     
    439392}
    440393
    441 /*---------------------------------------------------------------------------*/
     394
    442395/**
    443396 * Sets report id in usage path structure
     
    447400 * @return Error code
    448401 */
    449 int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path,
    450         uint8_t report_id)
     402int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, uint8_t report_id)
    451403{
    452404        if(path == NULL){
Note: See TracChangeset for help on using the changeset viewer.