Changeset a1732929 in mainline for uspace/drv/hid


Ignore:
Timestamp:
2018-01-15T17:04:34Z (8 years ago)
Author:
Ondřej Hlavatý <aearsis@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
9ff99e8
Parents:
c1a966e
git-author:
Ondřej Hlavatý <aearsis@…> (2018-01-15 17:04:32)
git-committer:
Ondřej Hlavatý <aearsis@…> (2018-01-15 17:04:34)
Message:

usb: unified logging

Use logger instead of printf. Logger adds newlines automatically.

Location:
uspace/drv/hid/usbhid
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/hid/usbhid/blink1/blink1.c

    rc1a966e ra1732929  
    6464        usb_blink1_t *blink1_dev = (usb_blink1_t *) ddf_fun_data_get(fun);
    6565        if (blink1_dev == NULL) {
    66                 usb_log_debug("Missing parameters.\n");
     66                usb_log_debug("Missing parameters.");
    6767                return EINVAL;
    6868        }
    … …  
    105105            fun_exposed, HID_BLINK1_FUN_NAME);
    106106        if (fun == NULL) {
    107                 usb_log_error("Could not create DDF function node `%s'.\n",
     107                usb_log_error("Could not create DDF function node `%s'.",
    108108                    HID_BLINK1_FUN_NAME);
    109109                return ENOMEM;
    … …  
    123123        int rc = ddf_fun_bind(fun);
    124124        if (rc != EOK) {
    125                 usb_log_error("Could not bind DDF function `%s': %s.\n",
     125                usb_log_error("Could not bind DDF function `%s': %s.",
    126126                    ddf_fun_get_name(fun), str_error(rc));
    127127                ddf_fun_destroy(fun);
    … …  
    131131        rc = ddf_fun_add_to_category(fun, HID_BLINK1_CATEGORY);
    132132        if (rc != EOK) {
    133                 usb_log_error("Could not add DDF function to category %s: %s.\n",
     133                usb_log_error("Could not add DDF function to category %s: %s.",
    134134                    HID_BLINK1_CATEGORY, str_error(rc));
    135135               

  • uspace/drv/hid/usbhid/generic/hiddev.c

    rc1a966e ra1732929  
    9696        const usb_hid_dev_t *hid_dev = fun_hid_dev(fun);
    9797
    98         usb_log_debug2("hid_dev: %p, Max input report size (%zu).\n",
     98        usb_log_debug2("hid_dev: %p, Max input report size (%zu).",
    9999            hid_dev, hid_dev->max_input_report_size);
    100100
    … …  
    105105    size_t size, size_t *act_size, int *event_nr, unsigned int flags)
    106106{
    107         usb_log_debug2("Generic HID: Get event.\n");
     107        usb_log_debug2("Generic HID: Get event.");
    108108
    109109        if (buffer == NULL || act_size == NULL || event_nr == NULL) {
    … …  
    115115
    116116        if (hid_dev->input_report_size > size) {
    117                 usb_log_debug("input_report_size > size (%zu, %zu)\n",
     117                usb_log_debug("input_report_size > size (%zu, %zu)",
    118118                    hid_dev->input_report_size, size);
    119119                return EINVAL;  // TODO: other error code
    … …  
    126126        *event_nr = usb_hid_report_number(hid_dev);
    127127
    128         usb_log_debug2("OK\n");
     128        usb_log_debug2("OK");
    129129
    130130        return EOK;
    … …  
    133133static size_t usb_generic_get_report_descriptor_length(ddf_fun_t *fun)
    134134{
    135         usb_log_debug("Generic HID: Get report descriptor length.\n");
    136 
    137         const usb_hid_dev_t *hid_dev = fun_hid_dev(fun);
    138 
    139         usb_log_debug2("hid_dev->report_desc_size = %zu\n",
     135        usb_log_debug("Generic HID: Get report descriptor length.");
     136
     137        const usb_hid_dev_t *hid_dev = fun_hid_dev(fun);
     138
     139        usb_log_debug2("hid_dev->report_desc_size = %zu",
    140140            hid_dev->report_desc_size);
    141141
    … …  
    146146    size_t size, size_t *actual_size)
    147147{
    148         usb_log_debug2("Generic HID: Get report descriptor.\n");
     148        usb_log_debug2("Generic HID: Get report descriptor.");
    149149
    150150        const usb_hid_dev_t *hid_dev = fun_hid_dev(fun);
    … …  
    162162static int usb_generic_hid_client_connected(ddf_fun_t *fun)
    163163{
    164         usb_log_debug("Generic HID: Client connected.\n");
     164        usb_log_debug("Generic HID: Client connected.");
    165165        return EOK;
    166166}
    … …  
    173173
    174174        if (ddf_fun_unbind(fun) != EOK) {
    175                 usb_log_error("Failed to unbind generic hid fun.\n");
     175                usb_log_error("Failed to unbind generic hid fun.");
    176176                return;
    177177        }
    178         usb_log_debug2("%s unbound.\n", ddf_fun_get_name(fun));
     178        usb_log_debug2("%s unbound.", ddf_fun_get_name(fun));
    179179        ddf_fun_destroy(fun);
    180180}
    … …  
    189189
    190190        /* Create the exposed function. */
    191         usb_log_debug("Creating DDF function %s...\n", HID_GENERIC_FUN_NAME);
     191        usb_log_debug("Creating DDF function %s...", HID_GENERIC_FUN_NAME);
    192192        ddf_fun_t *fun = usb_device_ddf_fun_create(hid_dev->usb_dev,
    193193            fun_exposed, HID_GENERIC_FUN_NAME);
    194194        if (fun == NULL) {
    195                 usb_log_error("Could not create DDF function node.\n");
     195                usb_log_error("Could not create DDF function node.");
    196196                return ENOMEM;
    197197        }
    … …  
    204204        int rc = ddf_fun_bind(fun);
    205205        if (rc != EOK) {
    206                 usb_log_error("Could not bind DDF function: %s.\n",
     206                usb_log_error("Could not bind DDF function: %s.",
    207207                    str_error(rc));
    208208                ddf_fun_destroy(fun);
    … …  
    210210        }
    211211
    212         usb_log_debug("HID function created. Handle: %" PRIun "\n",
     212        usb_log_debug("HID function created. Handle: %" PRIun "",
    213213            ddf_fun_get_handle(fun));
    214214        *data = fun;

  • uspace/drv/hid/usbhid/kbd/kbddev.c

    rc1a966e ra1732929  
    185185                if (kbd_dev->client_sess == NULL) {
    186186                        kbd_dev->client_sess = sess;
    187                         usb_log_debug("%s: OK\n", __FUNCTION__);
     187                        usb_log_debug("%s: OK", __FUNCTION__);
    188188                        async_answer_0(icallid, EOK);
    189189                } else {
    190                         usb_log_error("%s: console session already set\n",
     190                        usb_log_error("%s: console session already set",
    191191                           __FUNCTION__);
    192192                        async_answer_0(icallid, ELIMIT);
    … …  
    195195        }
    196196        default:
    197                         usb_log_error("%s: Unknown method: %d.\n",
     197                        usb_log_error("%s: Unknown method: %d.",
    198198                            __FUNCTION__, (int) method);
    199199                        async_answer_0(icallid, EINVAL);
    … …  
    226226        /* Reset the LED data. */
    227227        memset(kbd_dev->led_data, 0, kbd_dev->led_output_size * sizeof(int32_t));
    228         usb_log_debug("Creating output report:\n");
     228        usb_log_debug("Creating output report:");
    229229
    230230        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
    … …  
    266266        }
    267267
    268         usb_log_debug("Output report buffer: %s\n",
     268        usb_log_debug("Output report buffer: %s",
    269269            usb_debug_str_buffer(kbd_dev->output_buffer, kbd_dev->output_size,
    270270                0));
    … …  
    276276            kbd_dev->output_buffer, kbd_dev->output_size);
    277277        if (rc != EOK) {
    278                 usb_log_warning("Failed to set kbd indicators.\n");
     278                usb_log_warning("Failed to set kbd indicators.");
    279279        }
    280280}
    … …  
    289289void usb_kbd_push_ev(usb_kbd_t *kbd_dev, int type, unsigned key)
    290290{
    291         usb_log_debug2("Sending kbdev event %d/%d to the console\n", type, key);
     291        usb_log_debug2("Sending kbdev event %d/%d to the console", type, key);
    292292        if (kbd_dev->client_sess == NULL) {
    293293                usb_log_warning(
    … …  
    301301                async_exchange_end(exch);
    302302        } else {
    303                 usb_log_warning("Failed to send key to console.\n");
     303                usb_log_warning("Failed to send key to console.");
    304304        }
    305305}
    … …  
    353353            kbd_dev->key_count);
    354354        if (i != (size_t) -1) {
    355                 usb_log_error("Detected phantom state.\n");
     355                usb_log_error("Detected phantom state.");
    356356                return;
    357357        }
    … …  
    403403        ddf_dump_buffer(key_buffer, 512,
    404404            kbd_dev->keys_old, 4, kbd_dev->key_count, 0);
    405         usb_log_debug2("Stored keys %s.\n", key_buffer);
     405        usb_log_debug2("Stored keys %s.", key_buffer);
    406406}
    407407
    … …  
    431431        usb_hid_report_path_t *path = usb_hid_report_path();
    432432        if (path == NULL) {
    433                 usb_log_error("Failed to create hid/kbd report path.\n");
     433                usb_log_error("Failed to create hid/kbd report path.");
    434434                return;
    435435        }
    … …  
    438438           usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
    439439        if (ret != EOK) {
    440                 usb_log_error("Failed to append to hid/kbd report path.\n");
     440                usb_log_error("Failed to append to hid/kbd report path.");
    441441                return;
    442442        }
    … …  
    452452
    453453        while (field != NULL) {
    454                 usb_log_debug2("FIELD (%p) - VALUE(%d) USAGE(%u)\n",
     454                usb_log_debug2("FIELD (%p) - VALUE(%d) USAGE(%u)",
    455455                    field, field->value, field->usage);
    456456
    … …  
    464464                        kbd_dev->keys[i] = 0;
    465465                }
    466                 usb_log_debug2("Saved %u. key usage %d\n", i, kbd_dev->keys[i]);
     466                usb_log_debug2("Saved %u. key usage %d", i, kbd_dev->keys[i]);
    467467
    468468                ++i;
    … …  
    502502        usb_hid_report_path_t *path = usb_hid_report_path();
    503503        if (path == NULL) {
    504                 usb_log_error("Failed to create kbd report path.\n");
     504                usb_log_error("Failed to create kbd report path.");
    505505                usb_kbd_destroy(kbd_dev);
    506506                return ENOMEM;
    … …  
    510510            usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
    511511        if (ret != EOK) {
    512                 usb_log_error("Failed to append item to kbd report path.\n");
     512                usb_log_error("Failed to append item to kbd report path.");
    513513                usb_hid_report_path_free(path);
    514514                usb_kbd_destroy(kbd_dev);
    … …  
    523523        usb_hid_report_path_free(path);
    524524
    525         usb_log_debug("Size of the input report: %zu\n", kbd_dev->key_count);
     525        usb_log_debug("Size of the input report: %zu", kbd_dev->key_count);
    526526
    527527        kbd_dev->keys = calloc(kbd_dev->key_count, sizeof(int32_t));
    528528        if (kbd_dev->keys == NULL) {
    529                 usb_log_error("Failed to allocate key buffer.\n");
     529                usb_log_error("Failed to allocate key buffer.");
    530530                usb_kbd_destroy(kbd_dev);
    531531                return ENOMEM;
    … …  
    534534        kbd_dev->keys_old = calloc(kbd_dev->key_count, sizeof(int32_t));
    535535        if (kbd_dev->keys_old == NULL) {
    536                 usb_log_error("Failed to allocate old_key buffer.\n");
     536                usb_log_error("Failed to allocate old_key buffer.");
    537537                usb_kbd_destroy(kbd_dev);
    538538                return ENOMEM;
    … …  
    544544            &kbd_dev->output_size, 0);
    545545        if (kbd_dev->output_buffer == NULL) {
    546                 usb_log_error("Error creating output report buffer.\n");
     546                usb_log_error("Error creating output report buffer.");
    547547                usb_kbd_destroy(kbd_dev);
    548548                return ENOMEM;
    549549        }
    550550
    551         usb_log_debug("Output buffer size: %zu\n", kbd_dev->output_size);
     551        usb_log_debug("Output buffer size: %zu", kbd_dev->output_size);
    552552
    553553        kbd_dev->led_path = usb_hid_report_path();
    554554        if (kbd_dev->led_path == NULL) {
    555                 usb_log_error("Failed to create kbd led report path.\n");
     555                usb_log_error("Failed to create kbd led report path.");
    556556                usb_kbd_destroy(kbd_dev);
    557557                return ENOMEM;
    … …  
    561561            kbd_dev->led_path, USB_HIDUT_PAGE_LED, 0);
    562562        if (ret != EOK) {
    563                 usb_log_error("Failed to append to kbd/led report path.\n");
     563                usb_log_error("Failed to append to kbd/led report path.");
    564564                usb_kbd_destroy(kbd_dev);
    565565                return ret;
    … …  
    569569            &hid_dev->report, 0, USB_HID_REPORT_TYPE_OUTPUT);
    570570
    571         usb_log_debug("Output report size (in items): %zu\n",
     571        usb_log_debug("Output report size (in items): %zu",
    572572            kbd_dev->led_output_size);
    573573
    574574        kbd_dev->led_data = calloc(kbd_dev->led_output_size, sizeof(int32_t));
    575575        if (kbd_dev->led_data == NULL) {
    576                 usb_log_error("Error creating buffer for LED output report.\n");
     576                usb_log_error("Error creating buffer for LED output report.");
    577577                usb_kbd_destroy(kbd_dev);
    578578                return ENOMEM;
    … …  
    588588
    589589        kbd_dev->initialized = USB_KBD_STATUS_INITIALIZED;
    590         usb_log_debug("HID/KBD device structure initialized.\n");
     590        usb_log_debug("HID/KBD device structure initialized.");
    591591
    592592        return EOK;
    … …  
    618618int usb_kbd_init(usb_hid_dev_t *hid_dev, void **data)
    619619{
    620         usb_log_debug("Initializing HID/KBD structure...\n");
     620        usb_log_debug("Initializing HID/KBD structure...");
    621621
    622622        if (hid_dev == NULL) {
    … …  
    627627
    628628        /* Create the exposed function. */
    629         usb_log_debug("Creating DDF function %s...\n", HID_KBD_FUN_NAME);
     629        usb_log_debug("Creating DDF function %s...", HID_KBD_FUN_NAME);
    630630        ddf_fun_t *fun = usb_device_ddf_fun_create(hid_dev->usb_dev,
    631631            fun_exposed, HID_KBD_FUN_NAME);
    632632        if (fun == NULL) {
    633                 usb_log_error("Could not create DDF function node.\n");
     633                usb_log_error("Could not create DDF function node.");
    634634                return ENOMEM;
    635635        }
    … …  
    637637        usb_kbd_t *kbd_dev = ddf_fun_data_alloc(fun, sizeof(usb_kbd_t));
    638638        if (kbd_dev == NULL) {
    639                 usb_log_error("Failed to allocate KBD device structure.\n");
     639                usb_log_error("Failed to allocate KBD device structure.");
    640640                ddf_fun_destroy(fun);
    641641                return ENOMEM;
    … …  
    644644        int ret = kbd_dev_init(kbd_dev, hid_dev);
    645645        if (ret != EOK) {
    646                 usb_log_error("Failed to initialize KBD device  structure.\n");
     646                usb_log_error("Failed to initialize KBD device  structure.");
    647647                ddf_fun_destroy(fun);
    648648                return ret;
    … …  
    655655        ret = ddf_fun_bind(fun);
    656656        if (ret != EOK) {
    657                 usb_log_error("Could not bind DDF function: %s.\n",
     657                usb_log_error("Could not bind DDF function: %s.",
    658658                    str_error(ret));
    659659                usb_kbd_destroy(kbd_dev);
    … …  
    662662        }
    663663
    664         usb_log_debug("%s function created. Handle: %" PRIun "\n",
     664        usb_log_debug("%s function created. Handle: %" PRIun "",
    665665            HID_KBD_FUN_NAME, ddf_fun_get_handle(fun));
    666666
    667         usb_log_debug("Adding DDF function to category %s...\n",
     667        usb_log_debug("Adding DDF function to category %s...",
    668668            HID_KBD_CATEGORY_NAME);
    669669        ret = ddf_fun_add_to_category(fun, HID_KBD_CATEGORY_NAME);
    … …  
    753753        if (kbd_dev->fun) {
    754754                if (ddf_fun_unbind(kbd_dev->fun) != EOK) {
    755                         usb_log_warning("Failed to unbind %s.\n",
     755                        usb_log_warning("Failed to unbind %s.",
    756756                            ddf_fun_get_name(kbd_dev->fun));
    757757                } else {
    758                         usb_log_debug2("%s unbound.\n",
     758                        usb_log_debug2("%s unbound.",
    759759                            ddf_fun_get_name(kbd_dev->fun));
    760760                        ddf_fun_destroy(kbd_dev->fun);
    … …  
    784784
    785785        if (rc != EOK) {
    786                 usb_log_error("Failed to parse boot report descriptor: %s\n",
     786                usb_log_error("Failed to parse boot report descriptor: %s",
    787787                    str_error(rc));
    788788                return rc;

  • uspace/drv/hid/usbhid/kbd/kbdrepeat.c

    rc1a966e ra1732929  
    6969        unsigned int delay = 0;
    7070
    71         usb_log_debug("Starting autorepeat loop.\n");
     71        usb_log_debug("Starting autorepeat loop.");
    7272
    7373        while (true) {
    7474                /* Check if the kbd structure is usable. */
    7575                if (!usb_kbd_is_initialized(kbd)) {
    76                         usb_log_warning("kbd not ready, exiting autorepeat.\n");
     76                        usb_log_warning("kbd not ready, exiting autorepeat.");
    7777                        return;
    7878                }
    … …  
    8282                if (kbd->repeat.key_new > 0) {
    8383                        if (kbd->repeat.key_new == kbd->repeat.key_repeated) {
    84                                 usb_log_debug2("Repeating key: %u.\n",
     84                                usb_log_debug2("Repeating key: %u.",
    8585                                    kbd->repeat.key_repeated);
    8686                                usb_kbd_push_ev(kbd, KEY_PRESS,
    … …  
    8888                                delay = kbd->repeat.delay_between;
    8989                        } else {
    90                                 usb_log_debug2("New key to repeat: %u.\n",
     90                                usb_log_debug2("New key to repeat: %u.",
    9191                                    kbd->repeat.key_new);
    9292                                kbd->repeat.key_repeated = kbd->repeat.key_new;
    … …  
    9595                } else {
    9696                        if (kbd->repeat.key_repeated > 0) {
    97                                 usb_log_debug2("Stopping to repeat key: %u.\n",
     97                                usb_log_debug2("Stopping to repeat key: %u.",
    9898                                    kbd->repeat.key_repeated);
    9999                                kbd->repeat.key_repeated = 0;
    … …  
    119119int usb_kbd_repeat_fibril(void *arg)
    120120{
    121         usb_log_debug("Autorepeat fibril spawned.\n");
     121        usb_log_debug("Autorepeat fibril spawned.");
    122122
    123123        if (arg == NULL) {
    124                 usb_log_error("No device!\n");
     124                usb_log_error("No device!");
    125125                return EINVAL;
    126126        }

  • uspace/drv/hid/usbhid/main.c

    rc1a966e ra1732929  
    5858static int usb_hid_device_add(usb_device_t *dev)
    5959{
    60         usb_log_debug("%s\n", __FUNCTION__);
     60        usb_log_debug("%s", __FUNCTION__);
    6161
    6262        if (dev == NULL) {
    63                 usb_log_error("Wrong parameter given for add_device().\n");
     63                usb_log_error("Wrong parameter given for add_device().");
    6464                return EINVAL;
    6565        }
    … …  
    7373            usb_device_data_alloc(dev, sizeof(usb_hid_dev_t));
    7474        if (hid_dev == NULL) {
    75                 usb_log_error("Failed to create USB/HID device structure.\n");
     75                usb_log_error("Failed to create USB/HID device structure.");
    7676                return ENOMEM;
    7777        }
    … …  
    7979        int rc = usb_hid_init(hid_dev, dev);
    8080        if (rc != EOK) {
    81                 usb_log_error("Failed to initialize USB/HID device.\n");
     81                usb_log_error("Failed to initialize USB/HID device.");
    8282                usb_hid_deinit(hid_dev);
    8383                return rc;
    8484        }
    8585
    86         usb_log_debug("USB/HID device structure initialized.\n");
     86        usb_log_debug("USB/HID device structure initialized.");
    8787
    8888        /* Start automated polling function.
    … …  
    9292
    9393        if (rc != EOK) {
    94                 usb_log_error("Failed to start polling fibril for `%s'.\n",
     94                usb_log_error("Failed to start polling fibril for `%s'.",
    9595                    usb_device_get_name(dev));
    9696                usb_hid_deinit(hid_dev);
    … …  
    9999        hid_dev->running = true;
    100100
    101         usb_log_info("HID device `%s' ready.\n", usb_device_get_name(dev));
     101        usb_log_info("HID device `%s' ready.", usb_device_get_name(dev));
    102102
    103103        return EOK;
    … …  
    115115        /* Clean up. */
    116116        usb_hid_deinit(hid_dev);
    117         usb_log_info("%s destruction complete.\n", usb_device_get_name(dev));
     117        usb_log_info("%s destruction complete.", usb_device_get_name(dev));
    118118
    119119        return EOK;
    … …  
    132132        assert(hid_dev);
    133133
    134         usb_log_info("Device %s removed.\n", usb_device_get_name(dev));
     134        usb_log_info("Device %s removed.", usb_device_get_name(dev));
    135135        return join_and_clean(dev);
    136136}
    … …  
    148148        assert(hid_dev);
    149149
    150         usb_log_info("Device %s gone.\n", usb_device_get_name(dev));
     150        usb_log_info("Device %s gone.", usb_device_get_name(dev));
    151151        return join_and_clean(dev);
    152152}

  • uspace/drv/hid/usbhid/mouse/mousedev.c

    rc1a966e ra1732929  
    118118
    119119        if (mouse_dev == NULL) {
    120                 usb_log_debug("%s: Missing parameters.\n", __FUNCTION__);
     120                usb_log_debug("%s: Missing parameters.", __FUNCTION__);
    121121                async_answer_0(icallid, EINVAL);
    122122                return;
    123123        }
    124124
    125         usb_log_debug("%s: fun->name: %s\n", __FUNCTION__, ddf_fun_get_name(fun));
    126         usb_log_debug("%s: mouse_sess: %p\n",
     125        usb_log_debug("%s: fun->name: %s", __FUNCTION__, ddf_fun_get_name(fun));
     126        usb_log_debug("%s: mouse_sess: %p",
    127127            __FUNCTION__, mouse_dev->mouse_sess);
    128128
    … …  
    132132                if (mouse_dev->mouse_sess == NULL) {
    133133                        mouse_dev->mouse_sess = sess;
    134                         usb_log_debug("Console session to %s set ok (%p).\n",
     134                        usb_log_debug("Console session to %s set ok (%p).",
    135135                            ddf_fun_get_name(fun), sess);
    136136                        async_answer_0(icallid, EOK);
    137137                } else {
    138                         usb_log_error("Console session to %s already set.\n",
     138                        usb_log_error("Console session to %s already set.",
    139139                            ddf_fun_get_name(fun));
    140140                        async_answer_0(icallid, ELIMIT);
    … …  
    142142                }
    143143        } else {
    144                 usb_log_debug("%s: Invalid function.\n", __FUNCTION__);
     144                usb_log_debug("%s: Invalid function.", __FUNCTION__);
    145145                async_answer_0(icallid, EINVAL);
    146146        }
    … …  
    171171
    172172        if (mouse_dev->mouse_sess == NULL) {
    173                 usb_log_warning(NAME " No console session.\n");
     173                usb_log_warning(NAME " No console session.");
    174174                return;
    175175        }
    … …  
    225225        usb_hid_report_path_t *path = usb_hid_report_path();
    226226        if (path == NULL) {
    227                 usb_log_warning("Failed to create USB HID report path.\n");
     227                usb_log_warning("Failed to create USB HID report path.");
    228228                return;
    229229        }
    … …  
    232232        if (ret != EOK) {
    233233                usb_hid_report_path_free(path);
    234                 usb_log_warning("Failed to add buttons to report path.\n");
     234                usb_log_warning("Failed to add buttons to report path.");
    235235                return;
    236236        }
    … …  
    242242
    243243        while (field != NULL) {
    244                 usb_log_debug2(NAME " VALUE(%X) USAGE(%X)\n", field->value,
     244                usb_log_debug2(NAME " VALUE(%X) USAGE(%X)", field->value,
    245245                    field->usage);
    246246                assert(field->usage > field->usage_minimum);
    … …  
    331331
    332332        if (mouse_dev->buttons == NULL) {
    333                 usb_log_error(NAME ": out of memory, giving up on device!\n");
     333                usb_log_error(NAME ": out of memory, giving up on device!");
    334334                free(mouse_dev);
    335335                return ENOMEM;
    … …  
    344344int usb_mouse_init(usb_hid_dev_t *hid_dev, void **data)
    345345{
    346         usb_log_debug("Initializing HID/Mouse structure...\n");
     346        usb_log_debug("Initializing HID/Mouse structure...");
    347347
    348348        if (hid_dev == NULL) {
    … …  
    353353
    354354        /* Create the exposed function. */
    355         usb_log_debug("Creating DDF function %s...\n", HID_MOUSE_FUN_NAME);
     355        usb_log_debug("Creating DDF function %s...", HID_MOUSE_FUN_NAME);
    356356        ddf_fun_t *fun = usb_device_ddf_fun_create(hid_dev->usb_dev,
    357357            fun_exposed, HID_MOUSE_FUN_NAME);
    358358        if (fun == NULL) {
    359                 usb_log_error("Could not create DDF function node `%s'.\n",
     359                usb_log_error("Could not create DDF function node `%s'.",
    360360                    HID_MOUSE_FUN_NAME);
    361361                return ENOMEM;
    … …  
    364364        usb_mouse_t *mouse_dev = ddf_fun_data_alloc(fun, sizeof(usb_mouse_t));
    365365        if (mouse_dev == NULL) {
    366                 usb_log_error("Failed to alloc HID mouse device structure.\n");
     366                usb_log_error("Failed to alloc HID mouse device structure.");
    367367                ddf_fun_destroy(fun);
    368368                return ENOMEM;
    … …  
    371371        int ret = mouse_dev_init(mouse_dev, hid_dev);
    372372        if (ret != EOK) {
    373                 usb_log_error("Failed to init HID mouse device structure.\n");
     373                usb_log_error("Failed to init HID mouse device structure.");
    374374                return ret;
    375375        }
    … …  
    379379        ret = ddf_fun_bind(fun);
    380380        if (ret != EOK) {
    381                 usb_log_error("Could not bind DDF function `%s': %s.\n",
     381                usb_log_error("Could not bind DDF function `%s': %s.",
    382382                    ddf_fun_get_name(fun), str_error(ret));
    383383                ddf_fun_destroy(fun);
    … …  
    385385        }
    386386
    387         usb_log_debug("Adding DDF function `%s' to category %s...\n",
     387        usb_log_debug("Adding DDF function `%s' to category %s...",
    388388            ddf_fun_get_name(fun), HID_MOUSE_CATEGORY);
    389389        ret = ddf_fun_add_to_category(fun, HID_MOUSE_CATEGORY);
    … …  
    444444
    445445        if (rc != EOK) {
    446                 usb_log_error("Failed to parse boot report descriptor: %s\n",
     446                usb_log_error("Failed to parse boot report descriptor: %s",
    447447                    str_error(rc));
    448448                return rc;

  • uspace/drv/hid/usbhid/multimedia/multimedia.c

    rc1a966e ra1732929  
    8686    ipc_callid_t icallid, ipc_call_t *icall)
    8787{
    88         usb_log_debug(NAME " default_connection_handler()\n");
     88        usb_log_debug(NAME " default_connection_handler()");
    8989
    9090        usb_multimedia_t *multim_dev = ddf_fun_data_get(fun);
    … …  
    9595                if (multim_dev->console_sess == NULL) {
    9696                        multim_dev->console_sess = sess;
    97                         usb_log_debug(NAME " Saved session to console: %p\n",
     97                        usb_log_debug(NAME " Saved session to console: %p",
    9898                            sess);
    9999                        async_answer_0(icallid, EOK);
    … …  
    137137        };
    138138
    139         usb_log_debug2(NAME " Sending key %d to the console\n", ev.key);
     139        usb_log_debug2(NAME " Sending key %d to the console", ev.key);
    140140        if (multim_dev->console_sess == NULL) {
    141141                usb_log_warning(
    … …  
    149149                async_exchange_end(exch);
    150150        } else {
    151                 usb_log_warning("Failed to send multimedia key.\n");
     151                usb_log_warning("Failed to send multimedia key.");
    152152        }
    153153}
    … …  
    159159        }
    160160
    161         usb_log_debug(NAME " Initializing HID/multimedia structure...\n");
     161        usb_log_debug(NAME " Initializing HID/multimedia structure...");
    162162
    163163        /* Create the exposed function. */
    … …  
    165165            hid_dev->usb_dev, fun_exposed, NAME);
    166166        if (fun == NULL) {
    167                 usb_log_error("Could not create DDF function node.\n");
     167                usb_log_error("Could not create DDF function node.");
    168168                return ENOMEM;
    169169        }
    … …  
    184184        int rc = ddf_fun_bind(fun);
    185185        if (rc != EOK) {
    186                 usb_log_error("Could not bind DDF function: %s.\n",
     186                usb_log_error("Could not bind DDF function: %s.",
    187187                    str_error(rc));
    188188                ddf_fun_destroy(fun);
    … …  
    190190        }
    191191
    192         usb_log_debug(NAME " function created (handle: %" PRIun ").\n",
     192        usb_log_debug(NAME " function created (handle: %" PRIun ").",
    193193            ddf_fun_get_handle(fun));
    194194
    … …  
    199199                    str_error(rc));
    200200                if (ddf_fun_unbind(fun) != EOK) {
    201                         usb_log_error("Failed to unbind %s, won't destroy.\n",
     201                        usb_log_error("Failed to unbind %s, won't destroy.",
    202202                            ddf_fun_get_name(fun));
    203203                } else {
    … …  
    210210        *data = fun;
    211211
    212         usb_log_debug(NAME " HID/multimedia structure initialized.\n");
     212        usb_log_debug(NAME " HID/multimedia structure initialized.");
    213213        return EOK;
    214214}
    … …  
    224224                async_hangup(multim_dev->console_sess);
    225225        if (ddf_fun_unbind(fun) != EOK) {
    226                 usb_log_error("Failed to unbind %s, won't destroy.\n",
     226                usb_log_error("Failed to unbind %s, won't destroy.",
    227227                    ddf_fun_get_name(fun));
    228228        } else {
    229                 usb_log_debug2("%s unbound.\n", ddf_fun_get_name(fun));
     229                usb_log_debug2("%s unbound.", ddf_fun_get_name(fun));
    230230                /* This frees multim_dev too as it was stored in
    231231                 * fun->data */
    … …  
    266266        while (field != NULL) {
    267267                if (field->value != 0) {
    268                         usb_log_debug(NAME " KEY VALUE(%X) USAGE(%X)\n",
     268                        usb_log_debug(NAME " KEY VALUE(%X) USAGE(%X)",
    269269                            field->value, field->usage);
    270270                        const unsigned key =
    … …  
    272272                        const char *key_str =
    273273                            usbhid_multimedia_usage_to_str(field->usage);
    274                         usb_log_info("Pressed key: %s\n", key_str);
     274                        usb_log_info("Pressed key: %s", key_str);
    275275                        usb_multimedia_push_ev(multim_dev, KEY_PRESS, key);
    276276                }

  • uspace/drv/hid/usbhid/usbhid.c

    rc1a966e ra1732929  
    134134        usb_hid_report_path_t *usage_path = usb_hid_report_path();
    135135        if (usage_path == NULL) {
    136                 usb_log_debug("Failed to create usage path.\n");
     136                usb_log_debug("Failed to create usage path.");
    137137                return false;
    138138        }
    … …  
    143143                    mapping->usage_path[i].usage_page,
    144144                    mapping->usage_path[i].usage) != EOK) {
    145                         usb_log_debug("Failed to append to usage path.\n");
     145                        usb_log_debug("Failed to append to usage path.");
    146146                        usb_hid_report_path_free(usage_path);
    147147                        return false;
    … …  
    149149        }
    150150
    151         usb_log_debug("Compare flags: %d\n", mapping->compare);
     151        usb_log_debug("Compare flags: %d", mapping->compare);
    152152
    153153        bool matches = false;
    … …  
    155155
    156156        do {
    157                 usb_log_debug("Trying report id %u\n", report_id);
     157                usb_log_debug("Trying report id %u", report_id);
    158158                if (report_id != 0) {
    159159                        usb_hid_report_path_set_report_id(usage_path,
    … …  
    166166                        USB_HID_REPORT_TYPE_INPUT);
    167167
    168                 usb_log_debug("Field: %p\n", field);
     168                usb_log_debug("Field: %p", field);
    169169
    170170                if (field != NULL) {
    … …  
    243243                            mapping->product_id);
    244244                        if (usb_hid_ids_match(hid_dev, mapping)) {
    245                                 usb_log_debug("IDs matched.\n");
     245                                usb_log_debug("IDs matched.");
    246246                                matched = true;
    247247                        }
    … …  
    250250                /* Check usage match. */
    251251                if (mapping->usage_path != NULL) {
    252                         usb_log_debug("Comparing device against usage path.\n");
     252                        usb_log_debug("Comparing device against usage path.");
    253253                        if (usb_hid_path_matches(hid_dev, mapping)) {
    254254                                /* Does not matter if IDs were matched. */
    … …  
    258258
    259259                if (matched) {
    260                         usb_log_debug("Subdriver matched.\n");
     260                        usb_log_debug("Subdriver matched.");
    261261                        subdrivers[count++] = &mapping->subdriver;
    262262                }
    … …  
    285285                    usb_device_get_mapped_ep_desc(dev, endpoints[i].desc);
    286286                if (epm && epm->present) {
    287                         usb_log_debug("Found: %s.\n", endpoints[i].description);
     287                        usb_log_debug("Found: %s.", endpoints[i].description);
    288288                        hid_dev->poll_pipe_mapping = epm;
    289289                        return EOK;
    … …  
    301301
    302302        do {
    303                 usb_log_debug("Getting size of the report.\n");
     303                usb_log_debug("Getting size of the report.");
    304304                const size_t size =
    305305                    usb_hid_report_byte_size(&hid_dev->report, report_id,
    306306                        USB_HID_REPORT_TYPE_INPUT);
    307                 usb_log_debug("Report ID: %u, size: %zu\n", report_id, size);
     307                usb_log_debug("Report ID: %u, size: %zu", report_id, size);
    308308                max_size = (size > max_size) ? size : max_size;
    309                 usb_log_debug("Getting next report ID\n");
     309                usb_log_debug("Getting next report ID");
    310310                report_id = usb_hid_get_next_report_id(&hid_dev->report,
    311311                    report_id, USB_HID_REPORT_TYPE_INPUT);
    312312        } while (report_id != 0);
    313313
    314         usb_log_debug("Max size of input report: %zu\n", max_size);
     314        usb_log_debug("Max size of input report: %zu", max_size);
    315315
    316316        assert(hid_dev->input_report == NULL);
    … …  
    329329{
    330330        if (dev == NULL || arg == NULL || buffer == NULL) {
    331                 usb_log_error("Missing arguments to polling callback.\n");
     331                usb_log_error("Missing arguments to polling callback.");
    332332                return false;
    333333        }
    … …  
    336336        assert(hid_dev->input_report != NULL);
    337337
    338         usb_log_debug("New data [%zu/%zu]: %s\n", buffer_size,
     338        usb_log_debug("New data [%zu/%zu]: %s", buffer_size,
    339339            hid_dev->max_input_report_size,
    340340            usb_debug_str_buffer(buffer, buffer_size, 0));
    … …  
    419419        assert(dev);
    420420
    421         usb_log_debug("Initializing HID structure...\n");
     421        usb_log_debug("Initializing HID structure...");
    422422
    423423        usb_hid_report_init(&hid_dev->report);
    … …  
    441441                usb_hid_find_subdrivers(hid_dev);
    442442        } else {
    443                 usb_log_error("Failed to parse report descriptor: fallback.\n");
     443                usb_log_error("Failed to parse report descriptor: fallback.");
    444444                hid_dev->subdrivers = NULL;
    445445                hid_dev->subdriver_count = 0;
    446446        }
    447447
    448         usb_log_debug("Subdriver count(before trying boot protocol): %d\n",
     448        usb_log_debug("Subdriver count(before trying boot protocol): %d",
    449449            hid_dev->subdriver_count);
    450450
    … …  
    457457                switch (hid_dev->poll_pipe_mapping->interface->interface_protocol) {
    458458                case USB_HID_PROTOCOL_KEYBOARD:
    459                         usb_log_info("Falling back to kbd boot protocol.\n");
     459                        usb_log_info("Falling back to kbd boot protocol.");
    460460                        rc = usb_kbd_set_boot_protocol(hid_dev);
    461461                        if (rc == EOK) {
    … …  
    464464                        break;
    465465                case USB_HID_PROTOCOL_MOUSE:
    466                         usb_log_info("Falling back to mouse boot protocol.\n");
     466                        usb_log_info("Falling back to mouse boot protocol.");
    467467                        rc = usb_mouse_set_boot_protocol(hid_dev);
    468468                        if (rc == EOK) {
    … …  
    471471                        break;
    472472                default:
    473                         usb_log_info("Falling back to generic HID driver.\n");
     473                        usb_log_info("Falling back to generic HID driver.");
    474474                        usb_hid_set_generic_hid_subdriver(hid_dev);
    475475                }
    476476        }
    477477
    478         usb_log_debug("Subdriver count(after trying boot protocol): %d\n",
     478        usb_log_debug("Subdriver count(after trying boot protocol): %d",
    479479            hid_dev->subdriver_count);
    480480
    … …  
    491491        for (unsigned i = 0; i < hid_dev->subdriver_count; ++i) {
    492492                if (hid_dev->subdrivers[i].init != NULL) {
    493                         usb_log_debug("Initializing subdriver %d.\n",i);
     493                        usb_log_debug("Initializing subdriver %d.",i);
    494494                        const int pret = hid_dev->subdrivers[i].init(hid_dev,
    495495                            &hid_dev->subdrivers[i].data);
    … …  
    514514                rc = usb_hid_init_report(hid_dev);
    515515                if (rc != EOK) {
    516                         usb_log_error("Failed to initialize input report buffer: %s\n", str_error(rc));
     516                        usb_log_error("Failed to initialize input report buffer: %s", str_error(rc));
    517517                        // FIXME: What happens now?
    518518                }
    … …  
    520520                usb_polling_t *polling = &hid_dev->polling;
    521521                if ((rc = usb_polling_init(polling))) {
    522                         usb_log_error("Failed to initialize polling: %s\n", str_error(rc));
     522                        usb_log_error("Failed to initialize polling: %s", str_error(rc));
    523523                        // FIXME: What happens now?
    524524                }
    … …  
    555555        usb_polling_fini(&hid_dev->polling);
    556556
    557         usb_log_debug("Subdrivers: %p, subdriver count: %d\n",
     557        usb_log_debug("Subdrivers: %p, subdriver count: %d",
    558558            hid_dev->subdrivers, hid_dev->subdriver_count);
    559559
Note: See TracChangeset for help on using the changeset viewer.