Changeset 3bacee1 in mainline for uspace/drv/bus

Timestamp:

2018-04-12T16:27:17Z (8 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

3cf22f9

Parents:

76d0981d

git-author:

Jiri Svoboda <jiri@…> (2018-04-11 19:25:33)

git-committer:

Jiri Svoboda <jiri@…> (2018-04-12 16:27:17)

Message:

Make ccheck-fix again and commit more good files.

Location:

uspace/drv/bus

Files:

• isa/i8237.c (modified) (3 diffs)
• usb/ehci/ehci_batch.c (modified) (11 diffs)
• usb/ehci/ehci_rh.c (modified) (13 diffs)
• usb/ehci/hc.c (modified) (11 diffs)
• usb/ehci/hw_struct/transfer_descriptor.c (modified) (2 diffs)
• usb/ehci/res.c (modified) (3 diffs)
• usb/ohci/hc.c (modified) (6 diffs)
• usb/ohci/hw_struct/endpoint_descriptor.c (modified) (1 diff)
• usb/ohci/hw_struct/endpoint_descriptor.h (modified) (2 diffs)
• usb/ohci/hw_struct/transfer_descriptor.c (modified) (1 diff)
• usb/ohci/hw_struct/transfer_descriptor.h (modified) (2 diffs)
• usb/ohci/ohci_batch.c (modified) (8 diffs)
• usb/ohci/ohci_bus.c (modified) (2 diffs)
• usb/ohci/ohci_rh.c (modified) (6 diffs)
• usb/uhci/hc.c (modified) (15 diffs)
• usb/uhci/hw_struct/transfer_descriptor.c (modified) (3 diffs)
• usb/uhci/hw_struct/transfer_descriptor.h (modified) (1 diff)
• usb/uhci/transfer_list.c (modified) (3 diffs)
• usb/uhci/uhci_rh.c (modified) (7 diffs)
• usb/usbdiag/tests.c (modified) (1 diff)
• usb/usbhub/port.c (modified) (6 diffs)
• usb/usbhub/status.h (modified) (1 diff)
• usb/usbhub/usbhub.c (modified) (9 diffs)
• usb/usbmid/explore.c (modified) (2 diffs)
• usb/vhc/hub/virthub.c (modified) (3 diffs)
• usb/vhc/hub/virthubops.c (modified) (3 diffs)
• usb/xhci/commands.c (modified) (1 diff)
• usb/xhci/debug.c (modified) (2 diffs)
• usb/xhci/endpoint.c (modified) (6 diffs)
• usb/xhci/hc.c (modified) (26 diffs)
• usb/xhci/hw_struct/regs.h (modified) (1 diff)
• usb/xhci/hw_struct/trb.h (modified) (1 diff)
• usb/xhci/isoch.c (modified) (25 diffs)
• usb/xhci/rh.c (modified) (8 diffs)
• usb/xhci/streams.c (modified) (15 diffs)
• usb/xhci/test/reg-ops.c (modified) (9 diffs)
• usb/xhci/transfers.c (modified) (16 diffs)
• usb/xhci/trb_ring.c (modified) (6 diffs)

uspace/drv/bus/isa/i8237.c

@@ -293 +293 @@
 
         ret = pio_enable(DMA_CONTROLLER_SECOND_BASE,
-                sizeof(dma_controller_regs_second_t), (void **) &controller->second);
+            sizeof(dma_controller_regs_second_t), (void **) &controller->second);
         if (ret != EOK)
                 return EIO;
@@ -484 +484 @@
         fibril_mutex_unlock(&guard);
 
-        uint16_t remain = (value_high << 8 | value_low) ;
+        uint16_t remain = (value_high << 8 | value_low);
         /* 16 bit DMA size is in words,
          * the upper bits are bogus for 16bit transfers so we need to get
@@ -490 +490 @@
         if (is_dma16(channel))
                 remain <<= 1;
-        *size =  is_dma16(channel) ? remain + 2: remain + 1;
+        *size =  is_dma16(channel) ? remain + 2 : remain + 1;
         return EOK;
 }

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

@@ -53 +53 @@
 #define EHCI_TD_MAX_TRANSFER   (16 * 1024)
 
-static void (*const batch_setup[])(ehci_transfer_batch_t*);
+static void (*const batch_setup[])(ehci_transfer_batch_t *);
 
 /** Safely destructs ehci_transfer_batch_t structure
@@ -74 +74 @@
  *
  */
-ehci_transfer_batch_t * ehci_transfer_batch_create(endpoint_t *ep)
+ehci_transfer_batch_t *ehci_transfer_batch_create(endpoint_t *ep)
 {
         assert(ep);
@@ -99 +99 @@
         assert(ehci_batch);
 
-        const size_t setup_size = (ehci_batch->base.ep->transfer_type == USB_TRANSFER_CONTROL)
-                ? USB_SETUP_PACKET_SIZE
-                : 0;
+        const size_t setup_size = (ehci_batch->base.ep->transfer_type == USB_TRANSFER_CONTROL) ?
+            USB_SETUP_PACKET_SIZE :
+            0;
 
         const size_t size = ehci_batch->base.size;
@@ -109 +109 @@
 
         /* Determine number of TDs needed */
-        ehci_batch->td_count = (size + EHCI_TD_MAX_TRANSFER - 1)
-                / EHCI_TD_MAX_TRANSFER;
+        ehci_batch->td_count = (size + EHCI_TD_MAX_TRANSFER - 1) /
+            EHCI_TD_MAX_TRANSFER;
 
         /* Control transfer need Setup and Status stage */
@@ -173 +173 @@
             ehci_batch->qh->next, ehci_batch->qh->alternate);
 
-        if (!qh_halted(ehci_batch->qh) && (qh_transfer_pending(ehci_batch->qh)
-            || qh_transfer_active(ehci_batch->qh)))
+        if (!qh_halted(ehci_batch->qh) && (qh_transfer_pending(ehci_batch->qh) ||
+            qh_transfer_active(ehci_batch->qh)))
                 return false;
 
@@ -204 +204 @@
                          * we leave the very last(unused) TD behind.
                          */
