Changeset a1732929 in mainline for uspace/drv

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

Files:

• block/usbmast/bo_trans.c (modified) (3 diffs)
• block/usbmast/main.c (modified) (9 diffs)
• block/usbmast/scsi_ms.c (modified) (17 diffs)
• bus/usb/ehci/ehci_batch.c (modified) (2 diffs)
• bus/usb/ehci/ehci_rh.c (modified) (1 diff)
• bus/usb/ehci/endpoint_list.c (modified) (4 diffs)
• bus/usb/ehci/hc.c (modified) (5 diffs)
• bus/usb/ehci/res.c (modified) (9 diffs)
• bus/usb/ohci/endpoint_list.c (modified) (5 diffs)
• bus/usb/ohci/hc.c (modified) (26 diffs)
• bus/usb/ohci/ohci_batch.c (modified) (11 diffs)
• bus/usb/ohci/ohci_rh.c (modified) (6 diffs)
• bus/usb/uhci/hc.c (modified) (14 diffs)
• bus/usb/uhci/hw_struct/transfer_descriptor.c (modified) (2 diffs)
• bus/usb/uhci/transfer_list.c (modified) (5 diffs)
• bus/usb/uhci/uhci_batch.c (modified) (7 diffs)
• bus/usb/uhci/uhci_rh.c (modified) (8 diffs)
• bus/usb/usbdiag/device.c (modified) (1 diff)
• bus/usb/usbdiag/main.c (modified) (3 diffs)
• bus/usb/usbdiag/tests.c (modified) (5 diffs)
• bus/usb/usbflbk/main.c (modified) (1 diff)
• bus/usb/usbhub/port.c (modified) (4 diffs)
• bus/usb/usbhub/usbhub.c (modified) (13 diffs)
• bus/usb/usbmid/dump.c (modified) (1 diff)
• bus/usb/usbmid/explore.c (modified) (6 diffs)
• bus/usb/usbmid/main.c (modified) (6 diffs)
• bus/usb/vhc/conndev.c (modified) (2 diffs)
• bus/usb/vhc/hub/hub.c (modified) (3 diffs)
• bus/usb/vhc/main.c (modified) (4 diffs)
• bus/usb/vhc/transfer.c (modified) (3 diffs)
• bus/usb/xhci/bus.c (modified) (1 diff)
• bus/usb/xhci/hc.c (modified) (3 diffs)
• hid/usbhid/blink1/blink1.c (modified) (4 diffs)
• hid/usbhid/generic/hiddev.c (modified) (11 diffs)
• hid/usbhid/kbd/kbddev.c (modified) (29 diffs)
• hid/usbhid/kbd/kbdrepeat.c (modified) (5 diffs)
• hid/usbhid/main.c (modified) (8 diffs)
• hid/usbhid/mouse/mousedev.c (modified) (15 diffs)
• hid/usbhid/multimedia/multimedia.c (modified) (13 diffs)
• hid/usbhid/usbhid.c (modified) (21 diffs)

uspace/drv/block/usbmast/bo_trans.c

@@ -90 +90 @@
             str_error(rc));
         if (rc != EOK) {
-                usb_log_error("Bulk out write failed: %s\n", str_error(rc));
+                usb_log_error("Bulk out write failed: %s", str_error(rc));
                 return EIO;
         }
@@ -154 +154 @@
         case cbs_failed:
                 cmd->status = CMDS_FAILED;
-                usb_log_error("CBS Failed.\n");
+                usb_log_error("CBS Failed.");
                 break;
         case cbs_phase_error:
-                usb_log_error("CBS phase error.\n");
+                usb_log_error("CBS phase error.");
                 rc = EIO;
                 break;
         default:
-                usb_log_error("CBS other error.\n");
+                usb_log_error("CBS other error.");
                 rc = EIO;
                 break;
