Changeset 069b80d in mainline


Ignore:
Timestamp:
2011-10-20T20:29:58Z (12 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade
Children:
2fc487f, 4267908, e2793a4, e3ca824
Parents:
d75628da
Message:

Cleanup in usbhid driver.

  • Remove unused and commented out usb_hid_free_report_list().
  • Either remove or replace non-English comments.
  • Lots of cstyle fixes.
Location:
uspace/lib/usbhid
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/usbhid/include/usb/hid/hiddescriptor.h

    rd75628da r069b80d  
    7878void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item);
    7979
    80 void usb_hid_free_report_list(list_t *list);
    81 
    8280usb_hid_report_item_t *usb_hid_report_item_clone(
    8381                const usb_hid_report_item_t *item);
  • uspace/lib/usbhid/src/hiddescriptor.c

    rd75628da r069b80d  
    974974/*---------------------------------------------------------------------------*/
    975975
    976 /**
    977  * Releases whole linked list of report items
    978  *
    979  * @param list List of report descriptor items (usb_hid_report_item_t)
    980  * @return void
    981  */
    982 void usb_hid_free_report_list(list_t *list)
    983 {
    984         return; /* XXX What's this? */
    985        
    986 /*      usb_hid_report_item_t *report_item;
    987         link_t *next;
    988        
    989         if(list == NULL || list_empty(list)) {
    990             return;
    991         }
    992        
    993         next = list->head.next;
    994         while (next != &list->head) {
    995                 report_item = list_get_instance(next, usb_hid_report_item_t,
    996                     rpath_items_link);
    997 
    998                 while(!list_empty(&report_item->usage_path->link)) {
    999                         usb_hid_report_remove_last_item(report_item->usage_path);
    1000                 }
    1001 
    1002                
    1003             next = next->next;
    1004            
    1005             free(report_item);
    1006         }
    1007        
    1008         return;
    1009         */
    1010 }
    1011 /*---------------------------------------------------------------------------*/
    1012976
    1013977/** Frees the HID report descriptor parser structure
  • uspace/lib/usbhid/src/hidparser.c

    rd75628da r069b80d  
    5252        int32_t value);
    5353
    54 int usb_pow(int a, int b);
    55 
    56 /*---------------------------------------------------------------------------*/
    57 
    58 // TODO: tohle ma bejt asi jinde
    59 int usb_pow(int a, int b)
    60 {
    61         switch(b) {
     54/*---------------------------------------------------------------------------*/
     55
     56static int usb_pow(int a, int b)
     57{
     58        switch (b) {
    6259        case 0:
    6360                return 1;
     
    6764                break;
    6865        default:
    69                 return a * usb_pow(a, b-1);
     66                return a * usb_pow(a, b - 1);
    7067                break;
    7168        }
     
    8178 */
    8279size_t usb_hid_report_size(usb_hid_report_t *report, uint8_t report_id,
    83                            usb_hid_report_type_t type)
     80    usb_hid_report_type_t type)
    8481{
    8582        usb_hid_report_description_t *report_des;
    8683
    87         if(report == NULL) {
     84        if (report == NULL) {
    8885                return 0;
    8986        }
    9087
    91         report_des = usb_hid_report_find_description (report, report_id, type);
    92         if(report_des == NULL){
     88        report_des = usb_hid_report_find_description(report, report_id, type);
     89        if (report_des == NULL) {
    9390                return 0;
    94         }
    95         else {
     91        } else {
    9692                return report_des->item_length;
    9793        }
     
    106102 */
    107103size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id,
    108                            usb_hid_report_type_t type)
     104    usb_hid_report_type_t type)
    109105{
    110106        usb_hid_report_description_t *report_des;
    111107
    112         if(report == NULL) {
     108        if (report == NULL) {
    113109                return 0;
    114110        }
    115111
    116         report_des = usb_hid_report_find_description (report, report_id, type);
    117         if(report_des == NULL){
     112        report_des = usb_hid_report_find_description(report, report_id, type);
     113        if (report_des == NULL) {
    118114                return 0;
    119         }
    120         else {
     115        } else {
    121116                return ((report_des->bit_length + 7) / 8) ;
    122117        }
     
    133128 */
    134129int usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data,
    135         size_t size, uint8_t *report_id)
     130    size_t size, uint8_t *report_id)
    136131{
    137132        usb_hid_report_field_t *item;
     
    140135        usb_hid_report_type_t type = USB_HID_REPORT_TYPE_INPUT;
    141136       
    142         if(report == NULL) {
     137        if (report == NULL) {
    143138                return EINVAL;
    144139        }
    145140
    146         if(report->use_report_ids != 0) {
     141        if (report->use_report_ids != 0) {
    147142                *report_id = data[0];
    148         }       
    149         else {
     143        } else {
    150144                *report_id = 0;
    151145        }
    152146
    153 
    154147        report_des = usb_hid_report_find_description(report, *report_id,
    155                 type);
    156 
    157         if(report_des == NULL) {
     148            type);
     149
     150        if (report_des == NULL) {
    158151                return EINVAL;
    159152        }
     
    162155        list_foreach(report_des->report_items, list_item) {
    163156                item = list_get_instance(list_item, usb_hid_report_field_t,
    164                                 ritems_link);
    165 
    166                 if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) {
     157                    ritems_link);
     158
     159                if (USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) {
    167160                       
    168                         if(USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0){
    169 
    170                                 // array
     161                        if (USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) {
     162                                /* array */
    171163                                item->value =
    172164                                        usb_hid_translate_data(item, data);
    173165               
    174166                                item->usage = USB_HID_EXTENDED_USAGE(
    175                                     item->usages[
    176                                     item->value - item->physical_minimum]);
     167                                    item->usages[item->value -
     168                                    item->physical_minimum]);
    177169
    178170                                item->usage_page =
    179171                                    USB_HID_EXTENDED_USAGE_PAGE(
    180                                     item->usages[
    181                                     item->value - item->physical_minimum]);
    182 
    183                                 usb_hid_report_set_last_item (
     172                                    item->usages[item->value -
     173                                    item->physical_minimum]);
     174
     175                                usb_hid_report_set_last_item(
    184176                                    item->collection_path,
    185177                                    USB_HID_TAG_CLASS_GLOBAL,
    186178                                    item->usage_page);
    187179
    188                                 usb_hid_report_set_last_item (
     180                                usb_hid_report_set_last_item(
    189181                                    item->collection_path,
    190182                                    USB_HID_TAG_CLASS_LOCAL, item->usage);
    191                                
    192                         }
    193                         else {
    194                                 // variable item
     183                        } else {
     184                                /* variable item */
    195185                                item->value = usb_hid_translate_data(item,
    196186                                    data);                             
     
    200190       
    201191        return EOK;
    202        
    203192}
    204193
     
    217206        int part_size;
    218207       
    219         int32_t value=0;
    220         int32_t mask=0;
    221         const uint8_t *foo=0;
    222 
    223         // now only shot tags are allowed
    224         if(item->size > 32) {
     208        int32_t value = 0;
     209        int32_t mask = 0;
     210        const uint8_t *foo = 0;
     211
     212        /* now only short tags are allowed */
     213        if (item->size > 32) {
    225214                return 0;
    226215        }
    227216
    228         if((item->physical_minimum == 0) && (item->physical_maximum == 0)){
     217        if ((item->physical_minimum == 0) && (item->physical_maximum == 0)) {
    229218                item->physical_minimum = item->logical_minimum;
    230219                item->physical_maximum = item->logical_maximum;                 
     
    232221       
    233222
    234         if(item->physical_maximum == item->physical_minimum){
     223        if (item->physical_maximum == item->physical_minimum) {
    235224            resolution = 1;
    236         }
    237         else {
     225        } else {
    238226            resolution = (item->logical_maximum - item->logical_minimum) /
    239227                ((item->physical_maximum - item->physical_minimum) *
    240                 (usb_pow(10,(item->unit_exponent))));
     228                (usb_pow(10, (item->unit_exponent))));
    241229        }
    242230
    243231        offset = item->offset;
    244232        // FIXME
    245         if((size_t)(offset/8) != (size_t)((offset+item->size-1)/8)) {
     233        if ((size_t) (offset / 8) != (size_t) ((offset+item->size - 1) / 8)) {
    246234               
    247235                part_size = 0;
    248236
    249                 size_t i=0;
    250                 for(i=(size_t)(offset/8); i<=(size_t)(offset+item->size-1)/8; i++){
    251                         if(i == (size_t)(offset/8)) {
    252                                 // the higher one
     237                size_t i = 0;
     238                for (i = (size_t) (offset / 8);
     239                    i <= (size_t) (offset + item->size - 1) / 8; i++) {
     240                        if (i == (size_t) (offset / 8)) {
     241                                /* the higher one */
    253242                                part_size = 8 - (offset % 8);
    254243                                foo = data + i;
    255                                 mask =  ((1 << (item->size-part_size))-1);
     244                                mask =  ((1 << (item->size - part_size)) - 1);
    256245                                value = (*foo & mask);
    257                         }
    258                         else if(i == ((offset+item->size-1)/8)){
    259                                 // the lower one
     246                        } else if (i == ((offset + item->size - 1) / 8)) {
     247                                /* the lower one */
    260248                                foo = data + i;
    261                                 mask = ((1 << (item->size - part_size)) - 1)
    262                                         << (8 - (item->size - part_size));
     249                                mask = ((1 << (item->size - part_size)) - 1) <<
     250                                    (8 - (item->size - part_size));
    263251
    264252                                value = (((*foo & mask) >> (8 -
    265                                     (item->size - part_size))) << part_size )
    266                                     + value;
    267                         }
    268                         else {
    269                                 value = (*(data + 1) << (part_size + 8)) + value;
     253                                    (item->size - part_size))) << part_size) +
     254                                    value;
     255                        } else {
     256                                value = (*(data + 1) << (part_size + 8)) +
     257                                    value;
    270258                                part_size += 8;
    271259                        }
    272260                }
    273         }
    274         else {         
    275                 foo = data+(offset/8);
    276                 mask =  ((1 << item->size)-1) << (8-((offset%8)+item->size));
    277                 value = (*foo & mask) >> (8-((offset%8)+item->size));
    278         }
    279 
    280         if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
     261        } else {               
     262                foo = data + (offset / 8);
     263                mask = ((1 << item->size) - 1) <<
     264                    (8 - ((offset % 8) + item->size));
     265                value = (*foo & mask) >> (8 - ((offset % 8) + item->size));
     266        }
     267
     268        if ((item->logical_minimum < 0) || (item->logical_maximum < 0)) {
    281269                value = USB_HID_UINT32_TO_INT32(value, item->size);
    282270        }
    283271
    284         return (int)(((value - item->logical_minimum) / resolution) +
    285                 item->physical_minimum);
    286        
     272        return (int) (((value - item->logical_minimum) / resolution) +
     273            item->physical_minimum);
    287274}
    288275
     
    299286 */
    300287uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size,
    301         uint8_t report_id)
    302 {
    303         if(report == NULL) {
     288    uint8_t report_id)
     289{
     290        if (report == NULL) {
    304291                *size = 0;
    305292                return NULL;
     
    310297        list_foreach(report->reports, report_it) {
    311298                report_des = list_get_instance(report_it,
    312                         usb_hid_report_description_t, reports_link);
     299                    usb_hid_report_description_t, reports_link);
    313300               
    314                 if((report_des->report_id == report_id) &&
    315                         (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)){
     301                if ((report_des->report_id == report_id) &&
     302                    (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)) {
    316303                        break;
    317304                }
    318305        }
    319306
    320         if(report_des == NULL){
     307        if (report_des == NULL) {
    321308                *size = 0;
    322309                return NULL;
    323         }
    324         else {
    325                 *size = (report_des->bit_length + (8 - 1))/8;
     310        } else {
     311                *size = (report_des->bit_length + (8 - 1)) / 8;
    326312                uint8_t *ret = malloc((*size) * sizeof(uint8_t));
    327313                memset(ret, 0, (*size) * sizeof(uint8_t));
     
    337323 */
    338324void usb_hid_report_output_free(uint8_t *output)
    339 
    340 {
    341         if(output != NULL) {
    342                 free (output);
     325{
     326        if (output != NULL) {
     327                free(output);
    343328        }
    344329}
     
    354339 */
    355340int usb_hid_report_output_translate(usb_hid_report_t *report,
    356         uint8_t report_id, uint8_t *buffer, size_t size)
    357 {
    358         int32_t value=0;
     341    uint8_t report_id, uint8_t *buffer, size_t size)
     342{
     343        int32_t value = 0;
    359344        int offset;
    360345        int length;
    361346        int32_t tmp_value;
    362347       
    363         if(report == NULL) {
     348        if (report == NULL) {
    364349                return EINVAL;
    365350        }
    366351
    367         if(report->use_report_ids != 0) {
     352        if (report->use_report_ids != 0) {
    368353                buffer[0] = report_id;         
    369354        }
    370355
    371356        usb_hid_report_description_t *report_des;
    372         report_des = usb_hid_report_find_description (report, report_id,
    373                 USB_HID_REPORT_TYPE_OUTPUT);
    374        
    375         if(report_des == NULL){
     357        report_des = usb_hid_report_find_description(report, report_id,
     358            USB_HID_REPORT_TYPE_OUTPUT);
     359       
     360        if (report_des == NULL) {
    376361                return EINVAL;
    377362        }
     
    384369
    385370                value = usb_hid_translate_data_reverse(report_item,
    386                         report_item->value);
     371                    report_item->value);
    387372
    388373                offset = report_des->bit_length - report_item->offset - 1;
     
    391376                usb_log_debug("\ttranslated value: %x\n", value);
    392377
    393                 if((offset/8) == ((offset+length-1)/8)) {
    394                         // je to v jednom bytu
    395                         if(((size_t)(offset/8) >= size) ||
    396                                 ((size_t)(offset+length-1)/8) >= size) {
     378                if ((offset / 8) == ((offset + length - 1) / 8)) {
     379                        if (((size_t) (offset / 8) >= size) ||
     380                            ((size_t) (offset + length - 1) / 8) >= size) {
    397381                                break; // TODO ErrorCode
    398382                        }
    399                         size_t shift = 8 - offset%8 - length;
     383                        size_t shift = 8 - offset % 8 - length;
    400384                        value = value << shift;                                                 
    401                         value = value & (((1 << length)-1) << shift);
     385                        value = value & (((1 << length) - 1) << shift);
    402386                               
    403387                        uint8_t mask = 0;
    404388                        mask = 0xff - (((1 << length) - 1) << shift);
    405                         buffer[offset/8] = (buffer[offset/8] & mask) | value;
    406                 }
    407                 else {
     389                        buffer[offset / 8] = (buffer[offset / 8] & mask) |
     390                            value;
     391                } else {
    408392                        int i = 0;
    409393                        uint8_t mask = 0;
    410                         for(i = (offset/8); i <= ((offset+length-1)/8); i++) {
    411                                 if(i == (offset/8)) {
     394                        for (i = (offset / 8);
     395                            i <= ((offset + length - 1) / 8); i++) {
     396                                if (i == (offset / 8)) {
    412397                                        tmp_value = value;
    413398                                        tmp_value = tmp_value &
    414                                                 ((1 << (8-(offset%8)))-1);
    415 
    416                                         tmp_value = tmp_value << (offset%8);
    417        
    418                                         mask = ~(((1 << (8-(offset%8)))-1) <<
    419                                                         (offset%8));
     399                                            ((1 << (8 - (offset % 8))) - 1);
     400
     401                                        tmp_value = tmp_value << (offset % 8);
     402       
     403                                        mask = ~(((1 << (8 - (offset % 8))) - 1)
     404                                            << (offset % 8));
    420405
    421406                                        buffer[i] = (buffer[i] & mask) |
    422                                                 tmp_value;
    423                                 }
    424                                 else if (i == ((offset + length -1)/8)) {
     407                                            tmp_value;
     408                                } else if (i == ((offset + length - 1) / 8)) {
    425409                                       
    426410                                        value = value >> (length -
    427                                                 ((offset + length) % 8));
     411                                            ((offset + length) % 8));
    428412
    429413                                        value = value & ((1 << (length -
    430                                                 ((offset + length) % 8))) - 1);
     414                                            ((offset + length) % 8))) - 1);
    431415                               
    432416                                        mask = (1 << (length -
    433                                                 ((offset + length) % 8))) - 1;
     417                                            ((offset + length) % 8))) - 1;
    434418
    435419                                        buffer[i] = (buffer[i] & mask) | value;
    436                                 }
    437                                 else {
    438                                         buffer[i] = value & (0xFF << i);
     420                                } else {
     421                                        buffer[i] = value & (0xff << i);
    439422                                }
    440423                        }
    441424                }
    442425
    443                 // reset value
     426                /* reset value */
    444427                report_item->value = 0;
    445428        }
     
    456439 */
    457440uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item,
    458         int value)
    459 {
    460         int ret=0;
     441    int value)
     442{
     443        int ret = 0;
    461444        int resolution;
    462445
    463         if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags)) {
     446        if (USB_HID_ITEM_FLAG_CONSTANT(item->item_flags)) {
    464447                ret = item->logical_minimum;
    465448        }
    466449
    467         if((item->physical_minimum == 0) && (item->physical_maximum == 0)){
     450        if ((item->physical_minimum == 0) && (item->physical_maximum == 0)) {
    468451                item->physical_minimum = item->logical_minimum;
    469452                item->physical_maximum = item->logical_maximum;                 
    470453        }
    471454       
    472         // variable item
    473         if(item->physical_maximum == item->physical_minimum){
     455        /* variable item */
     456        if (item->physical_maximum == item->physical_minimum) {
    474457            resolution = 1;
    475         }
    476         else {
     458        } else {
    477459            resolution = (item->logical_maximum - item->logical_minimum) /
    478460                ((item->physical_maximum - item->physical_minimum) *
    479                 (usb_pow(10,(item->unit_exponent))));
     461                (usb_pow(10, (item->unit_exponent))));
    480462        }
    481463
    482464        ret = ((value - item->physical_minimum) * resolution) +
    483                 item->logical_minimum;
    484 
    485         usb_log_debug("\tvalue(%x), resolution(%x), phymin(%x) logmin(%x), \
    486                 ret(%x)\n", value, resolution, item->physical_minimum,
    487                 item->logical_minimum, ret);
    488        
    489         if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
     465            item->logical_minimum;
     466
     467        usb_log_debug("\tvalue(%x), resolution(%x), phymin(%x) logmin(%x), "
     468            "ret(%x)\n", value, resolution, item->physical_minimum,
     469            item->logical_minimum, ret);
     470       
     471        if ((item->logical_minimum < 0) || (item->logical_maximum < 0)) {
    490472                return USB_HID_INT32_TO_UINT32(ret, item->size);
    491473        }
    492         return (int32_t)0 + ret;
     474
     475        return (int32_t) 0 + ret;
    493476}
    494477
     
    501484 */
    502485usb_hid_report_item_t *usb_hid_report_item_clone(
    503         const usb_hid_report_item_t *item)
     486    const usb_hid_report_item_t *item)
    504487{
    505488        usb_hid_report_item_t *new_report_item;
    506489       
    507         if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) {
     490        if (!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) {
    508491                return NULL;
    509492        }                                       
     
    529512 */
    530513usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report,
    531         usb_hid_report_field_t *field, usb_hid_report_path_t *path, int flags,
    532         usb_hid_report_type_t type)
     514    usb_hid_report_field_t *field, usb_hid_report_path_t *path, int flags,
     515    usb_hid_report_type_t type)
    533516{
    534517        usb_hid_report_description_t *report_des =
    535                 usb_hid_report_find_description(report, path->report_id, type);
     518            usb_hid_report_find_description(report, path->report_id, type);
    536519
    537520        link_t *field_it;
    538521       
    539         if(report_des == NULL){
     522        if (report_des == NULL) {
    540523                return NULL;
    541524        }
    542525
    543         if(field == NULL){
     526        if (field == NULL) {
    544527                field_it = report_des->report_items.head.next;
    545         }
    546         else {
     528        } else {
    547529                field_it = field->ritems_link.next;
    548530        }
    549531
    550         while(field_it != &report_des->report_items.head) {
     532        while (field_it != &report_des->report_items.head) {
    551533                field = list_get_instance(field_it, usb_hid_report_field_t,
    552                         ritems_link);
    553 
    554                 if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) {
    555                         usb_hid_report_path_append_item (
    556                                 field->collection_path, field->usage_page,
    557                                 field->usage);
    558 
    559                         if(usb_hid_report_compare_usage_path(
    560                                 field->collection_path, path, flags) == EOK){
    561 
     534                    ritems_link);
     535
     536                if (USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) {
     537                        usb_hid_report_path_append_item(field->collection_path,
     538                            field->usage_page, field->usage);
     539
     540                        if (usb_hid_report_compare_usage_path(
     541                            field->collection_path, path, flags) == EOK) {
    562542                                usb_hid_report_remove_last_item(
    563                                         field->collection_path);
    564 
     543                                    field->collection_path);
    565544                                return field;
    566545                        }
    567                         usb_hid_report_remove_last_item (
    568                                 field->collection_path);
     546                        usb_hid_report_remove_last_item(field->collection_path);
    569547                }
    570548                field_it = field_it->next;
     
    586564 * @retval report_id otherwise
    587565 */
    588 uint8_t usb_hid_get_next_report_id(usb_hid_report_t *report,
    589         uint8_t report_id, usb_hid_report_type_t type)
    590 {
    591         if(report == NULL){
     566uint8_t usb_hid_get_next_report_id(usb_hid_report_t *report, uint8_t report_id,
     567    usb_hid_report_type_t type)
     568{
     569        if (report == NULL) {
    592570                return 0;
    593571        }
     
    596574        link_t *report_it;
    597575       
    598         if(report_id > 0) {
     576        if (report_id > 0) {
    599577                report_des = usb_hid_report_find_description(report, report_id,
    600                         type);
    601                 if(report_des == NULL) {
     578                    type);
     579                if (report_des == NULL) {
    602580                        return 0;
    603                 }
    604                 else {
     581                } else {
    605582                        report_it = report_des->reports_link.next;
    606583                }       
    607         }
    608         else {
     584        } else {
    609585                report_it = report->reports.head.next;
    610586        }
    611587
    612         while(report_it != &report->reports.head) {
     588        while (report_it != &report->reports.head) {
    613589                report_des = list_get_instance(report_it,
    614                         usb_hid_report_description_t, reports_link);
    615 
    616                 if(report_des->type == type){
     590                    usb_hid_report_description_t, reports_link);
     591
     592                if (report_des->type == type) {
    617593                        return report_des->report_id;
    618594                }
     
    635611void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item)
    636612{
    637         if(report_item == NULL) {
     613        if (report_item == NULL) {
    638614                return;
    639615        }
     
    651627        report_item->string_minimum = 0;
    652628        report_item->string_maximum = 0;
    653 
    654         return;
    655 }
     629}
     630
    656631/**
    657632 * @}
Note: See TracChangeset for help on using the changeset viewer.