Changeset a1732929 in mainline for uspace/lib


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/lib
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/usbdev/src/devdrv.c

    rc1a966e ra1732929  
    302302        int rc;
    303303        for (size_t i = 0; i < usb_dev->pipes_count; ++i) {
    304                 usb_log_debug2("Unregistering pipe %zu: %spresent.\n",
     304                usb_log_debug2("Unregistering pipe %zu: %spresent.",
    305305                    i, usb_dev->pipes[i].present ? "" : "not ");
    306306

  • uspace/lib/usbdev/src/driver.c

    rc1a966e ra1732929  
    6262        int rc = usb_device_create_ddf(gen_dev, driver->endpoints, &err_msg);
    6363        if (rc != EOK) {
    64                 usb_log_error("USB device `%s' init failed (%s): %s.\n",
     64                usb_log_error("USB device `%s' init failed (%s): %s.",
    6565                    ddf_dev_get_name(gen_dev), err_msg, str_error(rc));
    6666                return rc;

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

    rc1a966e ra1732929  
    881881{
    882882        if(list == NULL || list_empty(list)) {
    883             usb_log_debug("\tempty\n");
     883            usb_log_debug("\tempty");
    884884            return;
    885885        }
    … …  
    887887        list_foreach(*list, ritems_link, usb_hid_report_field_t,
    888888            report_item) {
    889                 usb_log_debug("\t\tOFFSET: %u\n", report_item->offset);
    890                 usb_log_debug("\t\tSIZE: %zu\n", report_item->size);
    891                 usb_log_debug("\t\tLOGMIN: %d\n",
     889                usb_log_debug("\t\tOFFSET: %u", report_item->offset);
     890                usb_log_debug("\t\tSIZE: %zu", report_item->size);
     891                usb_log_debug("\t\tLOGMIN: %d",
    892892                        report_item->logical_minimum);
    893                 usb_log_debug("\t\tLOGMAX: %d\n",
     893                usb_log_debug("\t\tLOGMAX: %d",
    894894                        report_item->logical_maximum);
    895                 usb_log_debug("\t\tPHYMIN: %d\n",
     895                usb_log_debug("\t\tPHYMIN: %d",
    896896                        report_item->physical_minimum);
    897                 usb_log_debug("\t\tPHYMAX: %d\n",
     897                usb_log_debug("\t\tPHYMAX: %d",
    898898                        report_item->physical_maximum);
    899                 usb_log_debug("\t\ttUSAGEMIN: %X\n",
     899                usb_log_debug("\t\ttUSAGEMIN: %X",
    900900                        report_item->usage_minimum);
    901                 usb_log_debug("\t\tUSAGEMAX: %X\n",
     901                usb_log_debug("\t\tUSAGEMAX: %X",
    902902                               report_item->usage_maximum);
    903                 usb_log_debug("\t\tUSAGES COUNT: %zu\n",
     903                usb_log_debug("\t\tUSAGES COUNT: %zu",
    904904                        report_item->usages_count);
    905905
    906                 usb_log_debug("\t\tVALUE: %X\n", report_item->value);
    907                 usb_log_debug("\t\ttUSAGE: %X\n", report_item->usage);
    908                 usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page);
     906                usb_log_debug("\t\tVALUE: %X", report_item->value);
     907                usb_log_debug("\t\ttUSAGE: %X", report_item->usage);
     908                usb_log_debug("\t\tUSAGE PAGE: %X", report_item->usage_page);
    909909
    910910                usb_hid_print_usage_path(report_item->collection_path);
    911 
    912                 usb_log_debug("\n");
    913911        }
    914912}
    … …  
    928926        list_foreach(report->reports, reports_link,
    929927            usb_hid_report_description_t, report_des) {
    930                 usb_log_debug("Report ID: %d\n", report_des->report_id);
    931                 usb_log_debug("\tType: %d\n", report_des->type);
    932                 usb_log_debug("\tLength: %zu\n", report_des->bit_length);
    933                 usb_log_debug("\tB Size: %zu\n",
     928                usb_log_debug("Report ID: %d", report_des->report_id);
     929                usb_log_debug("\tType: %d", report_des->type);
     930                usb_log_debug("\tLength: %zu", report_des->bit_length);
     931                usb_log_debug("\tB Size: %zu",
    934932                        usb_hid_report_byte_size(report,
    935933                                report_des->report_id,
    936934                                report_des->type));
    937                 usb_log_debug("\tItems: %zu\n", report_des->item_length);
     935                usb_log_debug("\tItems: %zu", report_des->item_length);
    938936
    939937                usb_hid_descriptor_print_list(&report_des->report_items);

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

    rc1a966e ra1732929  
    353353                length = report_item->size;
    354354               
    355                 usb_log_debug("\ttranslated value: %x\n", value);
     355                usb_log_debug("\ttranslated value: %x", value);
    356356
    357357                if ((offset / 8) == ((offset + length - 1) / 8)) {

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

    rc1a966e ra1732929  
    173173void usb_hid_print_usage_path(usb_hid_report_path_t *path)
    174174{
    175         usb_log_debug("USAGE_PATH FOR RId(%d):\n", path->report_id);
    176         usb_log_debug("\tLENGTH: %d\n", path->depth);
     175        usb_log_debug("USAGE_PATH FOR RId(%d):", path->report_id);
     176        usb_log_debug("\tLENGTH: %d", path->depth);
    177177
    178178        list_foreach(path->items, rpath_items_link,
    179179            usb_hid_report_usage_path_t, path_item) {
    180180
    181                 usb_log_debug("\tUSAGE_PAGE: %X\n", path_item->usage_page);
    182                 usb_log_debug("\tUSAGE: %X\n", path_item->usage);
    183                 usb_log_debug("\tFLAGS: %d\n", path_item->flags);
     181                usb_log_debug("\tUSAGE_PAGE: %X", path_item->usage_page);
     182                usb_log_debug("\tUSAGE: %X", path_item->usage);
     183                usb_log_debug("\tFLAGS: %d", path_item->flags);
    184184        }
    185185}

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

    rc1a966e ra1732929  
    8484       
    8585        if (d == NULL) {
    86                 usb_log_error("The %d. interface descriptor not found!\n",
     86                usb_log_error("The %d. interface descriptor not found!",
    8787                    usb_device_get_iface_number(dev));
    8888                return ENOENT;
    … …  
    104104       
    105105        if (d == NULL) {
    106                 usb_log_fatal("No HID descriptor found!\n");
     106                usb_log_fatal("No HID descriptor found!");
    107107                return ENOENT;
    108108        }
    … …  
    130130        }
    131131       
    132         usb_log_debug("Getting Report descriptor, expected size: %u\n", length);
     132        usb_log_debug("Getting Report descriptor, expected size: %u", length);
    133133       
    134134        /*
    … …  
    156156        *size = length;
    157157       
    158         usb_log_debug("Done.\n");
     158        usb_log_debug("Done.");
    159159       
    160160        return EOK;
    … …  
    178178       
    179179        if (rc != EOK) {
    180                 usb_log_error("Problem with getting Report descriptor: %s.\n",
     180                usb_log_error("Problem with getting Report descriptor: %s.",
    181181                    str_error(rc));
    182182                if (*report_desc != NULL) {
    … …  
    191191        rc = usb_hid_parse_report_descriptor(report, *report_desc, *report_size);
    192192        if (rc != EOK) {
    193                 usb_log_error("Problem parsing Report descriptor: %s.\n",
     193                usb_log_error("Problem parsing Report descriptor: %s.",
    194194                    str_error(rc));
    195195                free(*report_desc);

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

    rc1a966e ra1732929  
    6262{
    6363        if (ctrl_pipe == NULL) {
    64                 usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
     64                usb_log_warning("usbhid_req_set_report(): no pipe given.");
    6565                return EINVAL;
    6666        }
    … …  
    8282        value |= (type << 8);
    8383
    84         usb_log_debug("Sending Set Report request to the device.\n");
     84        usb_log_debug("Sending Set Report request to the device.");
    8585       
    8686        rc = usb_control_request_set(ctrl_pipe,
    … …  
    112112{
    113113        if (ctrl_pipe == NULL) {
    114                 usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
     114                usb_log_warning("usbhid_req_set_report(): no pipe given.");
    115115                return EINVAL;
    116116        }
    … …  
    160160{
    161161        if (ctrl_pipe == NULL) {
    162                 usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
     162                usb_log_warning("usbhid_req_set_report(): no pipe given.");
    163163                return EINVAL;
    164164        }
    … …  
    215215{
    216216        if (ctrl_pipe == NULL) {
    217                 usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
     217                usb_log_warning("usbhid_req_set_report(): no pipe given.");
    218218                return EINVAL;
    219219        }
    … …  
    235235        value |= (type << 8);
    236236       
    237         usb_log_debug("Sending Get Report request to the device.\n");
     237        usb_log_debug("Sending Get Report request to the device.");
    238238       
    239239        rc = usb_control_request_get(ctrl_pipe,
    … …  
    266266{
    267267        if (ctrl_pipe == NULL) {
    268                 usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
     268                usb_log_warning("usbhid_req_set_report(): no pipe given.");
    269269                return EINVAL;
    270270        }
    … …  
    300300       
    301301        if (actual_size != 1) {
    302                 usb_log_warning("Wrong data size: %zu, expected: 1.\n",
     302                usb_log_warning("Wrong data size: %zu, expected: 1.",
    303303                        actual_size);
    304304                return ELIMIT;
    … …  
    327327{
    328328        if (ctrl_pipe == NULL) {
    329                 usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
     329                usb_log_warning("usbhid_req_set_report(): no pipe given.");
    330330                return EINVAL;
    331331        }
    … …  
    363363       
    364364        if (actual_size != 1) {
    365                 usb_log_warning("Wrong data size: %zu, expected: 1.\n",
     365                usb_log_warning("Wrong data size: %zu, expected: 1.",
    366366                        actual_size);
    367367                return ELIMIT;

  • uspace/lib/usbhost/src/bus.c

    rc1a966e ra1732929  
    387387        }
    388388
    389         usb_log_debug("Register endpoint %d:%d %s-%s %zuB.\n",
     389        usb_log_debug("Register endpoint %d:%d %s-%s %zuB.",
    390390            device->address, ep->endpoint,
    391391            usb_str_transfer_type(ep->transfer_type),
    … …  
    467467                return ENOTSUP;
    468468
    469         usb_log_debug("Unregister endpoint %d:%d %s-%s %zuB.\n",
     469        usb_log_debug("Unregister endpoint %d:%d %s-%s %zuB.",
    470470            device->address, ep->endpoint,
    471471            usb_str_transfer_type(ep->transfer_type),
    … …  
    543543        endpoint_t *ep = bus_find_endpoint(device, target.endpoint, direction);
    544544        if (ep == NULL) {
    545                 usb_log_error("Endpoint(%d:%d) not registered for %s.\n",
     545                usb_log_error("Endpoint(%d:%d) not registered for %s.",
    546546                    device->address, target.endpoint, name);
    547547                return ENOENT;

  • uspace/lib/usbhost/src/ddf_helpers.c

    rc1a966e ra1732929  
    133133        assert(dev);
    134134
    135         usb_log_debug("Device %d requested default address at %s speed\n",
     135        usb_log_debug("Device %d requested default address at %s speed",
    136136            dev->address, usb_str_speed(speed));
    137137        return bus_reserve_default_address(hcd->bus, speed);
    … …  
    152152        assert(dev);
    153153
    154         usb_log_debug("Device %d released default address\n", dev->address);
     154        usb_log_debug("Device %d released default address", dev->address);
    155155        bus_release_default_address(hcd->bus);
    156156
    … …  
    173173        assert(hub);
    174174
    175         usb_log_debug("Hub %d reported a new USB device on port: %u\n",
     175        usb_log_debug("Hub %d reported a new USB device on port: %u",
    176176            hub->address, port);
    177177        return hcd_ddf_new_device(hcd, hc, hub, port);
    … …  
    185185        assert(ddf_dev);
    186186        assert(dev);
    187         usb_log_debug("Hub `%s' reported removal of device on port %u\n",
     187        usb_log_debug("Hub `%s' reported removal of device on port %u",
    188188            ddf_fun_get_name(fun), port);
    189189        return hcd_ddf_remove_device(ddf_dev, dev, port);
    … …  
    535535        hc_device_t *instance = ddf_dev_data_alloc(device, size);
    536536        if (instance == NULL) {
    537                 usb_log_error("Failed to allocate HCD ddf structure.\n");
     537                usb_log_error("Failed to allocate HCD ddf structure.");
    538538                return ENOMEM;
    539539        }
    … …  
    543543        instance->ctl_fun = ddf_fun_create(device, fun_exposed, "ctl");
    544544        if (!instance->ctl_fun) {
    545                 usb_log_error("Failed to create HCD ddf fun.\n");
     545                usb_log_error("Failed to create HCD ddf fun.");
    546546                goto err_destroy_fun;
    547547        }
    … …  
    549549        ret = ddf_fun_bind(instance->ctl_fun);
    550550        if (ret != EOK) {
    551                 usb_log_error("Failed to bind ctl_fun: %s.\n", str_error(ret));
     551                usb_log_error("Failed to bind ctl_fun: %s.", str_error(ret));
    552552                goto err_destroy_fun;
    553553        }
    … …  
    555555        ret = ddf_fun_add_to_category(instance->ctl_fun, USB_HC_CATEGORY);
    556556        if (ret != EOK) {
    557                 usb_log_error("Failed to add fun to category: %s.\n",
     557                usb_log_error("Failed to add fun to category: %s.",
    558558                    str_error(ret));
    559559                ddf_fun_unbind(instance->ctl_fun);

  • uspace/lib/usbhost/src/endpoint.c

    rc1a966e ra1732929  
    239239    usbhc_iface_transfer_callback_t on_complete, void *arg, const char *name)
    240240{
    241         usb_log_debug2("%s %d:%d %zu(%zu).\n",
     241        usb_log_debug2("%s %d:%d %zu(%zu).",
    242242            name, target.address, target.endpoint, size, ep->max_packet_size);
    243243
    … …  
    250250        const bus_ops_t *ops = BUS_OPS_LOOKUP(device->bus->ops, batch_schedule);
    251251        if (!ops) {
    252                 usb_log_error("HCD does not implement scheduler.\n");
     252                usb_log_error("HCD does not implement scheduler.");
    253253                return ENOTSUP;
    254254        }
    … …  
    270270        usb_transfer_batch_t *batch = usb_transfer_batch_create(ep);
    271271        if (!batch) {
    272                 usb_log_error("Failed to create transfer batch.\n");
     272                usb_log_error("Failed to create transfer batch.");
    273273                return ENOMEM;
    274274        }

  • uspace/lib/usbhost/src/hcd.c

    rc1a966e ra1732929  
    169169        const int irq = hc_driver->irq_code_gen(&irq_code, hcd, hw_res);
    170170        if (irq < 0) {
    171                 usb_log_error("Failed to generate IRQ code: %s.\n",
     171                usb_log_error("Failed to generate IRQ code: %s.",
    172172                    str_error(irq));
    173173                return irq;
    … …  
    178178        irq_code_clean(&irq_code);
    179179        if (irq_cap < 0) {
    180                 usb_log_error("Failed to register interrupt handler: %s.\n",
     180                usb_log_error("Failed to register interrupt handler: %s.",
    181181                    str_error(irq_cap));
    182182                return irq_cap;
    … …  
    186186        int ret = hcd_ddf_enable_interrupt(hcd, irq);
    187187        if (ret != EOK) {
    188                 usb_log_error("Failed to enable interrupts: %s.\n",
     188                usb_log_error("Failed to enable interrupts: %s.",
    189189                    str_error(ret));
    190190                unregister_interrupt_handler(hcd->ddf_dev, irq_cap);
    … …  
    219219        ret = hcd_ddf_setup_hc(device, hc_driver->hc_device_size);
    220220        if (ret != EOK) {
    221                 usb_log_error("Failed to setup HC device.\n");
     221                usb_log_error("Failed to setup HC device.");
    222222                return ret;
    223223        }
    … …  
    229229        if (ret != EOK) {
    230230                usb_log_error("Failed to get register memory addresses "
    231                     "for `%s': %s.\n", ddf_dev_get_name(device),
     231                    "for `%s': %s.", ddf_dev_get_name(device),
    232232                    str_error(ret));
    233233                goto err_hcd;
    … …  
    236236        ret = hc_driver->hc_add(hcd, &hw_res);
    237237        if (ret != EOK) {
    238                 usb_log_error("Failed to init HCD.\n");
     238                usb_log_error("Failed to init HCD.");
    239239                goto err_hw_res;
    240240        }
    … …  
    245245        hcd->irq_cap = hcd_ddf_setup_interrupts(hcd, &hw_res);
    246246        if (hcd->irq_cap >= 0) {
    247                 usb_log_debug("Hw interrupts enabled.\n");
     247                usb_log_debug("Hw interrupts enabled.");
    248248        }
    249249
    … …  
    261261                ret = hc_driver->start(hcd);
    262262        if (ret != EOK) {
    263                 usb_log_error("Failed to start HCD: %s.\n", str_error(ret));
     263                usb_log_error("Failed to start HCD: %s.", str_error(ret));
    264264                goto err_irq;
    265265        }
    … …  
    271271                hcd->polling_fibril = fibril_create(interrupt_polling, hcd->bus);
    272272                if (!hcd->polling_fibril) {
    273                         usb_log_error("Failed to create polling fibril\n");
     273                        usb_log_error("Failed to create polling fibril");
    274274                        ret = ENOMEM;
    275275                        goto err_started;
    … …  
    277277                fibril_add_ready(hcd->polling_fibril);
    278278                usb_log_warning("Failed to enable interrupts: %s."
    279                     " Falling back to polling.\n", str_error(hcd->irq_cap));
     279                    " Falling back to polling.", str_error(hcd->irq_cap));
    280280        }
    281281
    … …  
    287287                ret = hc_driver->setup_root_hub(hcd);
    288288        if (ret != EOK) {
    289                 usb_log_error("Failed to setup HC root hub: %s.\n",
     289                usb_log_error("Failed to setup HC root hub: %s.",
    290290                    str_error(ret));
    291291                goto err_polling;
    292292        }
    293293
    294         usb_log_info("Controlling new `%s' device `%s'.\n",
     294        usb_log_info("Controlling new `%s' device `%s'.",
    295295           hc_driver->name, ddf_dev_get_name(device));
    296296        return EOK;

  • uspace/lib/usbhost/src/usb_transfer_batch.c

    rc1a966e ra1732929  
    9393
    9494        if (ops) {
    95                 usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " destroying.\n",
     95                usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " destroying.",
    9696                    batch, USB_TRANSFER_BATCH_ARGS(*batch));
    9797                ops->batch_destroy(batch);
    9898        }
    9999        else {
    100                 usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " disposing.\n",
     100                usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " disposing.",
    101101                    batch, USB_TRANSFER_BATCH_ARGS(*batch));
    102102                free(batch);
    … …  
    114114        assert(batch->ep);
    115115
    116         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " finishing.\n",
     116        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " finishing.",
    117117            batch, USB_TRANSFER_BATCH_ARGS(*batch));
    118118

  • uspace/lib/usbvirt/src/ctrltransfer.c

    rc1a966e ra1732929  
    6868                }
    6969
    70                 usb_log_debug("Control transfer: %s(%s)\n", handler->name,
     70                usb_log_debug("Control transfer: %s(%s)", handler->name,
    7171                    usb_debug_str_buffer((uint8_t*) setup, sizeof(*setup), 0));
    7272                int rc = handler->callback(dev, setup, data, data_sent_size);

  • uspace/lib/usbvirt/src/transfer.c

    rc1a966e ra1732929  
    7979
    8080        if (rc == EFORWARD) {
    81                 usb_log_warning("Control transfer {%s (%s)} not handled.\n",
     81                usb_log_warning("Control transfer {%s (%s)} not handled.",
    8282                    usb_debug_str_buffer(setup, setup_size, 10),
    8383                    setup_packet->request_type & 0x80
Note: See TracChangeset for help on using the changeset viewer.