Ignore:
Timestamp:
2018-04-12T16:27:17Z (7 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
3cf22f9
Parents:
76d0981d
git-author:
Jiri Svoboda <jiri@…> (2018-04-11 19:25:33)
git-committer:
Jiri Svoboda <jiri@…> (2018-04-12 16:27:17)
Message:

Make ccheck-fix again and commit more good files.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r76d0981d r3bacee1  
    9696        usb_hid_report_path_t *path = NULL;
    9797
    98         if((report == NULL) || (cmp_path == NULL)) {
     98        if ((report == NULL) || (cmp_path == NULL)) {
    9999                return NULL;
    100100        }
    101101
    102         while(path_it != &report->collection_paths.head) {
     102        while (path_it != &report->collection_paths.head) {
    103103                path = list_get_instance(path_it, usb_hid_report_path_t,
    104                                 cpath_link);
    105 
    106                 if(usb_hid_report_compare_usage_path(path, cmp_path,
    107                                         USB_HID_PATH_COMPARE_STRICT) == 0){
     104                    cpath_link);
     105
     106                if (usb_hid_report_compare_usage_path(path, cmp_path,
     107                    USB_HID_PATH_COMPARE_STRICT) == 0) {
    108108                        break;
    109109                }
    110110                path_it = path_it->next;
    111111        }
    112         if(path_it == &report->collection_paths.head) {
     112        if (path_it == &report->collection_paths.head) {
    113113                path = usb_hid_report_path_clone(cmp_path);
    114                 if(path == NULL) {
     114                if (path == NULL) {
    115115                        return NULL;
    116116                }
    … …  
    119119
    120120                return path;
    121         }
    122         else {
     121        } else {
    123122                return list_get_instance(path_it, usb_hid_report_path_t,
    124                                 cpath_link);
     123                    cpath_link);
    125124        }
    126125}
    … …  
    146145
    147146        report->use_report_ids = 0;
    148     return EOK;
     147        return EOK;
    149148}
    150149
    … …  
    164163 */
    165164errno_t usb_hid_report_append_fields(usb_hid_report_t *report,
    166                 usb_hid_report_item_t *report_item) {
     165    usb_hid_report_item_t *report_item)
     166{
    167167
    168168        usb_hid_report_field_t *field;
    … …  
    170170
    171171        uint32_t *usages;
    172         int usages_used=0;
    173 
    174         if((report == NULL) || (report_item == NULL)) {
     172        int usages_used = 0;
     173
     174        if ((report == NULL) || (report_item == NULL)) {
    175175                return EINVAL;
    176176        }
    177177
    178         if(report_item->usages_count > 0){
     178        if (report_item->usages_count > 0) {
    179179                usages = malloc(sizeof(uint32_t) * report_item->usages_count);
    180180                memcpy(usages, report_item->usages, sizeof(int32_t) *
    181                                 report_item->usages_count);
    182         }
    183         else {
     181                    report_item->usages_count);
     182        } else {
    184183                usages = NULL;
    185184        }
    186185
    187186        usb_hid_report_path_t *path = report_item->usage_path;
    188         for(i=0; i<report_item->count; i++){
     187        for (i = 0; i < report_item->count; i++) {
    189188
    190189                field = malloc(sizeof(usb_hid_report_field_t));
    191                 if(field == NULL) {
     190                if (field == NULL) {
    192191                        return ENOMEM;
    193192                }
    … …  
    202201                field->physical_maximum = report_item->physical_maximum;
    203202
    204                 if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0){
     203                if (USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) {
    205204                        /*
    206205                        Store usage array. The Correct Usage Page and Usage is
    … …  
    213212                        field->usages = usages;
    214213                        usages_used = 1;
    215                 }
    216                 else {
     214                } else {
    217215
    218216                        /* Fill the correct Usage and Usage Page */
    219217                        int32_t usage;
    220                         if(i < report_item->usages_count) {
     218                        if (i < report_item->usages_count) {
    221219                                usage = report_item->usages[i];
     220                        } else {
     221                                usage = report_item->usages[report_item->usages_count - 1];
    222222                        }
    223                         else {
    224                                 usage = report_item->usages[
    225                                         report_item->usages_count- 1];
    226                         }
    227 
    228                         if(USB_HID_IS_EXTENDED_USAGE(usage)){
     223
     224                        if (USB_HID_IS_EXTENDED_USAGE(usage)) {
    229225                                field->usage = USB_HID_EXTENDED_USAGE(usage);
    230226                                field->usage_page =
    231                                         USB_HID_EXTENDED_USAGE_PAGE(usage);
    232                         }
    233                         else {
     227                                    USB_HID_EXTENDED_USAGE_PAGE(usage);
     228                        } else {
    234229                                // should not occur
    235230                                field->usage = usage;
    … …  
    239234
    240235                usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_GLOBAL,
    241                                 field->usage_page);
     236                    field->usage_page);
    242237                usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_LOCAL,
    243                                 field->usage);
     238                    field->usage);
    244239
    245240                field->collection_path =
    246                         usb_hid_report_path_try_insert(report, path);
     241                    usb_hid_report_path_try_insert(report, path);
    247242
    248243                field->size = report_item->size;
    … …  
    250245                field->offset = report_item->offset + (i * report_item->size);
    251246
    252                 if(report->use_report_ids != 0) {
     247                if (report->use_report_ids != 0) {
    253248                        field->offset += 8;
    254249                        report->use_report_ids = 1;
    … …  
    260255                usb_hid_report_description_t *report_des;
    261256                report_des = usb_hid_report_find_description(report,
    262                         report_item->id, report_item->type);
    263 
    264                 if(report_des == NULL){
     257                    report_item->id, report_item->type);
     258
     259                if (report_des == NULL) {
    265260                        report_des = malloc(
    266                                 sizeof(usb_hid_report_description_t));
    267                         if(report_des == NULL) {
     261                            sizeof(usb_hid_report_description_t));
     262                        if (report_des == NULL) {
    268263                                return ENOMEM;
    269264                        }
    270265
    271266                        memset(report_des, 0,
    272                                 sizeof(usb_hid_report_description_t));
     267                            sizeof(usb_hid_report_description_t));
    273268
    274269                        report_des->type = report_item->type;
    275270                        report_des->report_id = report_item->id;
    276                         if(report_des->report_id != 0) {
     271                        if (report_des->report_id != 0) {
    277272                                /* set up the bit length by report_id field */
    278273                                report_des->bit_length = 8;
    … …  
    296291
    297292        // free only when not used!!!
    298         if(usages && usages_used == 0) {
     293        if (usages && usages_used == 0) {
    299294                free(usages);
    300295        }
    … …  
    313308 * @retval NULL If no description is founded
    314309 */
    315 usb_hid_report_description_t * usb_hid_report_find_description(
    316                 const usb_hid_report_t *report, uint8_t report_id,
    317                 usb_hid_report_type_t type) {
    318 
    319         if(report == NULL) {
     310usb_hid_report_description_t *usb_hid_report_find_description(
     311    const usb_hid_report_t *report, uint8_t report_id,
     312    usb_hid_report_type_t type)
     313{
     314
     315        if (report == NULL) {
    320316                return NULL;
    321317        }
    … …  
    324320            usb_hid_report_description_t, report_des) {
    325321                // 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)) {
     322                if (((report_des->report_id == report_id) || (report_id == 0)) &&
     323                    (report_des->type == type)) {
    328324                        return report_des;
    329325                }
    … …  
    346342    const uint8_t *data, size_t size)
    347343{
    348         size_t i=0;
    349         uint8_t tag=0;
    350         uint8_t item_size=0;
    351         int class=0;
     344        size_t i = 0;
     345        uint8_t tag = 0;
     346        uint8_t item_size = 0;
     347        int class = 0;
    352348        int ret;
    353         usb_hid_report_item_t *report_item=0;
     349        usb_hid_report_item_t *report_item = 0;
    354350        usb_hid_report_item_t *new_report_item;
    355351        usb_hid_report_path_t *usage_path;
    356352
    357         size_t offset_input=0;
    358         size_t offset_output=0;
    359         size_t offset_feature=0;
     353        size_t offset_input = 0;
     354        size_t offset_output = 0;
     355        size_t offset_feature = 0;
    360356
    361357        link_t *item_link;
    … …  
    365361
    366362        /* parser structure initialization*/
    367         if(usb_hid_report_init(report) != EOK) {
     363        if (usb_hid_report_init(report) != EOK) {
    368364                return EINVAL;
    369365        }
    370366
    371367        /*report item initialization*/
    372         if(!(report_item=malloc(sizeof(usb_hid_report_item_t)))){
     368        if (!(report_item = malloc(sizeof(usb_hid_report_item_t)))) {
    373369                return ENOMEM;
    374370        }
    … …  
    377373
    378374        /* usage path context initialization */
    379         if(!(usage_path=usb_hid_report_path())){
     375        if (!(usage_path = usb_hid_report_path())) {
    380376                return ENOMEM;
    381377        }
    382378        usb_hid_report_path_append_item(usage_path, 0, 0);
    383379
    384         while(i<size){
    385                 if(!USB_HID_ITEM_IS_LONG(data[i])){
    386 
    387                         if((i+USB_HID_ITEM_SIZE(data[i]))>= size){
     380        while (i < size) {
     381                if (!USB_HID_ITEM_IS_LONG(data[i])) {
     382
     383                        if ((i + USB_HID_ITEM_SIZE(data[i])) >= size) {
    388384                                return EINVAL;
    389385                        }
    … …  
    393389                        class = USB_HID_ITEM_TAG_CLASS(data[i]);
    394390
    395                         ret = usb_hid_report_parse_tag(tag,class,data+i+1,
    396                                 item_size,report_item, usage_path);
    397 
    398                         switch(ret){
     391                        ret = usb_hid_report_parse_tag(tag, class, data + i + 1,
     392                            item_size, report_item, usage_path);
     393
     394                        switch (ret) {
    399395                        case USB_HID_NEW_REPORT_ITEM:
    400396                                /* store report item to report and create the
    … …  
    404400
    405401                                usb_hid_report_path_set_report_id(
    406                                      report_item->usage_path, report_item->id);
    407 
    408                                 if(report_item->id != 0){
     402                                    report_item->usage_path, report_item->id);
     403
     404                                if (report_item->id != 0) {
    409405                                        report->use_report_ids = 1;
    410406                                }
    411407
    412                                 switch(tag) {
     408                                switch (tag) {
    413409                                case USB_HID_REPORT_TAG_INPUT:
    414410                                        report_item->type =
    … …  
    435431                                        report_item->offset = offset_feature;
    436432                                        offset_feature += report_item->count *
    437                                                 report_item->size;
     433                                            report_item->size;
    438434                                        break;
    439435
    … …  
    441437                                        usb_log_debug2(
    442438                                            "\tjump over - tag %X\n", tag);
    443                                         break;
     439                                        break;
    444440                                }
    445441
    … …  
    508504                        /* jump over the processed block */
    509505                        i += 1 + USB_HID_ITEM_SIZE(data[i]);
    510                 }
    511                 else{
     506                } else {
    512507                        // TBD
    513                         i += 3 + USB_HID_ITEM_SIZE(data[i+1]);
     508                        i += 3 + USB_HID_ITEM_SIZE(data[i + 1]);
    514509                }
    515510
    … …  
    532527 */
    533528int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data,
    534         size_t item_size, usb_hid_report_item_t *report_item,
    535         usb_hid_report_path_t *usage_path) {
     529    size_t item_size, usb_hid_report_item_t *report_item,
     530    usb_hid_report_path_t *usage_path)
     531{
    536532
    537533        int ret;
    538534
    539         switch(class){
     535        switch (class) {
    540536        case USB_HID_TAG_CLASS_MAIN:
    541537
    542                 if((ret=usb_hid_report_parse_main_tag(tag, data, item_size,
    543                         report_item, usage_path)) == 0) {
     538                if ((ret = usb_hid_report_parse_main_tag(tag, data, item_size,
     539                    report_item, usage_path)) == 0) {
    544540
    545541                        return USB_HID_NEW_REPORT_ITEM;
    546                 }
    547                 else {
     542                } else {
    548543                        return ret;
    549544                }
    … …  
    552547        case USB_HID_TAG_CLASS_GLOBAL:
    553548                return usb_hid_report_parse_global_tag(tag, data, item_size,
    554                         report_item, usage_path);
     549                    report_item, usage_path);
    555550                break;
    556551
    557552        case USB_HID_TAG_CLASS_LOCAL:
    558553                return usb_hid_report_parse_local_tag(tag, data, item_size,
    559                         report_item, usage_path);
     554                    report_item, usage_path);
    560555                break;
    561556
    … …  
    576571
    577572int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data,
    578         size_t item_size, usb_hid_report_item_t *report_item,
    579         usb_hid_report_path_t *usage_path)
     573    size_t item_size, usb_hid_report_item_t *report_item,
     574    usb_hid_report_path_t *usage_path)
    580575{
    581576        usb_hid_report_usage_path_t *path_item;
    582577
    583         switch(tag)
    584         {
     578        switch (tag) {
    585579        case USB_HID_REPORT_TAG_INPUT:
    586580        case USB_HID_REPORT_TAG_OUTPUT:
    … …  
    594588                /* store collection atributes */
    595589                path_item = list_get_instance(list_first(&usage_path->items),
    596                         usb_hid_report_usage_path_t, rpath_items_link);
     590                    usb_hid_report_usage_path_t, rpath_items_link);
    597591                path_item->flags = *data;
    598592
    599593                /* set last item */
    600594                usb_hid_report_set_last_item(usage_path,
    601                         USB_HID_TAG_CLASS_GLOBAL,
    602                         USB_HID_EXTENDED_USAGE_PAGE(report_item->usages[
    603                                 report_item->usages_count-1]));
     595                    USB_HID_TAG_CLASS_GLOBAL,
     596                    USB_HID_EXTENDED_USAGE_PAGE(report_item->usages[report_item->usages_count - 1]));
    604597
    605598                usb_hid_report_set_last_item(usage_path,
    606                         USB_HID_TAG_CLASS_LOCAL,
    607                         USB_HID_EXTENDED_USAGE(report_item->usages[
    608                                 report_item->usages_count-1]));
     599                    USB_HID_TAG_CLASS_LOCAL,
     600                    USB_HID_EXTENDED_USAGE(report_item->usages[report_item->usages_count - 1]));
    609601
    610602                /* append the new one which will be set by common usage/usage
    611603                 * page */
    612604                usb_hid_report_path_append_item(usage_path,
    613                         report_item->usage_page,
    614                         report_item->usages[report_item->usages_count-1]);
     605                    report_item->usage_page,
     606                    report_item->usages[report_item->usages_count - 1]);
    615607
    616608                usb_hid_report_reset_local_items (report_item);
    … …  
    640632 */
    641633int 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) {
    644 
    645         switch(tag)
    646         {
     634    size_t item_size, usb_hid_report_item_t *report_item,
     635    usb_hid_report_path_t *usage_path)
     636{
     637
     638        switch (tag) {
    647639        case USB_HID_REPORT_TAG_USAGE_PAGE:
    648640                report_item->usage_page =
    649                         usb_hid_report_tag_data_uint32(data, item_size);
     641                    usb_hid_report_tag_data_uint32(data, item_size);
    650642                break;
    651643
    652644        case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
    653645                report_item->logical_minimum = USB_HID_UINT32_TO_INT32(
    654                         usb_hid_report_tag_data_uint32(data,item_size),
    655                         item_size * 8);
     646                    usb_hid_report_tag_data_uint32(data, item_size),
     647                    item_size * 8);
    656648                break;
    657649
    658650        case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM:
    659651                report_item->logical_maximum = USB_HID_UINT32_TO_INT32(
    660                         usb_hid_report_tag_data_uint32(data,item_size),
    661                         item_size * 8);
     652                    usb_hid_report_tag_data_uint32(data, item_size),
     653                    item_size * 8);
    662654                break;
    663655
    664656        case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM:
    665657                report_item->physical_minimum = USB_HID_UINT32_TO_INT32(
    666                         usb_hid_report_tag_data_uint32(data,item_size),
    667                         item_size * 8);
     658                    usb_hid_report_tag_data_uint32(data, item_size),
     659                    item_size * 8);
    668660                break;
    669661
    670662        case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM:
    671663                report_item->physical_maximum = USB_HID_UINT32_TO_INT32(
    672                         usb_hid_report_tag_data_uint32(data,item_size),
    673                         item_size * 8);
     664                    usb_hid_report_tag_data_uint32(data, item_size),
     665                    item_size * 8);
    674666                break;
    675667
    676668        case USB_HID_REPORT_TAG_UNIT_EXPONENT:
    677669                report_item->unit_exponent = usb_hid_report_tag_data_uint32(
    678                         data,item_size);
     670                    data, item_size);
    679671                break;
    680672
    681673        case USB_HID_REPORT_TAG_UNIT:
    682674                report_item->unit = usb_hid_report_tag_data_uint32(
    683                         data,item_size);
     675                    data, item_size);
    684676                break;
    685677
    686678        case USB_HID_REPORT_TAG_REPORT_SIZE:
    687679                report_item->size = usb_hid_report_tag_data_uint32(
    688                         data,item_size);
     680                    data, item_size);
    689681                break;
    690682
    691683        case USB_HID_REPORT_TAG_REPORT_COUNT:
    692684                report_item->count = usb_hid_report_tag_data_uint32(
    693                         data,item_size);
     685                    data, item_size);
    694686                break;
    695687
    696688        case USB_HID_REPORT_TAG_REPORT_ID:
    697689                report_item->id = usb_hid_report_tag_data_uint32(data,
    698                         item_size);
     690                    item_size);
    699691                return USB_HID_RESET_OFFSET;
    700692                break;
    … …  
    785777                        report_item->extended_usage_page =
    786778                            USB_HID_EXTENDED_USAGE_PAGE(
    787                             usb_hid_report_tag_data_uint32(data,item_size));
     779                            usb_hid_report_tag_data_uint32(data, item_size));
    788780
    789781                        report_item->usage_maximum =
    790782                            USB_HID_EXTENDED_USAGE(
    791                             usb_hid_report_tag_data_uint32(data,item_size));
     783                            usb_hid_report_tag_data_uint32(data, item_size));
    792784                } else {
    793785                        report_item->usage_maximum =
    794                             usb_hid_report_tag_data_uint32(data,item_size);
     786                            usb_hid_report_tag_data_uint32(data, item_size);
    795787                }
    796788
    … …  
    866858
    867859        result = 0;
    868         for(i=0; i<size; i++) {
    869                 result = (result | (data[i]) << (i*8));
     860        for (i = 0; i < size; i++) {
     861                result = (result | (data[i]) << (i * 8));
    870862        }
    871863
    … …  
    882874void usb_hid_descriptor_print_list(list_t *list)
    883875{
    884         if(list == NULL || list_empty(list)) {
    885             usb_log_debug("\tempty");
    886             return;
    887         }
    888 
    889         list_foreach(*list, ritems_link, usb_hid_report_field_t,
    890             report_item) {
     876        if (list == NULL || list_empty(list)) {
     877                usb_log_debug("\tempty");
     878                return;
     879        }
     880
     881        list_foreach(*list, ritems_link, usb_hid_report_field_t,
     882            report_item) {
    891883                usb_log_debug("\t\tOFFSET: %u", report_item->offset);
    892884                usb_log_debug("\t\tSIZE: %zu", report_item->size);
    893885                usb_log_debug("\t\tLOGMIN: %d",
    894                         report_item->logical_minimum);
     886                    report_item->logical_minimum);
    895887                usb_log_debug("\t\tLOGMAX: %d",
    896                         report_item->logical_maximum);
     888                    report_item->logical_maximum);
    897889                usb_log_debug("\t\tPHYMIN: %d",
    898                         report_item->physical_minimum);
     890                    report_item->physical_minimum);
    899891                usb_log_debug("\t\tPHYMAX: %d",
    900                         report_item->physical_maximum);
     892                    report_item->physical_maximum);
    901893                usb_log_debug("\t\ttUSAGEMIN: %X",
    902                         report_item->usage_minimum);
     894                    report_item->usage_minimum);
    903895                usb_log_debug("\t\tUSAGEMAX: %X",
    904                                report_item->usage_maximum);
     896                    report_item->usage_maximum);
    905897                usb_log_debug("\t\tUSAGES COUNT: %zu",
    906                         report_item->usages_count);
     898                    report_item->usages_count);
    907899
    908900                usb_log_debug("\t\tVALUE: %X", report_item->value);
    … …  
    932924                usb_log_debug("\tLength: %zu", report_des->bit_length);
    933925                usb_log_debug("\tB Size: %zu",
    934                         usb_hid_report_byte_size(report,
    935                                 report_des->report_id,
    936                                 report_des->type));
     926                    usb_hid_report_byte_size(report,
     927                    report_des->report_id,
     928                    report_des->type));
    937929                usb_log_debug("\tItems: %zu", report_des->item_length);
    938930
    … …  
    950942void usb_hid_report_deinit(usb_hid_report_t *report)
    951943{
    952         if(report == NULL){
     944        if (report == NULL) {
    953945                return;
    954946        }
    … …  
    957949        link_t *path_link;
    958950        usb_hid_report_path_t *path;
    959         while(!list_empty(&report->collection_paths)) {
     951        while (!list_empty(&report->collection_paths)) {
    960952                path_link = list_first(&report->collection_paths);
    961953                path = list_get_instance(path_link,
    … …  
    969961        usb_hid_report_description_t *report_des;
    970962        usb_hid_report_field_t *field;
    971         while(!list_empty(&report->reports)) {
     963        while (!list_empty(&report->reports)) {
    972964                report_des = list_get_instance(list_first(&report->reports),
    973                                 usb_hid_report_description_t, reports_link);
     965                    usb_hid_report_description_t, reports_link);
    974966
    975967                list_remove(&report_des->reports_link);
    976968
    977                 while(!list_empty(&report_des->report_items)) {
     969                while (!list_empty(&report_des->report_items)) {
    978970                        field = list_get_instance(
    979971                            list_first(&report_des->report_items),
Note: See TracChangeset for help on using the changeset viewer.