-                        ehci_batch->base.transferred_size
-                            -= td_remain_size(&ehci_batch->tds[i]);
+                        ehci_batch->base.transferred_size -=
+                            td_remain_size(&ehci_batch->tds[i]);
                 } else {
                         usb_log_debug("Batch %p found error TD(%zu):%08x: %s.",
@@ -274 +274 @@
             dma_buffer_phys(&ehci_batch->ehci_dma_buffer, ehci_batch->setup_buffer),
             USB_DIRECTION_BOTH, USB_SETUP_PACKET_SIZE, toggle, false);
-        usb_log_debug2("Batch %p: Created CONTROL SETUP TD(%"PRIxn"): "
+        usb_log_debug2("Batch %p: Created CONTROL SETUP TD(%" PRIxn "): "
             "%08x:%08x:%08x", ehci_batch,
             dma_buffer_phys(&ehci_batch->ehci_dma_buffer, &ehci_batch->tds[0]),
@@ -292 +292 @@
                     dma_buffer_phys(&ehci_batch->ehci_dma_buffer, &ehci_batch->tds[td_current + 1]),
                     buffer, data_dir, transfer_size, toggle, false);
-                usb_log_debug2("Batch %p: Created CONTROL DATA TD(%"PRIxn"): "
+                usb_log_debug2("Batch %p: Created CONTROL DATA TD(%" PRIxn "): "
                     "%08x:%08x:%08x", ehci_batch,
                     dma_buffer_phys(&ehci_batch->ehci_dma_buffer, &ehci_batch->tds[td_current]),
@@ -308 +308 @@
         assert(td_current == ehci_batch->td_count - 1);
         td_init(&ehci_batch->tds[td_current], 0, 0, status_dir, 0, 1, true);
-        usb_log_debug2("Batch %p: Created CONTROL STATUS TD %d(%"PRIxn"): "
+        usb_log_debug2("Batch %p: Created CONTROL STATUS TD %d(%" PRIxn "): "
             "%08x:%08x:%08x", ehci_batch, td_current,
             dma_buffer_phys(&ehci_batch->ehci_dma_buffer, &ehci_batch->tds[td_current]),
@@ -340 +340 @@
             ehci_batch->data_buffer);
         while (remain_size > 0) {
-                const size_t transfer_size = remain_size > EHCI_TD_MAX_TRANSFER
-                    ? EHCI_TD_MAX_TRANSFER : remain_size;
+                const size_t transfer_size = remain_size > EHCI_TD_MAX_TRANSFER ?
+                    EHCI_TD_MAX_TRANSFER : remain_size;
 
                 const bool last = (remain_size == transfer_size);
                 td_init(&ehci_batch->tds[td_current],
                     last ? 0 : dma_buffer_phys(&ehci_batch->ehci_dma_buffer,
-                            &ehci_batch->tds[td_current + 1]),
+                    &ehci_batch->tds[td_current + 1]),
                     buffer, ehci_batch->base.dir, transfer_size, -1, last);
 
-                usb_log_debug2("Batch %p: DATA TD(%"PRIxn": %08x:%08x:%08x",
+                usb_log_debug2("Batch %p: DATA TD(%" PRIxn ": %08x:%08x:%08x",
                     ehci_batch,
                     dma_buffer_phys(&ehci_batch->ehci_dma_buffer,
-                        &ehci_batch->tds[td_current]),
+                    &ehci_batch->tds[td_current]),
                     ehci_batch->tds[td_current].status,
                     ehci_batch->tds[td_current].next,
@@ -365 +365 @@
 
 /** Transfer setup table. */
-static void (*const batch_setup[])(ehci_transfer_batch_t*) =
-{
+static void (*const batch_setup[])(ehci_transfer_batch_t *) =
+    {
         [USB_TRANSFER_CONTROL] = batch_control,
         [USB_TRANSFER_BULK] = batch_data,

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

@@ -119 +119 @@
         }
         for (unsigned i = 0; i < instance->port_count; ++i)
-                usb_log_debug2("RH(%p-%u): status: %"PRIx32, instance, i,
+                usb_log_debug2("RH(%p-%u): status: %" PRIx32, instance, i,
                     EHCI_RD(regs->portsc[i]));
 
@@ -147 +147 @@
         assert(batch);
         batch->error = virthub_base_request(&instance->base, batch->target,
-            batch->dir, (void*) batch->setup.buffer,
+            batch->dir, (void *) batch->setup.buffer,
             batch->dma_buffer.virt, batch->size,
             &batch->transferred_size);
@@ -195 +195 @@
         }
 
-        usb_transfer_batch_t * const batch = ep->active_batch;
+        usb_transfer_batch_t *const batch = ep->active_batch;
         endpoint_deactivate_locked(ep);
         instance->status_change_endpoint = NULL;
@@ -206 +206 @@
                     instance, batch);
                 batch->error = virthub_base_request(&instance->base, batch->target,
-                    batch->dir, (void*) batch->setup.buffer,
+                    batch->dir, (void *) batch->setup.buffer,
                     batch->dma_buffer.virt, batch->size,
                     &batch->transferred_size);
@@ -304 +304 @@
             EHCI2USB(reg, USB_PORTSC_PORT_POWER_FLAG, USB2_HUB_PORT_STATUS_POWER) |
             (((reg & USB_PORTSC_LINE_STATUS_MASK) == USB_PORTSC_LINE_STATUS_K) ?
-                (USB2_HUB_PORT_STATUS_LOW_SPEED) : 0) |
+            (USB2_HUB_PORT_STATUS_LOW_SPEED) : 0) |
             ((reg & USB_PORTSC_PORT_OWNER_FLAG) ? 0 : USB2_HUB_PORT_STATUS_HIGH_SPEED) |
             EHCI2USB(reg, USB_PORTSC_PORT_TEST_MASK, USB2_HUB_PORT_STATUS_TEST) |
@@ -312 +312 @@
             (hub->resume_flag[port] ? USB2_HUB_PORT_STATUS_C_SUSPEND : 0) |
             EHCI2USB(reg, USB_PORTSC_OC_CHANGE_FLAG, USB_HUB_PORT_STATUS_C_OC) |
-            (hub->reset_flag[port] ? USB_HUB_PORT_STATUS_C_RESET: 0)
-        );
+            (hub->reset_flag[port] ? USB_HUB_PORT_STATUS_C_RESET : 0));
         /* Note feature numbers for test and indicator feature do not
          * correspond to the port status bit locations */
-        usb_log_debug2("RH(%p-%u) port status: %"PRIx32"(%"PRIx32")", hub, port,
+        usb_log_debug2("RH(%p-%u) port status: %" PRIx32 "(%" PRIx32 ")", hub, port,
             status, reg);
         memcpy(data, &status, sizeof(status));
@@ -345 +344 @@
         if (!(EHCI_RD(job->hub->registers->portsc[job->port]) &
             USB_PORTSC_ENABLED_FLAG)) {
-                usb_log_info("RH(%p-%u): Port not enabled after reset (%"PRIX32
+                usb_log_info("RH(%p-%u): Port not enabled after reset (%" PRIX32
                     "), giving up ownership", job->hub, job->port,
                     EHCI_RD(job->hub->registers->portsc[job->port]));
@@ -370 +369 @@
 }
 
-static errno_t delayed_job(errno_t (*func)(void*), ehci_rh_t *rh, unsigned port)
+static errno_t delayed_job(errno_t (*func)(void *), ehci_rh_t *rh, unsigned port)
 {
         ehci_rh_job_t *job = malloc(sizeof(*job));
@@ -405 +404 @@
         const unsigned feature = uint16_usb2host(setup_packet->value);
         /* Enabled features to clear: see page 269 of USB specs */
-        switch (feature)
-        {
+        switch (feature) {
         case USB_HUB_FEATURE_PORT_POWER:          /*8*/
                 usb_log_debug2("RH(%p-%u): Clear port power.", hub, port);
@@ -424 +422 @@
                 if ((EHCI_RD(hub->registers->portsc[port]) &
                     USB_PORTSC_SUSPEND_FLAG) == 0)
-                    return EOK;
+                        return EOK;
                 /* Host driven resume */
                 EHCI_SET(hub->registers->portsc[port],
@@ -542 +540 @@
                         if ((status & USB_PORTSC_CONNECT_CH_FLAG) &&
                             (status & USB_PORTSC_LINE_STATUS_MASK) ==
-                                USB_PORTSC_LINE_STATUS_K)
+                            USB_PORTSC_LINE_STATUS_K)
                                 EHCI_SET(hub->registers->portsc[port],
                                     USB_PORTSC_PORT_OWNER_FLAG);
@@ -550 +548 @@
         }
 
-        usb_log_debug2("RH(%p): root hub interrupt mask: %"PRIx16, hub, mask);
+        usb_log_debug2("RH(%p): root hub interrupt mask: %" PRIx16, hub, mask);
 
         if (mask == 0)
@@ -619 +617 @@
 /** Virtual EHCI root hub ops */
 static usbvirt_device_ops_t ops = {
-        .control = control_transfer_handlers,
-        .data_in[HUB_STATUS_CHANGE_PIPE] = req_status_change_handler,
+        .control = control_transfer_handlers,
+        .data_in[HUB_STATUS_CHANGE_PIPE] = req_status_change_handler,
 };

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

@@ -133 +133 @@
 
         ehci_regs_t *registers =
-                (ehci_regs_t *)(RNGABSPTR(regs) + EHCI_RD8(instance->caps->caplength));
+            (ehci_regs_t *)(RNGABSPTR(regs) + EHCI_RD8(instance->caps->caplength));
         code->cmds[0].addr = (void *) &registers->usbsts;
         code->cmds[3].addr = (void *) &registers->usbsts;
@@ -158 +158 @@
         if (hw_res->mem_ranges.count != 1 ||
             hw_res->mem_ranges.ranges[0].size <
-                (sizeof(ehci_caps_regs_t) + sizeof(ehci_regs_t)))
-            return EINVAL;
+            (sizeof(ehci_caps_regs_t) + sizeof(ehci_regs_t)))
+                return EINVAL;
 
         errno_t ret = pio_enable_range(&hw_res->mem_ranges.ranges[0],
@@ -169 +169 @@
         }
 
-        usb_log_info("HC(%p): Device registers at %"PRIx64" (%zuB) accessible.",
+        usb_log_info("HC(%p): Device registers at %" PRIx64 " (%zuB) accessible.",
             instance, hw_res->mem_ranges.ranges[0].address.absolute,
             hw_res->mem_ranges.ranges[0].size);
         instance->registers =
-            (void*)instance->caps + EHCI_RD8(instance->caps->caplength);
+            (void *)instance->caps + EHCI_RD8(instance->caps->caplength);
         usb_log_info("HC(%p): Device control registers at %" PRIx64, instance,
-            hw_res->mem_ranges.ranges[0].address.absolute
-            + EHCI_RD8(instance->caps->caplength));
+            hw_res->mem_ranges.ranges[0].address.absolute +
+            EHCI_RD8(instance->caps->caplength));
 
         list_initialize(&instance->pending_endpoints);
@@ -221 +221 @@
             usb_str_transfer_type_short(ep->transfer_type),
             usb_str_direction(ep->direction));
-        switch (ep->transfer_type)
-        {
+        switch (ep->transfer_type) {
         case USB_TRANSFER_CONTROL:
         case USB_TRANSFER_BULK:
@@ -245 +244 @@
             usb_str_transfer_type_short(ep->transfer_type),
             usb_str_direction(ep->direction));
-        switch (ep->transfer_type)
-        {
+        switch (ep->transfer_type) {
         case USB_TRANSFER_INTERRUPT:
                 endpoint_list_remove_ep(&instance->int_list, ehci_ep);
@@ -305 +303 @@
         }
 
-        endpoint_t * const ep = batch->ep;
-        ehci_endpoint_t * const ehci_ep = ehci_endpoint_get(ep);
+        endpoint_t *const ep = batch->ep;
+        ehci_endpoint_t *const ehci_ep = ehci_endpoint_get(ep);
         ehci_transfer_batch_t *ehci_batch = ehci_transfer_batch_get(batch);
 
@@ -345 +343 @@
         assert(hc);
 
-        usb_log_debug2("HC(%p): Interrupt: %"PRIx32, hc, status);
+        usb_log_debug2("HC(%p): Interrupt: %" PRIx32, hc, status);
         if (status & USB_STS_PORT_CHANGE_FLAG) {
                 ehci_rh_interrupt(&hc->rh);
@@ -361 +359 @@
 
                 usb_log_debug2("HC(%p): Scanning %lu pending endpoints", hc,
-                        list_count(&hc->pending_endpoints));
+                    list_count(&hc->pending_endpoints));
                 list_foreach_safe(hc->pending_endpoints, current, next) {
-                        ehci_endpoint_t *ep
-                                = list_get_instance(current, ehci_endpoint_t, pending_link);
-
-                        ehci_transfer_batch_t *batch
-                                = ehci_transfer_batch_get(ep->base.active_batch);
+                        ehci_endpoint_t *ep =
+                            list_get_instance(current, ehci_endpoint_t, pending_link);
+
+                        ehci_transfer_batch_t *batch =
+                            ehci_transfer_batch_get(ep->base.active_batch);
                         assert(batch);
 
@@ -429 +427 @@
         assert(instance->periodic_list);
         uintptr_t phys_base =
-            addr_to_phys((void*)instance->periodic_list);
+            addr_to_phys((void *)instance->periodic_list);
         assert((phys_base & USB_PERIODIC_LIST_BASE_MASK) == phys_base);
         EHCI_WR(instance->registers->periodiclistbase, phys_base);
@@ -437 +435 @@
 
         /* Enable Async schedule */
-        phys_base = addr_to_phys((void*)instance->async_list.list_head);
+        phys_base = addr_to_phys((void *)instance->async_list.list_head);
         assert((phys_base & USB_ASYNCLIST_MASK) == phys_base);
         EHCI_WR(instance->registers->asynclistaddr, phys_base);
@@ -516 +514 @@
 
         usb_log_debug2("HC(%p): Initializing Periodic list.", instance);
-        for (unsigned i = 0; i < PAGE_SIZE/sizeof(link_pointer_t); ++i)
-        {
+        for (unsigned i = 0; i < PAGE_SIZE / sizeof(link_pointer_t); ++i) {
                 /* Disable everything for now */
                 instance->periodic_list[i] =

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

@@ -92 +92 @@
             ((dir[direction] & TD_STATUS_PID_MASK) << TD_STATUS_PID_SHIFT) |
             ((size & TD_STATUS_TOTAL_MASK) << TD_STATUS_TOTAL_SHIFT) |
-            (ioc ? TD_STATUS_IOC_FLAG : 0) );
+            (ioc ? TD_STATUS_IOC_FLAG : 0));
 
         if (toggle == 0 || toggle == 1) {
@@ -101 +101 @@
         if (buffer != 0) {
                 assert(size != 0);
-                for (unsigned i = 0; (i < ARRAY_SIZE(instance->buffer_pointer))
-                    && size; ++i) {
+                for (unsigned i = 0; (i < ARRAY_SIZE(instance->buffer_pointer)) &&
+                    size; ++i) {
                         const uintptr_t offset = buffer & TD_BUFFER_POINTER_OFFSET_MASK;
                         assert(offset == 0 || i == 0);

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

@@ -95 +95 @@
         ret = pci_config_space_read_32(
             parent_sess, eecp + USBLEGSUP_OFFSET, &usblegsup);
-        while ((ret == EOK) && (wait < DEFAULT_WAIT)
-            && (usblegsup & USBLEGSUP_BIOS_CONTROL)) {
+        while ((ret == EOK) && (wait < DEFAULT_WAIT) &&
+            (usblegsup & USBLEGSUP_BIOS_CONTROL)) {
                 async_usleep(WAIT_STEP);
                 ret = pci_config_space_read_32(parent_sess,
@@ -109 +109 @@
 
         /* BIOS failed to hand over control, this should not happen. */
-        usb_log_warning( "BIOS failed to release control after "
+        usb_log_warning("BIOS failed to release control after "
             "%zu usecs, force it.", wait);
         ret = pci_config_space_write_32(parent_sess,
@@ -197 +197 @@
                 usb_log_error("Failed to disable extended capabilities: %s.",
                     str_error(ret));
-                    goto clean;
+                goto clean;
         }
 clean:

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

@@ -158 +158 @@
         if (hw_res->mem_ranges.count != 1 ||
             hw_res->mem_ranges.ranges[0].size < sizeof(ohci_regs_t))
-            return EINVAL;
+                return EINVAL;
 
         errno_t ret = pio_enable_range(&hw_res->mem_ranges.ranges[0],
@@ -273 +273 @@
         assert(hc);
 
-        if (hc->registers){
+        if (hc->registers) {
                 *status = OHCI_RD(hc->registers->interrupt_status);
                 OHCI_WR(hc->registers->interrupt_status, *status);
@@ -301 +301 @@
 
         endpoint_t *ep = batch->ep;
-        ohci_endpoint_t * const ohci_ep = ohci_endpoint_get(ep);
+        ohci_endpoint_t *const ohci_ep = ohci_endpoint_get(ep);
         ohci_transfer_batch_t *ohci_batch = ohci_transfer_batch_get(batch);
         int err;
@@ -319 +319 @@
 
         /* Control and bulk schedules need a kick to start working */
-        switch (batch->ep->transfer_type)
-        {
+        switch (batch->ep->transfer_type) {
         case USB_TRANSFER_CONTROL:
                 OHCI_SET(hc->registers->command_status, CS_CLF);
@@ -364 +363 @@
 
                 list_foreach_safe(hc->pending_endpoints, current, next) {
-                        ohci_endpoint_t *ep
-                                = list_get_instance(current, ohci_endpoint_t, pending_link);
-
-                        ohci_transfer_batch_t *batch
-                                = ohci_transfer_batch_get(ep->base.active_batch);
+                        ohci_endpoint_t *ep =
+                            list_get_instance(current, ohci_endpoint_t, pending_link);
+
+                        ohci_transfer_batch_t *batch =
+                            ohci_transfer_batch_get(ep->base.active_batch);
                         assert(batch);
 
@@ -407 +406 @@
                  */
                 volatile uint32_t *ohci_emulation_reg =
-                (uint32_t*)((char*)instance->registers + LEGACY_REGS_OFFSET);
+                    (uint32_t *)((char *)instance->registers + LEGACY_REGS_OFFSET);
                 usb_log_debug("OHCI legacy register %p: %x.",
                     ohci_emulation_reg, OHCI_RD(*ohci_emulation_reg));

uspace/drv/bus/usb/ohci/hw_struct/endpoint_descriptor.c

@@ -81 +81 @@
         /* Status: address, endpoint nr, direction mask and max packet size. */
         OHCI_MEM32_WR(instance->status,
-            ((ep->device->address & ED_STATUS_FA_MASK) << ED_STATUS_FA_SHIFT)
-            | ((ep->endpoint & ED_STATUS_EN_MASK) << ED_STATUS_EN_SHIFT)
-            | ((dir[ep->direction] & ED_STATUS_D_MASK) << ED_STATUS_D_SHIFT)
-            | ((ep->max_packet_size & ED_STATUS_MPS_MASK) << ED_STATUS_MPS_SHIFT));
+            ((ep->device->address & ED_STATUS_FA_MASK) << ED_STATUS_FA_SHIFT) |
+            ((ep->endpoint & ED_STATUS_EN_MASK) << ED_STATUS_EN_SHIFT) |
+            ((dir[ep->direction] & ED_STATUS_D_MASK) << ED_STATUS_D_SHIFT) |
+            ((ep->max_packet_size & ED_STATUS_MPS_MASK) << ED_STATUS_MPS_SHIFT));
 
         /* Low speed flag */

uspace/drv/bus/usb/ohci/hw_struct/endpoint_descriptor.h

@@ -119 +119 @@
 {
         assert(instance);
-        return (OHCI_MEM32_RD(instance->td_head) & ED_TDHEAD_HALTED_FLAG)
-            || (OHCI_MEM32_RD(instance->status) & ED_STATUS_K_FLAG);
+        return (OHCI_MEM32_RD(instance->td_head) & ED_TDHEAD_HALTED_FLAG) ||
+            (OHCI_MEM32_RD(instance->status) & ED_STATUS_K_FLAG);
 }
 
@@ -137 +137 @@
 {
         assert(instance);
-        return (OHCI_MEM32_RD(instance->td_head) & ED_TDHEAD_PTR_MASK)
-            != (OHCI_MEM32_RD(instance->td_tail) & ED_TDTAIL_PTR_MASK);
+        return (OHCI_MEM32_RD(instance->td_head) & ED_TDHEAD_PTR_MASK) !=
+            (OHCI_MEM32_RD(instance->td_tail) & ED_TDTAIL_PTR_MASK);
 }
 

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

@@ -68 +68 @@
         /* Set PID and Error code */
         OHCI_MEM32_WR(instance->status,
-            ((dir[direction] & TD_STATUS_DP_MASK) << TD_STATUS_DP_SHIFT)
-            | ((CC_NOACCESS2 & TD_STATUS_CC_MASK) << TD_STATUS_CC_SHIFT));
+            ((dir[direction] & TD_STATUS_DP_MASK) << TD_STATUS_DP_SHIFT) |
+            ((CC_NOACCESS2 & TD_STATUS_CC_MASK) << TD_STATUS_CC_SHIFT));
 
         if (toggle == 0 || toggle == 1) {

uspace/drv/bus/usb/ohci/hw_struct/transfer_descriptor.h

@@ -103 +103 @@
 {
         assert(instance);
-        const int cc = (OHCI_MEM32_RD(instance->status) >> TD_STATUS_CC_SHIFT)
-                & TD_STATUS_CC_MASK;
+        const int cc = (OHCI_MEM32_RD(instance->status) >> TD_STATUS_CC_SHIFT) &
+            TD_STATUS_CC_MASK;
         /* This value is changed on transfer completion,
          * either to CC_NOERROR or and error code.
@@ -122 +122 @@
 {
         assert(instance);
-        const int cc = (OHCI_MEM32_RD(instance->status)
-            >> TD_STATUS_CC_SHIFT) & TD_STATUS_CC_MASK;
+        const int cc = (OHCI_MEM32_RD(instance->status) >>
+            TD_STATUS_CC_SHIFT) & TD_STATUS_CC_MASK;
         return cc_to_rc(cc);
 }

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

@@ -48 +48 @@
 #include "ohci_bus.h"
 
-static void (*const batch_setup[])(ohci_transfer_batch_t*);
+static void (*const batch_setup[])(ohci_transfer_batch_t *);
 
 /** Safely destructs ohci_transfer_batch_t structure
@@ -67 +67 @@
  * NULL otherwise.
  */
-ohci_transfer_batch_t * ohci_transfer_batch_create(endpoint_t *ep)
+ohci_transfer_batch_t *ohci_transfer_batch_create(endpoint_t *ep)
 {
         assert(ep);
@@ -97 +97 @@
                 return ENOTSUP;
 
-        ohci_batch->td_count = (usb_batch->size + OHCI_TD_MAX_TRANSFER - 1)
-            / OHCI_TD_MAX_TRANSFER;
+        ohci_batch->td_count = (usb_batch->size + OHCI_TD_MAX_TRANSFER - 1) /
+            OHCI_TD_MAX_TRANSFER;
         /* Control transfer need Setup and Status stage */
         if (usb_batch->ep->transfer_type == USB_TRANSFER_CONTROL) {
@@ -110 +110 @@
 
         const size_t td_size = ohci_batch->td_count * sizeof(td_t);
-        const size_t setup_size = (usb_batch->ep->transfer_type == USB_TRANSFER_CONTROL)
-                ? USB_SETUP_PACKET_SIZE
-                : 0;
+        const size_t setup_size = (usb_batch->ep->transfer_type == USB_TRANSFER_CONTROL) ?
+            USB_SETUP_PACKET_SIZE :
+            0;
 
         if (dma_buffer_alloc(&ohci_batch->ohci_dma_buffer, td_size + setup_size)) {
@@ -190 +190 @@
                          * we leave the very last(unused) TD behind.
                          */
-                        usb_batch->transferred_size
-                            -= td_remain_size(ohci_batch->tds[i]);
+                        usb_batch->transferred_size -=
+                            td_remain_size(ohci_batch->tds[i]);
                 } else {
                         usb_log_debug("Batch %p found error TD(%zu):%08x.",
@@ -289 +289 @@
         /* Data stage */
         size_t td_current = 1;
-        const char* buffer = ohci_batch->data_buffer;
+        const char *buffer = ohci_batch->data_buffer;
         size_t remain_size = ohci_batch->base.size;
         while (remain_size > 0) {
@@ -347 +347 @@
         char *buffer = ohci_batch->data_buffer;
         while (remain_size > 0) {
-                const size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER
-                    ? OHCI_TD_MAX_TRANSFER : remain_size;
+                const size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
+                    OHCI_TD_MAX_TRANSFER : remain_size;
 
                 td_init(
@@ -374 +374 @@
 
 /** Transfer setup table. */
-static void (*const batch_setup[])(ohci_transfer_batch_t*) =
-{
+static void (*const batch_setup[])(ohci_transfer_batch_t *) =
+    {
         [USB_TRANSFER_CONTROL] = batch_control,
         [USB_TRANSFER_BULK] = batch_data,

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

@@ -134 +134 @@
 static void ohci_unregister_ep(endpoint_t *ep)
 {
-        ohci_bus_t * const bus = (ohci_bus_t *) endpoint_get_bus(ep);
-        hc_t * const hc = bus->hc;
+        ohci_bus_t *const bus = (ohci_bus_t *) endpoint_get_bus(ep);
+        hc_t *const hc = bus->hc;
         assert(ep);
 
@@ -151 +151 @@
         endpoint_set_offline_locked(ep);
         list_remove(&ohci_ep->pending_link);
-        usb_transfer_batch_t * const batch = ep->active_batch;
+        usb_transfer_batch_t *const batch = ep->active_batch;
         endpoint_deactivate_locked(ep);
         fibril_mutex_unlock(&hc->guard);

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

@@ -94 +94 @@
         } else {
                 instance->hub_descriptor.rempow[1] =
-                     ((port_desc >> RHDB_DR_SHIFT) >> 8) & 0xff;
+                    ((port_desc >> RHDB_DR_SHIFT) >> 8) & 0xff;
         }
 
@@ -224 +224 @@
         }
 
-        usb_transfer_batch_t * const batch = ep->active_batch;
+        usb_transfer_batch_t *const batch = ep->active_batch;
         endpoint_deactivate_locked(ep);
         instance->status_change_endpoint = NULL;
@@ -347 +347 @@
         const unsigned feature = uint16_usb2host(setup_packet->value);
         /* Enabled features to clear: see page 269 of USB specs */
-        switch (feature)
-        {
+        switch (feature) {
         case USB_HUB_FEATURE_PORT_POWER:          /*8*/
                 rhda = OHCI_RD(hub->registers->rh_desc_a);
@@ -418 +417 @@
                 /* Ganged power switching, one port powers all */
                 if (!(rhda & RHDA_PSM_FLAG)) {
-                        OHCI_WR(hub->registers->rh_status,RHS_SET_GLOBAL_POWER);
+                        OHCI_WR(hub->registers->rh_status, RHS_SET_GLOBAL_POWER);
                         return EOK;
                 }
@@ -467 +466 @@
         for (unsigned port = 1; port <= hub->port_count; ++port) {
                 /* Write-clean bits are those that indicate change */
-                if (OHCI_RD(hub->registers->rh_port_status[port - 1])
-                    & RHPS_CHANGE_WC_MASK) {
+                if (OHCI_RD(hub->registers->rh_port_status[port - 1]) &
+                    RHPS_CHANGE_WC_MASK) {
                         mask |= (1 << port);
                 }
@@ -542 +541 @@
 /** Virtual OHCI root hub ops */
 static usbvirt_device_ops_t ops = {
-        .control = control_transfer_handlers,
-        .data_in[HUB_STATUS_CHANGE_PIPE] = req_status_change_handler,
+        .control = control_transfer_handlers,
+        .data_in[HUB_STATUS_CHANGE_PIPE] = req_status_change_handler,
 };

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

@@ -142 +142 @@
         memcpy(code->cmds, uhci_irq_commands, sizeof(uhci_irq_commands));
         uhci_regs_t *registers = (uhci_regs_t *) RNGABSPTR(regs);
-        code->cmds[0].addr = (void*)&registers->usbsts;
-        code->cmds[3].addr = (void*)&registers->usbsts;
+        code->cmds[0].addr = (void *)&registers->usbsts;
+        code->cmds[3].addr = (void *)&registers->usbsts;
 
         usb_log_debug("I/O regs at %p (size %zu), IRQ %d.",
@@ -215 +215 @@
         if (hw_res->io_ranges.count != 1 ||
             hw_res->io_ranges.ranges[0].size < sizeof(uhci_regs_t))
-            return EINVAL;
+                return EINVAL;
 
         instance->hw_failures = 0;
@@ -224 +224 @@
         if (ret != EOK) {
                 usb_log_error("Failed to gain access to registers: %s.",
-                    str_error(ret));
+                    str_error(ret));
                 return ret;
         }
@@ -285 +285 @@
         /* Reset hc, all states and counters. Hope that hw is not broken */
         pio_write_16(&registers->usbcmd, UHCI_CMD_HCRESET);
-        do { async_usleep(10); }
-        while ((pio_read_16(&registers->usbcmd) & UHCI_CMD_HCRESET) != 0);
+        do {
+                async_usleep(10);
+        } while ((pio_read_16(&registers->usbcmd) & UHCI_CMD_HCRESET) != 0);
 
         /* Set frame to exactly 1ms */
@@ -331 +332 @@
 static errno_t endpoint_register(endpoint_t *ep)
 {
-        hc_t * const hc = bus_to_hc(endpoint_get_bus(ep));
+        hc_t *const hc = bus_to_hc(endpoint_get_bus(ep));
 
         const errno_t err = usb2_bus_endpoint_register(&hc->bus_helper, ep);
@@ -353 +354 @@
 static void endpoint_unregister(endpoint_t *ep)
 {
-        hc_t * const hc = bus_to_hc(endpoint_get_bus(ep));
+        hc_t *const hc = bus_to_hc(endpoint_get_bus(ep));
         usb2_bus_endpoint_unregister(&hc->bus_helper, ep);
 
@@ -390 +391 @@
         }
 
-        uhci_transfer_batch_t * const batch =
-                uhci_transfer_batch_get(ep->active_batch);
+        uhci_transfer_batch_t *const batch =
+            uhci_transfer_batch_get(ep->active_batch);
 
         /* Remove the batch from the schedule to stop it from being finished. */
@@ -412 +413 @@
 static int device_enumerate(device_t *dev)
 {
-        hc_t * const hc = bus_to_hc(dev->bus);
+        hc_t *const hc = bus_to_hc(dev->bus);
         return usb2_bus_device_enumerate(&hc->bus_helper, dev);
 }
@@ -418 +419 @@
 static void device_gone(device_t *dev)
 {
-        hc_t * const hc = bus_to_hc(dev->bus);
+        hc_t *const hc = bus_to_hc(dev->bus);
         usb2_bus_device_gone(&hc->bus_helper, dev);
 }
@@ -482 +483 @@
         /* Set all frames to point to the first queue head */
         const uint32_t queue = LINK_POINTER_QH(
-                addr_to_phys(instance->transfers_interrupt.queue_head));
+            addr_to_phys(instance->transfers_interrupt.queue_head));
 
         for (unsigned i = 0; i < UHCI_FRAME_LIST_COUNT; ++i) {
@@ -524 +525 @@
         /* Connect lists into one schedule */
         transfer_list_set_next(&instance->transfers_control_full,
-                &instance->transfers_bulk_full);
+            &instance->transfers_bulk_full);
         transfer_list_set_next(&instance->transfers_control_slow,
-                &instance->transfers_control_full);
+            &instance->transfers_control_full);
         transfer_list_set_next(&instance->transfers_interrupt,
-                &instance->transfers_control_slow);
+            &instance->transfers_control_slow);
 
         /*FSBR, This feature is not needed (adds no benefit) and is supposedly
@@ -539 +540 @@
         /* Assign pointers to be used during scheduling */
         instance->transfers[USB_SPEED_FULL][USB_TRANSFER_INTERRUPT] =
-          &instance->transfers_interrupt;
+            &instance->transfers_interrupt;
         instance->transfers[USB_SPEED_LOW][USB_TRANSFER_INTERRUPT] =
-          &instance->transfers_interrupt;
+            &instance->transfers_interrupt;
         instance->transfers[USB_SPEED_FULL][USB_TRANSFER_CONTROL] =
-          &instance->transfers_control_full;
+            &instance->transfers_control_full;
         instance->transfers[USB_SPEED_LOW][USB_TRANSFER_CONTROL] =
-          &instance->transfers_control_slow;
+            &instance->transfers_control_slow;
         instance->transfers[USB_SPEED_FULL][USB_TRANSFER_BULK] =
-          &instance->transfers_bulk_full;
+            &instance->transfers_bulk_full;
 
         return EOK;
@@ -582 +583 @@
                 return uhci_rh_schedule(&hc->rh, batch);
 
-        transfer_list_t * const list =
+        transfer_list_t *const list =
             hc->transfers[ep->device->speed][ep->transfer_type];
 
@@ -629 +630 @@
                 int frnum = pio_read_16(&instance->registers->frnum) & 0x3ff;
 
-                uintptr_t expected_pa = instance->frame_list[frnum]
-                    & LINK_POINTER_ADDRESS_MASK;
+                uintptr_t expected_pa = instance->frame_list[frnum] &
+                    LINK_POINTER_ADDRESS_MASK;
                 uintptr_t real_pa = addr_to_phys(QH(interrupt));
                 if (expected_pa != real_pa) {
@@ -653 +654 @@
                 expected_pa = QH(control_full)->next & LINK_POINTER_ADDRESS_MASK;
                 real_pa = addr_to_phys(QH(bulk_full));
-                if (expected_pa != real_pa ) {
+                if (expected_pa != real_pa) {
                         usb_log_debug("Bulk QH: %p vs. %p.",
                             (void *) expected_pa, (void *) real_pa);

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

@@ -72 +72 @@
         assert(instance);
         assert(size < 1024);
-        assert((pid == USB_PID_SETUP) || (pid == USB_PID_IN)
-            || (pid == USB_PID_OUT));
+        assert((pid == USB_PID_SETUP) || (pid == USB_PID_IN) ||
+            (pid == USB_PID_OUT));
 
         const uint32_t next_pa = addr_to_phys(next);
         assert((next_pa & LINK_POINTER_ADDRESS_MASK) == next_pa);
 
-        instance->next = 0
-            | LINK_POINTER_VERTICAL_FLAG
-            | (next_pa ? next_pa : LINK_POINTER_TERMINATE_FLAG);
+        instance->next = 0 |
+            LINK_POINTER_VERTICAL_FLAG |
+            (next_pa ? next_pa : LINK_POINTER_TERMINATE_FLAG);
 
-        instance->status = 0
-            | ((err_count & TD_STATUS_ERROR_COUNT_MASK)
-                << TD_STATUS_ERROR_COUNT_POS)
-            | (low_speed ? TD_STATUS_LOW_SPEED_FLAG : 0)
-            | (iso ? TD_STATUS_ISOCHRONOUS_FLAG : 0)
-            | TD_STATUS_ERROR_ACTIVE;
+        instance->status = 0 |
+            ((err_count & TD_STATUS_ERROR_COUNT_MASK) <<
+            TD_STATUS_ERROR_COUNT_POS) |
+            (low_speed ? TD_STATUS_LOW_SPEED_FLAG : 0) |
+            (iso ? TD_STATUS_ISOCHRONOUS_FLAG : 0) |
+            TD_STATUS_ERROR_ACTIVE;
 
         if (pid == USB_PID_IN && !iso) {
@@ -93 +93 @@
         }
 
-        instance->device = 0
-            | (((size - 1) & TD_DEVICE_MAXLEN_MASK) << TD_DEVICE_MAXLEN_POS)
-            | (toggle ? TD_DEVICE_DATA_TOGGLE_ONE_FLAG : 0)
-            | ((target.address & TD_DEVICE_ADDRESS_MASK)
-                << TD_DEVICE_ADDRESS_POS)
-            | ((target.endpoint & TD_DEVICE_ENDPOINT_MASK)
-                << TD_DEVICE_ENDPOINT_POS)
-            | ((pid & TD_DEVICE_PID_MASK) << TD_DEVICE_PID_POS);
+        instance->device = 0 |
+            (((size - 1) & TD_DEVICE_MAXLEN_MASK) << TD_DEVICE_MAXLEN_POS) |
+            (toggle ? TD_DEVICE_DATA_TOGGLE_ONE_FLAG : 0) |
+            ((target.address & TD_DEVICE_ADDRESS_MASK) <<
+            TD_DEVICE_ADDRESS_POS) |
+            ((target.endpoint & TD_DEVICE_ENDPOINT_MASK) <<
+            TD_DEVICE_ENDPOINT_POS) |
+            ((pid & TD_DEVICE_PID_MASK) << TD_DEVICE_PID_POS);
 
         instance->buffer_ptr = addr_to_phys(buffer);
@@ -175 +175 @@
             (s & TD_STATUS_ERROR_BIT_STUFF) ? " BIT_STUFF," : "",
             (s & TD_STATUS_ERROR_RESERVED) ? " RESERVED," : "",
-            td_act_size(instance)
-        );
+            td_act_size(instance));
 }
 /**

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

@@ -129 +129 @@
         const size_t act_size = td_act_size(instance);
         const size_t max_size =
-            ((instance->device >> TD_DEVICE_MAXLEN_POS) + 1)
-            & TD_DEVICE_MAXLEN_MASK;
+            ((instance->device >> TD_DEVICE_MAXLEN_POS) + 1) &
+            TD_DEVICE_MAXLEN_MASK;
         return
             (instance->status | TD_STATUS_SPD_FLAG) && act_size < max_size;

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

@@ -66 +66 @@
         }
         const uint32_t queue_head_pa = addr_to_phys(instance->queue_head);
-        usb_log_debug2("Transfer list %s setup with QH: %p (%#" PRIx32" ).",
+        usb_log_debug2("Transfer list %s setup with QH: %p (%#" PRIx32 " ).",
             name, instance->queue_head, queue_head_pa);
 
@@ -203 +203 @@
         fibril_mutex_lock(&instance->guard);
         while (!list_empty(&instance->batch_list)) {
-                link_t * const current = list_first(&instance->batch_list);
+                link_t *const current = list_first(&instance->batch_list);
                 uhci_transfer_batch_t *batch = uhci_transfer_batch_from_link(current);
                 transfer_list_remove_batch(instance, batch);
@@ -240 +240 @@
                 qpos = "NOT FIRST";
         }
-        assert((prev_qh->next & LINK_POINTER_ADDRESS_MASK)
-            == addr_to_phys(uhci_batch->qh));
+        assert((prev_qh->next & LINK_POINTER_ADDRESS_MASK) ==
+            addr_to_phys(uhci_batch->qh));
         prev_qh->next = uhci_batch->qh->next;
 

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

@@ -107 +107 @@
         do {
                 batch->error = virthub_base_request(&instance->base, batch->target,
-                    batch->dir, (void*) batch->setup.buffer,
+                    batch->dir, (void *) batch->setup.buffer,
                     batch->dma_buffer.virt, batch->size, &batch->transferred_size);
                 if (batch->error == ENAK)
@@ -151 +151 @@
         port_status &= ~STATUS_IN_RESET;
         pio_write_16(port, port_status);
-        while ((port_status = pio_read_16(port)) & STATUS_IN_RESET);
+        while ((port_status = pio_read_16(port)) & STATUS_IN_RESET)
+                ;
         /* PIO delay, should not be longer than 3ms as the device might
          * enter suspend state. */
@@ -201 +202 @@
 
         const uint16_t value = pio_read_16(hub->ports[port]);
-        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")",
+        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 ")",
             data[0], value);
         *act_size = 1;
@@ -246 +247 @@
             UHCI2USB(val, STATUS_ENABLED_CHANGED, USB2_HUB_PORT_STATUS_C_ENABLE) |
 //          UHCI2USB(val, STATUS_SUSPEND, USB2_HUB_PORT_STATUS_C_SUSPEND) |
-            (hub->reset_changed[port] ?  USB_HUB_PORT_STATUS_C_RESET : 0)
-        );
+            (hub->reset_changed[port] ?  USB_HUB_PORT_STATUS_C_RESET : 0));
         RH_DEBUG(hub, port, "Port status %" PRIx32 " (source %" PRIx16
             "%s)", uint32_usb2host(status), val,
@@ -413 +413 @@
         const uint8_t status =
             ((((status_a & STATUS_CHANGE_BITS) != 0) || hub->reset_changed[0]) ?
-                0x2 : 0) |
+            0x2 : 0) |
             ((((status_b & STATUS_CHANGE_BITS) != 0) || hub->reset_changed[1]) ?
-                0x4 : 0);
+            0x4 : 0);
         if (status)
                 RH_DEBUG(hub, -1, "Event mask %" PRIx8
@@ -421 +421 @@
                     " (status_b %" PRIx16 "%s)", status,
                     status_a, hub->reset_changed[0] ? "-reset" : "",
-                    status_b, hub->reset_changed[1] ? "-reset" : "" );
+                    status_b, hub->reset_changed[1] ? "-reset" : "");
         ((uint8_t *)buffer)[0] = status;
         *actual_size = 1;
@@ -496 +496 @@
 
 static usbvirt_device_ops_t ops = {
-        .control = control_transfer_handlers,
-        .data_in[HUB_STATUS_CHANGE_PIPE] = req_status_change_handler,
+        .control = control_transfer_handlers,
+        .data_in[HUB_STATUS_CHANGE_PIPE] = req_status_change_handler,
 };

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

@@ -111 +111 @@
                                 if (beef_buffer[i] != test_data) {
                                         usb_log_error("Read of %s IN endpoint returned "
-                                                "invalid data at address %zu. [ 0x%X != 0x%X ]",
-                                                usb_str_transfer_type(pipe->desc.transfer_type), i * sizeof(test_data), beef_buffer[i], test_data);
+                                            "invalid data at address %zu. [ 0x%X != 0x%X ]",
+                                            usb_str_transfer_type(pipe->desc.transfer_type), i * sizeof(test_data), beef_buffer[i], test_data);
                                         rc = EINVAL;
                                 }

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

@@ -126 +126 @@
         port_log(debug, port, "Resetting port.");
         if ((err = usb_hub_set_port_feature(port->hub, port->port_number,
-                            USB_HUB_FEATURE_PORT_RESET))) {
+            USB_HUB_FEATURE_PORT_RESET))) {
                 port_log(warning, port, "Port reset request failed: %s",
                     str_error(err));
@@ -140 +140 @@
         port_log(debug, port, "Enumerating device.");
         if ((err = usbhc_device_enumerate(exch, port->port_number,
-                            port->speed))) {
+            port->speed))) {
                 port_log(error, port, "Failed to enumerate device: %s",
                     str_error(err));
@@ -165 +165 @@
         port_log(debug, port, "Issuing a warm reset.");
         if ((err = usb_hub_set_port_feature(port->hub, port->port_number,
-                            USB3_HUB_FEATURE_BH_PORT_RESET))) {
+            USB3_HUB_FEATURE_BH_PORT_RESET))) {
                 port_log(warning, port, "Port reset request failed: %s",
                     str_error(err));
@@ -179 +179 @@
         port_log(debug, port, "Enumerating device.");
         if ((err = usbhc_device_enumerate(exch, port->port_number,
-                            port->speed))) {
+            port->speed))) {
                 port_log(error, port, "Failed to enumerate device: %s",
                     str_error(err));
@@ -200 +200 @@
         }
 
-        const errno_t err = port->hub->speed == USB_SPEED_SUPER
-                ? enumerate_device_usb3(port, exch)
-                : enumerate_device_usb2(port, exch);
+        const errno_t err = port->hub->speed == USB_SPEED_SUPER ?
+            enumerate_device_usb3(port, exch) :
+            enumerate_device_usb2(port, exch);
 
         usb_device_bus_exchange_end(exch);
@@ -211 +211 @@
 {
         const bool connected = !!(status & USB_HUB_PORT_STATUS_CONNECTION);
-        port_log(debug, port, "Connection change: device %s.", connected
-            ? "attached" : "removed");
+        port_log(debug, port, "Connection change: device %s.", connected ?
+            "attached" : "removed");
 
         if (connected) {

uspace/drv/bus/usb/usbhub/status.h

@@ -59 +59 @@
         if (hub_speed == USB_SPEED_SUPER)
                 return USB_SPEED_SUPER;
-        if (hub_speed == USB_SPEED_HIGH
-            && (status & USB2_HUB_PORT_STATUS_HIGH_SPEED))
+        if (hub_speed == USB_SPEED_HIGH &&
+            (status & USB2_HUB_PORT_STATUS_HIGH_SPEED))
                 return USB_SPEED_HIGH;
         if ((status & USB2_HUB_PORT_STATUS_LOW_SPEED) != 0)

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

@@ -83 +83 @@
  */
 static const usb_endpoint_description_t
-        status_change_single_tt_only = HUB_STATUS_CHANGE_EP(0),
-        status_change_mtt_available = HUB_STATUS_CHANGE_EP(1);
+    status_change_single_tt_only = HUB_STATUS_CHANGE_EP(0),
+    status_change_mtt_available = HUB_STATUS_CHANGE_EP(1);
 
 const usb_endpoint_description_t *usb_hub_endpoints [] = {
@@ -107 +107 @@
 
 static bool usb_hub_polling_error_callback(usb_device_t *dev,
-        errno_t err_code, void *arg)
+    errno_t err_code, void *arg)
 {
         assert(dev);
@@ -113 +113 @@
 
         usb_log_error("Device %s polling error: %s",
-                usb_device_get_name(dev), str_error(err_code));
+            usb_device_get_name(dev), str_error(err_code));
 
         return true;
@@ -153 +153 @@
         }
 
-        const usb_endpoint_description_t *status_change = hub_dev->mtt_available
-            ? &status_change_mtt_available
-            : &status_change_single_tt_only;
-
-        usb_endpoint_mapping_t *status_change_mapping
-                = usb_device_get_mapped_ep_desc(hub_dev->usb_device, status_change);
+        const usb_endpoint_description_t *status_change = hub_dev->mtt_available ?
+            &status_change_mtt_available :
+            &status_change_single_tt_only;
+
+        usb_endpoint_mapping_t *status_change_mapping =
+            usb_device_get_mapped_ep_desc(hub_dev->usb_device, status_change);
         if (!status_change_mapping) {
                 usb_log_error("Failed to map the Status Change Endpoint of a hub.");
@@ -212 +212 @@
         if (ret != EOK) {
                 usb_log_error("(%p) Failed to unbind '%s' function: %s.",
-                   hub, HUB_FNC_NAME, str_error(ret));
+                    hub, HUB_FNC_NAME, str_error(ret));
                 return ret;
         }
@@ -272 +272 @@
  */
 static errno_t usb_hub_polling_init(usb_hub_dev_t *hub_dev,
-        usb_endpoint_mapping_t *mapping)
+    usb_endpoint_mapping_t *mapping)
 {
         errno_t err;
@@ -377 +377 @@
         usb_pipe_t *control_pipe = usb_device_get_default_pipe(hub_dev->usb_device);
 
-        usb_descriptor_type_t desc_type = hub_dev->speed >= USB_SPEED_SUPER
-                ? USB_DESCTYPE_SSPEED_HUB : USB_DESCTYPE_HUB;
+        usb_descriptor_type_t desc_type = hub_dev->speed >= USB_SPEED_SUPER ?
+            USB_DESCTYPE_SSPEED_HUB : USB_DESCTYPE_HUB;
 
         /* Get hub descriptor. */
@@ -420 +420 @@
             descriptor.characteristics & HUB_CHAR_POWER_PER_PORT_FLAG;
 
-        const uint8_t protocol = usb_device_descriptors(hub_dev->usb_device)
-                ->device.device_protocol;
+        const uint8_t protocol = usb_device_descriptors(hub_dev->usb_device)->device.device_protocol;
         hub_dev->mtt_available = (protocol == 2);
 
@@ -456 +455 @@
 
         if (config_size < sizeof(usb_standard_configuration_descriptor_t)) {
-            usb_log_error("Configuration descriptor is not big enough"
-                " to fit standard configuration descriptor.\n");
-            return EOVERFLOW;
+                usb_log_error("Configuration descriptor is not big enough"
+                    " to fit standard configuration descriptor.\n");
+                return EOVERFLOW;
         }
 

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

@@ -89 +89 @@
         for (; interface_ptr != NULL;
             interface_ptr = usb_dp_get_sibling_descriptor(
-                &parser, &data, config_descriptor, interface_ptr))
-        {
+            &parser, &data, config_descriptor, interface_ptr)) {
                 /* The second byte is DESCTYPE byte in all desriptors. */
                 if (interface_ptr[1] != USB_DESCTYPE_INTERFACE)
                         continue;
 
-                const usb_standard_interface_descriptor_t *interface
-                    = (usb_standard_interface_descriptor_t *) interface_ptr;
+                const usb_standard_interface_descriptor_t *interface =
+                    (usb_standard_interface_descriptor_t *) interface_ptr;
 
                 /* Skip alternate interfaces. */
@@ -112 +111 @@
                 usbmid_interface_t *iface = NULL;
                 const errno_t rc = usbmid_spawn_interface_child(usb_dev, &iface,
-                        &usb_device_descriptors(usb_dev)->device, interface);
+                    &usb_device_descriptors(usb_dev)->device, interface);
                 if (rc != EOK) {
                         //TODO: Do something about that failure.

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

@@ -101 +101 @@
         .descriptor_type = USB_DESCTYPE_CONFIGURATION,
         .total_length =
-                sizeof(usb_standard_configuration_descriptor_t)
-                + sizeof(std_interface_descriptor)
-                + sizeof(hub_descriptor)
-                + sizeof(endpoint_descriptor)
-                ,
+            sizeof(usb_standard_configuration_descriptor_t) +
+            sizeof(std_interface_descriptor) +
+            sizeof(hub_descriptor) +
+            sizeof(endpoint_descriptor),
         .interface_count = 1,
         .configuration_number = HUB_CONFIGURATION_ID,
@@ -133 +132 @@
         .descriptor = &std_configuration_descriptor,
         .extra = extra_descriptors,
-        .extra_count = sizeof(extra_descriptors)/sizeof(extra_descriptors[0])
+        .extra_count = sizeof(extra_descriptors) / sizeof(extra_descriptors[0])
 };
 
@@ -148 +147 @@
  * @return Error code.
  */
-errno_t virthub_init(usbvirt_device_t *dev, const char* name)
+errno_t virthub_init(usbvirt_device_t *dev, const char *name)
 {
         if (dev == NULL) {

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

@@ -49 +49 @@
 
         switch (new_state) {
-                case USBVIRT_STATE_CONFIGURED:
-                        hub_set_port_state_all(hub, HUB_PORT_STATE_POWERED_OFF);
-                        break;
-                case USBVIRT_STATE_ADDRESS:
-                        hub_set_port_state_all(hub, HUB_PORT_STATE_NOT_CONFIGURED);
-                        break;
-                default:
-                        break;
+        case USBVIRT_STATE_CONFIGURED:
+                hub_set_port_state_all(hub, HUB_PORT_STATE_POWERED_OFF);
+                break;
+        case USBVIRT_STATE_ADDRESS:
+                hub_set_port_state_all(hub, HUB_PORT_STATE_NOT_CONFIGURED);
+                break;
+        default:
+                break;
         }
 
@@ -137 +137 @@
 
         switch (feature) {
-                case USB2_HUB_FEATURE_PORT_ENABLE:
-                        if ((port_state != HUB_PORT_STATE_NOT_CONFIGURED)
-                            && (port_state != HUB_PORT_STATE_POWERED_OFF)) {
-                                hub_set_port_state(hub, port, HUB_PORT_STATE_DISABLED);
-                        }
+        case USB2_HUB_FEATURE_PORT_ENABLE:
+                if ((port_state != HUB_PORT_STATE_NOT_CONFIGURED) &&
+                    (port_state != HUB_PORT_STATE_POWERED_OFF)) {
+                        hub_set_port_state(hub, port, HUB_PORT_STATE_DISABLED);
+                }
+                rc = EOK;
+                break;
+
+        case USB2_HUB_FEATURE_PORT_SUSPEND:
+                if (port_state != HUB_PORT_STATE_SUSPENDED) {
                         rc = EOK;
                         break;
-
-                case USB2_HUB_FEATURE_PORT_SUSPEND:
-                        if (port_state != HUB_PORT_STATE_SUSPENDED) {
-                                rc = EOK;
-                                break;
-                        }
-                        hub_set_port_state(hub, port, HUB_PORT_STATE_RESUMING);
-                        rc = EOK;
-                        break;
-
-                case USB_HUB_FEATURE_PORT_POWER:
-                        if (port_state != HUB_PORT_STATE_NOT_CONFIGURED) {
-                                hub_set_port_state(hub, port, HUB_PORT_STATE_POWERED_OFF);
-                        }
-                        rc = EOK;
-                        break;
-
-                case USB_HUB_FEATURE_C_PORT_CONNECTION:
-                        hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_CONNECTION);
-                        rc = EOK;
-                        break;
-
-                case USB2_HUB_FEATURE_C_PORT_ENABLE:
-                        hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_ENABLE);
-                        rc = EOK;
-                        break;
-
-                case USB2_HUB_FEATURE_C_PORT_SUSPEND:
-                        hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_SUSPEND);
-                        rc = EOK;
-                        break;
-
-                case USB_HUB_FEATURE_C_PORT_OVER_CURRENT:
-                        hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_OVER_CURRENT);
-                        rc = EOK;
-                        break;
-
-                case USB_HUB_FEATURE_C_PORT_RESET:
-                        hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_RESET);
-                        rc = EOK;
-                        break;
-
-                default:
-                        rc = ENOTSUP;
-                        break;
+                }
+                hub_set_port_state(hub, port, HUB_PORT_STATE_RESUMING);
+                rc = EOK;
+                break;
+
+        case USB_HUB_FEATURE_PORT_POWER:
+                if (port_state != HUB_PORT_STATE_NOT_CONFIGURED) {
+                        hub_set_port_state(hub, port, HUB_PORT_STATE_POWERED_OFF);
+                }
+                rc = EOK;
+                break;
+
+        case USB_HUB_FEATURE_C_PORT_CONNECTION:
+                hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_CONNECTION);
+                rc = EOK;
+                break;
+
+        case USB2_HUB_FEATURE_C_PORT_ENABLE:
+                hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_ENABLE);
+                rc = EOK;
+                break;
+
+        case USB2_HUB_FEATURE_C_PORT_SUSPEND:
+                hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_SUSPEND);
+                rc = EOK;
+                break;
+
+        case USB_HUB_FEATURE_C_PORT_OVER_CURRENT:
+                hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_OVER_CURRENT);
+                rc = EOK;
+                break;
+
+        case USB_HUB_FEATURE_C_PORT_RESET:
+                hub_clear_port_status_change(hub, port, HUB_STATUS_C_PORT_RESET);
+                rc = EOK;
+                break;
+
+        default:
+                rc = ENOTSUP;
+                break;
         }
 
@@ -310 +310 @@
 
         switch (feature) {
-                case USB_HUB_FEATURE_PORT_RESET:
-                        if (port_state != HUB_PORT_STATE_POWERED_OFF) {
-                                hub_set_port_state(hub, port, HUB_PORT_STATE_RESETTING);
-                        }
-                        rc = EOK;
-                        break;
-
-                case USB2_HUB_FEATURE_PORT_SUSPEND:
-                        if (port_state == HUB_PORT_STATE_ENABLED) {
-                                hub_set_port_state(hub, port, HUB_PORT_STATE_SUSPENDED);
-                        }
-                        rc = EOK;
-                        break;
-
-                case USB_HUB_FEATURE_PORT_POWER:
-                        if (port_state == HUB_PORT_STATE_POWERED_OFF) {
-                                hub_set_port_state(hub, port, HUB_PORT_STATE_DISCONNECTED);
-                        }
-                        rc = EOK;
-                        break;
-
-                default:
-                        break;
+        case USB_HUB_FEATURE_PORT_RESET:
+                if (port_state != HUB_PORT_STATE_POWERED_OFF) {
+                        hub_set_port_state(hub, port, HUB_PORT_STATE_RESETTING);
+                }
+                rc = EOK;
+                break;
+
+        case USB2_HUB_FEATURE_PORT_SUSPEND:
+                if (port_state == HUB_PORT_STATE_ENABLED) {
+                        hub_set_port_state(hub, port, HUB_PORT_STATE_SUSPENDED);
+                }
+                rc = EOK;
+                break;
+
+        case USB_HUB_FEATURE_PORT_POWER:
+                if (port_state == HUB_PORT_STATE_POWERED_OFF) {
+                        hub_set_port_state(hub, port, HUB_PORT_STATE_DISCONNECTED);
+                }
+                rc = EOK;
+                break;
+
+        default:
+                break;
         }
 

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

@@ -159 +159 @@
         }
 
-        return cmd_link
-            ? list_get_instance(cmd_link, xhci_cmd_t, _header.link)
-            : NULL;
+        return cmd_link ?
+            list_get_instance(cmd_link, xhci_cmd_t, _header.link) :
+            NULL;
 }
 

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

@@ -382 +382 @@
 }
 
-void xhci_dump_input_ctx(const xhci_hc_t * hc, const struct xhci_input_ctx *ictx)
+void xhci_dump_input_ctx(const xhci_hc_t *hc, const struct xhci_input_ctx *ictx)
 {
         xhci_device_ctx_t *device_ctx = XHCI_GET_DEVICE_CTX(ictx, hc);
@@ -400 +400 @@
 
         for (uint8_t dci = 1; dci <= XHCI_EP_COUNT; dci++)
-                if (XHCI_INPUT_CTRL_CTX_DROP(*ctrl_ctx, dci)
-                    || XHCI_INPUT_CTRL_CTX_ADD(*ctrl_ctx, dci)) {
+                if (XHCI_INPUT_CTRL_CTX_DROP(*ctrl_ctx, dci) ||
+                    XHCI_INPUT_CTRL_CTX_ADD(*ctrl_ctx, dci)) {
                         usb_log_debug("Endpoint context DCI %u:", dci);
                         xhci_ep_ctx_t *ep_ctx = XHCI_GET_EP_CTX(device_ctx, hc, dci);

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

@@ -59 +59 @@
  */
 static errno_t xhci_endpoint_init(xhci_endpoint_t *xhci_ep, device_t *dev,
-        const usb_endpoint_descriptors_t *desc)
+    const usb_endpoint_descriptors_t *desc)
 {
         errno_t rc;
@@ -88 +88 @@
         if (dev->speed >= USB_SPEED_SUPER) {
                 ep->packets_per_uframe = xhci_ep->max_burst * xhci_ep->mult;
-                if (ep->transfer_type == USB_TRANSFER_ISOCHRONOUS
-                        || ep->transfer_type == USB_TRANSFER_INTERRUPT) {
+                if (ep->transfer_type == USB_TRANSFER_ISOCHRONOUS ||
+                    ep->transfer_type == USB_TRANSFER_INTERRUPT) {
                         ep->max_transfer_size = ep->max_packet_size * ep->packets_per_uframe;
                 }
@@ -100 +100 @@
          * others have 2-based log of it.
          */
-        if (dev->speed >= USB_SPEED_HIGH
-            || ep->transfer_type != USB_TRANSFER_INTERRUPT) {
+        if (dev->speed >= USB_SPEED_HIGH ||
+            ep->transfer_type != USB_TRANSFER_INTERRUPT) {
                 xhci_ep->interval = 1 << (xhci_ep->interval - 1);
         }
@@ -141 +141 @@
  */
 endpoint_t *xhci_endpoint_create(device_t *dev,
-        const usb_endpoint_descriptors_t *desc)
+    const usb_endpoint_descriptors_t *desc)
 {
         const usb_transfer_type_t type = USB_ED_GET_TRANSFER_TYPE(desc->endpoint);
 
-        xhci_endpoint_t *ep = calloc(1, sizeof(xhci_endpoint_t)
-                + (type == USB_TRANSFER_ISOCHRONOUS) * sizeof(*ep->isoch));
+        xhci_endpoint_t *ep = calloc(1, sizeof(xhci_endpoint_t) +
+            (type == USB_TRANSFER_ISOCHRONOUS) * sizeof(*ep->isoch));
         if (!ep)
                 return NULL;
@@ -230 +230 @@
         }
 
-        usb_transfer_batch_t * const batch = ep->active_batch;
+        usb_transfer_batch_t *const batch = ep->active_batch;
 
         const errno_t err = hc_stop_endpoint(xhci_ep);
@@ -289 +289 @@
 
         case USB_TRANSFER_ISOCHRONOUS:
-                return in ? EP_TYPE_ISOCH_IN
-                          : EP_TYPE_ISOCH_OUT;
+                return in ? EP_TYPE_ISOCH_IN :
+                    EP_TYPE_ISOCH_OUT;
 
         case USB_TRANSFER_BULK:
-                return in ? EP_TYPE_BULK_IN
-                          : EP_TYPE_BULK_OUT;
+                return in ? EP_TYPE_BULK_IN :
+                    EP_TYPE_BULK_OUT;
 
         case USB_TRANSFER_INTERRUPT:
-                return in ? EP_TYPE_INTERRUPT_IN
-                          : EP_TYPE_INTERRUPT_OUT;
+                return in ? EP_TYPE_INTERRUPT_IN :
+                    EP_TYPE_INTERRUPT_OUT;
         }
 

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

@@ -87 +87 @@
         xhci_port_speed_t *speeds = hc->speeds;
 
-        for (xhci_extcap_t *ec = hc->xecp; ec; ec = xhci_extcap_next(ec)) {
+        for (xhci_extcap_t * ec = hc->xecp; ec; ec = xhci_extcap_next(ec)) {
                 xhci_dump_extcap(ec);
                 switch (XHCI_REG_RD(ec, XHCI_EC_CAP_ID)) {
@@ -151 +151 @@
                                          * mapping also for devices connected to hubs.
                                          */
-                                        if (psiv < ARRAY_SIZE(default_psiv_to_port_speed)
-                                           && default_psiv_to_port_speed[psiv].major == major
-                                           && default_psiv_to_port_speed[psiv].minor == minor
-                                           && default_psiv_to_port_speed[psiv].rx_bps == bps
-                                           && default_psiv_to_port_speed[psiv].tx_bps == bps) {
+                                        if (psiv < ARRAY_SIZE(default_psiv_to_port_speed) &&
+                                            default_psiv_to_port_speed[psiv].major == major &&
+                                            default_psiv_to_port_speed[psiv].minor == minor &&
+                                            default_psiv_to_port_speed[psiv].rx_bps == bps &&
+                                            default_psiv_to_port_speed[psiv].tx_bps == bps) {
                                                 speeds[psiv] = default_psiv_to_port_speed[psiv];
                                                 usb_log_debug("Assumed default %s speed of USB %u.",
-                                                        usb_str_speed(speeds[psiv].usb_speed), major);
+                                                    usb_str_speed(speeds[psiv].usb_speed), major);
                                                 continue;
                                         }
@@ -173 +173 @@
                                                 speeds[psiv].tx_bps = bps;
                                                 usb_log_debug("Speed %u set up for bps %" PRIu64
-                                                        " / %" PRIu64 ".", psiv, speeds[psiv].rx_bps,
-                                                        speeds[psiv].tx_bps);
+                                                    " / %" PRIu64 ".", psiv, speeds[psiv].rx_bps,
+                                                    speeds[psiv].tx_bps);
                                         }
                                 }
@@ -384 +384 @@
         code->rangecount = 1;
         code->ranges[0] = (irq_pio_range_t) {
-            .base = RNGABS(hc->mmio_range),
-            .size = RNGSZ(hc->mmio_range),
+                .base = RNGABS(hc->mmio_range),
+                .size = RNGSZ(hc->mmio_range),
         };
 
@@ -391 +391 @@
         memcpy(code->cmds, irq_commands, sizeof(irq_commands));
 
-        void *intr0_iman = RNGABSPTR(hc->mmio_range)
-            + XHCI_REG_RD(hc->cap_regs, XHCI_CAP_RTSOFF)
-            + offsetof(xhci_rt_regs_t, ir[0]);
-        void *usbsts = RNGABSPTR(hc->mmio_range)
-            + XHCI_REG_RD(hc->cap_regs, XHCI_CAP_LENGTH)
-            + offsetof(xhci_op_regs_t, usbsts);
+        void *intr0_iman = RNGABSPTR(hc->mmio_range) +
+            XHCI_REG_RD(hc->cap_regs, XHCI_CAP_RTSOFF) +
+            offsetof(xhci_rt_regs_t, ir[0]);
+        void *usbsts = RNGABSPTR(hc->mmio_range) +
+            XHCI_REG_RD(hc->cap_regs, XHCI_CAP_LENGTH) +
+            offsetof(xhci_op_regs_t, usbsts);
 
         code->cmds[0].addr = intr0_iman;
@@ -425 +425 @@
         for (int i = 0; i <= (XHCI_LEGSUP_BIOS_TIMEOUT_US / XHCI_LEGSUP_POLLING_DELAY_1MS); i++) {
                 usb_log_debug("LEGSUP: elapsed: %i ms, bios: %x, os: %x", i,
-                        XHCI_REG_RD(hc->legsup, XHCI_LEGSUP_SEM_BIOS),
-                        XHCI_REG_RD(hc->legsup, XHCI_LEGSUP_SEM_OS));
+                    XHCI_REG_RD(hc->legsup, XHCI_LEGSUP_SEM_BIOS),
+                    XHCI_REG_RD(hc->legsup, XHCI_LEGSUP_SEM_OS));
                 if (XHCI_REG_RD(hc->legsup, XHCI_LEGSUP_SEM_BIOS) == 0) {
                         return XHCI_REG_RD(hc->legsup, XHCI_LEGSUP_SEM_OS) == 1 ? EOK : EIO;
@@ -559 +559 @@
         const uint32_t usbsts = XHCI_REG_RD_FIELD(&hc->op_regs->usbsts, 32);
 
-        return !(usbcmd & XHCI_REG_MASK(XHCI_OP_RS))
-            ||  (usbsts & XHCI_REG_MASK(XHCI_OP_HCE))
-            ||  (usbsts & XHCI_REG_MASK(XHCI_OP_HSE));
+        return !(usbcmd & XHCI_REG_MASK(XHCI_OP_RS)) ||
+            (usbsts & XHCI_REG_MASK(XHCI_OP_HCE)) ||
+            (usbsts & XHCI_REG_MASK(XHCI_OP_HSE));
 }
 
@@ -589 +589 @@
         struct timeval tv;
         getuptime(&tv);
-        usb_log_debug("Microframe index wrapped (@%lu.%li, %"PRIu64" total).",
+        usb_log_debug("Microframe index wrapped (@%lu.%li, %" PRIu64 " total).",
             tv.tv_sec, tv.tv_usec, hc->wrap_count);
         hc->wrap_time = ((uint64_t) tv.tv_sec) * 1000000 + ((uint64_t) tv.tv_usec);
@@ -634 +634 @@
         errno_t err;
         xhci_trb_t trb;
-        xhci_hc_t * const hc = arg;
+        xhci_hc_t *const hc = arg;
         assert(hc);
 
@@ -654 +654 @@
  */
 static void hc_run_event_ring(xhci_hc_t *hc, xhci_event_ring_t *event_ring,
-        xhci_interrupter_regs_t *intr)
+    xhci_interrupter_regs_t *intr)
 {
         errno_t err;
@@ -720 +720 @@
         if (status) {
                 usb_log_error("Non-zero status after interrupt handling (%08x) "
-                        " - missing something?", status);
+                    " - missing something?", status);
         }
 }
@@ -766 +766 @@
 {
         return (2 * ep->base.endpoint) +
-                (ep->base.transfer_type == USB_TRANSFER_CONTROL
-                 || ep->base.direction == USB_DIRECTION_IN);
+            (ep->base.transfer_type == USB_TRANSFER_CONTROL ||
+            ep->base.direction == USB_DIRECTION_IN);
 }
 
 void hc_ring_ep_doorbell(xhci_endpoint_t *ep, uint32_t stream_id)
 {
-        xhci_device_t * const dev = xhci_ep_to_dev(ep);
-        xhci_hc_t * const hc = bus_to_hc(dev->base.bus);
+        xhci_device_t *const dev = xhci_ep_to_dev(ep);
+        xhci_hc_t *const hc = bus_to_hc(dev->base.bus);
         const uint8_t dci = endpoint_dci(ep);
         const uint32_t target = (stream_id << 16) | (dci & 0x1ff);
@@ -786 +786 @@
 {
         errno_t err;
-        xhci_hc_t * const hc = bus_to_hc(dev->base.bus);
+        xhci_hc_t *const hc = bus_to_hc(dev->base.bus);
 
         /* Prepare memory for the context */
@@ -821 +821 @@
 {
         errno_t err;
-        xhci_hc_t * const hc = bus_to_hc(dev->base.bus);
+        xhci_hc_t *const hc = bus_to_hc(dev->base.bus);
         xhci_cmd_t cmd;
 
@@ -846 +846 @@
 static errno_t create_configure_ep_input_ctx(xhci_device_t *dev, dma_buffer_t *dma_buf)
 {
-        const xhci_hc_t * hc = bus_to_hc(dev->base.bus);
+        const xhci_hc_t *hc = bus_to_hc(dev->base.bus);
         const errno_t err = dma_buffer_alloc(dma_buf, XHCI_INPUT_CTX_SIZE(hc));
         if (err)
@@ -870 +870 @@
 {
         errno_t err = ENOMEM;
-        xhci_hc_t * const hc = bus_to_hc(dev->base.bus);
+        xhci_hc_t *const hc = bus_to_hc(dev->base.bus);
         xhci_endpoint_t *ep0 = xhci_endpoint_get(dev->base.endpoints[0]);
 
@@ -920 +920 @@
 errno_t hc_configure_device(xhci_device_t *dev)
 {
-        xhci_hc_t * const hc = bus_to_hc(dev->base.bus);
+        xhci_hc_t *const hc = bus_to_hc(dev->base.bus);
         xhci_cmd_t cmd;
 
@@ -945 +945 @@
 errno_t hc_deconfigure_device(xhci_device_t *dev)
 {
-        xhci_hc_t * const hc = bus_to_hc(dev->base.bus);
+        xhci_hc_t *const hc = bus_to_hc(dev->base.bus);
         xhci_cmd_t cmd;
         errno_t err;
@@ -972 +972 @@
 errno_t hc_add_endpoint(xhci_endpoint_t *ep)
 {
-        xhci_device_t * const dev = xhci_ep_to_dev(ep);
+        xhci_device_t *const dev = xhci_ep_to_dev(ep);
         const unsigned dci = endpoint_dci(ep);
         xhci_cmd_t cmd;
@@ -984 +984 @@
         xhci_input_ctx_t *ictx = ictx_dma_buf.virt;
 
-        xhci_hc_t * const hc = bus_to_hc(dev->base.bus);
+        xhci_hc_t *const hc = bus_to_hc(dev->base.bus);
         XHCI_INPUT_CTRL_CTX_ADD_SET(*XHCI_GET_CTRL_CTX(ictx, hc), dci);
 
@@ -1007 +1007 @@
 errno_t hc_drop_endpoint(xhci_endpoint_t *ep)
 {
-        xhci_device_t * const dev = xhci_ep_to_dev(ep);
-        xhci_hc_t * const hc = bus_to_hc(dev->base.bus);
+        xhci_device_t *const dev = xhci_ep_to_dev(ep);
+        xhci_hc_t *const hc = bus_to_hc(dev->base.bus);
         const unsigned dci = endpoint_dci(ep);
         xhci_cmd_t cmd;
@@ -1043 +1043 @@
 errno_t hc_update_endpoint(xhci_endpoint_t *ep)
 {
-        xhci_device_t * const dev = xhci_ep_to_dev(ep);
+        xhci_device_t *const dev = xhci_ep_to_dev(ep);
         const unsigned dci = endpoint_dci(ep);
         xhci_cmd_t cmd;
 
         dma_buffer_t ictx_dma_buf;
-        xhci_hc_t * const hc = bus_to_hc(dev->base.bus);
+        xhci_hc_t *const hc = bus_to_hc(dev->base.bus);
 
         errno_t err = dma_buffer_alloc(&ictx_dma_buf, XHCI_INPUT_CTX_SIZE(hc));
@@ -1078 +1078 @@
 errno_t hc_stop_endpoint(xhci_endpoint_t *ep)
 {
-        xhci_device_t * const dev = xhci_ep_to_dev(ep);
+        xhci_device_t *const dev = xhci_ep_to_dev(ep);
         const unsigned dci = endpoint_dci(ep);
-        xhci_hc_t * const hc = bus_to_hc(dev->base.bus);
+        xhci_hc_t *const hc = bus_to_hc(dev->base.bus);
         xhci_cmd_t cmd;
         errno_t err;
@@ -1104 +1104 @@
 errno_t hc_reset_endpoint(xhci_endpoint_t *ep)
 {
-        xhci_device_t * const dev = xhci_ep_to_dev(ep);
+        xhci_device_t *const dev = xhci_ep_to_dev(ep);
         const unsigned dci = endpoint_dci(ep);
-        xhci_hc_t * const hc = bus_to_hc(dev->base.bus);
+        xhci_hc_t *const hc = bus_to_hc(dev->base.bus);
         xhci_cmd_t cmd;
         errno_t err;
@@ -1126 +1126 @@
 errno_t hc_reset_ring(xhci_endpoint_t *ep, uint32_t stream_id)
 {
-        xhci_device_t * const dev = xhci_ep_to_dev(ep);
+        xhci_device_t *const dev = xhci_ep_to_dev(ep);
         const unsigned dci = endpoint_dci(ep);
         uintptr_t addr;
@@ -1135 +1135 @@
         xhci_trb_ring_reset_dequeue_state(ring, &addr);
 
-        xhci_hc_t * const hc = bus_to_hc(endpoint_get_bus(&ep->base));
+        xhci_hc_t *const hc = bus_to_hc(endpoint_get_bus(&ep->base));
 
         xhci_cmd_init(&cmd, XHCI_CMD_SET_TR_DEQUEUE_POINTER);

uspace/drv/bus/usb/xhci/hw_struct/regs.h

@@ -235 +235 @@
 #define XHCI_CAP_CIC          hccparams2, 32,  FLAG,  5
 
-static inline unsigned xhci_get_max_spbuf(xhci_cap_regs_t *cap_regs) {
-        return XHCI_REG_RD(cap_regs, XHCI_CAP_MAX_SPBUF_HI) << 5
-                | XHCI_REG_RD(cap_regs, XHCI_CAP_MAX_SPBUF_LO);
+static inline unsigned xhci_get_max_spbuf(xhci_cap_regs_t *cap_regs)
+{
+        return XHCI_REG_RD(cap_regs, XHCI_CAP_MAX_SPBUF_HI) << 5 |
+            XHCI_REG_RD(cap_regs, XHCI_CAP_MAX_SPBUF_LO);
 }
 

uspace/drv/bus/usb/xhci/hw_struct/trb.h

@@ -166 +166 @@
 
         return chain_bit &&
-            (type == XHCI_TRB_TYPE_NORMAL
-            || type == XHCI_TRB_TYPE_DATA_STAGE
-            || type == XHCI_TRB_TYPE_STATUS_STAGE
-            || type == XHCI_TRB_TYPE_ISOCH);
+            (type == XHCI_TRB_TYPE_NORMAL ||
+            type == XHCI_TRB_TYPE_DATA_STAGE ||
+            type == XHCI_TRB_TYPE_STATUS_STAGE ||
+            type == XHCI_TRB_TYPE_ISOCH);
 }
 

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

@@ -49 +49 @@
 {
         assert(ep->base.transfer_type == USB_TRANSFER_ISOCHRONOUS);
-        xhci_isoch_t * const isoch = ep->isoch;
+        xhci_isoch_t *const isoch = ep->isoch;
 
         fibril_mutex_initialize(&isoch->guard);
@@ -70 +70 @@
 static void isoch_reset(xhci_endpoint_t *ep)
 {
-        xhci_isoch_t * const isoch = ep->isoch;
+        xhci_isoch_t *const isoch = ep->isoch;
         assert(fibril_mutex_is_locked(&isoch->guard));
 
@@ -87 +87 @@
 static void isoch_reset_no_timer(xhci_endpoint_t *ep)
 {
-        xhci_isoch_t * const isoch = ep->isoch;
+        xhci_isoch_t *const isoch = ep->isoch;
         assert(fibril_mutex_is_locked(&isoch->guard));
         /*
@@ -97 +97 @@
 }
 
-static void isoch_reset_timer(void *ep) {
-        xhci_isoch_t * const isoch = xhci_endpoint_get(ep)->isoch;
+static void isoch_reset_timer(void *ep)
+{
+        xhci_isoch_t *const isoch = xhci_endpoint_get(ep)->isoch;
         fibril_mutex_lock(&isoch->guard);
         isoch_reset(ep);
@@ -109 +110 @@
  */
 #define RESET_TIMER_DELAY 100000
-static void timer_schedule_reset(xhci_endpoint_t *ep) {
-        xhci_isoch_t * const isoch = ep->isoch;
-        const suseconds_t delay = isoch->buffer_count * ep->interval * 125
-            + RESET_TIMER_DELAY;
+static void timer_schedule_reset(xhci_endpoint_t *ep)
+{
+        xhci_isoch_t *const isoch = ep->isoch;
+        const suseconds_t delay = isoch->buffer_count * ep->interval * 125 +
+            RESET_TIMER_DELAY;
 
         fibril_timer_clear_locked(isoch->reset_timer);
         fibril_timer_set_locked(isoch->reset_timer, delay,
-                isoch_reset_timer, ep);
+            isoch_reset_timer, ep);
 }
 
@@ -122 +124 @@
 {
         assert(ep->base.transfer_type == USB_TRANSFER_ISOCHRONOUS);
-        xhci_isoch_t * const isoch = ep->isoch;
+        xhci_isoch_t *const isoch = ep->isoch;
 
         if (isoch->feeding_timer) {
@@ -141 +143 @@
  * Allocate isochronous buffers. Create the feeding timer.
  */
-errno_t isoch_alloc_transfers(xhci_endpoint_t *ep) {
-        assert(ep->base.transfer_type == USB_TRANSFER_ISOCHRONOUS);
-        xhci_isoch_t * const isoch = ep->isoch;
+errno_t isoch_alloc_transfers(xhci_endpoint_t *ep)
+{
+        assert(ep->base.transfer_type == USB_TRANSFER_ISOCHRONOUS);
+        xhci_isoch_t *const isoch = ep->isoch;
 
         isoch->feeding_timer = fibril_timer_create(&isoch->guard);
@@ -151 +154 @@
 
         isoch->transfers = calloc(isoch->buffer_count, sizeof(xhci_isoch_transfer_t));
-        if(!isoch->transfers)
+        if (!isoch->transfers)
                 goto err;
 
@@ -185 +188 @@
         size_t tdpc = it->size / 1024 + ((it->size % 1024) ? 1 : 0);
         size_t tbc = tdpc / ep->max_burst;
-        if (!tdpc % ep->max_burst) --tbc;
+        if (!tdpc % ep->max_burst)
+                --tbc;
         size_t bsp = tdpc % ep->max_burst;
         size_t tlbpc = (bsp ? bsp : ep->max_burst) - 1;
@@ -220 +224 @@
          */
         uint64_t epoch = hc->wrap_count;
-        if (reg_mfindex < EPOCH_LOW_MFINDEX
-            && get_system_time() - hc->wrap_time > EPOCH_DELAY) {
+        if (reg_mfindex < EPOCH_LOW_MFINDEX &&
+            get_system_time() - hc->wrap_time > EPOCH_DELAY) {
                 ++epoch;
         }
@@ -229 +233 @@
 static inline void calc_next_mfindex(xhci_endpoint_t *ep, xhci_isoch_transfer_t *it)
 {
-        xhci_isoch_t * const isoch = ep->isoch;
+        xhci_isoch_t *const isoch = ep->isoch;
         if (isoch->last_mf == -1U) {
                 const xhci_bus_t *bus = bus_to_xhci_bus(ep->base.device->bus);
@@ -270 +274 @@
  */
 static inline void window_decide(window_decision_t *res, xhci_hc_t *hc,
-        uint64_t mfindex)
+    uint64_t mfindex)
 {
         const uint64_t current_mf = get_current_microframe(hc);
@@ -300 +304 @@
 {
         assert(ep->base.transfer_type == USB_TRANSFER_ISOCHRONOUS);
-        xhci_isoch_t * const isoch = ep->isoch;
+        xhci_isoch_t *const isoch = ep->isoch;
         assert(fibril_mutex_is_locked(&isoch->guard));
 
@@ -309 +313 @@
 
         while (isoch->transfers[isoch->hw_enqueue].state == ISOCH_FILLED) {
-                xhci_isoch_transfer_t * const it = &isoch->transfers[isoch->hw_enqueue];
+                xhci_isoch_transfer_t *const it = &isoch->transfers[isoch->hw_enqueue];
                 suseconds_t delay;
 
@@ -321 +325 @@
                         delay = wd.offset * 125;
                         usb_log_debug("[isoch] delaying feeding buffer %zu for %ldus",
-                                it - isoch->transfers, delay);
+                            it - isoch->transfers, delay);
                         fibril_timer_set_locked(isoch->feeding_timer, delay,
                             isoch_feed_out_timer, ep);
@@ -346 +350 @@
                          */
                         usb_log_debug("[isoch] missed feeding buffer %zu at 0x%llx by "
-                                "%llu uframes", it - isoch->transfers, it->mfindex, wd.offset);
+                            "%llu uframes", it - isoch->transfers, it->mfindex, wd.offset);
                         it->state = ISOCH_COMPLETE;
                         it->error = EOK;
@@ -370 +374 @@
 static void isoch_feed_out_timer(void *ep)
 {
-        xhci_isoch_t * const isoch = xhci_endpoint_get(ep)->isoch;
+        xhci_isoch_t *const isoch = xhci_endpoint_get(ep)->isoch;
         fibril_mutex_lock(&isoch->guard);
         isoch_feed_out(ep);
@@ -386 +390 @@
 {
         assert(ep->base.transfer_type == USB_TRANSFER_ISOCHRONOUS);
-        xhci_isoch_t * const isoch = ep->isoch;
+        xhci_isoch_t *const isoch = ep->isoch;
         assert(fibril_mutex_is_locked(&isoch->guard));
 
@@ -395 +399 @@
 
         while (isoch->transfers[isoch->enqueue].state <= ISOCH_FILLED) {
-                xhci_isoch_transfer_t * const it = &isoch->transfers[isoch->enqueue];
+                xhci_isoch_transfer_t *const it = &isoch->transfers[isoch->enqueue];
                 suseconds_t delay;
 
@@ -419 +423 @@
                 case WINDOW_TOO_LATE:
                         usb_log_debug("[isoch] missed feeding buffer %zu at 0x%llx by"
-                                "%llu uframes", it - isoch->transfers, it->mfindex, wd.offset);
+                            "%llu uframes", it - isoch->transfers, it->mfindex, wd.offset);
                         /* Missed the opportunity to schedule. Schedule ASAP. */
                         it->mfindex += wd.offset;
@@ -458 +462 @@
 static void isoch_feed_in_timer(void *ep)
 {
-        xhci_isoch_t * const isoch = xhci_endpoint_get(ep)->isoch;
+        xhci_isoch_t *const isoch = xhci_endpoint_get(ep)->isoch;
         fibril_mutex_lock(&isoch->guard);
         isoch_feed_in(ep);
@@ -477 +481 @@
         xhci_endpoint_t *ep = xhci_endpoint_get(transfer->batch.ep);
         assert(ep->base.transfer_type == USB_TRANSFER_ISOCHRONOUS);
-        xhci_isoch_t * const isoch = ep->isoch;
+        xhci_isoch_t *const isoch = ep->isoch;
 
         /* This shall be already checked by endpoint */
@@ -541 +545 @@
         xhci_endpoint_t *ep = xhci_endpoint_get(transfer->batch.ep);
         assert(ep->base.transfer_type == USB_TRANSFER_ISOCHRONOUS);
-        xhci_isoch_t * const isoch = ep->isoch;
+        xhci_isoch_t *const isoch = ep->isoch;
 
         if (transfer->batch.size < ep->base.max_transfer_size) {
@@ -585 +589 @@
 
 void isoch_handle_transfer_event(xhci_hc_t *hc, xhci_endpoint_t *ep,
-        xhci_trb_t *trb)
-{
-        assert(ep->base.transfer_type == USB_TRANSFER_ISOCHRONOUS);
-        xhci_isoch_t * const isoch = ep->isoch;
+    xhci_trb_t *trb)
+{
+        assert(ep->base.transfer_type == USB_TRANSFER_ISOCHRONOUS);
+        xhci_isoch_t *const isoch = ep->isoch;
 
         fibril_mutex_lock(&ep->isoch->guard);
@@ -632 +636 @@
                 }
 
-                xhci_isoch_transfer_t * const it = &isoch->transfers[di];
+                xhci_isoch_transfer_t *const it = &isoch->transfers[di];
 
                 if (it->state == ISOCH_FED && it->interrupt_trb_phys == trb->parameter) {

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

@@ -54 +54 @@
 /* This mask only lists registers, which imply port change. */
 static const uint32_t port_events_mask =
-        XHCI_REG_MASK(XHCI_PORT_CSC) |
-        XHCI_REG_MASK(XHCI_PORT_PEC) |
-        XHCI_REG_MASK(XHCI_PORT_WRC) |
-        XHCI_REG_MASK(XHCI_PORT_OCC) |
-        XHCI_REG_MASK(XHCI_PORT_PRC) |
-        XHCI_REG_MASK(XHCI_PORT_PLC) |
-        XHCI_REG_MASK(XHCI_PORT_CEC);
+    XHCI_REG_MASK(XHCI_PORT_CSC) |
+    XHCI_REG_MASK(XHCI_PORT_PEC) |
+    XHCI_REG_MASK(XHCI_PORT_WRC) |
+    XHCI_REG_MASK(XHCI_PORT_OCC) |
+    XHCI_REG_MASK(XHCI_PORT_PRC) |
+    XHCI_REG_MASK(XHCI_PORT_PLC) |
+    XHCI_REG_MASK(XHCI_PORT_CEC);
 
 static const uint32_t port_reset_mask =
-        XHCI_REG_MASK(XHCI_PORT_WRC) |
-        XHCI_REG_MASK(XHCI_PORT_PRC);
+    XHCI_REG_MASK(XHCI_PORT_WRC) |
+    XHCI_REG_MASK(XHCI_PORT_PRC);
 
 typedef struct rh_port {
@@ -167 +167 @@
                 return ENOENT;
 
-        unsigned psiv = (status & XHCI_REG_MASK(XHCI_PORT_PS))
-            >> XHCI_REG_SHIFT(XHCI_PORT_PS);
+        unsigned psiv = (status & XHCI_REG_MASK(XHCI_PORT_PS)) >>
+            XHCI_REG_SHIFT(XHCI_PORT_PS);
         const usb_speed_t speed = port->rh->hc->speeds[psiv].usb_speed;
 
@@ -233 +233 @@
 static void handle_port_change(xhci_rh_t *rh, uint8_t port_id)
 {
-        rh_port_t * const port = &rh->ports[port_id - 1];
+        rh_port_t *const port = &rh->ports[port_id - 1];
 
         uint32_t status = XHCI_REG_RD_FIELD(&port->regs->portsc, 32);
@@ -280 +280 @@
 
 void xhci_rh_set_ports_protocol(xhci_rh_t *rh,
-        unsigned offset, unsigned count, unsigned major)
+    unsigned offset, unsigned count, unsigned major)
 {
         for (unsigned i = offset; i < offset + count; i++)
@@ -297 +297 @@
                 handle_port_change(rh, i + 1);
 
-                rh_port_t * const port = &rh->ports[i];
+                rh_port_t *const port = &rh->ports[i];
 
                 /*
@@ -304 +304 @@
                  * such ports.
                  */
-                if (XHCI_REG_RD(port->regs, XHCI_PORT_CCS)
-                    && port->base.state == PORT_DISABLED)
+                if (XHCI_REG_RD(port->regs, XHCI_PORT_CCS) &&
+                    port->base.state == PORT_DISABLED)
                         usb_port_connected(&port->base, &rh_enumerate_device);
         }
@@ -320 +320 @@
 
         for (uint8_t i = 0; i < rh->max_ports; ++i) {
-                rh_port_t * const port = &rh->ports[i];
+                rh_port_t *const port = &rh->ports[i];
                 usb_port_disabled(&port->base, &rh_remove_device);
                 usb_port_fini(&port->base);
@@ -328 +328 @@
 static int rh_worker(void *arg)
 {
-        xhci_rh_t * const rh = arg;
+        xhci_rh_t *const rh = arg;
 
         xhci_trb_t trb;

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

@@ -88 +88 @@
 {
         usb_log_debug("Allocating primary stream context array of size %u "
-                "for endpoint " XHCI_EP_FMT, count, XHCI_EP_ARGS(*xhci_ep));
+            "for endpoint " XHCI_EP_FMT, count, XHCI_EP_ARGS(*xhci_ep));
 
         if ((dma_buffer_alloc(&xhci_ep->primary_stream_ctx_dma,
-                count * sizeof(xhci_stream_ctx_t)))) {
+            count * sizeof(xhci_stream_ctx_t)))) {
                 return ENOMEM;
         }
@@ -110 +110 @@
 {
         usb_log_debug("Deallocating primary stream structures for "
-                "endpoint " XHCI_EP_FMT, XHCI_EP_ARGS(*xhci_ep));
+            "endpoint " XHCI_EP_FMT, XHCI_EP_ARGS(*xhci_ep));
 
         dma_buffer_free(&xhci_ep->primary_stream_ctx_dma);
@@ -138 +138 @@
 {
         usb_log_debug("Freeing stream rings and context arrays of endpoint "
-                XHCI_EP_FMT, XHCI_EP_ARGS(*xhci_ep));
+            XHCI_EP_FMT, XHCI_EP_ARGS(*xhci_ep));
 
         for (size_t index = 0; index < xhci_ep->primary_stream_data_size; ++index) {
@@ -153 +153 @@
  */
 static errno_t initialize_primary_stream(xhci_hc_t *hc, xhci_endpoint_t *xhci_ep,
-        unsigned index)
+    unsigned index)
 {
         xhci_stream_ctx_t *ctx = &xhci_ep->primary_stream_ctx_array[index];
@@ -206 +206 @@
  */
 static errno_t initialize_secondary_streams(xhci_hc_t *hc, xhci_endpoint_t *xhci_ep,
-        unsigned idx, unsigned count)
+    unsigned idx, unsigned count)
 {
         if (count == 0) {
@@ -218 +218 @@
         if ((count & (count - 1)) != 0 || count < 8 || count > 256) {
                 usb_log_error("The secondary stream array size must be a power of 2 "
-                        "between 8 and 256.");
+                    "between 8 and 256.");
                 return EINVAL;
         }
@@ -233 +233 @@
 
         if ((dma_buffer_alloc(&data->secondary_stream_ctx_dma,
-                count * sizeof(xhci_stream_ctx_t)))) {
+            count * sizeof(xhci_stream_ctx_t)))) {
                 free(data->secondary_data);
                 return ENOMEM;
@@ -275 +275 @@
  */
 static void setup_stream_context(xhci_endpoint_t *xhci_ep, xhci_ep_ctx_t *ctx,
-        unsigned pstreams, unsigned lsa)
+    unsigned pstreams, unsigned lsa)
 {
         XHCI_EP_TYPE_SET(*ctx, xhci_endpoint_type(xhci_ep));
@@ -295 +295 @@
  */
 static errno_t verify_stream_conditions(xhci_hc_t *hc, xhci_device_t *dev,
-        xhci_endpoint_t *xhci_ep, unsigned count)
-{
-        if (xhci_ep->base.transfer_type != USB_TRANSFER_BULK
-                || dev->base.speed != USB_SPEED_SUPER) {
+    xhci_endpoint_t *xhci_ep, unsigned count)
+{
+        if (xhci_ep->base.transfer_type != USB_TRANSFER_BULK ||
+            dev->base.speed != USB_SPEED_SUPER) {
                 usb_log_error("Streams are only supported by superspeed bulk endpoints.");
                 return EINVAL;
@@ -321 +321 @@
         if (count > max_psa_size) {
                 usb_log_error("Host controller only supports "
-                        "%u primary streams.", max_psa_size);
+                    "%u primary streams.", max_psa_size);
                 return EINVAL;
         }
@@ -327 +327 @@
         if (count > xhci_ep->max_streams) {
                 usb_log_error("Endpoint " XHCI_EP_FMT " supports only %" PRIu32 " streams.",
-                        XHCI_EP_ARGS(*xhci_ep), xhci_ep->max_streams);
+                    XHCI_EP_ARGS(*xhci_ep), xhci_ep->max_streams);
                 return EINVAL;
         }
@@ -346 +346 @@
  */
 errno_t xhci_endpoint_remove_streams(xhci_hc_t *hc, xhci_device_t *dev,
-        xhci_endpoint_t *xhci_ep)
+    xhci_endpoint_t *xhci_ep)
 {
         if (!xhci_ep->primary_stream_data_size) {
@@ -374 +374 @@
  */
 errno_t xhci_endpoint_request_primary_streams(xhci_hc_t *hc, xhci_device_t *dev,
-        xhci_endpoint_t *xhci_ep, unsigned count)
+    xhci_endpoint_t *xhci_ep, unsigned count)
 {
         errno_t err = verify_stream_conditions(hc, dev, xhci_ep, count);
@@ -422 +422 @@
  */
 errno_t xhci_endpoint_request_secondary_streams(xhci_hc_t *hc, xhci_device_t *dev,
-        xhci_endpoint_t *xhci_ep, unsigned *sizes, unsigned count)
+    xhci_endpoint_t *xhci_ep, unsigned *sizes, unsigned count)
 {
         /* Check if HC supports secondary indexing */
@@ -454 +454 @@
         if (max * count > xhci_ep->max_streams) {
                 usb_log_error("Endpoint " XHCI_EP_FMT " supports only %" PRIu32 " streams.",
-                        XHCI_EP_ARGS(*xhci_ep), xhci_ep->max_streams);
+                    XHCI_EP_ARGS(*xhci_ep), xhci_ep->max_streams);
                 return EINVAL;
         }

uspace/drv/bus/usb/xhci/test/reg-ops.c

@@ -23 +23 @@
 #define EQ(exp, act) PCUT_ASSERT_INT_EQUALS((exp), (act))
 
-PCUT_TEST(ops_8_field) {
+PCUT_TEST(ops_8_field)
+{
         RESET;
         EQ(0, XHCI_REG_RD(regs, REG_8_FIELD));
@@ -41 +42 @@
 }
 
-PCUT_TEST(ops_8_range) {
+PCUT_TEST(ops_8_range)
+{
         RESET;
         EQ(0, XHCI_REG_RD(regs, REG_8_RANGE));
@@ -58 +60 @@
 }
 
-PCUT_TEST(ops_8_flag) {
+PCUT_TEST(ops_8_flag)
+{
         RESET;
         EQ(0, XHCI_REG_RD(regs, REG_8_FLAG));
@@ -76 +79 @@
 }
 
-PCUT_TEST(ops_16_field) {
+PCUT_TEST(ops_16_field)
+{
         RESET;
         EQ(0, XHCI_REG_RD(regs, REG_16_FIELD));
@@ -93 +97 @@
 }
 
-PCUT_TEST(ops_16_range) {
+PCUT_TEST(ops_16_range)
+{
         RESET;
         EQ(0, XHCI_REG_RD(regs, REG_16_RANGE));
@@ -110 +115 @@
 }
 
-PCUT_TEST(ops_16_flag) {
+PCUT_TEST(ops_16_flag)
+{
         RESET;
         EQ(0, XHCI_REG_RD(regs, REG_16_FLAG));
@@ -128 +134 @@
 }
 
-PCUT_TEST(ops_32_field) {
+PCUT_TEST(ops_32_field)
+{
         RESET;
         EQ(0, XHCI_REG_RD(regs, REG_32_FIELD));
@@ -145 +152 @@
 }
 
-PCUT_TEST(ops_32_range) {
+PCUT_TEST(ops_32_range)
+{
         RESET;
         EQ(0, XHCI_REG_RD(regs, REG_32_RANGE));
@@ -162 +170 @@
 }
 
-PCUT_TEST(ops_32_flag) {
+PCUT_TEST(ops_32_flag)
+{
         RESET;
         EQ(0, XHCI_REG_RD(regs, REG_32_FLAG));

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

@@ -51 +51 @@
  *  See Table 7 of xHCI specification.
  */
-static inline stage_dir_flag_t get_status_direction_flag(xhci_trb_t* trb,
-        uint8_t bmRequestType, uint16_t wLength)
+static inline stage_dir_flag_t get_status_direction_flag(xhci_trb_t *trb,
+    uint8_t bmRequestType, uint16_t wLength)
 {
         /* See Table 7 of xHCI specification */
-        return SETUP_REQUEST_TYPE_IS_DEVICE_TO_HOST(bmRequestType) && (wLength > 0)
-                ? STAGE_OUT
-                : STAGE_IN;
+        return SETUP_REQUEST_TYPE_IS_DEVICE_TO_HOST(bmRequestType) && (wLength > 0) ?
+            STAGE_OUT :
+            STAGE_IN;
 }
 
@@ -69 +69 @@
  *  See Table 8 of xHCI specification.
  */
-static inline data_stage_type_t get_transfer_type(xhci_trb_t* trb, uint8_t
-        bmRequestType, uint16_t wLength)
+static inline data_stage_type_t get_transfer_type(xhci_trb_t *trb, uint8_t
+    bmRequestType, uint16_t wLength)
 {
         if (wLength == 0)
@@ -76 +76 @@
 
         /* See Table 7 of xHCI specification */
-        return SETUP_REQUEST_TYPE_IS_DEVICE_TO_HOST(bmRequestType)
-                ? DATA_STAGE_IN
-                : DATA_STAGE_NO;
+        return SETUP_REQUEST_TYPE_IS_DEVICE_TO_HOST(bmRequestType) ?
+            DATA_STAGE_IN :
+            DATA_STAGE_NO;
 }
 
@@ -86 +86 @@
 
         return request_type == USB_REQUEST_TYPE_STANDARD &&
-                (setup->request == USB_DEVREQ_SET_CONFIGURATION
-                || setup->request == USB_DEVREQ_SET_INTERFACE);
+            (setup->request == USB_DEVREQ_SET_CONFIGURATION ||
+            setup->request == USB_DEVREQ_SET_INTERFACE);
 }
 
@@ -95 +95 @@
  * Bus callback.
  */
-usb_transfer_batch_t * xhci_transfer_create(endpoint_t* ep)
+usb_transfer_batch_t *xhci_transfer_create(endpoint_t *ep)
 {
         xhci_transfer_t *transfer = calloc(1, sizeof(xhci_transfer_t));
@@ -108 +108 @@
  * Destroy a xHCI transfer.
  */
-void xhci_transfer_destroy(usb_transfer_batch_t* batch)
+void xhci_transfer_destroy(usb_transfer_batch_t *batch)
 {
         xhci_transfer_t *transfer = xhci_transfer_from_batch(batch);
@@ -137 +137 @@
 
         const size_t chunk_mask = dma_policy_chunk_mask(ts->buf.policy);
-        ts->chunk_size = (chunk_mask > MAX_CHUNK_SIZE + 1)
-                ? MAX_CHUNK_SIZE : (chunk_mask + 1);
+        ts->chunk_size = (chunk_mask > MAX_CHUNK_SIZE + 1) ?
+            MAX_CHUNK_SIZE : (chunk_mask + 1);
 
         ts->remaining = transfer->batch.size;
@@ -183 +183 @@
 }
 
-static errno_t schedule_control(xhci_hc_t* hc, xhci_transfer_t* transfer)
+static errno_t schedule_control(xhci_hc_t *hc, xhci_transfer_t *transfer)
 {
         usb_transfer_batch_t *batch = &transfer->batch;
         xhci_endpoint_t *xhci_ep = xhci_endpoint_get(transfer->batch.ep);
 
-        usb_device_request_setup_packet_t* setup = &batch->setup.packet;
+        usb_device_request_setup_packet_t *setup = &batch->setup.packet;
 
         trb_splitter_t splitter;
@@ -210 +210 @@
             get_transfer_type(trb_setup, setup->request_type, setup->length));
 
-        stage_dir_flag_t stage_dir = (transfer->batch.dir == USB_DIRECTION_IN)
-                                ? STAGE_IN : STAGE_OUT;
+        stage_dir_flag_t stage_dir = (transfer->batch.dir == USB_DIRECTION_IN) ?
+            STAGE_IN : STAGE_OUT;
 
         /* Data stage - first TRB is special */
@@ -243 +243 @@
 }
 
-static errno_t schedule_bulk_intr(xhci_hc_t* hc, xhci_transfer_t *transfer)
-{
-        xhci_trb_ring_t * const ring = get_ring(transfer);
+static errno_t schedule_bulk_intr(xhci_hc_t *hc, xhci_transfer_t *transfer)
+{
+        xhci_trb_ring_t *const ring = get_ring(transfer);
         if (!ring)
                 return EINVAL;
@@ -266 +266 @@
                 /* Set the interrupt bit for last TRB */
                 TRB_CTRL_SET_IOC(trbs[trbs_used - 1], 1);
-        }
-        else {
+        } else {
                 /* Clear the chain bit on the last TRB */
                 TRB_CTRL_SET_CHAIN(trbs[trbs_used - 1], 1);
@@ -280 +279 @@
 
         return xhci_trb_ring_enqueue_multiple(ring, trbs, trbs_used,
-                &transfer->interrupt_trb_phys);
-}
-
-static int schedule_isochronous(xhci_transfer_t* transfer)
+            &transfer->interrupt_trb_phys);
+}
+
+static int schedule_isochronous(xhci_transfer_t *transfer)
 {
         endpoint_t *ep = transfer->batch.ep;
 
-        return ep->direction == USB_DIRECTION_OUT
-                ? isoch_schedule_out(transfer)
-                : isoch_schedule_in(transfer);
-}
-
-errno_t xhci_handle_transfer_event(xhci_hc_t* hc, xhci_trb_t* trb)
+        return ep->direction == USB_DIRECTION_OUT ?
+            isoch_schedule_out(transfer) :
+            isoch_schedule_in(transfer);
+}
+
+errno_t xhci_handle_transfer_event(xhci_hc_t *hc, xhci_trb_t *trb)
 {
         uintptr_t addr = trb->parameter;
@@ -327 +326 @@
                     transfer->interrupt_trb_phys);
                 batch = &transfer->batch;
-        }
-        else {
+        } else {
                 xhci_trb_ring_update_dequeue(&ep->ring, addr);
 
@@ -354 +352 @@
         const xhci_trb_completion_code_t completion_code = TRB_COMPLETION_CODE(*trb);
         switch (completion_code) {
-                case XHCI_TRBC_SHORT_PACKET:
-                case XHCI_TRBC_SUCCESS:
-                        batch->error = EOK;
-                        batch->transferred_size = batch->size - TRB_TRANSFER_LENGTH(*trb);
-                        break;
-
-                case XHCI_TRBC_DATA_BUFFER_ERROR:
-                        usb_log_warning("Transfer ended with data buffer error.");
-                        batch->error = EAGAIN;
-                        batch->transferred_size = 0;
-                        break;
-
-                case XHCI_TRBC_BABBLE_DETECTED_ERROR:
-                        usb_log_warning("Babble detected during the transfer.");
-                        batch->error = EAGAIN;
-                        batch->transferred_size = 0;
-                        break;
-
-                case XHCI_TRBC_USB_TRANSACTION_ERROR:
-                        usb_log_warning("USB Transaction error.");
-                        batch->error = EAGAIN;
-                        batch->transferred_size = 0;
-                        break;
-
-                case XHCI_TRBC_TRB_ERROR:
-                        usb_log_error("Invalid transfer parameters.");
-                        batch->error = EINVAL;
-                        batch->transferred_size = 0;
-                        break;
-
-                case XHCI_TRBC_STALL_ERROR:
-                        usb_log_warning("Stall condition detected.");
-                        batch->error = ESTALL;
-                        batch->transferred_size = 0;
-                        break;
-
-                case XHCI_TRBC_SPLIT_TRANSACTION_ERROR:
-                        usb_log_error("Split transcation error detected.");
-                        batch->error = EAGAIN;
-                        batch->transferred_size = 0;
-                        break;
-
-                default:
-                        usb_log_warning("Transfer not successfull: %u", completion_code);
-                        batch->error = EIO;
+        case XHCI_TRBC_SHORT_PACKET:
+        case XHCI_TRBC_SUCCESS:
+                batch->error = EOK;
+                batch->transferred_size = batch->size - TRB_TRANSFER_LENGTH(*trb);
+                break;
+
+        case XHCI_TRBC_DATA_BUFFER_ERROR:
+                usb_log_warning("Transfer ended with data buffer error.");
+                batch->error = EAGAIN;
+                batch->transferred_size = 0;
+                break;
+
+        case XHCI_TRBC_BABBLE_DETECTED_ERROR:
+                usb_log_warning("Babble detected during the transfer.");
+                batch->error = EAGAIN;
+                batch->transferred_size = 0;
+                break;
+
+        case XHCI_TRBC_USB_TRANSACTION_ERROR:
+                usb_log_warning("USB Transaction error.");
+                batch->error = EAGAIN;
+                batch->transferred_size = 0;
+                break;
+
+        case XHCI_TRBC_TRB_ERROR:
+                usb_log_error("Invalid transfer parameters.");
+                batch->error = EINVAL;
+                batch->transferred_size = 0;
+                break;
+
+        case XHCI_TRBC_STALL_ERROR:
+                usb_log_warning("Stall condition detected.");
+                batch->error = ESTALL;
+                batch->transferred_size = 0;
+                break;
+
+        case XHCI_TRBC_SPLIT_TRANSACTION_ERROR:
+                usb_log_error("Split transcation error detected.");
+                batch->error = EAGAIN;
+                batch->transferred_size = 0;
+                break;
+
+        default:
+                usb_log_warning("Transfer not successfull: %u", completion_code);
+                batch->error = EIO;
         }
 
@@ -456 +454 @@
          * the Reset Endpoint command.
          */
-        if (batch->ep->transfer_type == USB_TRANSFER_CONTROL
-            && batch->dir == USB_DIRECTION_OUT) {
+        if (batch->ep->transfer_type == USB_TRANSFER_CONTROL &&
+            batch->dir == USB_DIRECTION_OUT) {
                 const usb_device_request_setup_packet_t *request = &batch->setup.packet;
-                if (request->request == USB_DEVREQ_CLEAR_FEATURE
-                    && request->request_type == USB_REQUEST_RECIPIENT_ENDPOINT
-                    && request->value == USB_FEATURE_ENDPOINT_HALT) {
+                if (request->request == USB_DEVREQ_CLEAR_FEATURE &&
+                    request->request_type == USB_REQUEST_RECIPIENT_ENDPOINT &&
+                    request->value == USB_FEATURE_ENDPOINT_HALT) {
                         const uint16_t index = uint16_usb2host(request->index);
                         const usb_endpoint_t ep_num = index & 0xf;
-                        const usb_direction_t dir = (index >> 7)
-                            ? USB_DIRECTION_IN
-                            : USB_DIRECTION_OUT;
+                        const usb_direction_t dir = (index >> 7) ?
+                            USB_DIRECTION_IN :
+                            USB_DIRECTION_OUT;
                         endpoint_t *halted_ep = bus_find_endpoint(&xhci_dev->base, ep_num, dir);
                         if (halted_ep) {
@@ -488 +486 @@
                         } else {
                                 usb_log_warning("Device(%u): Resetting unregistered endpoint"
-                                        " %u %s.", xhci_dev->base.address, ep_num,
-                                        usb_str_direction(dir));
+                                    " %u %s.", xhci_dev->base.address, ep_num,
+                                    usb_str_direction(dir));
                         }
                 }

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

@@ -122 +122 @@
 
         list_initialize(&ring->segments);
-        size_t segment_count = (initial_size + SEGMENT_TRB_USEFUL_COUNT - 1)
-                / SEGMENT_TRB_USEFUL_COUNT;
+        size_t segment_count = (initial_size + SEGMENT_TRB_USEFUL_COUNT - 1) /
+            SEGMENT_TRB_USEFUL_COUNT;
 
         for (size_t i = 0; i < segment_count; ++i) {
@@ -134 +134 @@
         }
 
-        trb_segment_t * const segment = get_first_segment(&ring->segments);
+        trb_segment_t *const segment = get_first_segment(&ring->segments);
         xhci_trb_t *last = segment_end(segment) - 1;
         xhci_trb_link_fill(last, segment->phys);
@@ -198 +198 @@
 static bool trb_generates_interrupt(xhci_trb_t *trb)
 {
-        return TRB_TYPE(*trb) >= XHCI_TRB_TYPE_ENABLE_SLOT_CMD
-                || TRB_IOC(*trb);
+        return TRB_TYPE(*trb) >= XHCI_TRB_TYPE_ENABLE_SLOT_CMD ||
+            TRB_IOC(*trb);
 }
 
@@ -220 +220 @@
  */
 errno_t xhci_trb_ring_enqueue_multiple(xhci_trb_ring_t *ring, xhci_trb_t *first_trb,
-        size_t trbs, uintptr_t *phys)
+    size_t trbs, uintptr_t *phys)
 {
         errno_t err;
@@ -230 +230 @@
         fibril_mutex_lock(&ring->guard);
 
-        xhci_trb_t * const saved_enqueue_trb = ring->enqueue_trb;
-        trb_segment_t * const saved_enqueue_segment = ring->enqueue_segment;
+        xhci_trb_t *const saved_enqueue_trb = ring->enqueue_trb;
+        trb_segment_t *const saved_enqueue_segment = ring->enqueue_segment;
         if (phys)
                 *phys = (uintptr_t)NULL;
@@ -365 +365 @@
 {
         list_foreach(ring->segments, segments_link, trb_segment_t, segment)
-                memset(segment->trb_storage, 0, sizeof(segment->trb_storage));
-
-        trb_segment_t * const segment = get_first_segment(&ring->segments);
+            memset(segment->trb_storage, 0, sizeof(segment->trb_storage));
+
+        trb_segment_t *const segment = get_first_segment(&ring->segments);
         ring->dequeue_segment = segment;
         ring->dequeue_trb = segment_begin(segment);