Ignore:
Timestamp:
2011-06-19T14:38:59Z (13 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
74464e8
Parents:
1d1bb0f
Message:

Separate list_t typedef from link_t (user-space part).

  • list_t represents lists
  • Use list_first(), list_last(), list_empty() where appropriate
  • Use list_foreach() where possible
  • assert_link_not_used()
  • usb_hid_report_path_free() shall not unlink the path, caller must do it
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1d1bb0f rb72efe8  
    8888 * @retval NULL If some error occurs
    8989 */
    90 usb_hid_report_path_t *usb_hid_report_path_try_insert(
    91                 usb_hid_report_t *report, usb_hid_report_path_t *cmp_path) {
    92        
    93         link_t *path_it = report->collection_paths.next;
     90usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report,
     91    usb_hid_report_path_t *cmp_path)
     92{
     93        link_t *path_it = report->collection_paths.head.next;
    9494        usb_hid_report_path_t *path = NULL;
    9595       
    … …  
    9898        }
    9999       
    100         while(path_it != &report->collection_paths) {
     100        while(path_it != &report->collection_paths.head) {
    101101                path = list_get_instance(path_it, usb_hid_report_path_t,
    102                                 link);
     102                                cpath_link);
    103103               
    104104                if(usb_hid_report_compare_usage_path(path, cmp_path,
    105105                                        USB_HID_PATH_COMPARE_STRICT) == EOK){
    106106                        break;
    107                 }                       
     107                }
    108108                path_it = path_it->next;
    109109        }
    110         if(path_it == &report->collection_paths) {
     110        if(path_it == &report->collection_paths.head) {
    111111                path = usb_hid_report_path_clone(cmp_path);
    112112                if(path == NULL) {
    113113                        return NULL;
    114114                }
    115                 list_append(&path->link, &report->collection_paths);                                   
     115                list_append(&path->cpath_link, &report->collection_paths);
    116116                report->collection_paths_count++;
    117117
    … …  
    120120        else {
    121121                return list_get_instance(path_it, usb_hid_report_path_t,
    122                                 link);
     122                                cpath_link);
    123123        }
    124124}
    … …  
    192192
    193193                memset(field, 0, sizeof(usb_hid_report_field_t));
    194                 list_initialize(&field->link);
     194                link_initialize(&field->ritems_link);
    195195
    196196                /* fill the attributes */               
    … …  
    291291                        }
    292292
    293                         list_initialize (&report_des->link);
     293                        link_initialize (&report_des->reports_link);
    294294                        list_initialize (&report_des->report_items);
    295295
    296                         list_append(&report_des->link, &report->reports);
     296                        list_append(&report_des->reports_link, &report->reports);
    297297                        report->report_count++;
    298298                }
    299299
    300300                /* append this field to the end of founded report list */
    301                 list_append (&field->link, &report_des->report_items);
     301                list_append(&field->ritems_link, &report_des->report_items);
    302302               
    303303                /* update the sizes */
    … …  
    333333        }
    334334
    335         link_t *report_it = report->reports.next;
    336335        usb_hid_report_description_t *report_des = NULL;
    337336       
    338         while(report_it != &report->reports) {
     337        list_foreach(report->reports, report_it) {
    339338                report_des = list_get_instance(report_it,
    340                                 usb_hid_report_description_t, link);
     339                                usb_hid_report_description_t, reports_link);
    341340
    342341                // if report id not set, return the first of the type
    … …  
    345344                        return report_des;
    346345                }
    347                
    348                 report_it = report_it->next;
    349346        }
    350347
    … …  
    377374        size_t offset_output=0;
    378375        size_t offset_feature=0;
    379 
    380         link_t stack;
    381         list_initialize(&stack);       
     376       
     377        link_t *item_link;
     378
     379        list_t stack;
     380        list_initialize(&stack);
    382381
    383382        /* parser structure initialization*/
    … …  
    391390        }
    392391        memset(report_item, 0, sizeof(usb_hid_report_item_t));
    393         list_initialize(&(report_item->link)); 
     392        link_initialize(&(report_item->link));
    394393
    395394        /* usage path context initialization */
    … …  
    493492                        case USB_HID_REPORT_TAG_POP:
    494493                                // restore current state from stack
    495                                 if(list_empty (&stack)) {
     494                                item_link = list_first(&stack);
     495                                if (item_link == NULL) {
    496496                                        return EINVAL;
    497497                                }
    498498                                free(report_item);
    499                                                
    500                                 report_item = list_get_instance(stack.next,
     499                               
     500                                report_item = list_get_instance(item_link,
    501501                                    usb_hid_report_item_t, link);
    502                                        
     502                               
    503503                                usb_hid_report_usage_path_t *tmp_usage_path;
    504504                                tmp_usage_path = list_get_instance(
    505                                     report_item->usage_path->link.prev,
    506                                     usb_hid_report_usage_path_t, link);
    507                                        
     505                                    report_item->usage_path->cpath_link.prev,
     506                                    usb_hid_report_usage_path_t, rpath_items_link);
     507                               
    508508                                usb_hid_report_set_last_item(usage_path,
    509509                                    USB_HID_TAG_CLASS_GLOBAL, tmp_usage_path->usage_page);
    … …  
    513513
    514514                                usb_hid_report_path_free(report_item->usage_path);
    515                                 list_remove (stack.next);
     515                                list_remove (item_link);
    516516                                       
    517517                                break;
    … …  
    609609
    610610                /* store collection atributes */
    611                 path_item = list_get_instance(usage_path->head.prev,
    612                         usb_hid_report_usage_path_t, link);
    613                 path_item->flags = *data;       
     611                path_item = list_get_instance(list_first(&usage_path->items),
     612                        usb_hid_report_usage_path_t, rpath_items_link);
     613                path_item->flags = *data;
    614614                       
    615615                /* set last item */
    … …  
    900900 * @return void
    901901 */
    902 void usb_hid_descriptor_print_list(link_t *head)
     902void usb_hid_descriptor_print_list(list_t *list)
    903903{
    904904        usb_hid_report_field_t *report_item;
    905         link_t *item;
    906 
    907 
    908         if(head == NULL || list_empty(head)) {
     905
     906        if(list == NULL || list_empty(list)) {
    909907            usb_log_debug("\tempty\n");
    910908            return;
    911909        }
    912        
    913         for(item = head->next; item != head; item = item->next) {
    914                
    915                 report_item = list_get_instance(item, usb_hid_report_field_t,
    916                                 link);
     910
     911        list_foreach(*list, item) {
     912                report_item = list_get_instance(item, usb_hid_report_field_t,
     913                                ritems_link);
    917914
    918915                usb_log_debug("\t\tOFFSET: %X\n", report_item->offset);
    919916                usb_log_debug("\t\tSIZE: %zu\n", report_item->size);
    920                 usb_log_debug("\t\tLOGMIN: %d\n", 
     917                usb_log_debug("\t\tLOGMIN: %d\n",
    921918                        report_item->logical_minimum);
    922                 usb_log_debug("\t\tLOGMAX: %d\n", 
    923                         report_item->logical_maximum);         
    924                 usb_log_debug("\t\tPHYMIN: %d\n", 
    925                         report_item->physical_minimum);         
    926                 usb_log_debug("\t\tPHYMAX: %d\n", 
    927                         report_item->physical_maximum);                         
    928                 usb_log_debug("\t\ttUSAGEMIN: %X\n", 
     919                usb_log_debug("\t\tLOGMAX: %d\n",
     920                        report_item->logical_maximum);
     921                usb_log_debug("\t\tPHYMIN: %d\n",
     922                        report_item->physical_minimum);
     923                usb_log_debug("\t\tPHYMAX: %d\n",
     924                        report_item->physical_maximum);
     925                usb_log_debug("\t\ttUSAGEMIN: %X\n",
    929926                        report_item->usage_minimum);
    930927                usb_log_debug("\t\tUSAGEMAX: %X\n",
    931928                               report_item->usage_maximum);
    932                 usb_log_debug("\t\tUSAGES COUNT: %zu\n", 
     929                usb_log_debug("\t\tUSAGES COUNT: %zu\n",
    933930                        report_item->usages_count);
    934931
    … …  
    936933                usb_log_debug("\t\ttUSAGE: %X\n", report_item->usage);
    937934                usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page);
    938                
     935
    939936                usb_hid_print_usage_path(report_item->collection_path);
    940937
    941                 usb_log_debug("\n");           
     938                usb_log_debug("\n");
    942939
    943940        }
    … …  
    958955        }
    959956
    960         link_t *report_it = report->reports.next;
    961957        usb_hid_report_description_t *report_des;
    962958
    963         while(report_it != &report->reports) {
    964                 report_des = list_get_instance(report_it, 
    965                         usb_hid_report_description_t, link);
     959        list_foreach(report->reports, report_it) {
     960                report_des = list_get_instance(report_it,
     961                        usb_hid_report_description_t, reports_link);
    966962                usb_log_debug("Report ID: %d\n", report_des->report_id);
    967963                usb_log_debug("\tType: %d\n", report_des->type);
    968                 usb_log_debug("\tLength: %zu\n", report_des->bit_length);               
     964                usb_log_debug("\tLength: %zu\n", report_des->bit_length);
    969965                usb_log_debug("\tB Size: %zu\n",
    970                         usb_hid_report_byte_size(report, 
    971                                 report_des->report_id, 
     966                        usb_hid_report_byte_size(report,
     967                                report_des->report_id,
    972968                                report_des->type));
    973                 usb_log_debug("\tItems: %zu\n", report_des->item_length);               
     969                usb_log_debug("\tItems: %zu\n", report_des->item_length);
    974970
    975971                usb_hid_descriptor_print_list(&report_des->report_items);
    976 
    977                 report_it = report_it->next;
    978972        }
    979973}
    … …  
    983977 * Releases whole linked list of report items
    984978 *
    985  * @param head Head of list of report descriptor items (usb_hid_report_item_t)
     979 * @param list List of report descriptor items (usb_hid_report_item_t)
    986980 * @return void
    987981 */
    988 void usb_hid_free_report_list(link_t *head)
     982void usb_hid_free_report_list(list_t *list)
    989983{
    990         return;
    991        
    992         usb_hid_report_item_t *report_item;
     984        return; /* XXX What's this? */
     985       
     986/*      usb_hid_report_item_t *report_item;
    993987        link_t *next;
    994988       
    995         if(head == NULL || list_empty(head)) {         
     989        if(list == NULL || list_empty(list)) {
    996990            return;
    997991        }
    998992       
    999         next = head->next;
    1000         while(next != head) {
    1001        
    1002             report_item = list_get_instance(next, usb_hid_report_item_t, link);
     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);
    1003997
    1004998                while(!list_empty(&report_item->usage_path->link)) {
    1005                     usb_hid_report_remove_last_item(report_item->usage_path);
     999                        usb_hid_report_remove_last_item(report_item->usage_path);
    10061000                }
    10071001
    … …  
    10131007       
    10141008        return;
    1015        
     1009        */
    10161010}
    10171011/*---------------------------------------------------------------------------*/
    … …  
    10291023
    10301024        // free collection paths
     1025        link_t *path_link;
    10311026        usb_hid_report_path_t *path;
    10321027        while(!list_empty(&report->collection_paths)) {
    1033                 path = list_get_instance(report->collection_paths.next,
    1034                                 usb_hid_report_path_t, link);
    1035 
    1036                 usb_hid_report_path_free(path);         
     1028                path_link = list_first(&report->collection_paths);
     1029                path = list_get_instance(path_link,
     1030                    usb_hid_report_path_t, cpath_link);
     1031
     1032                list_remove(path_link);
     1033                usb_hid_report_path_free(path);
    10371034        }
    10381035       
    … …  
    10411038        usb_hid_report_field_t *field;
    10421039        while(!list_empty(&report->reports)) {
    1043                 report_des = list_get_instance(report->reports.next,
    1044                                 usb_hid_report_description_t, link);
    1045 
    1046                 list_remove(&report_des->link);
     1040                report_des = list_get_instance(list_first(&report->reports),
     1041                                usb_hid_report_description_t, reports_link);
     1042
     1043                list_remove(&report_des->reports_link);
    10471044               
    10481045                while(!list_empty(&report_des->report_items)) {
    10491046                        field = list_get_instance(
    1050                                 report_des->report_items.next,
    1051                                 usb_hid_report_field_t, link);
    1052 
    1053                         list_remove(&field->link);
     1047                            list_first(&report_des->report_items),
     1048                            usb_hid_report_field_t, ritems_link);
     1049
     1050                        list_remove(&field->ritems_link);
    10541051
    10551052                        free(field);
Note: See TracChangeset for help on using the changeset viewer.