Changeset a1732929 in mainline for uspace/lib/usbhost/src


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/usbhost/src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • 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
Note: See TracChangeset for help on using the changeset viewer.