@@ -168 +168 @@
         const size_t residue = uint32_usb2host(csw.dCSWDataResidue);
         if (residue > dbuf_size) {
-                usb_log_error("Residue > buffer size (%zu > %zu).\n",
+                usb_log_error("Residue > buffer size (%zu > %zu).",
                     residue, dbuf_size);
                 return EIO;

uspace/drv/block/usbmast/main.c

@@ -156 +156 @@
             usb_device_get_mapped_ep_desc(dev, &bulk_out_ep);
         if (!epm_in || !epm_out || !epm_in->present || !epm_out->present) {
-                usb_log_error("Required EPs were not mapped.\n");
+                usb_log_error("Required EPs were not mapped.");
                 return ENOENT;
         }
@@ -163 +163 @@
         mdev = usb_device_data_alloc(dev, sizeof(usbmast_dev_t));
         if (mdev == NULL) {
-                usb_log_error("Failed allocating softstate.\n");
+                usb_log_error("Failed allocating softstate.");
                 return ENOMEM;
         }
@@ -169 +169 @@
         mdev->usb_dev = dev;
 
-        usb_log_info("Initializing mass storage `%s'.\n",
+        usb_log_info("Initializing mass storage `%s'.",
             usb_device_get_name(dev));
-        usb_log_debug("Bulk in endpoint: %d [%zuB].\n",
+        usb_log_debug("Bulk in endpoint: %d [%zuB].",
             epm_in->pipe.desc.endpoint_no, epm_in->pipe.desc.max_transfer_size);
-        usb_log_debug("Bulk out endpoint: %d [%zuB].\n",
+        usb_log_debug("Bulk out endpoint: %d [%zuB].",
             epm_out->pipe.desc.endpoint_no, epm_out->pipe.desc.max_transfer_size);
 
-        usb_log_debug("Get LUN count...\n");
+        usb_log_debug("Get LUN count...");
         mdev->lun_count = usb_masstor_get_lun_count(mdev);
         mdev->luns = calloc(mdev->lun_count, sizeof(ddf_fun_t*));
         if (mdev->luns == NULL) {
                 rc = ENOMEM;
-                usb_log_error("Failed allocating luns table.\n");
+                usb_log_error("Failed allocating luns table.");
                 goto error;
         }
@@ -226 +226 @@
 
         if (asprintf(&fun_name, "l%u", lun) < 0) {
-                usb_log_error("Out of memory.\n");
+                usb_log_error("Out of memory.");
                 rc = ENOMEM;
                 goto error;
@@ -233 +233 @@
         fun = usb_device_ddf_fun_create(mdev->usb_dev, fun_exposed, fun_name);
         if (fun == NULL) {
-                usb_log_error("Failed to create DDF function %s.\n", fun_name);
+                usb_log_error("Failed to create DDF function %s.", fun_name);
                 rc = ENOMEM;
                 goto error;
@@ -241 +241 @@
         mfun = ddf_fun_data_alloc(fun, sizeof(usbmast_fun_t));
         if (mfun == NULL) {
-                usb_log_error("Failed allocating softstate.\n");
+                usb_log_error("Failed allocating softstate.");
                 rc = ENOMEM;
                 goto error;
@@ -257 +257 @@
         ddf_fun_set_conn_handler(fun, usbmast_bd_connection);
 
-        usb_log_debug("Inquire...\n");
+        usb_log_debug("Inquire...");
         usbmast_inquiry_data_t inquiry;
         rc = usbmast_inquiry(mfun, &inquiry);
         if (rc != EOK) {
-                usb_log_warning("Failed to inquire device `%s': %s.\n",
+                usb_log_warning("Failed to inquire device `%s': %s.",
                     usb_device_get_name(mdev->usb_dev), str_error(rc));
                 rc = EIO;
@@ -281 +281 @@
         rc = usbmast_read_capacity(mfun, &nblocks, &block_size);
         if (rc != EOK) {
-                usb_log_warning("Failed to read capacity, device `%s': %s.\n",
+                usb_log_warning("Failed to read capacity, device `%s': %s.",
                     usb_device_get_name(mdev->usb_dev), str_error(rc));
                 rc = EIO;
@@ -295 +295 @@
         rc = ddf_fun_bind(fun);
         if (rc != EOK) {
-                usb_log_error("Failed to bind DDF function %s: %s.\n",
+                usb_log_error("Failed to bind DDF function %s: %s.",
                     fun_name, str_error(rc));
                 goto error;

uspace/drv/block/usbmast/scsi_ms.c

@@ -116 +116 @@
                 rc = usb_massstor_unit_ready(mfun);
                 if (rc != EOK) {
-                        usb_log_error("Inquiry transport failed, device %s: %s.\n",
+                        usb_log_error("Inquiry transport failed, device %s: %s.",
                            usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
                         return rc;
@@ -123 +123 @@
                 rc = usb_massstor_cmd(mfun, 0xDEADBEEF, cmd);
                 if (rc != EOK) {
-                        usb_log_error("Inquiry transport failed, device %s: %s.\n",
+                        usb_log_error("Inquiry transport failed, device %s: %s.",
                            usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
                         return rc;
@@ -131 +131 @@
                         return EOK;
 
-                usb_log_error("SCSI command failed, device %s.\n",
+                usb_log_error("SCSI command failed, device %s.",
                     usb_device_get_name(mfun->mdev->usb_dev));
 
                 rc = usbmast_request_sense(mfun, &sense_buf, sizeof(sense_buf));
                 if (rc != EOK) {
-                        usb_log_error("Failed to read sense data.\n");
+                        usb_log_error("Failed to read sense data.");
                         return EIO;
                 }
@@ -182 +182 @@
 
         if (rc != EOK) {
-                usb_log_error("Inquiry transport failed, device %s: %s.\n",
+                usb_log_error("Inquiry transport failed, device %s: %s.",
                    usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
                 return rc;
@@ -188 +188 @@
 
         if (cmd.status != CMDS_GOOD) {
-                usb_log_error("Inquiry command failed, device %s.\n",
+                usb_log_error("Inquiry command failed, device %s.",
                    usb_device_get_name(mfun->mdev->usb_dev));
                 return EIO;
@@ -194 +194 @@
 
         if (cmd.rcvd_size < SCSI_STD_INQUIRY_DATA_MIN_SIZE) {
-                usb_log_error("SCSI Inquiry response too short (%zu).\n",
+                usb_log_error("SCSI Inquiry response too short (%zu).",
                     cmd.rcvd_size);
                 return EIO;
@@ -250 +250 @@
 
         if (rc != EOK || cmd.status != CMDS_GOOD) {
-                usb_log_error("Request Sense failed, device %s: %s.\n",
+                usb_log_error("Request Sense failed, device %s: %s.",
                    usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
                 return rc;
@@ -292 +292 @@
 
         if (rc != EOK) {
-                usb_log_error("Read Capacity (10) transport failed, device %s: %s.\n",
+                usb_log_error("Read Capacity (10) transport failed, device %s: %s.",
                    usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
                 return rc;
@@ -298 +298 @@
 
         if (cmd.status != CMDS_GOOD) {
-                usb_log_error("Read Capacity (10) command failed, device %s.\n",
+                usb_log_error("Read Capacity (10) command failed, device %s.",
                    usb_device_get_name(mfun->mdev->usb_dev));
                 return EIO;
@@ -304 +304 @@
 
         if (cmd.rcvd_size < sizeof(data)) {
-                usb_log_error("SCSI Read Capacity response too short (%zu).\n",
+                usb_log_error("SCSI Read Capacity response too short (%zu).",
                     cmd.rcvd_size);
                 return EIO;
@@ -349 +349 @@
 
         if (rc != EOK) {
-                usb_log_error("Read (10) transport failed, device %s: %s.\n",
+                usb_log_error("Read (10) transport failed, device %s: %s.",
                    usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
                 return rc;
@@ -355 +355 @@
 
         if (cmd.status != CMDS_GOOD) {
-                usb_log_error("Read (10) command failed, device %s.\n",
+                usb_log_error("Read (10) command failed, device %s.",
                    usb_device_get_name(mfun->mdev->usb_dev));
                 return EIO;
@@ -361 +361 @@
 
         if (cmd.rcvd_size < nblocks * mfun->block_size) {
-                usb_log_error("SCSI Read response too short (%zu).\n",
+                usb_log_error("SCSI Read response too short (%zu).",
                     cmd.rcvd_size);
                 return EIO;
@@ -405 +405 @@
 
         if (rc != EOK) {
-                usb_log_error("Write (10) transport failed, device %s: %s.\n",
+                usb_log_error("Write (10) transport failed, device %s: %s.",
                    usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
                 return rc;
@@ -411 +411 @@
 
         if (cmd.status != CMDS_GOOD) {
-                usb_log_error("Write (10) command failed, device %s.\n",
+                usb_log_error("Write (10) command failed, device %s.",
                    usb_device_get_name(mfun->mdev->usb_dev));
                 return EIO;
@@ -450 +450 @@
 
         if (rc != EOK) {
-                usb_log_error("Synchronize Cache (10) transport failed, device %s: %s.\n",
+                usb_log_error("Synchronize Cache (10) transport failed, device %s: %s.",
                    usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
                 return rc;
@@ -456 +456 @@
 
         if (cmd.status != CMDS_GOOD) {
-                usb_log_error("Synchronize Cache (10) command failed, device %s.\n",
+                usb_log_error("Synchronize Cache (10) command failed, device %s.",
                    usb_device_get_name(mfun->mdev->usb_dev));
                 return EIO;

uspace/drv/bus/usb/ehci/ehci_batch.c

@@ -143 +143 @@
         batch_setup[ehci_batch->base.ep->transfer_type](ehci_batch);
 
-        usb_log_debug("Batch %p %s " USB_TRANSFER_BATCH_FMT " initialized.\n",
+        usb_log_debug("Batch %p %s " USB_TRANSFER_BATCH_FMT " initialized.",
             ehci_batch, usb_str_direction(ehci_batch->base.dir),
             USB_TRANSFER_BATCH_ARGS(ehci_batch->base));
@@ -163 +163 @@
         assert(ehci_batch);
 
-        usb_log_debug("Batch %p: checking %zu td(s) for completion.\n",
+        usb_log_debug("Batch %p: checking %zu td(s) for completion.",
             ehci_batch, ehci_batch->td_count);
 
-        usb_log_debug2("Batch %p: QH: %08x:%08x:%08x:%08x:%08x:%08x.\n",
+        usb_log_debug2("Batch %p: QH: %08x:%08x:%08x:%08x:%08x:%08x.",
             ehci_batch,
             ehci_batch->qh->ep_char, ehci_batch->qh->ep_cap,

uspace/drv/bus/usb/ehci/ehci_rh.c

@@ -107 +107 @@
             (EHCI_RD(caps->hcsparams) >> EHCI_CAPS_HCS_N_PORTS_SHIFT) &
             EHCI_CAPS_HCS_N_PORTS_MASK;
-        usb_log_debug2("RH(%p): hcsparams: %x.\n", instance,
+        usb_log_debug2("RH(%p): hcsparams: %x.", instance,
             EHCI_RD(caps->hcsparams));
-        usb_log_info("RH(%p): Found %u ports.\n", instance,
+        usb_log_info("RH(%p): Found %u ports.", instance,
             instance->port_count);
 

uspace/drv/bus/usb/ehci/endpoint_list.c

@@ -97 +97 @@
         assert(ep);
         assert(ep->qh);
-        usb_log_debug2("EPL(%p-%s): Append endpoint(%p).\n",
+        usb_log_debug2("EPL(%p-%s): Append endpoint(%p).",
             instance, instance->name, ep);
 
@@ -128 +128 @@
         ehci_endpoint_t *first = ehci_endpoint_list_instance(
             list_first(&instance->endpoint_list));
-        usb_log_debug("EPL(%p-%s): EP(%p) added to list, first is %p(%p).\n",
+        usb_log_debug("EPL(%p-%s): EP(%p) added to list, first is %p(%p).",
             instance, instance->name, ep, first, first->qh);
         if (last_qh == instance->list_head) {
-                usb_log_debug2("EPL(%p-%s): head EP(%p-%"PRIxn"): %x:%x.\n",
+                usb_log_debug2("EPL(%p-%s): head EP(%p-%"PRIxn"): %x:%x.",
                     instance, instance->name, last_qh,
                     addr_to_phys(instance->list_head),
@@ -153 +153 @@
         fibril_mutex_lock(&instance->guard);
 
-        usb_log_debug2("EPL(%p-%s): removing EP(%p).\n",
+        usb_log_debug2("EPL(%p-%s): removing EP(%p).",
             instance, instance->name, ep);
 
@@ -172 +172 @@
         write_barrier();
 
-        usb_log_debug("EPL(%p-%s): EP(%p) removed (%s), horizontal %x.\n",
+        usb_log_debug("EPL(%p-%s): EP(%p) removed (%s), horizontal %x.",
             instance, instance->name,  ep, qpos, ep->qh->horizontal);
 

uspace/drv/bus/usb/ehci/hc.c

@@ -134 +134 @@
         EHCI_WR(code->cmds[1].value, EHCI_USED_INTERRUPTS);
 
-        usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.\n",
+        usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.",
             RNGABSPTR(regs), RNGSZ(regs), hw_res->irqs.irqs[0]);
 
@@ -160 +160 @@
         if (ret != EOK) {
                 usb_log_error("HC(%p): Failed to gain access to device "
-                    "registers: %s.\n", instance, str_error(ret));
+                    "registers: %s.", instance, str_error(ret));
                 return ret;
         }
@@ -211 +211 @@
         assert(ep);
         ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
-        usb_log_debug("HC(%p) enqueue EP(%d:%d:%s:%s)\n", instance,
+        usb_log_debug("HC(%p) enqueue EP(%d:%d:%s:%s)", instance,
             ep->device->address, ep->endpoint,
             usb_str_transfer_type_short(ep->transfer_type),
@@ -235 +235 @@
         assert(ep);
         ehci_endpoint_t *ehci_ep = ehci_endpoint_get(ep);
-        usb_log_debug("HC(%p) dequeue EP(?:%d:%s:%s)\n", instance,
+        usb_log_debug("HC(%p) dequeue EP(?:%d:%s:%s)", instance,
             ep->endpoint,
             usb_str_transfer_type_short(ep->transfer_type),
@@ -423 +423 @@
         usb_log_debug("HC(%p): HW started.", instance);
 
-        usb_log_debug2("HC(%p): Registers: \n"
-            "\tUSBCMD(%p): %x(0x00080000 = at least 1ms between interrupts)\n"
-            "\tUSBSTS(%p): %x(0x00001000 = HC halted)\n"
-            "\tUSBINT(%p): %x(0x0 = no interrupts).\n"
-            "\tCONFIG(%p): %x(0x0 = ports controlled by companion hc).\n",
+        usb_log_debug2("HC(%p): Registers: "
+            "\tUSBCMD(%p): %x(0x00080000 = at least 1ms between interrupts)"
+            "\tUSBSTS(%p): %x(0x00001000 = HC halted)"
+            "\tUSBINT(%p): %x(0x0 = no interrupts)."
+            "\tCONFIG(%p): %x(0x0 = ports controlled by companion hc).",
             instance,
             &instance->registers->usbcmd, EHCI_RD(instance->registers->usbcmd),

uspace/drv/bus/usb/ehci/res.c

@@ -74 +74 @@
             eecp + USBLEGSUP_OFFSET, &usblegsup);
         if (ret != EOK) {
-                usb_log_error("Failed to read USBLEGSUP: %s.\n", str_error(ret));
-                return ret;
-        }
-        usb_log_debug2("USBLEGSUP: %" PRIx32 ".\n", usblegsup);
+                usb_log_error("Failed to read USBLEGSUP: %s.", str_error(ret));
+                return ret;
+        }
+        usb_log_debug2("USBLEGSUP: %" PRIx32 ".", usblegsup);
 
         /* Request control from firmware/BIOS by writing 1 to highest
          * byte. (OS Control semaphore)*/
-        usb_log_debug("Requesting OS control.\n");
+        usb_log_debug("Requesting OS control.");
         ret = pci_config_space_write_8(parent_sess,
             eecp + USBLEGSUP_OFFSET + 3, 1);
         if (ret != EOK) {
-                usb_log_error("Failed to request OS EHCI control: %s.\n",
+                usb_log_error("Failed to request OS EHCI control: %s.",
                     str_error(ret));
                 return ret;
@@ -103 +103 @@
 
         if ((usblegsup & USBLEGSUP_BIOS_CONTROL) == 0) {
-                usb_log_info("BIOS released control after %zu usec.\n", wait);
+                usb_log_info("BIOS released control after %zu usec.", wait);
                 return EOK;
         }
@@ -109 +109 @@
         /* BIOS failed to hand over control, this should not happen. */
         usb_log_warning( "BIOS failed to release control after "
-            "%zu usecs, force it.\n", wait);
+            "%zu usecs, force it.", wait);
         ret = pci_config_space_write_32(parent_sess,
             eecp + USBLEGSUP_OFFSET, USBLEGSUP_OS_CONTROL);
         if (ret != EOK) {
-                usb_log_error("Failed to force OS control: %s.\n",
+                usb_log_error("Failed to force OS control: %s.",
                     str_error(ret));
                 return ret;
@@ -130 +130 @@
                     eecp + USBLEGCTLSTS_OFFSET, &usblegctlsts);
                 if (ret != EOK) {
-                        usb_log_error("Failed to get USBLEGCTLSTS: %s.\n",
+                        usb_log_error("Failed to get USBLEGCTLSTS: %s.",
                             str_error(ret));
                         return ret;
                 }
-                usb_log_debug2("USBLEGCTLSTS: %" PRIx32 ".\n", usblegctlsts);
+                usb_log_debug2("USBLEGCTLSTS: %" PRIx32 ".", usblegctlsts);
                 /*
                  * Zero SMI enables in legacy control register.
@@ -143 +143 @@
                     eecp + USBLEGCTLSTS_OFFSET, 0xe0000000);
                 if (ret != EOK) {
-                        usb_log_error("Failed to zero USBLEGCTLSTS: %s\n",
+                        usb_log_error("Failed to zero USBLEGCTLSTS: %s",
                             str_error(ret));
                         return ret;
@@ -153 +153 @@
                     eecp + USBLEGCTLSTS_OFFSET, &usblegctlsts);
                 if (ret != EOK) {
-                        usb_log_error("Failed to get USBLEGCTLSTS 2: %s.\n",
+                        usb_log_error("Failed to get USBLEGCTLSTS 2: %s.",
                             str_error(ret));
                         return ret;
                 }
-                usb_log_debug2("Zeroed USBLEGCTLSTS: %" PRIx32 ".\n",
+                usb_log_debug2("Zeroed USBLEGCTLSTS: %" PRIx32 ".",
                     usblegctlsts);
         }
@@ -165 +165 @@
             eecp + USBLEGSUP_OFFSET, &usblegsup);
         if (ret != EOK) {
-                usb_log_error("Failed to read USBLEGSUP: %s.\n",
-                    str_error(ret));
-                return ret;
-        }
-        usb_log_debug2("USBLEGSUP: %" PRIx32 ".\n", usblegsup);
+                usb_log_error("Failed to read USBLEGSUP: %s.",
+                    str_error(ret));
+                return ret;
+        }
+        usb_log_debug2("USBLEGSUP: %" PRIx32 ".", usblegsup);
         return ret;
 }
@@ -181 +181 @@
                 return ENOMEM;
 
-        usb_log_debug("Disabling EHCI legacy support.\n");
+        usb_log_debug("Disabling EHCI legacy support.");
 
 
         const uint32_t hcc_params = EHCI_RD(hc->caps->hccparams);
-        usb_log_debug2("Value of hcc params register: %x.\n", hcc_params);
+        usb_log_debug2("Value of hcc params register: %x.", hcc_params);
 
         /* Read value of EHCI Extended Capabilities Pointer
@@ -191 +191 @@
         const uint32_t eecp =
             (hcc_params >> EHCI_CAPS_HCC_EECP_SHIFT) & EHCI_CAPS_HCC_EECP_MASK;
-        usb_log_debug2("Value of EECP: %x.\n", eecp);
+        usb_log_debug2("Value of EECP: %x.", eecp);
 
         int ret = disable_extended_caps(parent_sess, eecp);
         if (ret != EOK) {
-                usb_log_error("Failed to disable extended capabilities: %s.\n",
+                usb_log_error("Failed to disable extended capabilities: %s.",
                     str_error(ret));
                     goto clean;

uspace/drv/bus/usb/ohci/endpoint_list.c

@@ -57 +57 @@
         instance->list_head = malloc32(sizeof(ed_t));
         if (!instance->list_head) {
-                usb_log_error("Failed to allocate list head.\n");
+                usb_log_error("Failed to allocate list head.");
                 return ENOMEM;
         }
         instance->list_head_pa = addr_to_phys(instance->list_head);
-        usb_log_debug2("Transfer list %s setup with ED: %p(0x%0" PRIx32 ")).\n",
+        usb_log_debug2("Transfer list %s setup with ED: %p(0x%0" PRIx32 ")).",
             name, instance->list_head, instance->list_head_pa);
 
@@ -96 +96 @@
         assert(instance);
         assert(ep);
-        usb_log_debug2("Queue %s: Adding endpoint(%p).\n", instance->name, ep);
+        usb_log_debug2("Queue %s: Adding endpoint(%p).", instance->name, ep);
 
         fibril_mutex_lock(&instance->guard);
@@ -126 +126 @@
         ohci_endpoint_t *first = list_get_instance(
             list_first(&instance->endpoint_list), ohci_endpoint_t, link);
-        usb_log_debug("HCD EP(%p) added to list %s, first is %p(%p).\n",
+        usb_log_debug("HCD EP(%p) added to list %s, first is %p(%p).",
                 ep, instance->name, first, first->ed);
         if (last_ed == instance->list_head) {
-                usb_log_debug2("%s head ED(%p-0x%0" PRIx32 "): %x:%x:%x:%x.\n",
+                usb_log_debug2("%s head ED(%p-0x%0" PRIx32 "): %x:%x:%x:%x.",
                     instance->name, last_ed, instance->list_head_pa,
                     last_ed->status, last_ed->td_tail, last_ed->td_head,
@@ -151 +151 @@
         fibril_mutex_lock(&instance->guard);
 
-        usb_log_debug2("Queue %s: removing endpoint(%p).\n", instance->name, ep);
+        usb_log_debug2("Queue %s: removing endpoint(%p).", instance->name, ep);
 
         const char *qpos = NULL;
@@ -171 +171 @@
         write_barrier();
 
-        usb_log_debug("HCD EP(%p) removed (%s) from %s, next %x.\n",
+        usb_log_debug("HCD EP(%p) removed (%s) from %s, next %x.",
             ep, qpos, instance->name, ep->ed->next);
 

uspace/drv/bus/usb/ohci/hc.c

@@ -136 +136 @@
         OHCI_WR(code->cmds[1].value, OHCI_USED_INTERRUPTS);
 
-        usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.\n",
+        usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.",
             RNGABSPTR(regs), RNGSZ(regs), hw_res->irqs.irqs[0]);
 
@@ -160 +160 @@
             (void **) &instance->registers);
         if (ret != EOK) {
-                usb_log_error("Failed to gain access to registers: %s.\n",
+                usb_log_error("Failed to gain access to registers: %s.",
                     str_error(ret));
                 return ret;
         }
-        usb_log_debug("Device registers at %" PRIx64 " (%zuB) accessible.\n",
+        usb_log_debug("Device registers at %" PRIx64 " (%zuB) accessible.",
             hw_res->mem_ranges.ranges[0].address.absolute,
             hw_res->mem_ranges.ranges[0].size);
@@ -173 +173 @@
         ret = hc_init_memory(instance);
         if (ret != EOK) {
-                usb_log_error("Failed to create OHCI memory structures: %s.\n",
+                usb_log_error("Failed to create OHCI memory structures: %s.",
                     str_error(ret));
                 // TODO: We should disable pio access here
@@ -293 +293 @@
         /* Check for root hub communication */
         if (batch->target.address == ohci_rh_get_address(&hc->rh)) {
-                usb_log_debug("OHCI root hub request.\n");
+                usb_log_debug("OHCI root hub request.");
                 return ohci_rh_schedule(&hc->rh, batch);
         }
@@ -341 +341 @@
         if ((status & ~I_SF) == 0) /* ignore sof status */
                 return;
-        usb_log_debug2("OHCI(%p) interrupt: %x.\n", hc, status);
+        usb_log_debug2("OHCI(%p) interrupt: %x.", hc, status);
         if (status & I_RHSC)
                 ohci_rh_interrupt(&hc->rh);
@@ -347 +347 @@
         if (status & I_WDH) {
                 fibril_mutex_lock(&hc->guard);
-                usb_log_debug2("HCCA: %p-%#" PRIx32 " (%p).\n", hc->hcca,
+                usb_log_debug2("HCCA: %p-%#" PRIx32 " (%p).", hc->hcca,
                     OHCI_RD(hc->registers->hcca),
                     (void *) addr_to_phys(hc->hcca));
-                usb_log_debug2("Periodic current: %#" PRIx32 ".\n",
+                usb_log_debug2("Periodic current: %#" PRIx32 ".",
                     OHCI_RD(hc->registers->periodic_current));
 
@@ -370 +370 @@
 
         if (status & I_UE) {
-                usb_log_fatal("Error like no other!\n");
+                usb_log_fatal("Error like no other!");
                 hc_start(&hc->base);
         }
@@ -387 +387 @@
         hc_t *instance = hcd_to_hc(hcd);
 
-        usb_log_debug("Requesting OHCI control.\n");
+        usb_log_debug("Requesting OHCI control.");
         if (OHCI_RD(instance->registers->revision) & R_LEGACY_FLAG) {
                 /* Turn off legacy emulation, it should be enough to zero
@@ -396 +396 @@
                 volatile uint32_t *ohci_emulation_reg =
                 (uint32_t*)((char*)instance->registers + LEGACY_REGS_OFFSET);
-                usb_log_debug("OHCI legacy register %p: %x.\n",
+                usb_log_debug("OHCI legacy register %p: %x.",
                     ohci_emulation_reg, OHCI_RD(*ohci_emulation_reg));
                 /* Zero everything but A20State */
@@ -402 +402 @@
                 OHCI_CLR(*ohci_emulation_reg, ~0x100);
                 usb_log_debug(
-                    "OHCI legacy register (should be 0 or 0x100) %p: %x.\n",
+                    "OHCI legacy register (should be 0 or 0x100) %p: %x.",
                     ohci_emulation_reg, OHCI_RD(*ohci_emulation_reg));
         }
@@ -408 +408 @@
         /* Interrupt routing enabled => smm driver is active */
         if (OHCI_RD(instance->registers->control) & C_IR) {
-                usb_log_debug("SMM driver: request ownership change.\n");
+                usb_log_debug("SMM driver: request ownership change.");
                 // TODO: should we ack interrupts before doing this?
                 OHCI_SET(instance->registers->command_status, CS_OCR);
@@ -415 +415 @@
                         async_usleep(1000);
                 }
-                usb_log_info("SMM driver: Ownership taken.\n");
+                usb_log_info("SMM driver: Ownership taken.");
                 C_HCFS_SET(instance->registers->control, C_HCFS_RESET);
                 async_usleep(50000);
@@ -424 +424 @@
         /* Interrupt routing disabled && status != USB_RESET => BIOS active */
         if (hc_status != C_HCFS_RESET) {
-                usb_log_debug("BIOS driver found.\n");
+                usb_log_debug("BIOS driver found.");
                 if (hc_status == C_HCFS_OPERATIONAL) {
-                        usb_log_info("BIOS driver: HC operational.\n");
+                        usb_log_info("BIOS driver: HC operational.");
                         return EOK;
                 }
@@ -432 +432 @@
                 C_HCFS_SET(instance->registers->control, C_HCFS_RESUME);
                 async_usleep(20000);
-                usb_log_info("BIOS driver: HC resumed.\n");
+                usb_log_info("BIOS driver: HC resumed.");
                 return EOK;
         }
@@ -438 +438 @@
         /* HC is in reset (hw startup) => no other driver
          * maintain reset for at least the time specified in USB spec (50 ms)*/
-        usb_log_debug("Host controller found in reset state.\n");
+        usb_log_debug("Host controller found in reset state.");
         async_usleep(50000);
         return EOK;
@@ -454 +454 @@
         /* OHCI guide page 42 */
         assert(instance);
-        usb_log_debug2("Started hc initialization routine.\n");
+        usb_log_debug2("Started hc initialization routine.");
 
         /* Save contents of fm_interval register */
         const uint32_t fm_interval = OHCI_RD(instance->registers->fm_interval);
-        usb_log_debug2("Old value of HcFmInterval: %x.\n", fm_interval);
+        usb_log_debug2("Old value of HcFmInterval: %x.", fm_interval);
 
         /* Reset hc */
-        usb_log_debug2("HC reset.\n");
+        usb_log_debug2("HC reset.");
         size_t time = 0;
         OHCI_WR(instance->registers->command_status, CS_HCR);
@@ -468 +468 @@
                 time += 10;
         }
-        usb_log_debug2("HC reset complete in %zu us.\n", time);
+        usb_log_debug2("HC reset complete in %zu us.", time);
 
         /* Restore fm_interval */
@@ -475 +475 @@
 
         /* hc is now in suspend state */
-        usb_log_debug2("HC should be in suspend state(%x).\n",
+        usb_log_debug2("HC should be in suspend state(%x).",
             OHCI_RD(instance->registers->control));
 
@@ -484 +484 @@
         OHCI_WR(instance->registers->bulk_head,
             instance->lists[USB_TRANSFER_BULK].list_head_pa);
-        usb_log_debug2("Bulk HEAD set to: %p (%#" PRIx32 ").\n",
+        usb_log_debug2("Bulk HEAD set to: %p (%#" PRIx32 ").",
             instance->lists[USB_TRANSFER_BULK].list_head,
             instance->lists[USB_TRANSFER_BULK].list_head_pa);
@@ -490 +490 @@
         OHCI_WR(instance->registers->control_head,
             instance->lists[USB_TRANSFER_CONTROL].list_head_pa);
-        usb_log_debug2("Control HEAD set to: %p (%#" PRIx32 ").\n",
+        usb_log_debug2("Control HEAD set to: %p (%#" PRIx32 ").",
             instance->lists[USB_TRANSFER_CONTROL].list_head,
             instance->lists[USB_TRANSFER_CONTROL].list_head_pa);
@@ -496 +496 @@
         /* Enable queues */
         OHCI_SET(instance->registers->control, (C_PLE | C_IE | C_CLE | C_BLE));
-        usb_log_debug("Queues enabled(%x).\n",
+        usb_log_debug("Queues enabled(%x).",
             OHCI_RD(instance->registers->control));
 
@@ -503 +503 @@
                 OHCI_WR(instance->registers->interrupt_enable,
                     OHCI_USED_INTERRUPTS);
-                usb_log_debug("Enabled interrupts: %x.\n",
+                usb_log_debug("Enabled interrupts: %x.",
                     OHCI_RD(instance->registers->interrupt_enable));
                 OHCI_WR(instance->registers->interrupt_enable, I_MI);
@@ -513 +513 @@
         OHCI_WR(instance->registers->periodic_start,
             ((frame_length / 10) * 9) & PS_MASK << PS_SHIFT);
-        usb_log_debug2("All periodic start set to: %x(%u - 90%% of %d).\n",
+        usb_log_debug2("All periodic start set to: %x(%u - 90%% of %d).",
             OHCI_RD(instance->registers->periodic_start),
             OHCI_RD(instance->registers->periodic_start), frame_length);
         C_HCFS_SET(instance->registers->control, C_HCFS_OPERATIONAL);
-        usb_log_debug("OHCI HC up and running (ctl_reg=0x%x).\n",
+        usb_log_debug("OHCI HC up and running (ctl_reg=0x%x).",
             OHCI_RD(instance->registers->control));
 
@@ -536 +536 @@
         const int ret = endpoint_list_init(&instance->lists[type], name); \
         if (ret != EOK) { \
-                usb_log_error("Failed to setup %s endpoint list: %s.\n", \
+                usb_log_error("Failed to setup %s endpoint list: %s.", \
                     name, str_error(ret)); \
                 endpoint_list_fini(&instance->lists[USB_TRANSFER_ISOCHRONOUS]);\
@@ -577 +577 @@
         if (instance->hcca == NULL)
                 return ENOMEM;
-        usb_log_debug2("OHCI HCCA initialized at %p.\n", instance->hcca);
+        usb_log_debug2("OHCI HCCA initialized at %p.", instance->hcca);
 
         for (unsigned i = 0; i < HCCA_INT_EP_COUNT; ++i) {
@@ -583 +583 @@
                     instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa);
         }
-        usb_log_debug2("Interrupt HEADs set to: %p (%#" PRIx32 ").\n",
+        usb_log_debug2("Interrupt HEADs set to: %p (%#" PRIx32 ").",
             instance->lists[USB_TRANSFER_INTERRUPT].list_head,
             instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa);

uspace/drv/bus/usb/ohci/ohci_batch.c

@@ -175 +175 @@
         assert(ohci_batch);
 
-        usb_log_debug("Batch %p checking %zu td(s) for completion.\n",
+        usb_log_debug("Batch %p checking %zu td(s) for completion.",
             &ohci_batch->base, ohci_batch->td_count);
-        usb_log_debug2("ED: %08x:%08x:%08x:%08x.\n",
+        usb_log_debug2("ED: %08x:%08x:%08x:%08x.",
             ohci_batch->ed->status, ohci_batch->ed->td_head,
             ohci_batch->ed->td_tail, ohci_batch->ed->next);
@@ -196 +196 @@
         for (size_t i = 0; i < ohci_batch->td_count; ++i) {
                 assert(ohci_batch->tds[i] != NULL);
-                usb_log_debug("TD %zu: %08x:%08x:%08x:%08x.\n", i,
+                usb_log_debug("TD %zu: %08x:%08x:%08x:%08x.", i,
                     ohci_batch->tds[i]->status, ohci_batch->tds[i]->cbp,
                     ohci_batch->tds[i]->next, ohci_batch->tds[i]->be);
@@ -217 +217 @@
                             -= td_remain_size(ohci_batch->tds[i]);
                 } else {
-                        usb_log_debug("Batch %p found error TD(%zu):%08x.\n",
+                        usb_log_debug("Batch %p found error TD(%zu):%08x.",
                             &ohci_batch->base, i,
                             ohci_batch->tds[i]->status);
@@ -295 +295 @@
         assert(dir == USB_DIRECTION_IN || dir == USB_DIRECTION_OUT);
 
-        usb_log_debug("Using ED(%p): %08x:%08x:%08x:%08x.\n", ohci_batch->ed,
+        usb_log_debug("Using ED(%p): %08x:%08x:%08x:%08x.", ohci_batch->ed,
             ohci_batch->ed->status, ohci_batch->ed->td_tail,
             ohci_batch->ed->td_head, ohci_batch->ed->next);
@@ -312 +312 @@
             ohci_batch->tds[0], ohci_batch->tds[1], USB_DIRECTION_BOTH,
             buffer, USB_SETUP_PACKET_SIZE, toggle);
-        usb_log_debug("Created CONTROL SETUP TD: %08x:%08x:%08x:%08x.\n",
+        usb_log_debug("Created CONTROL SETUP TD: %08x:%08x:%08x:%08x.",
             ohci_batch->tds[0]->status, ohci_batch->tds[0]->cbp,
             ohci_batch->tds[0]->next, ohci_batch->tds[0]->be);
@@ -328 +328 @@
                     ohci_batch->tds[td_current + 1],
                     data_dir, buffer, transfer_size, toggle);
-                usb_log_debug("Created CONTROL DATA TD: %08x:%08x:%08x:%08x.\n",
+                usb_log_debug("Created CONTROL DATA TD: %08x:%08x:%08x:%08x.",
                     ohci_batch->tds[td_current]->status,
                     ohci_batch->tds[td_current]->cbp,
@@ -344 +344 @@
         td_init(ohci_batch->tds[td_current], ohci_batch->tds[td_current + 1],
             status_dir, NULL, 0, 1);
-        usb_log_debug("Created CONTROL STATUS TD: %08x:%08x:%08x:%08x.\n",
+        usb_log_debug("Created CONTROL STATUS TD: %08x:%08x:%08x:%08x.",
             ohci_batch->tds[td_current]->status,
             ohci_batch->tds[td_current]->cbp,
@@ -350 +350 @@
             ohci_batch->tds[td_current]->be);
         usb_log_debug2(
-            "Batch %p %s %s " USB_TRANSFER_BATCH_FMT " initialized.\n", \
+            "Batch %p %s %s " USB_TRANSFER_BATCH_FMT " initialized.", \
             &ohci_batch->base,
             usb_str_transfer_type(ohci_batch->base.ep->transfer_type),
@@ -371 +371 @@
         usb_direction_t dir = ohci_batch->base.dir;
         assert(dir == USB_DIRECTION_IN || dir == USB_DIRECTION_OUT);
-        usb_log_debug("Using ED(%p): %08x:%08x:%08x:%08x.\n", ohci_batch->ed,
+        usb_log_debug("Using ED(%p): %08x:%08x:%08x:%08x.", ohci_batch->ed,
             ohci_batch->ed->status, ohci_batch->ed->td_tail,
             ohci_batch->ed->td_head, ohci_batch->ed->next);
@@ -386 +386 @@
                     dir, buffer, transfer_size, -1);
 
-                usb_log_debug("Created DATA TD: %08x:%08x:%08x:%08x.\n",
+                usb_log_debug("Created DATA TD: %08x:%08x:%08x:%08x.",
                     ohci_batch->tds[td_current]->status,
                     ohci_batch->tds[td_current]->cbp,
@@ -398 +398 @@
         }
         usb_log_debug2(
-            "Batch %p %s %s " USB_TRANSFER_BATCH_FMT " initialized.\n", \
+            "Batch %p %s %s " USB_TRANSFER_BATCH_FMT " initialized.", \
             &ohci_batch->base,
             usb_str_transfer_type(ohci_batch->base.ep->transfer_type),

uspace/drv/bus/usb/ohci/ohci_rh.c

@@ -114 +114 @@
         instance->registers = regs;
         instance->port_count = OHCI_RD(regs->rh_desc_a) & RHDA_NDS_MASK;
-        usb_log_debug2("rh_desc_a: %x.\n", OHCI_RD(regs->rh_desc_a));
+        usb_log_debug2("rh_desc_a: %x.", OHCI_RD(regs->rh_desc_a));
         if (instance->port_count > OHCI_MAX_PORTS) {
                 usb_log_warning("OHCI specification does not allow %d ports. "
-                    "Max %d ports will be used.\n", instance->port_count,
+                    "Max %d ports will be used.", instance->port_count,
                     OHCI_MAX_PORTS);
                 instance->port_count = OHCI_MAX_PORTS;
         }
-        usb_log_info("%s: Found %u ports.\n", name, instance->port_count);
+        usb_log_info("%s: Found %u ports.", name, instance->port_count);
 
 #if defined OHCI_POWER_SWITCH_no
-        usb_log_info("%s: Set power mode to no power switching.\n", name);
+        usb_log_info("%s: Set power mode to no power switching.", name);
         /* Set port power mode to no power-switching. (always on) */
         OHCI_SET(regs->rh_desc_a, RHDA_NPS_FLAG);
@@ -132 +132 @@
 
 #elif defined OHCI_POWER_SWITCH_ganged
-        usb_log_info("%s: Set power mode to ganged power switching.\n", name);
+        usb_log_info("%s: Set power mode to ganged power switching.", name);
         /* Set port power mode to ganged power-switching. */
         OHCI_CLR(regs->rh_desc_a, RHDA_NPS_FLAG);
@@ -144 +144 @@
         OHCI_CLR(regs->rh_desc_a, RHDA_OCPM_FLAG);
 #else
-        usb_log_info("%s: Set power mode to per-port power switching.\n", name);
+        usb_log_info("%s: Set power mode to per-port power switching.", name);
         /* Set port power mode to per port power-switching. */
         OHCI_CLR(regs->rh_desc_a, RHDA_NPS_FLAG);
@@ -356 +356 @@
         case USB_HUB_FEATURE_C_PORT_RESET:        /*20*/
                 usb_log_debug2("Clearing port C_CONNECTION, C_ENABLE, "
-                    "C_SUSPEND, C_OC or C_RESET on port %u.\n", port);
+                    "C_SUSPEND, C_OC or C_RESET on port %u.", port);
                 /* Bit offsets correspond to the feature number */
                 OHCI_WR(hub->registers->rh_port_status[port],
@@ -405 +405 @@
         case USB_HUB_FEATURE_PORT_RESET:   /*4*/
                 usb_log_debug2("Setting port POWER, ENABLE, SUSPEND or RESET "
-                    "on port %u.\n", port);
+                    "on port %u.", port);
                 /* Bit offsets correspond to the feature number */
                 OHCI_WR(hub->registers->rh_port_status[port], 1 << feature);
@@ -451 +451 @@
         }
 
-        usb_log_debug2("OHCI root hub interrupt mask: %hx.\n", mask);
+        usb_log_debug2("OHCI root hub interrupt mask: %hx.", mask);
 
         if (mask == 0)

uspace/drv/bus/usb/uhci/hc.c

@@ -141 +141 @@
         code->cmds[3].addr = (void*)&registers->usbsts;
 
-        usb_log_debug("I/O regs at %p (size %zu), IRQ %d.\n",
+        usb_log_debug("I/O regs at %p (size %zu), IRQ %d.",
             RNGABSPTR(regs), RNGSZ(regs), hw_res->irqs.irqs[0]);
 
@@ -182 +182 @@
         /* Resume interrupts are not supported */
         if (status & UHCI_STATUS_RESUME) {
-                usb_log_error("Resume interrupt!\n");
+                usb_log_error("Resume interrupt!");
         }
 
         /* Bits 4 and 5 indicate hc error */
         if (status & (UHCI_STATUS_PROCESS_ERROR | UHCI_STATUS_SYSTEM_ERROR)) {
-                usb_log_error("UHCI hardware failure!.\n");
+                usb_log_error("UHCI hardware failure!.");
                 ++instance->hw_failures;
                 transfer_list_abort_all(&instance->transfers_interrupt);
@@ -198 +198 @@
                         hc_init_hw(instance);
                 } else {
-                        usb_log_fatal("Too many UHCI hardware failures!.\n");
+                        usb_log_fatal("Too many UHCI hardware failures!.");
                         hc_gone(&instance->base);
                 }
@@ -229 +229 @@
             (void **) &instance->registers);
         if (ret != EOK) {
-                usb_log_error("Failed to gain access to registers: %s.\n",
+                usb_log_error("Failed to gain access to registers: %s.",
                     str_error(ret));
                 return ret;
         }
 
-        usb_log_debug("Device registers at %" PRIx64 " (%zuB) accessible.\n",
+        usb_log_debug("Device registers at %" PRIx64 " (%zuB) accessible.",
             hw_res->io_ranges.ranges[0].address.absolute,
             hw_res->io_ranges.ranges[0].size);
@@ -240 +240 @@
         ret = hc_init_mem_structures(instance, hcd);
         if (ret != EOK) {
-                usb_log_error("Failed to init UHCI memory structures: %s.\n",
+                usb_log_error("Failed to init UHCI memory structures: %s.",
                     str_error(ret));
                 // TODO: we should disable pio here
@@ -304 +304 @@
         const uint16_t cmd = pio_read_16(&registers->usbcmd);
         if (cmd != 0)
-                usb_log_warning("Previous command value: %x.\n", cmd);
+                usb_log_warning("Previous command value: %x.", cmd);
 
         /* Start the hc with large(64B) packet FSBR */
@@ -399 +399 @@
                 return ENOMEM;
         }
-        usb_log_debug("Initialized frame list at %p.\n", instance->frame_list);
+        usb_log_debug("Initialized frame list at %p.", instance->frame_list);
 
         /* Init transfer lists */
         int ret = hc_init_transfer_lists(instance);
         if (ret != EOK) {
-                usb_log_error("Failed to initialize transfer lists.\n");
+                usb_log_error("Failed to initialize transfer lists.");
                 return_page(instance->frame_list);
                 return ENOMEM;
         }
-        usb_log_debug("Initialized transfer lists.\n");
+        usb_log_debug("Initialized transfer lists.");
 
 
@@ -438 +438 @@
         int ret = transfer_list_init(&instance->transfers_##type, name); \
         if (ret != EOK) { \
-                usb_log_error("Failed to setup %s transfer list: %s.\n", \
+                usb_log_error("Failed to setup %s transfer list: %s.", \
                     name, str_error(ret)); \
                 transfer_list_fini(&instance->transfers_bulk_full); \
@@ -552 +552 @@
 
                 if (((cmd & UHCI_CMD_RUN_STOP) != 1) || (sts != 0)) {
-                        usb_log_debug2("Command: %X Status: %X Intr: %x\n",
+                        usb_log_debug2("Command: %X Status: %X Intr: %x",
                             cmd, sts, intr);
                 }
@@ -559 +559 @@
                     pio_read_32(&instance->registers->flbaseadd) & ~0xfff;
                 if (frame_list != addr_to_phys(instance->frame_list)) {
-                        usb_log_debug("Framelist address: %p vs. %p.\n",
+                        usb_log_debug("Framelist address: %p vs. %p.",
                             (void *) frame_list,
                             (void *) addr_to_phys(instance->frame_list));
@@ -570 +570 @@
                 uintptr_t real_pa = addr_to_phys(QH(interrupt));
                 if (expected_pa != real_pa) {
-                        usb_log_debug("Interrupt QH: %p (frame %d) vs. %p.\n",
+                        usb_log_debug("Interrupt QH: %p (frame %d) vs. %p.",
                             (void *) expected_pa, frnum, (void *) real_pa);
                 }
@@ -577 +577 @@
                 real_pa = addr_to_phys(QH(control_slow));
                 if (expected_pa != real_pa) {
-                        usb_log_debug("Control Slow QH: %p vs. %p.\n",
+                        usb_log_debug("Control Slow QH: %p vs. %p.",
                             (void *) expected_pa, (void *) real_pa);
                 }
@@ -584 +584 @@
                 real_pa = addr_to_phys(QH(control_full));
                 if (expected_pa != real_pa) {
-                        usb_log_debug("Control Full QH: %p vs. %p.\n",
+                        usb_log_debug("Control Full QH: %p vs. %p.",
                             (void *) expected_pa, (void *) real_pa);
                 }
@@ -591 +591 @@
                 real_pa = addr_to_phys(QH(bulk_full));
                 if (expected_pa != real_pa ) {
-                        usb_log_debug("Bulk QH: %p vs. %p.\n",
+                        usb_log_debug("Bulk QH: %p vs. %p.",
                             (void *) expected_pa, (void *) real_pa);
                 }

uspace/drv/bus/usb/uhci/hw_struct/transfer_descriptor.c

@@ -104 +104 @@
         instance->buffer_ptr = addr_to_phys(buffer);
 
-        usb_log_debug2("Created TD(%p): %X:%X:%X:%X(%p).\n",
+        usb_log_debug2("Created TD(%p): %X:%X:%X:%X(%p).",
             instance, instance->next, instance->status, instance->device,
             instance->buffer_ptr, buffer);
         td_print_status(instance);
         if (pid == USB_PID_SETUP) {
-                usb_log_debug2("SETUP BUFFER: %s\n",
+                usb_log_debug2("SETUP BUFFER: %s",
                     usb_debug_str_buffer(buffer, 8, 8));
         }
@@ -160 +160 @@
         assert(instance);
         const uint32_t s = instance->status;
-        usb_log_debug2("TD(%p) status(%#" PRIx32 "):%s %d,%s%s%s%s%s%s%s%s%s%s%s %zu.\n",
+        usb_log_debug2("TD(%p) status(%#" PRIx32 "):%s %d,%s%s%s%s%s%s%s%s%s%s%s %zu.",
             instance, instance->status,
             (s & TD_STATUS_SPD_FLAG) ? " SPD," : "",

uspace/drv/bus/usb/uhci/transfer_list.c

@@ -59 +59 @@
         instance->queue_head = malloc32(sizeof(qh_t));
         if (!instance->queue_head) {
-                usb_log_error("Failed to allocate queue head.\n");
+                usb_log_error("Failed to allocate queue head.");
                 return ENOMEM;
         }
         const uint32_t queue_head_pa = addr_to_phys(instance->queue_head);
-        usb_log_debug2("Transfer list %s setup with QH: %p (%#" PRIx32" ).\n",
+        usb_log_debug2("Transfer list %s setup with QH: %p (%#" PRIx32" ).",
             name, instance->queue_head, queue_head_pa);
 
@@ -120 +120 @@
         fibril_mutex_unlock(&ep->guard);
 
-        usb_log_debug2("Batch %p adding to queue %s.\n",
+        usb_log_debug2("Batch %p adding to queue %s.",
             uhci_batch, instance->name);
 
@@ -150 +150 @@
 
         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT
-            " scheduled in queue %s.\n", uhci_batch,
+            " scheduled in queue %s.", uhci_batch,
             USB_TRANSFER_BATCH_ARGS(uhci_batch->base), instance->name);
         fibril_mutex_unlock(&instance->guard);
@@ -213 +213 @@
         assert(fibril_mutex_is_locked(&instance->guard));
 
-        usb_log_debug2("Batch %p removing from queue %s.\n",
+        usb_log_debug2("Batch %p removing from queue %s.",
             uhci_batch, instance->name);
 
@@ -236 +236 @@
         list_remove(&uhci_batch->link);
         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " removed (%s) "
-            "from %s, next: %x.\n", uhci_batch,
+            "from %s, next: %x.", uhci_batch,
             USB_TRANSFER_BATCH_ARGS(uhci_batch->base),
             qpos, instance->name, uhci_batch->qh->next);

uspace/drv/bus/usb/uhci/uhci_batch.c

@@ -75 +75 @@
             calloc(1, sizeof(uhci_transfer_batch_t));
         if (!uhci_batch) {
-                usb_log_error("Failed to allocate UHCI batch.\n");
+                usb_log_error("Failed to allocate UHCI batch.");
                 return NULL;
         }
@@ -112 +112 @@
         uhci_batch->device_buffer = malloc32(total_size);
         if (!uhci_batch->device_buffer) {
-                usb_log_error("Failed to allocate UHCI buffer.\n");
+                usb_log_error("Failed to allocate UHCI buffer.");
                 return ENOMEM;
         }
@@ -135 +135 @@
         }
         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT
-            " memory structures ready.\n", usb_batch,
+            " memory structures ready.", usb_batch,
             USB_TRANSFER_BATCH_ARGS(*usb_batch));
 
@@ -159 +159 @@
 
         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT
-            " checking %zu transfer(s) for completion.\n",
+            " checking %zu transfer(s) for completion.",
             uhci_batch, USB_TRANSFER_BATCH_ARGS(*batch),
             uhci_batch->td_count);
@@ -174 +174 @@
 
                         usb_log_debug("Batch %p found error TD(%zu->%p):%"
-                            PRIx32 ".\n", uhci_batch, i,
+                            PRIx32 ".", uhci_batch, i,
                             &uhci_batch->tds[i], uhci_batch->tds[i].status);
                         td_print_status(&uhci_batch->tds[i]);
@@ -260 +260 @@
         uhci_batch->base.ep->toggle = toggle;
         usb_log_debug2(
-            "Batch %p %s %s " USB_TRANSFER_BATCH_FMT " initialized.\n", \
+            "Batch %p %s %s " USB_TRANSFER_BATCH_FMT " initialized.", \
             uhci_batch,
             usb_str_transfer_type(uhci_batch->base.ep->transfer_type),
@@ -333 +333 @@
         td_set_ioc(&uhci_batch->tds[td]);
 
-        usb_log_debug2("Control last TD status: %x.\n",
+        usb_log_debug2("Control last TD status: %x.",
             uhci_batch->tds[td].status);
 }

uspace/drv/bus/usb/uhci/uhci_rh.c

@@ -202 +202 @@
         data[0] = ((value & STATUS_LINE_D_MINUS) ? 1 : 0)
             | ((value & STATUS_LINE_D_PLUS) ? 2 : 0);
-        RH_DEBUG(hub, port, "Bus state %" PRIx8 "(source %" PRIx16")\n",
+        RH_DEBUG(hub, port, "Bus state %" PRIx8 "(source %" PRIx16")",
             data[0], value);
         *act_size = 1;
@@ -248 +248 @@
         );
         RH_DEBUG(hub, port, "Port status %" PRIx32 " (source %" PRIx16
-            "%s)\n", uint32_usb2host(status), val,
+            "%s)", uint32_usb2host(status), val,
             hub->reset_changed[port] ? "-reset" : "");
         memcpy(data, &status, sizeof(status));
@@ -276 +276 @@
         case USB_HUB_FEATURE_PORT_ENABLE:
                 RH_DEBUG(hub, port, "Clear port enable (status %"
-                    PRIx16 ")\n", status);
+                    PRIx16 ")", status);
                 pio_write_16(hub->ports[port], val & ~STATUS_ENABLED);
                 break;
         case USB_HUB_FEATURE_PORT_SUSPEND:
                 RH_DEBUG(hub, port, "Clear port suspend (status %"
-                    PRIx16 ")\n", status);
+                    PRIx16 ")", status);
                 pio_write_16(hub->ports[port], val & ~STATUS_SUSPEND);
                 // TODO we should do resume magic
-                usb_log_warning("Resume is not implemented on port %u\n", port);
+                usb_log_warning("Resume is not implemented on port %u", port);
                 break;
         case USB_HUB_FEATURE_PORT_POWER:
-                RH_DEBUG(hub, port, "Clear port power (status %" PRIx16 ")\n",
+                RH_DEBUG(hub, port, "Clear port power (status %" PRIx16 ")",
                     status);
                 /* We are always powered */
-                usb_log_warning("Tried to power off port %u\n", port);
+                usb_log_warning("Tried to power off port %u", port);
                 break;
         case USB_HUB_FEATURE_C_PORT_CONNECTION:
                 RH_DEBUG(hub, port, "Clear port conn change (status %"
-                    PRIx16 ")\n", status);
+                    PRIx16 ")", status);
                 pio_write_16(hub->ports[port], val | STATUS_CONNECTED_CHANGED);
                 break;
         case USB_HUB_FEATURE_C_PORT_RESET:
                 RH_DEBUG(hub, port, "Clear port reset change (status %"
-                    PRIx16 ")\n", status);
+                    PRIx16 ")", status);
                 hub->reset_changed[port] = false;
                 break;
         case USB_HUB_FEATURE_C_PORT_ENABLE:
                 RH_DEBUG(hub, port, "Clear port enable change (status %"
-                    PRIx16 ")\n", status);
+                    PRIx16 ")", status);
                 pio_write_16(hub->ports[port], status | STATUS_ENABLED_CHANGED);
                 break;
         case USB_HUB_FEATURE_C_PORT_SUSPEND:
                 RH_DEBUG(hub, port, "Clear port suspend change (status %"
-                    PRIx16 ")\n", status);
+                    PRIx16 ")", status);
                 //TODO
                 return ENOTSUP;
         case USB_HUB_FEATURE_C_PORT_OVER_CURRENT:
                 RH_DEBUG(hub, port, "Clear port OC change (status %"
-                    PRIx16 ")\n", status);
+                    PRIx16 ")", status);
                 /* UHCI Does not report over current */
                 //TODO: newer chips do, but some have broken wiring
@@ -320 +320 @@
         default:
                 RH_DEBUG(hub, port, "Clear unknown feature %d (status %"
-                    PRIx16 ")\n", feature, status);
-                usb_log_warning("Clearing feature %d is unsupported\n",
+                    PRIx16 ")", feature, status);
+                usb_log_warning("Clearing feature %d is unsupported",
                     feature);
                 return ESTALL;
@@ -348 +348 @@
         case USB_HUB_FEATURE_PORT_RESET:
                 RH_DEBUG(hub, port, "Set port reset before (status %" PRIx16
-                    ")\n", status);
+                    ")", status);
                 uhci_port_reset_enable(hub->ports[port]);
                 hub->reset_changed[port] = true;
                 RH_DEBUG(hub, port, "Set port reset after (status %" PRIx16
-                    ")\n", pio_read_16(hub->ports[port]));
+                    ")", pio_read_16(hub->ports[port]));
                 break;
         case USB_HUB_FEATURE_PORT_SUSPEND:
                 RH_DEBUG(hub, port, "Set port suspend (status %" PRIx16
-                    ")\n", status);
+                    ")", status);
                 pio_write_16(hub->ports[port],
                     (status & ~STATUS_WC_BITS) | STATUS_SUSPEND);
-                usb_log_warning("Suspend is not implemented on port %u\n", port);
+                usb_log_warning("Suspend is not implemented on port %u", port);
                 break;
         case USB_HUB_FEATURE_PORT_POWER:
                 RH_DEBUG(hub, port, "Set port power (status %" PRIx16
-                    ")\n", status);
+                    ")", status);
                 /* We are always powered */
-                usb_log_warning("Tried to power port %u\n", port);
+                usb_log_warning("Tried to power port %u", port);
                 break;
         case USB_HUB_FEATURE_C_PORT_CONNECTION:
@@ -372 +372 @@
         case USB_HUB_FEATURE_C_PORT_OVER_CURRENT:
                 RH_DEBUG(hub, port, "Set port change flag (status %" PRIx16
-                    ")\n", status);
+                    ")", status);
                 /* These are voluntary and don't have to be set
                  * there is no way we could do it on UHCI anyway */
@@ -378 +378 @@
         default:
                 RH_DEBUG(hub, port, "Set unknown feature %d (status %" PRIx16
-                    ")\n", feature, status);
-                usb_log_warning("Setting feature %d is unsupported\n",
+                    ")", feature, status);
+                usb_log_warning("Setting feature %d is unsupported",
                     feature);
                 return ESTALL;
@@ -418 +418 @@
                 RH_DEBUG(hub, -1, "Event mask %" PRIx8
                     " (status_a %" PRIx16 "%s),"
-                    " (status_b %" PRIx16 "%s)\n", status,
+                    " (status_b %" PRIx16 "%s)", status,
                     status_a, hub->reset_changed[0] ? "-reset" : "",
                     status_b, hub->reset_changed[1] ? "-reset" : "" );

uspace/drv/bus/usb/usbdiag/device.c

@@ -79 +79 @@
         usb_endpoint_mapping_t *epm = usb_device_get_mapped_ep(dev->usb_dev, USBDIAG_EP_##ep_no);\
         if (!epm || !epm->present) {\
-                usb_log_error("Failed to map endpoint: " #ep_no ".\n");\
+                usb_log_error("Failed to map endpoint: " #ep_no ".");\
                 rc = ENOENT;\
                 goto err_fun;\

uspace/drv/bus/usb/usbdiag/main.c

@@ -52 +52 @@
         usbdiag_dev_t *diag_dev;
         if ((rc = usbdiag_dev_create(dev, &diag_dev))) {
-                usb_log_error("Failed create device: %s.\n", str_error(rc));
+                usb_log_error("Failed create device: %s.", str_error(rc));
                 goto err;
         }
 
         if ((rc = ddf_fun_bind(diag_dev->fun))) {
-                usb_log_error("Failed to bind DDF function: %s.\n", str_error(rc));
+                usb_log_error("Failed to bind DDF function: %s.", str_error(rc));
                 goto err_create;
         }
@@ -96 +96 @@
 
         if ((rc = ddf_fun_unbind(diag_dev->fun))) {
-                usb_log_error("Failed to unbind DDF function: %s\n", str_error(rc));
+                usb_log_error("Failed to unbind DDF function: %s", str_error(rc));
                 goto err;
         }
@@ -117 +117 @@
 
         if ((rc = ddf_fun_unbind(diag_dev->fun))) {
-                usb_log_error("Failed to unbind DDF function: %s\n", str_error(rc));
+                usb_log_error("Failed to unbind DDF function: %s", str_error(rc));
                 goto err;
         }

uspace/drv/bus/usb/usbdiag/tests.c

@@ -68 +68 @@
                 while (remaining > 0) {
                         if ((rc = usb_pipe_read(pipe, buffer + size - remaining, remaining, &transferred))) {
-                                usb_log_error("Read of %s IN endpoint failed with error: %s\n", usb_str_transfer_type(pipe->desc.transfer_type), str_error(rc));
+                                usb_log_error("Read of %s IN endpoint failed with error: %s", usb_str_transfer_type(pipe->desc.transfer_type), str_error(rc));
                                 break;
                         }
 
                         if (transferred > remaining) {
-                                usb_log_error("Read of %s IN endpoint returned more data than expected.\n", usb_str_transfer_type(pipe->desc.transfer_type));
+                                usb_log_error("Read of %s IN endpoint returned more data than expected.", usb_str_transfer_type(pipe->desc.transfer_type));
                                 rc = EINVAL;
                                 break;
@@ -121 +121 @@
                 // Write buffer to device.
                 if ((rc = usb_pipe_write(pipe, buffer, size))) {
-                        usb_log_error("Write to %s OUT endpoint failed with error: %s\n", usb_str_transfer_type(pipe->desc.transfer_type), str_error(rc));
+                        usb_log_error("Write to %s OUT endpoint failed with error: %s", usb_str_transfer_type(pipe->desc.transfer_type), str_error(rc));
                         break;
                 }
@@ -169 +169 @@
                 while (remaining > 0) {
                         if ((rc = usb_pipe_read(pipe, buffer + size - remaining, remaining, &transferred))) {
-                                usb_log_error("Read of %s IN endpoint failed with error: %s\n", usb_str_transfer_type(pipe->desc.transfer_type), str_error(rc));
+                                usb_log_error("Read of %s IN endpoint failed with error: %s", usb_str_transfer_type(pipe->desc.transfer_type), str_error(rc));
                                 break;
                         }
 
                         if (transferred > remaining) {
-                                usb_log_error("Read of %s IN endpoint returned more data than expected.\n", usb_str_transfer_type(pipe->desc.transfer_type));
+                                usb_log_error("Read of %s IN endpoint returned more data than expected.", usb_str_transfer_type(pipe->desc.transfer_type));
                                 rc = EINVAL;
                                 break;
@@ -187 +187 @@
                 for (size_t i = 0; i < size; i += sizeof(test_data)) {
                         if (*(uint32_t *)(buffer + i) != test_data) {
-                                usb_log_error("Read of %s IN endpoint returned invald data at address %lu.\n", usb_str_transfer_type(pipe->desc.transfer_type), i);
+                                usb_log_error("Read of %s IN endpoint returned invald data at address %lu.", usb_str_transfer_type(pipe->desc.transfer_type), i);
                                 rc = EINVAL;
                                 break;
@@ -238 +238 @@
                 // Write buffer to device.
                 if ((rc = usb_pipe_write(pipe, buffer, size))) {
-                        usb_log_error("Write to %s OUT endpoint failed with error: %s\n", usb_str_transfer_type(pipe->desc.transfer_type), str_error(rc));
+                        usb_log_error("Write to %s OUT endpoint failed with error: %s", usb_str_transfer_type(pipe->desc.transfer_type), str_error(rc));
                         break;
                 }

uspace/drv/bus/usb/usbflbk/main.c

@@ -48 +48 @@
 static int usbfallback_device_add(usb_device_t *dev)
 {
-        usb_log_info("Pretending to control %s `%s'.\n",
+        usb_log_info("Pretending to control %s `%s'.",
             usb_device_get_iface_number(dev) < 0 ? "device" : "interface",
             usb_device_get_name(dev));

uspace/drv/bus/usb/usbhub/port.c

@@ -141 +141 @@
         assert(port);
         assert(hub);
-        usb_log_debug2("(%p-%u): Interrupt.\n", hub, port->port_number);
+        usb_log_debug2("(%p-%u): Interrupt.", hub, port->port_number);
 
         usb_port_status_t status = 0;
         const int opResult = get_port_status(port, &status);
         if (opResult != EOK) {
-                usb_log_error("(%p-%u): Failed to get port status: %s.\n", hub,
+                usb_log_error("(%p-%u): Failed to get port status: %s.", hub,
                     port->port_number, str_error(opResult));
                 return;
@@ -155 +155 @@
                 const bool connected =
                     (status & USB_HUB_PORT_STATUS_CONNECTION) != 0;
-                usb_log_debug("(%p-%u): Connection change: device %s.\n", hub,
+                usb_log_debug("(%p-%u): Connection change: device %s.", hub,
                     port->port_number, connected ? "attached" : "removed");
 
@@ -189 +189 @@
         if (status & USB_HUB_PORT_C_STATUS_ENABLED) {
                 // TODO: maybe HS reset failed?
-                usb_log_info("(%p-%u): Port disabled because of errors.\n", hub,
+                usb_log_info("(%p-%u): Port disabled because of errors.", hub,
                    port->port_number);
                 usb_hub_port_device_gone(port, hub);
@@ -294 +294 @@
         if (enabled) {
                 port->reset_status = RESET_OK;
-                usb_log_debug("(%p-%u): Port reset complete.\n", hub,
+                usb_log_debug("(%p-%u): Port reset complete.", hub,
                     port->port_number);
         } else {

uspace/drv/bus/usb/usbhub/usbhub.c

@@ -117 +117 @@
             usb_device_data_alloc(usb_dev, sizeof(usb_hub_dev_t));
         if (hub_dev == NULL) {
-                usb_log_error("Failed to create hub driver structure.\n");
+                usb_log_error("Failed to create hub driver structure.");
                 return ENOMEM;
         }
@@ -129 +129 @@
         int opResult = usb_set_first_configuration(usb_dev);
         if (opResult != EOK) {
-                usb_log_error("Could not set hub configuration: %s\n",
+                usb_log_error("Could not set hub configuration: %s",
                     str_error(opResult));
                 return opResult;
@@ -137 +137 @@
         opResult = usb_hub_process_hub_specific_info(hub_dev);
         if (opResult != EOK) {
-                usb_log_error("Could process hub specific info, %s\n",
+                usb_log_error("Could process hub specific info, %s",
                     str_error(opResult));
                 return opResult;
@@ -143 +143 @@
 
         /* Create hub control function. */
-        usb_log_debug("Creating DDF function '" HUB_FNC_NAME "'.\n");
+        usb_log_debug("Creating DDF function '" HUB_FNC_NAME "'.");
         hub_dev->hub_fun = usb_device_ddf_fun_create(hub_dev->usb_device,
             fun_exposed, HUB_FNC_NAME);
         if (hub_dev->hub_fun == NULL) {
-                usb_log_error("Failed to create hub function.\n");
+                usb_log_error("Failed to create hub function.");
                 return ENOMEM;
         }
@@ -154 +154 @@
         opResult = ddf_fun_bind(hub_dev->hub_fun);
         if (opResult != EOK) {
-                usb_log_error("Failed to bind hub function: %s.\n",
+                usb_log_error("Failed to bind hub function: %s.",
                    str_error(opResult));
                 ddf_fun_destroy(hub_dev->hub_fun);
@@ -167 +167 @@
                 ddf_fun_unbind(hub_dev->hub_fun);
                 ddf_fun_destroy(hub_dev->hub_fun);
-                usb_log_error("Failed to initialize polling fibril: %s.\n",
+                usb_log_error("Failed to initialize polling fibril: %s.",
                     str_error(opResult));
                 return opResult;
@@ -189 +189 @@
                 ddf_fun_unbind(hub_dev->hub_fun);
                 ddf_fun_destroy(hub_dev->hub_fun);
-                usb_log_error("Failed to create polling fibril: %s.\n",
+                usb_log_error("Failed to create polling fibril: %s.",
                     str_error(opResult));
                 return opResult;
@@ -195 +195 @@
 
         hub_dev->running = true;
-        usb_log_info("Controlling hub '%s' (%p: %zu ports).\n",
+        usb_log_info("Controlling hub '%s' (%p: %zu ports).",
             usb_device_get_name(hub_dev->usb_device), hub_dev,
             hub_dev->port_count);
@@ -335 +335 @@
             sizeof(usb_hub_descriptor_header_t), &received_size);
         if (opResult != EOK) {
-                usb_log_error("(%p): Failed to receive hub descriptor: %s.\n",
+                usb_log_error("(%p): Failed to receive hub descriptor: %s.",
                     hub_dev, str_error(opResult));
                 return opResult;
         }
 
-        usb_log_debug("(%p): Setting port count to %d.\n", hub_dev,
+        usb_log_debug("(%p): Setting port count to %d.", hub_dev,
             descriptor.port_count);
         hub_dev->port_count = descriptor.port_count;
@@ -365 +365 @@
         }
 
-        usb_log_info("(%p): Hub port power switching enabled (%s).\n", hub_dev,
+        usb_log_info("(%p): Hub port power switching enabled (%s).", hub_dev,
             hub_dev->per_port_power ? "per port" : "ganged");
 
@@ -374 +374 @@
 
                 if (ret != EOK) {
-                        usb_log_error("(%p-%u): Cannot power on port: %s.\n",
+                        usb_log_error("(%p-%u): Cannot power on port: %s.",
                             hub_dev, hub_dev->ports[port].port_number,
                             str_error(ret));
@@ -402 +402 @@
         const size_t configuration_count =
             usb_device_descriptors(usb_device)->device.configuration_count;
-        usb_log_debug("Hub has %zu configurations.\n", configuration_count);
+        usb_log_debug("Hub has %zu configurations.", configuration_count);
 
         if (configuration_count < 1) {
-                usb_log_error("There are no configurations available\n");
+                usb_log_error("There are no configurations available");
                 return EINVAL;
         }
@@ -426 +426 @@
             config_descriptor->configuration_number);
         if (opResult != EOK) {
-                usb_log_error("Failed to set hub configuration: %s.\n",
+                usb_log_error("Failed to set hub configuration: %s.",
                     str_error(opResult));
         } else {
-                usb_log_debug("\tUsed configuration %d\n",
+                usb_log_debug("\tUsed configuration %d",
                     config_descriptor->configuration_number);
         }

uspace/drv/bus/usb/usbmid/dump.c

@@ -56 +56 @@
                 usb_standard_interface_descriptor_t *descriptor
                     = (usb_standard_interface_descriptor_t *) data;
-                usb_log_info("Found interface: %s (0x%02x/0x%02x/0x%02x).\n",
+                usb_log_info("Found interface: %s (0x%02x/0x%02x/0x%02x).",
                     usb_str_class(descriptor->interface_class),
                     (int) descriptor->interface_class,

uspace/drv/bus/usb/usbmid/explore.c

@@ -106 +106 @@
 
 
-                usb_log_info("Creating child for interface %d (%s).\n",
+                usb_log_info("Creating child for interface %d (%s).",
                     interface->interface_number,
                     usb_str_class(interface->interface_class));
@@ -144 +144 @@
                     dev_class, usb_str_class(dev_class),
                     USB_CLASS_USE_INTERFACE);
-                usb_log_error("Not a multi-interface device, refusing.\n");
+                usb_log_error("Not a multi-interface device, refusing.");
                 return ENOTSUP;
         }
@@ -160 +160 @@
             config_descriptor->configuration_number);
         if (rc != EOK) {
-                usb_log_error("Failed to set device configuration: %s.\n",
+                usb_log_error("Failed to set device configuration: %s.",
                     str_error(rc));
                 return rc;
@@ -168 +168 @@
         usb_mid_t *usb_mid = usb_device_data_alloc(dev, sizeof(usb_mid_t));
         if (!usb_mid) {
-                usb_log_error("Failed to create USB MID structure.\n");
+                usb_log_error("Failed to create USB MID structure.");
                 return ENOMEM;
         }
@@ -175 +175 @@
         usb_mid->ctl_fun = usb_device_ddf_fun_create(dev, fun_exposed, "ctl");
         if (usb_mid->ctl_fun == NULL) {
-                usb_log_error("Failed to create control function.\n");
+                usb_log_error("Failed to create control function.");
                 return ENOMEM;
         }
@@ -182 +182 @@
         rc = ddf_fun_bind(usb_mid->ctl_fun);
         if (rc != EOK) {
-                usb_log_error("Failed to bind control function: %s.\n",
+                usb_log_error("Failed to bind control function: %s.",
                     str_error(rc));
                 ddf_fun_destroy(usb_mid->ctl_fun);

uspace/drv/bus/usb/usbmid/main.c

@@ -51 +51 @@
 static int usbmid_device_add(usb_device_t *dev)
 {
-        usb_log_info("Taking care of new MID `%s'.\n", usb_device_get_name(dev));
+        usb_log_info("Taking care of new MID `%s'.", usb_device_get_name(dev));
 
         return usbmid_explore_device(dev);
@@ -68 +68 @@
                 const int pret = usbmid_interface_destroy(iface);
                 if (pret != EOK) {
-                        usb_log_error("Failed to remove child `%s': %s\n",
+                        usb_log_error("Failed to remove child `%s': %s",
                             ddf_fun_get_name(iface->fun), str_error(pret));
                         ret = pret;
@@ -91 +91 @@
         int ret = ddf_fun_unbind(usb_mid->ctl_fun);
         if (ret != EOK) {
-                usb_log_error("Failed to unbind USB MID ctl function: %s.\n",
+                usb_log_error("Failed to unbind USB MID ctl function: %s.",
                     str_error(ret));
                 return ret;
@@ -99 +99 @@
         /* Remove all children */
         list_foreach(usb_mid->interface_list, link, usbmid_interface_t, iface) {
-                usb_log_info("Removing child `%s'.\n",
+                usb_log_info("Removing child `%s'.",
                     ddf_fun_get_name(iface->fun));
 
@@ -105 +105 @@
                 int pret = ddf_fun_offline(iface->fun);
                 if (pret != EOK) {
-                        usb_log_warning("Failed to turn off child `%s': %s\n",
+                        usb_log_warning("Failed to turn off child `%s': %s",
                             ddf_fun_get_name(iface->fun), str_error(pret));
                         ret = pret;
@@ -125 +125 @@
         assert(usb_mid);
 
-        usb_log_info("USB MID gone: `%s'.\n", usb_device_get_name(dev));
+        usb_log_info("USB MID gone: `%s'.", usb_device_get_name(dev));
 
         /* Remove ctl function */
         int ret = ddf_fun_unbind(usb_mid->ctl_fun);
         if (ret != EOK) {
-                usb_log_error("Failed to unbind USB MID ctl function: %s.\n",
+                usb_log_error("Failed to unbind USB MID ctl function: %s.",
                     str_error(ret));
                 return ret;

uspace/drv/bus/usb/vhc/conndev.c

@@ -113 +113 @@
                 receive_device_name(callback);
                 
-                usb_log_info("New virtual device `%s' (id: %" PRIxn ").\n",
+                usb_log_info("New virtual device `%s' (id: %" PRIxn ").",
                     plugged_device_name, plugged_device_handle);
         } else
@@ -130 +130 @@
 
         if (plugged_device_handle != 0) {
-                usb_log_info("Virtual device `%s' disconnected (id: %" PRIxn ").\n",
+                usb_log_info("Virtual device `%s' disconnected (id: %" PRIxn ").",
                     plugged_device_name, plugged_device_handle);
                 vhc_virtdev_unplug(vhc, plugged_device_handle);

uspace/drv/bus/usb/vhc/hub/hub.c

@@ -231 +231 @@
         }
 
-        usb_log_debug("Setting port %zu to state %d.\n", port_index, state);
+        usb_log_debug("Setting port %zu to state %d.", port_index, state);
 
         switch (state) {
@@ -423 +423 @@
         uint16_t old_value = port->status_change;
         port->status_change |= change;
-        usb_log_debug("Changing status change on %zu: %04x => %04x\n",
+        usb_log_debug("Changing status change on %zu: %04x => %04x",
             port->index,
             (unsigned int) old_value, (unsigned int) port->status_change);
@@ -510 +510 @@
         fid_t fibril = fibril_create(set_port_state_delayed_fibril, change);
         if (fibril == 0) {
-                printf("Failed to create fibril\n");
+                usb_log_error("Failed to create fibril.");
                 free(change);
                 return;

uspace/drv/bus/usb/vhc/main.c

@@ -77 +77 @@
         int ret = hcd_ddf_setup_hc(dev, sizeof(vhc_data_t));
         if (ret != EOK) {
-                usb_log_error("Failed to init HCD structures: %s.\n",
+                usb_log_error("Failed to init HCD structures: %s.",
                    str_error(ret));
                 return ret;
@@ -90 +90 @@
         ret = vhc_control_node(dev, &ctl_fun);
         if (ret != EOK) {
-                usb_log_error("Failed to setup control node.\n");
+                usb_log_error("Failed to setup control node.");
                 return ret;
         }
@@ -97 +97 @@
         ret = vhc_virtdev_plug_hub(vhc, &vhc->hub, NULL, 0);
         if (ret != EOK) {
-                usb_log_error("Failed to plug root hub: %s.\n", str_error(ret));
+                usb_log_error("Failed to plug root hub: %s.", str_error(ret));
                 ddf_fun_destroy(ctl_fun);
                 return ret;
@@ -108 +108 @@
         ret = hcd_setup_virtual_root_hub(&vhc->base);
         if (ret != EOK) {
-                usb_log_error("Failed to init VHC root hub: %s\n",
+                usb_log_error("Failed to init VHC root hub: %s",
                         str_error(ret));
                 // TODO do something here...

uspace/drv/bus/usb/vhc/transfer.c

@@ -207 +207 @@
         
         if (targets > 1)
-                usb_log_warning("Transfer would be accepted by more devices!\n");
+                usb_log_warning("Transfer would be accepted by more devices!");
 
         return targets ? EOK : ENOENT;
@@ -236 +236 @@
                             dev->dev_local, &data_transfer_size);
                 } else {
-                        usb_log_warning("Device has no remote phone nor local node.\n");
+                        usb_log_warning("Device has no remote phone nor local node.");
                         rc = ESTALL;
                 }
 
-                usb_log_debug2("Transfer %p processed: %s.\n",
+                usb_log_debug2("Transfer %p processed: %s.",
                     transfer, str_error(rc));
 
@@ -249 +249 @@
                                     (void*) transfer->batch.setup.buffer;
                                 dev->address = setup->value;
-                                usb_log_debug2("Address changed to %d\n",
+                                usb_log_debug2("Address changed to %d",
                                     dev->address);
                         }

uspace/drv/bus/usb/xhci/bus.c

@@ -73 +73 @@
         if ((err = hc_enable_slot(bus->hc, &dev->slot_id)) != EOK)
                 return err;
-        usb_log_debug2("Obtained slot ID: %u.\n", dev->slot_id);
+        usb_log_debug2("Obtained slot ID: %u.", dev->slot_id);
 
         /* Create and configure control endpoint. */

uspace/drv/bus/usb/xhci/hc.c

@@ -190 +190 @@
         hc->mmio_range = hw_res->mem_ranges.ranges[0];
 
-        usb_log_debug("MMIO area at %p (size %zu), IRQ %d.\n",
+        usb_log_debug("MMIO area at %p (size %zu), IRQ %d.",
             RNGABSPTR(hc->mmio_range), RNGSZ(hc->mmio_range), hw_res->irqs.irqs[0]);
 
@@ -406 +406 @@
                 async_usleep(XHCI_LEGSUP_POLLING_DELAY_1MS);
         }
-        usb_log_error("BIOS did not release XHCI legacy hold!\n");
+        usb_log_error("BIOS did not release XHCI legacy hold!");
 
         return ENOTSUP;
@@ -776 +776 @@
         xhci_device_ctx_t *dev_ctx = dev->dev_ctx.virt;
         dev->base.address = XHCI_SLOT_DEVICE_ADDRESS(dev_ctx->slot_ctx);
-        usb_log_debug2("Obtained USB address: %d.\n", dev->base.address);
+        usb_log_debug2("Obtained USB address: %d.", dev->base.address);
 
         return EOK;

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

@@ -64 +64 @@
         usb_blink1_t *blink1_dev = (usb_blink1_t *) ddf_fun_data_get(fun);
         if (blink1_dev == NULL) {
-                usb_log_debug("Missing parameters.\n");
+                usb_log_debug("Missing parameters.");
                 return EINVAL;
         }
@@ -105 +105 @@
             fun_exposed, HID_BLINK1_FUN_NAME);
         if (fun == NULL) {
-                usb_log_error("Could not create DDF function node `%s'.\n",
+                usb_log_error("Could not create DDF function node `%s'.",
                     HID_BLINK1_FUN_NAME);
                 return ENOMEM;
@@ -123 +123 @@
         int rc = ddf_fun_bind(fun);
         if (rc != EOK) {
-                usb_log_error("Could not bind DDF function `%s': %s.\n",
+                usb_log_error("Could not bind DDF function `%s': %s.",
                     ddf_fun_get_name(fun), str_error(rc));
                 ddf_fun_destroy(fun);
@@ -131 +131 @@
         rc = ddf_fun_add_to_category(fun, HID_BLINK1_CATEGORY);
         if (rc != EOK) {
-                usb_log_error("Could not add DDF function to category %s: %s.\n",
+                usb_log_error("Could not add DDF function to category %s: %s.",
                     HID_BLINK1_CATEGORY, str_error(rc));
                 

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

@@ -96 +96 @@
         const usb_hid_dev_t *hid_dev = fun_hid_dev(fun);
 
-        usb_log_debug2("hid_dev: %p, Max input report size (%zu).\n",
+        usb_log_debug2("hid_dev: %p, Max input report size (%zu).",
             hid_dev, hid_dev->max_input_report_size);
 
@@ -105 +105 @@
     size_t size, size_t *act_size, int *event_nr, unsigned int flags)
 {
-        usb_log_debug2("Generic HID: Get event.\n");
+        usb_log_debug2("Generic HID: Get event.");
 
         if (buffer == NULL || act_size == NULL || event_nr == NULL) {
@@ -115 +115 @@
 
         if (hid_dev->input_report_size > size) {
-                usb_log_debug("input_report_size > size (%zu, %zu)\n",
+                usb_log_debug("input_report_size > size (%zu, %zu)",
                     hid_dev->input_report_size, size);
                 return EINVAL;  // TODO: other error code
@@ -126 +126 @@
         *event_nr = usb_hid_report_number(hid_dev);
 
-        usb_log_debug2("OK\n");
+        usb_log_debug2("OK");
 
         return EOK;
@@ -133 +133 @@
 static size_t usb_generic_get_report_descriptor_length(ddf_fun_t *fun)
 {
-        usb_log_debug("Generic HID: Get report descriptor length.\n");
-
-        const usb_hid_dev_t *hid_dev = fun_hid_dev(fun);
-
-        usb_log_debug2("hid_dev->report_desc_size = %zu\n",
+        usb_log_debug("Generic HID: Get report descriptor length.");
+
+        const usb_hid_dev_t *hid_dev = fun_hid_dev(fun);
+
+        usb_log_debug2("hid_dev->report_desc_size = %zu",
             hid_dev->report_desc_size);
 
@@ -146 +146 @@
     size_t size, size_t *actual_size)
 {
-        usb_log_debug2("Generic HID: Get report descriptor.\n");
+        usb_log_debug2("Generic HID: Get report descriptor.");
 
         const usb_hid_dev_t *hid_dev = fun_hid_dev(fun);
@@ -162 +162 @@
 static int usb_generic_hid_client_connected(ddf_fun_t *fun)
 {
-        usb_log_debug("Generic HID: Client connected.\n");
+        usb_log_debug("Generic HID: Client connected.");
         return EOK;
 }
@@ -173 +173 @@
 
         if (ddf_fun_unbind(fun) != EOK) {
-                usb_log_error("Failed to unbind generic hid fun.\n");
+                usb_log_error("Failed to unbind generic hid fun.");
                 return;
         }
-        usb_log_debug2("%s unbound.\n", ddf_fun_get_name(fun));
+        usb_log_debug2("%s unbound.", ddf_fun_get_name(fun));
         ddf_fun_destroy(fun);
 }
@@ -189 +189 @@
 
         /* Create the exposed function. */
-        usb_log_debug("Creating DDF function %s...\n", HID_GENERIC_FUN_NAME);
+        usb_log_debug("Creating DDF function %s...", HID_GENERIC_FUN_NAME);
         ddf_fun_t *fun = usb_device_ddf_fun_create(hid_dev->usb_dev,
             fun_exposed, HID_GENERIC_FUN_NAME);
         if (fun == NULL) {
-                usb_log_error("Could not create DDF function node.\n");
+                usb_log_error("Could not create DDF function node.");
                 return ENOMEM;
         }
@@ -204 +204 @@
         int rc = ddf_fun_bind(fun);
         if (rc != EOK) {
-                usb_log_error("Could not bind DDF function: %s.\n",
+                usb_log_error("Could not bind DDF function: %s.",
                     str_error(rc));
                 ddf_fun_destroy(fun);
@@ -210 +210 @@
         }
 
-        usb_log_debug("HID function created. Handle: %" PRIun "\n",
+        usb_log_debug("HID function created. Handle: %" PRIun "",
             ddf_fun_get_handle(fun));
         *data = fun;

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

@@ -185 +185 @@
                 if (kbd_dev->client_sess == NULL) {
                         kbd_dev->client_sess = sess;
-                        usb_log_debug("%s: OK\n", __FUNCTION__);
+                        usb_log_debug("%s: OK", __FUNCTION__);
                         async_answer_0(icallid, EOK);
                 } else {
-                        usb_log_error("%s: console session already set\n",
+                        usb_log_error("%s: console session already set",
                            __FUNCTION__);
                         async_answer_0(icallid, ELIMIT);
@@ -195 +195 @@
         }
         default:
-                        usb_log_error("%s: Unknown method: %d.\n",
+                        usb_log_error("%s: Unknown method: %d.",
                             __FUNCTION__, (int) method);
                         async_answer_0(icallid, EINVAL);
@@ -226 +226 @@
         /* Reset the LED data. */
         memset(kbd_dev->led_data, 0, kbd_dev->led_output_size * sizeof(int32_t));
-        usb_log_debug("Creating output report:\n");
+        usb_log_debug("Creating output report:");
 
         usb_hid_report_field_t *field = usb_hid_report_get_sibling(
@@ -266 +266 @@
         }
 
-        usb_log_debug("Output report buffer: %s\n",
+        usb_log_debug("Output report buffer: %s",
             usb_debug_str_buffer(kbd_dev->output_buffer, kbd_dev->output_size,
                 0));
@@ -276 +276 @@
             kbd_dev->output_buffer, kbd_dev->output_size);
         if (rc != EOK) {
-                usb_log_warning("Failed to set kbd indicators.\n");
+                usb_log_warning("Failed to set kbd indicators.");
         }
 }
@@ -289 +289 @@
 void usb_kbd_push_ev(usb_kbd_t *kbd_dev, int type, unsigned key)
 {
-        usb_log_debug2("Sending kbdev event %d/%d to the console\n", type, key);
+        usb_log_debug2("Sending kbdev event %d/%d to the console", type, key);
         if (kbd_dev->client_sess == NULL) {
                 usb_log_warning(
@@ -301 +301 @@
                 async_exchange_end(exch);
         } else {
-                usb_log_warning("Failed to send key to console.\n");
+                usb_log_warning("Failed to send key to console.");
         }
 }
@@ -353 +353 @@
             kbd_dev->key_count);
         if (i != (size_t) -1) {
-                usb_log_error("Detected phantom state.\n");
+                usb_log_error("Detected phantom state.");
                 return;
         }
@@ -403 +403 @@
         ddf_dump_buffer(key_buffer, 512,
             kbd_dev->keys_old, 4, kbd_dev->key_count, 0);
-        usb_log_debug2("Stored keys %s.\n", key_buffer);
+        usb_log_debug2("Stored keys %s.", key_buffer);
 }
 
@@ -431 +431 @@
         usb_hid_report_path_t *path = usb_hid_report_path();
         if (path == NULL) {
-                usb_log_error("Failed to create hid/kbd report path.\n");
+                usb_log_error("Failed to create hid/kbd report path.");
                 return;
         }
@@ -438 +438 @@
            usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
         if (ret != EOK) {
-                usb_log_error("Failed to append to hid/kbd report path.\n");
+                usb_log_error("Failed to append to hid/kbd report path.");
                 return;
         }
@@ -452 +452 @@
 
         while (field != NULL) {
-                usb_log_debug2("FIELD (%p) - VALUE(%d) USAGE(%u)\n",
+                usb_log_debug2("FIELD (%p) - VALUE(%d) USAGE(%u)",
                     field, field->value, field->usage);
 
@@ -464 +464 @@
                         kbd_dev->keys[i] = 0;
                 }
-                usb_log_debug2("Saved %u. key usage %d\n", i, kbd_dev->keys[i]);
+                usb_log_debug2("Saved %u. key usage %d", i, kbd_dev->keys[i]);
 
                 ++i;
@@ -502 +502 @@
         usb_hid_report_path_t *path = usb_hid_report_path();
         if (path == NULL) {
-                usb_log_error("Failed to create kbd report path.\n");
+                usb_log_error("Failed to create kbd report path.");
                 usb_kbd_destroy(kbd_dev);
                 return ENOMEM;
@@ -510 +510 @@
             usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
         if (ret != EOK) {
-                usb_log_error("Failed to append item to kbd report path.\n");
+                usb_log_error("Failed to append item to kbd report path.");
                 usb_hid_report_path_free(path);
                 usb_kbd_destroy(kbd_dev);
@@ -523 +523 @@
         usb_hid_report_path_free(path);
 
-        usb_log_debug("Size of the input report: %zu\n", kbd_dev->key_count);
+        usb_log_debug("Size of the input report: %zu", kbd_dev->key_count);
 
         kbd_dev->keys = calloc(kbd_dev->key_count, sizeof(int32_t));
         if (kbd_dev->keys == NULL) {
-                usb_log_error("Failed to allocate key buffer.\n");
+                usb_log_error("Failed to allocate key buffer.");
                 usb_kbd_destroy(kbd_dev);
                 return ENOMEM;
@@ -534 +534 @@
         kbd_dev->keys_old = calloc(kbd_dev->key_count, sizeof(int32_t));
         if (kbd_dev->keys_old == NULL) {
-                usb_log_error("Failed to allocate old_key buffer.\n");
+                usb_log_error("Failed to allocate old_key buffer.");
                 usb_kbd_destroy(kbd_dev);
                 return ENOMEM;
@@ -544 +544 @@
             &kbd_dev->output_size, 0);
         if (kbd_dev->output_buffer == NULL) {
-                usb_log_error("Error creating output report buffer.\n");
+                usb_log_error("Error creating output report buffer.");
                 usb_kbd_destroy(kbd_dev);
                 return ENOMEM;
         }
 
-        usb_log_debug("Output buffer size: %zu\n", kbd_dev->output_size);
+        usb_log_debug("Output buffer size: %zu", kbd_dev->output_size);
 
         kbd_dev->led_path = usb_hid_report_path();
         if (kbd_dev->led_path == NULL) {
-                usb_log_error("Failed to create kbd led report path.\n");
+                usb_log_error("Failed to create kbd led report path.");
                 usb_kbd_destroy(kbd_dev);
                 return ENOMEM;
@@ -561 +561 @@
             kbd_dev->led_path, USB_HIDUT_PAGE_LED, 0);
         if (ret != EOK) {
-                usb_log_error("Failed to append to kbd/led report path.\n");
+                usb_log_error("Failed to append to kbd/led report path.");
                 usb_kbd_destroy(kbd_dev);
                 return ret;
@@ -569 +569 @@
             &hid_dev->report, 0, USB_HID_REPORT_TYPE_OUTPUT);
 
-        usb_log_debug("Output report size (in items): %zu\n",
+        usb_log_debug("Output report size (in items): %zu",
             kbd_dev->led_output_size);
 
         kbd_dev->led_data = calloc(kbd_dev->led_output_size, sizeof(int32_t));
         if (kbd_dev->led_data == NULL) {
-                usb_log_error("Error creating buffer for LED output report.\n");
+                usb_log_error("Error creating buffer for LED output report.");
                 usb_kbd_destroy(kbd_dev);
                 return ENOMEM;
@@ -588 +588 @@
 
         kbd_dev->initialized = USB_KBD_STATUS_INITIALIZED;
-        usb_log_debug("HID/KBD device structure initialized.\n");
+        usb_log_debug("HID/KBD device structure initialized.");
 
         return EOK;
@@ -618 +618 @@
 int usb_kbd_init(usb_hid_dev_t *hid_dev, void **data)
 {
-        usb_log_debug("Initializing HID/KBD structure...\n");
+        usb_log_debug("Initializing HID/KBD structure...");
 
         if (hid_dev == NULL) {
@@ -627 +627 @@
 
         /* Create the exposed function. */
-        usb_log_debug("Creating DDF function %s...\n", HID_KBD_FUN_NAME);
+        usb_log_debug("Creating DDF function %s...", HID_KBD_FUN_NAME);
         ddf_fun_t *fun = usb_device_ddf_fun_create(hid_dev->usb_dev,
             fun_exposed, HID_KBD_FUN_NAME);
         if (fun == NULL) {
-                usb_log_error("Could not create DDF function node.\n");
+                usb_log_error("Could not create DDF function node.");
                 return ENOMEM;
         }
@@ -637 +637 @@
         usb_kbd_t *kbd_dev = ddf_fun_data_alloc(fun, sizeof(usb_kbd_t));
         if (kbd_dev == NULL) {
-                usb_log_error("Failed to allocate KBD device structure.\n");
+                usb_log_error("Failed to allocate KBD device structure.");
                 ddf_fun_destroy(fun);
                 return ENOMEM;
@@ -644 +644 @@
         int ret = kbd_dev_init(kbd_dev, hid_dev);
         if (ret != EOK) {
-                usb_log_error("Failed to initialize KBD device  structure.\n");
+                usb_log_error("Failed to initialize KBD device  structure.");
                 ddf_fun_destroy(fun);
                 return ret;
@@ -655 +655 @@
         ret = ddf_fun_bind(fun);
         if (ret != EOK) {
-                usb_log_error("Could not bind DDF function: %s.\n",
+                usb_log_error("Could not bind DDF function: %s.",
                     str_error(ret));
                 usb_kbd_destroy(kbd_dev);
@@ -662 +662 @@
         }
 
-        usb_log_debug("%s function created. Handle: %" PRIun "\n",
+        usb_log_debug("%s function created. Handle: %" PRIun "",
             HID_KBD_FUN_NAME, ddf_fun_get_handle(fun));
 
-        usb_log_debug("Adding DDF function to category %s...\n",
+        usb_log_debug("Adding DDF function to category %s...",
             HID_KBD_CATEGORY_NAME);
         ret = ddf_fun_add_to_category(fun, HID_KBD_CATEGORY_NAME);
@@ -753 +753 @@
         if (kbd_dev->fun) {
                 if (ddf_fun_unbind(kbd_dev->fun) != EOK) {
-                        usb_log_warning("Failed to unbind %s.\n",
+                        usb_log_warning("Failed to unbind %s.",
                             ddf_fun_get_name(kbd_dev->fun));
                 } else {
-                        usb_log_debug2("%s unbound.\n",
+                        usb_log_debug2("%s unbound.",
                             ddf_fun_get_name(kbd_dev->fun));
                         ddf_fun_destroy(kbd_dev->fun);
@@ -784 +784 @@
 
         if (rc != EOK) {
-                usb_log_error("Failed to parse boot report descriptor: %s\n",
+                usb_log_error("Failed to parse boot report descriptor: %s",
                     str_error(rc));
                 return rc;

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

@@ -69 +69 @@
         unsigned int delay = 0;
 
-        usb_log_debug("Starting autorepeat loop.\n");
+        usb_log_debug("Starting autorepeat loop.");
 
         while (true) {
                 /* Check if the kbd structure is usable. */
                 if (!usb_kbd_is_initialized(kbd)) {
-                        usb_log_warning("kbd not ready, exiting autorepeat.\n");
+                        usb_log_warning("kbd not ready, exiting autorepeat.");
                         return;
                 }
@@ -82 +82 @@
                 if (kbd->repeat.key_new > 0) {
                         if (kbd->repeat.key_new == kbd->repeat.key_repeated) {
-                                usb_log_debug2("Repeating key: %u.\n",
+                                usb_log_debug2("Repeating key: %u.",
                                     kbd->repeat.key_repeated);
                                 usb_kbd_push_ev(kbd, KEY_PRESS,
@@ -88 +88 @@
                                 delay = kbd->repeat.delay_between;
                         } else {
-                                usb_log_debug2("New key to repeat: %u.\n",
+                                usb_log_debug2("New key to repeat: %u.",
                                     kbd->repeat.key_new);
                                 kbd->repeat.key_repeated = kbd->repeat.key_new;
@@ -95 +95 @@
                 } else {
                         if (kbd->repeat.key_repeated > 0) {
-                                usb_log_debug2("Stopping to repeat key: %u.\n",
+                                usb_log_debug2("Stopping to repeat key: %u.",
                                     kbd->repeat.key_repeated);
                                 kbd->repeat.key_repeated = 0;
@@ -119 +119 @@
 int usb_kbd_repeat_fibril(void *arg)
 {
-        usb_log_debug("Autorepeat fibril spawned.\n");
+        usb_log_debug("Autorepeat fibril spawned.");
 
         if (arg == NULL) {
-                usb_log_error("No device!\n");
+                usb_log_error("No device!");
                 return EINVAL;
         }

uspace/drv/hid/usbhid/main.c

@@ -58 +58 @@
 static int usb_hid_device_add(usb_device_t *dev)
 {
-        usb_log_debug("%s\n", __FUNCTION__);
+        usb_log_debug("%s", __FUNCTION__);
 
         if (dev == NULL) {
-                usb_log_error("Wrong parameter given for add_device().\n");
+                usb_log_error("Wrong parameter given for add_device().");
                 return EINVAL;
         }
@@ -73 +73 @@
             usb_device_data_alloc(dev, sizeof(usb_hid_dev_t));
         if (hid_dev == NULL) {
-                usb_log_error("Failed to create USB/HID device structure.\n");
+                usb_log_error("Failed to create USB/HID device structure.");
                 return ENOMEM;
         }
@@ -79 +79 @@
         int rc = usb_hid_init(hid_dev, dev);
         if (rc != EOK) {
-                usb_log_error("Failed to initialize USB/HID device.\n");
+                usb_log_error("Failed to initialize USB/HID device.");
                 usb_hid_deinit(hid_dev);
                 return rc;
         }
 
-        usb_log_debug("USB/HID device structure initialized.\n");
+        usb_log_debug("USB/HID device structure initialized.");
 
         /* Start automated polling function.
@@ -92 +92 @@
 
         if (rc != EOK) {
-                usb_log_error("Failed to start polling fibril for `%s'.\n",
+                usb_log_error("Failed to start polling fibril for `%s'.",
                     usb_device_get_name(dev));
                 usb_hid_deinit(hid_dev);
@@ -99 +99 @@
         hid_dev->running = true;
 
-        usb_log_info("HID device `%s' ready.\n", usb_device_get_name(dev));
+        usb_log_info("HID device `%s' ready.", usb_device_get_name(dev));
 
         return EOK;
@@ -115 +115 @@
         /* Clean up. */
         usb_hid_deinit(hid_dev);
-        usb_log_info("%s destruction complete.\n", usb_device_get_name(dev));
+        usb_log_info("%s destruction complete.", usb_device_get_name(dev));
 
         return EOK;
@@ -132 +132 @@
         assert(hid_dev);
 
-        usb_log_info("Device %s removed.\n", usb_device_get_name(dev));
+        usb_log_info("Device %s removed.", usb_device_get_name(dev));
         return join_and_clean(dev);
 }
@@ -148 +148 @@
         assert(hid_dev);
 
-        usb_log_info("Device %s gone.\n", usb_device_get_name(dev));
+        usb_log_info("Device %s gone.", usb_device_get_name(dev));
         return join_and_clean(dev);
 }

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

@@ -118 +118 @@
 
         if (mouse_dev == NULL) {
-                usb_log_debug("%s: Missing parameters.\n", __FUNCTION__);
+                usb_log_debug("%s: Missing parameters.", __FUNCTION__);
                 async_answer_0(icallid, EINVAL);
                 return;
         }
 
-        usb_log_debug("%s: fun->name: %s\n", __FUNCTION__, ddf_fun_get_name(fun));
-        usb_log_debug("%s: mouse_sess: %p\n",
+        usb_log_debug("%s: fun->name: %s", __FUNCTION__, ddf_fun_get_name(fun));
+        usb_log_debug("%s: mouse_sess: %p",
             __FUNCTION__, mouse_dev->mouse_sess);
 
@@ -132 +132 @@
                 if (mouse_dev->mouse_sess == NULL) {
                         mouse_dev->mouse_sess = sess;
-                        usb_log_debug("Console session to %s set ok (%p).\n",
+                        usb_log_debug("Console session to %s set ok (%p).",
                             ddf_fun_get_name(fun), sess);
                         async_answer_0(icallid, EOK);
                 } else {
-                        usb_log_error("Console session to %s already set.\n",
+                        usb_log_error("Console session to %s already set.",
                             ddf_fun_get_name(fun));
                         async_answer_0(icallid, ELIMIT);
@@ -142 +142 @@
                 }
         } else {
-                usb_log_debug("%s: Invalid function.\n", __FUNCTION__);
+                usb_log_debug("%s: Invalid function.", __FUNCTION__);
                 async_answer_0(icallid, EINVAL);
         }
@@ -171 +171 @@
 
         if (mouse_dev->mouse_sess == NULL) {
-                usb_log_warning(NAME " No console session.\n");
+                usb_log_warning(NAME " No console session.");
                 return;
         }
@@ -225 +225 @@
         usb_hid_report_path_t *path = usb_hid_report_path();
         if (path == NULL) {
-                usb_log_warning("Failed to create USB HID report path.\n");
+                usb_log_warning("Failed to create USB HID report path.");
                 return;
         }
@@ -232 +232 @@
         if (ret != EOK) {
                 usb_hid_report_path_free(path);
-                usb_log_warning("Failed to add buttons to report path.\n");
+                usb_log_warning("Failed to add buttons to report path.");
                 return;
         }
@@ -242 +242 @@
 
         while (field != NULL) {
-                usb_log_debug2(NAME " VALUE(%X) USAGE(%X)\n", field->value,
+                usb_log_debug2(NAME " VALUE(%X) USAGE(%X)", field->value,
                     field->usage);
                 assert(field->usage > field->usage_minimum);
@@ -331 +331 @@
 
         if (mouse_dev->buttons == NULL) {
-                usb_log_error(NAME ": out of memory, giving up on device!\n");
+                usb_log_error(NAME ": out of memory, giving up on device!");
                 free(mouse_dev);
                 return ENOMEM;
@@ -344 +344 @@
 int usb_mouse_init(usb_hid_dev_t *hid_dev, void **data)
 {
-        usb_log_debug("Initializing HID/Mouse structure...\n");
+        usb_log_debug("Initializing HID/Mouse structure...");
 
         if (hid_dev == NULL) {
@@ -353 +353 @@
 
         /* Create the exposed function. */
-        usb_log_debug("Creating DDF function %s...\n", HID_MOUSE_FUN_NAME);
+        usb_log_debug("Creating DDF function %s...", HID_MOUSE_FUN_NAME);
         ddf_fun_t *fun = usb_device_ddf_fun_create(hid_dev->usb_dev,
             fun_exposed, HID_MOUSE_FUN_NAME);
         if (fun == NULL) {
-                usb_log_error("Could not create DDF function node `%s'.\n",
+                usb_log_error("Could not create DDF function node `%s'.",
                     HID_MOUSE_FUN_NAME);
                 return ENOMEM;
@@ -364 +364 @@
         usb_mouse_t *mouse_dev = ddf_fun_data_alloc(fun, sizeof(usb_mouse_t));
         if (mouse_dev == NULL) {
-                usb_log_error("Failed to alloc HID mouse device structure.\n");
+                usb_log_error("Failed to alloc HID mouse device structure.");
                 ddf_fun_destroy(fun);
                 return ENOMEM;
@@ -371 +371 @@
         int ret = mouse_dev_init(mouse_dev, hid_dev);
         if (ret != EOK) {
-                usb_log_error("Failed to init HID mouse device structure.\n");
+                usb_log_error("Failed to init HID mouse device structure.");
                 return ret;
         }
@@ -379 +379 @@
         ret = ddf_fun_bind(fun);
         if (ret != EOK) {
-                usb_log_error("Could not bind DDF function `%s': %s.\n",
+                usb_log_error("Could not bind DDF function `%s': %s.",
                     ddf_fun_get_name(fun), str_error(ret));
                 ddf_fun_destroy(fun);
@@ -385 +385 @@
         }
 
-        usb_log_debug("Adding DDF function `%s' to category %s...\n",
+        usb_log_debug("Adding DDF function `%s' to category %s...",
             ddf_fun_get_name(fun), HID_MOUSE_CATEGORY);
         ret = ddf_fun_add_to_category(fun, HID_MOUSE_CATEGORY);
@@ -444 +444 @@
 
         if (rc != EOK) {
-                usb_log_error("Failed to parse boot report descriptor: %s\n",
+                usb_log_error("Failed to parse boot report descriptor: %s",
                     str_error(rc));
                 return rc;

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

@@ -86 +86 @@
     ipc_callid_t icallid, ipc_call_t *icall)
 {
-        usb_log_debug(NAME " default_connection_handler()\n");
+        usb_log_debug(NAME " default_connection_handler()");
 
         usb_multimedia_t *multim_dev = ddf_fun_data_get(fun);
@@ -95 +95 @@
                 if (multim_dev->console_sess == NULL) {
                         multim_dev->console_sess = sess;
-                        usb_log_debug(NAME " Saved session to console: %p\n",
+                        usb_log_debug(NAME " Saved session to console: %p",
                             sess);
                         async_answer_0(icallid, EOK);
@@ -137 +137 @@
         };
 
-        usb_log_debug2(NAME " Sending key %d to the console\n", ev.key);
+        usb_log_debug2(NAME " Sending key %d to the console", ev.key);
         if (multim_dev->console_sess == NULL) {
                 usb_log_warning(
@@ -149 +149 @@
                 async_exchange_end(exch);
         } else {
-                usb_log_warning("Failed to send multimedia key.\n");
+                usb_log_warning("Failed to send multimedia key.");
         }
 }
@@ -159 +159 @@
         }
 
-        usb_log_debug(NAME " Initializing HID/multimedia structure...\n");
+        usb_log_debug(NAME " Initializing HID/multimedia structure...");
 
         /* Create the exposed function. */
@@ -165 +165 @@
             hid_dev->usb_dev, fun_exposed, NAME);
         if (fun == NULL) {
-                usb_log_error("Could not create DDF function node.\n");
+                usb_log_error("Could not create DDF function node.");
                 return ENOMEM;
         }
@@ -184 +184 @@
         int rc = ddf_fun_bind(fun);
         if (rc != EOK) {
-                usb_log_error("Could not bind DDF function: %s.\n",
+                usb_log_error("Could not bind DDF function: %s.",
                     str_error(rc));
                 ddf_fun_destroy(fun);
@@ -190 +190 @@
         }
 
-        usb_log_debug(NAME " function created (handle: %" PRIun ").\n",
+        usb_log_debug(NAME " function created (handle: %" PRIun ").",
             ddf_fun_get_handle(fun));
 
@@ -199 +199 @@
                     str_error(rc));
                 if (ddf_fun_unbind(fun) != EOK) {
-                        usb_log_error("Failed to unbind %s, won't destroy.\n",
+                        usb_log_error("Failed to unbind %s, won't destroy.",
                             ddf_fun_get_name(fun));
                 } else {
@@ -210 +210 @@
         *data = fun;
 
-        usb_log_debug(NAME " HID/multimedia structure initialized.\n");
+        usb_log_debug(NAME " HID/multimedia structure initialized.");
         return EOK;
 }
@@ -224 +224 @@
                 async_hangup(multim_dev->console_sess);
         if (ddf_fun_unbind(fun) != EOK) {
-                usb_log_error("Failed to unbind %s, won't destroy.\n",
+                usb_log_error("Failed to unbind %s, won't destroy.",
                     ddf_fun_get_name(fun));
         } else {
-                usb_log_debug2("%s unbound.\n", ddf_fun_get_name(fun));
+                usb_log_debug2("%s unbound.", ddf_fun_get_name(fun));
                 /* This frees multim_dev too as it was stored in
                  * fun->data */
@@ -266 +266 @@
         while (field != NULL) {
                 if (field->value != 0) {
-                        usb_log_debug(NAME " KEY VALUE(%X) USAGE(%X)\n",
+                        usb_log_debug(NAME " KEY VALUE(%X) USAGE(%X)",
                             field->value, field->usage);
                         const unsigned key =
@@ -272 +272 @@
                         const char *key_str =
                             usbhid_multimedia_usage_to_str(field->usage);
-                        usb_log_info("Pressed key: %s\n", key_str);
+                        usb_log_info("Pressed key: %s", key_str);
                         usb_multimedia_push_ev(multim_dev, KEY_PRESS, key);
                 }

uspace/drv/hid/usbhid/usbhid.c

@@ -134 +134 @@
         usb_hid_report_path_t *usage_path = usb_hid_report_path();
         if (usage_path == NULL) {
-                usb_log_debug("Failed to create usage path.\n");
+                usb_log_debug("Failed to create usage path.");
                 return false;
         }
@@ -143 +143 @@
                     mapping->usage_path[i].usage_page,
                     mapping->usage_path[i].usage) != EOK) {
-                        usb_log_debug("Failed to append to usage path.\n");
+                        usb_log_debug("Failed to append to usage path.");
                         usb_hid_report_path_free(usage_path);
                         return false;
@@ -149 +149 @@
         }
 
-        usb_log_debug("Compare flags: %d\n", mapping->compare);
+        usb_log_debug("Compare flags: %d", mapping->compare);
 
         bool matches = false;
@@ -155 +155 @@
 
         do {
-                usb_log_debug("Trying report id %u\n", report_id);
+                usb_log_debug("Trying report id %u", report_id);
                 if (report_id != 0) {
                         usb_hid_report_path_set_report_id(usage_path,
@@ -166 +166 @@
                         USB_HID_REPORT_TYPE_INPUT);
 
-                usb_log_debug("Field: %p\n", field);
+                usb_log_debug("Field: %p", field);
 
                 if (field != NULL) {
@@ -243 +243 @@
                             mapping->product_id);
                         if (usb_hid_ids_match(hid_dev, mapping)) {
-                                usb_log_debug("IDs matched.\n");
+                                usb_log_debug("IDs matched.");
                                 matched = true;
                         }
@@ -250 +250 @@
                 /* Check usage match. */
                 if (mapping->usage_path != NULL) {
-                        usb_log_debug("Comparing device against usage path.\n");
+                        usb_log_debug("Comparing device against usage path.");
                         if (usb_hid_path_matches(hid_dev, mapping)) {
                                 /* Does not matter if IDs were matched. */
@@ -258 +258 @@
 
                 if (matched) {
-                        usb_log_debug("Subdriver matched.\n");
+                        usb_log_debug("Subdriver matched.");
                         subdrivers[count++] = &mapping->subdriver;
                 }
@@ -285 +285 @@
                     usb_device_get_mapped_ep_desc(dev, endpoints[i].desc);
                 if (epm && epm->present) {
-                        usb_log_debug("Found: %s.\n", endpoints[i].description);
+                        usb_log_debug("Found: %s.", endpoints[i].description);
                         hid_dev->poll_pipe_mapping = epm;
                         return EOK;
@@ -301 +301 @@
 
         do {
-                usb_log_debug("Getting size of the report.\n");
+                usb_log_debug("Getting size of the report.");
                 const size_t size =
                     usb_hid_report_byte_size(&hid_dev->report, report_id,
                         USB_HID_REPORT_TYPE_INPUT);
-                usb_log_debug("Report ID: %u, size: %zu\n", report_id, size);
+                usb_log_debug("Report ID: %u, size: %zu", report_id, size);
                 max_size = (size > max_size) ? size : max_size;
-                usb_log_debug("Getting next report ID\n");
+                usb_log_debug("Getting next report ID");
                 report_id = usb_hid_get_next_report_id(&hid_dev->report,
                     report_id, USB_HID_REPORT_TYPE_INPUT);
         } while (report_id != 0);
 
-        usb_log_debug("Max size of input report: %zu\n", max_size);
+        usb_log_debug("Max size of input report: %zu", max_size);
 
         assert(hid_dev->input_report == NULL);
@@ -329 +329 @@
 {
         if (dev == NULL || arg == NULL || buffer == NULL) {
-                usb_log_error("Missing arguments to polling callback.\n");
+                usb_log_error("Missing arguments to polling callback.");
                 return false;
         }
@@ -336 +336 @@
         assert(hid_dev->input_report != NULL);
 
-        usb_log_debug("New data [%zu/%zu]: %s\n", buffer_size,
+        usb_log_debug("New data [%zu/%zu]: %s", buffer_size,
             hid_dev->max_input_report_size,
             usb_debug_str_buffer(buffer, buffer_size, 0));
@@ -419 +419 @@
         assert(dev);
 
-        usb_log_debug("Initializing HID structure...\n");
+        usb_log_debug("Initializing HID structure...");
 
         usb_hid_report_init(&hid_dev->report);
@@ -441 +441 @@
                 usb_hid_find_subdrivers(hid_dev);
         } else {
-                usb_log_error("Failed to parse report descriptor: fallback.\n");
+                usb_log_error("Failed to parse report descriptor: fallback.");
                 hid_dev->subdrivers = NULL;
                 hid_dev->subdriver_count = 0;
         }
 
-        usb_log_debug("Subdriver count(before trying boot protocol): %d\n",
+        usb_log_debug("Subdriver count(before trying boot protocol): %d",
             hid_dev->subdriver_count);
 
@@ -457 +457 @@
                 switch (hid_dev->poll_pipe_mapping->interface->interface_protocol) {
                 case USB_HID_PROTOCOL_KEYBOARD:
-                        usb_log_info("Falling back to kbd boot protocol.\n");
+                        usb_log_info("Falling back to kbd boot protocol.");
                         rc = usb_kbd_set_boot_protocol(hid_dev);
                         if (rc == EOK) {
@@ -464 +464 @@
                         break;
                 case USB_HID_PROTOCOL_MOUSE:
-                        usb_log_info("Falling back to mouse boot protocol.\n");
+                        usb_log_info("Falling back to mouse boot protocol.");
                         rc = usb_mouse_set_boot_protocol(hid_dev);
                         if (rc == EOK) {
@@ -471 +471 @@
                         break;
                 default:
-                        usb_log_info("Falling back to generic HID driver.\n");
+                        usb_log_info("Falling back to generic HID driver.");
                         usb_hid_set_generic_hid_subdriver(hid_dev);
                 }
         }
 
-        usb_log_debug("Subdriver count(after trying boot protocol): %d\n",
+        usb_log_debug("Subdriver count(after trying boot protocol): %d",
             hid_dev->subdriver_count);
 
@@ -491 +491 @@
         for (unsigned i = 0; i < hid_dev->subdriver_count; ++i) {
                 if (hid_dev->subdrivers[i].init != NULL) {
-                        usb_log_debug("Initializing subdriver %d.\n",i);
+                        usb_log_debug("Initializing subdriver %d.",i);
                         const int pret = hid_dev->subdrivers[i].init(hid_dev,
                             &hid_dev->subdrivers[i].data);
@@ -514 +514 @@
                 rc = usb_hid_init_report(hid_dev);
                 if (rc != EOK) {
-                        usb_log_error("Failed to initialize input report buffer: %s\n", str_error(rc));
+                        usb_log_error("Failed to initialize input report buffer: %s", str_error(rc));
                         // FIXME: What happens now?
                 }
@@ -520 +520 @@
                 usb_polling_t *polling = &hid_dev->polling;
                 if ((rc = usb_polling_init(polling))) {
-                        usb_log_error("Failed to initialize polling: %s\n", str_error(rc));
+                        usb_log_error("Failed to initialize polling: %s", str_error(rc));
                         // FIXME: What happens now?
                 }
@@ -555 +555 @@
         usb_polling_fini(&hid_dev->polling);
 
-        usb_log_debug("Subdrivers: %p, subdriver count: %d\n",
+        usb_log_debug("Subdrivers: %p, subdriver count: %d",
             hid_dev->subdrivers, hid_dev->subdriver_count);