Ignore:
Timestamp:
2018-02-28T17:52:03Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
3061bc1
Parents:
df6ded8
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:26:03)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:52:03)
Message:

style: Remove trailing whitespace on non-empty lines, in certain file types.

Command used: tools/srepl '\([^[:space:]]\)\s\+$' '\1' -- *.c *.h *.py *.sh *.s *.S *.ag

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rdf6ded8 r1b20da0  
    8585 * inserts it if not.
    8686 *
    87  * @param report Report structure 
    88  * @param cmp_path The collection path 
     87 * @param report Report structure
     88 * @param cmp_path The collection path
    8989 * @return Pointer to the result collection path in report structure.
    9090 * @retval NULL If some error occurs
    … …  
    122122        else {
    123123                return list_get_instance(path_it, usb_hid_report_path_t,
    124                                 cpath_link); 
     124                                cpath_link);
    125125        }
    126126}
    … …  
    156156 * @param report Report structure in which the new report items should be
    157157 *               stored
    158  * @param report_item Current report descriptor's parsing state table 
     158 * @param report_item Current report descriptor's parsing state table
    159159 * @return Error code
    160160 * @retval EOK If all fields were successfully append to report
    … …  
    179179                usages = malloc(sizeof(uint32_t) * report_item->usages_count);
    180180                memcpy(usages, report_item->usages, sizeof(int32_t) *
    181                                 report_item->usages_count); 
     181                                report_item->usages_count);
    182182        }
    183183        else {
    … …  
    185185        }
    186186       
    187         usb_hid_report_path_t *path = report_item->usage_path; 
     187        usb_hid_report_path_t *path = report_item->usage_path;
    188188        for(i=0; i<report_item->count; i++){
    189189
    … …  
    196196                link_initialize(&field->ritems_link);
    197197
    198                 /* fill the attributes */               
     198                /* fill the attributes */
    199199                field->logical_minimum = report_item->logical_minimum;
    200200                field->logical_maximum = report_item->logical_maximum;
    … …  
    203203
    204204                if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0){
    205                         /* 
     205                        /*
    206206                        Store usage array. The Correct Usage Page and Usage is
    207207                        depending on data in report and will be filled later
    … …  
    223223                        else {
    224224                                usage = report_item->usages[
    225                                         report_item->usages_count- 1]; 
     225                                        report_item->usages_count- 1];
    226226                        }
    227227
    228228                        if(USB_HID_IS_EXTENDED_USAGE(usage)){
    229229                                field->usage = USB_HID_EXTENDED_USAGE(usage);
    230                                 field->usage_page = 
     230                                field->usage_page =
    231231                                        USB_HID_EXTENDED_USAGE_PAGE(usage);
    232232                        }
    … …  
    324324            usb_hid_report_description_t, report_des) {
    325325                // if report id not set, return the first of the type
    326                 if(((report_des->report_id == report_id) || (report_id == 0)) && 
    327                    (report_des->type == type)) { 
     326                if(((report_des->report_id == report_id) || (report_id == 0)) &&
     327                   (report_des->type == type)) {
    328328                        return report_des;
    329329                }
    … …  
    343343 * @retval EOK If report descriptor is successfully parsed
    344344 */
    345 errno_t usb_hid_parse_report_descriptor(usb_hid_report_t *report, 
     345errno_t usb_hid_parse_report_descriptor(usb_hid_report_t *report,
    346346    const uint8_t *data, size_t size)
    347347{
    … …  
    352352        int ret;
    353353        usb_hid_report_item_t *report_item=0;
    354         usb_hid_report_item_t *new_report_item; 
     354        usb_hid_report_item_t *new_report_item;
    355355        usb_hid_report_path_t *usage_path;
    356356
    … …  
    380380                return ENOMEM;
    381381        }
    382         usb_hid_report_path_append_item(usage_path, 0, 0);     
    383        
    384         while(i<size){ 
     382        usb_hid_report_path_append_item(usage_path, 0, 0);
     383       
     384        while(i<size){
    385385                if(!USB_HID_ITEM_IS_LONG(data[i])){
    386386
    … …  
    412412                                switch(tag) {
    413413                                case USB_HID_REPORT_TAG_INPUT:
    414                                         report_item->type = 
     414                                        report_item->type =
    415415                                            USB_HID_REPORT_TYPE_INPUT;
    416416
    417417                                        report_item->offset = offset_input;
    418                                         offset_input += report_item->count * 
     418                                        offset_input += report_item->count *
    419419                                            report_item->size;
    420420                                        break;
    421421       
    422422                                case USB_HID_REPORT_TAG_OUTPUT:
    423                                         report_item->type = 
     423                                        report_item->type =
    424424                                            USB_HID_REPORT_TYPE_OUTPUT;
    425425                                       
    426426                                        report_item->offset = offset_output;
    427                                         offset_output += report_item->count * 
     427                                        offset_output += report_item->count *
    428428                                            report_item->size;
    429429                                        break;
    430430       
    431431                                case USB_HID_REPORT_TAG_FEATURE:
    432                                         report_item->type = 
     432                                        report_item->type =
    433433                                            USB_HID_REPORT_TYPE_FEATURE;
    434434
    435435                                        report_item->offset = offset_feature;
    436                                         offset_feature += report_item->count * 
     436                                        offset_feature += report_item->count *
    437437                                                report_item->size;
    438438                                        break;
    … …  
    444444                                }
    445445                                       
    446                                 /* 
    447                                  * append new fields to the report structure                                     
     446                                /*
     447                                 * append new fields to the report structure
    448448                                 */
    449                                 usb_hid_report_append_fields(report, 
     449                                usb_hid_report_append_fields(report,
    450450                                    report_item);
    451451
    … …  
    458458                                offset_output = 0;
    459459                                offset_feature = 0;
    460                                 usb_hid_report_path_set_report_id (usage_path, 
     460                                usb_hid_report_path_set_report_id (usage_path,
    461461                                    report_item->id);
    462462                                break;
    … …  
    467467                                    report_item);
    468468                               
    469                                 usb_hid_report_path_t *tmp_path = 
     469                                usb_hid_report_path_t *tmp_path =
    470470                                    usb_hid_report_path_clone(usage_path);
    471471
    472                                 new_report_item->usage_path = tmp_path; 
     472                                new_report_item->usage_path = tmp_path;
    473473
    474474                                list_prepend (&new_report_item->link, &stack);
    … …  
    490490                                    usb_hid_report_usage_path_t, rpath_items_link);
    491491                               
    492                                 usb_hid_report_set_last_item(usage_path, 
     492                                usb_hid_report_set_last_item(usage_path,
    493493                                    USB_HID_TAG_CLASS_GLOBAL, tmp_usage_path->usage_page);
    494494                               
    495                                 usb_hid_report_set_last_item(usage_path, 
     495                                usb_hid_report_set_last_item(usage_path,
    496496                                    USB_HID_TAG_CLASS_LOCAL, tmp_usage_path->usage);
    497497
    … …  
    502502                                       
    503503                        default:
    504                                 // nothing special to do                                       
     504                                // nothing special to do
    505505                                break;
    506506                        }
    … …  
    533533int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data,
    534534        size_t item_size, usb_hid_report_item_t *report_item,
    535         usb_hid_report_path_t *usage_path) {   
     535        usb_hid_report_path_t *usage_path) {
    536536       
    537537        int ret;
    … …  
    550550                break;
    551551
    552         case USB_HID_TAG_CLASS_GLOBAL: 
     552        case USB_HID_TAG_CLASS_GLOBAL:
    553553                return usb_hid_report_parse_global_tag(tag, data, item_size,
    554554                        report_item, usage_path);
    555555                break;
    556556
    557         case USB_HID_TAG_CLASS_LOCAL:                   
     557        case USB_HID_TAG_CLASS_LOCAL:
    558558                return usb_hid_report_parse_local_tag(tag, data, item_size,
    559559                        report_item, usage_path);
    … …  
    575575 */
    576576
    577 int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, 
     577int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data,
    578578        size_t item_size, usb_hid_report_item_t *report_item,
    579579        usb_hid_report_path_t *usage_path)
    … …  
    586586        case USB_HID_REPORT_TAG_OUTPUT:
    587587        case USB_HID_REPORT_TAG_FEATURE:
    588                 report_item->item_flags = *data;                       
    589                 return 0;                       
     588                report_item->item_flags = *data;
     589                return 0;
    590590                break;
    591591                       
    … …  
    598598                       
    599599                /* set last item */
    600                 usb_hid_report_set_last_item(usage_path, 
    601                         USB_HID_TAG_CLASS_GLOBAL, 
     600                usb_hid_report_set_last_item(usage_path,
     601                        USB_HID_TAG_CLASS_GLOBAL,
    602602                        USB_HID_EXTENDED_USAGE_PAGE(report_item->usages[
    603603                                report_item->usages_count-1]));
    604604
    605                 usb_hid_report_set_last_item(usage_path, 
    606                         USB_HID_TAG_CLASS_LOCAL, 
     605                usb_hid_report_set_last_item(usage_path,
     606                        USB_HID_TAG_CLASS_LOCAL,
    607607                        USB_HID_EXTENDED_USAGE(report_item->usages[
    608608                                report_item->usages_count-1]));
    … …  
    610610                /* append the new one which will be set by common usage/usage
    611611                 * page */
    612                 usb_hid_report_path_append_item(usage_path, 
    613                         report_item->usage_page, 
     612                usb_hid_report_path_append_item(usage_path,
     613                        report_item->usage_page,
    614614                        report_item->usages[report_item->usages_count-1]);
    615615
    … …  
    639639 * @return 0 or USB_HID_ code
    640640 */
    641 int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, 
    642         size_t item_size, usb_hid_report_item_t *report_item, 
    643         usb_hid_report_path_t *usage_path) { 
     641int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data,
     642        size_t item_size, usb_hid_report_item_t *report_item,
     643        usb_hid_report_path_t *usage_path) {
    644644       
    645645        switch(tag)
    646646        {
    647647        case USB_HID_REPORT_TAG_USAGE_PAGE:
    648                 report_item->usage_page = 
     648                report_item->usage_page =
    649649                        usb_hid_report_tag_data_uint32(data, item_size);
    650650                break;
    … …  
    658658        case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM:
    659659                report_item->logical_maximum = USB_HID_UINT32_TO_INT32(
    660                         usb_hid_report_tag_data_uint32(data,item_size), 
     660                        usb_hid_report_tag_data_uint32(data,item_size),
    661661                        item_size * 8);
    662662                break;
    … …  
    664664        case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM:
    665665                report_item->physical_minimum = USB_HID_UINT32_TO_INT32(
    666                         usb_hid_report_tag_data_uint32(data,item_size), 
     666                        usb_hid_report_tag_data_uint32(data,item_size),
    667667                        item_size * 8);
    668                 break;                 
     668                break;
    669669
    670670        case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM:
    671671                report_item->physical_maximum = USB_HID_UINT32_TO_INT32(
    672                         usb_hid_report_tag_data_uint32(data,item_size), 
     672                        usb_hid_report_tag_data_uint32(data,item_size),
    673673                        item_size * 8);
    674674                break;
    … …  
    695695
    696696        case USB_HID_REPORT_TAG_REPORT_ID:
    697                 report_item->id = usb_hid_report_tag_data_uint32(data, 
     697                report_item->id = usb_hid_report_tag_data_uint32(data,
    698698                        item_size);
    699699                return USB_HID_RESET_OFFSET;
    … …  
    702702        case USB_HID_REPORT_TAG_PUSH:
    703703        case USB_HID_REPORT_TAG_POP:
    704                 /* 
     704                /*
    705705                 * stack operations are done in top level parsing
    706706                 * function
    … …  
    943943
    944944
    945 /** Frees the HID report descriptor parser structure 
     945/** Frees the HID report descriptor parser structure
    946946 *
    947947 * @param parser Opaque HID report parser structure
Note: See TracChangeset for help on using the changeset viewer.