Changes in / [087768f:0a208110] in mainline

Files:

• HelenOS.config (modified) (1 diff)
• boot/arch/ppc32/Makefile.inc (modified) (1 diff)
• defaults/ppc32/Makefile.config (modified) (1 diff)
• uspace/Makefile (modified) (1 diff)
• uspace/drv/bus/pci/pciintel/pci.c (modified) (5 diffs)
• uspace/drv/bus/pci/pciintel/pci.h (modified) (1 diff)
• uspace/drv/bus/usb/ohci/endpoint_list.c (modified) (1 diff)
• uspace/drv/bus/usb/ohci/hc.c (modified) (16 diffs)
• uspace/drv/bus/usb/ohci/hw_struct/endpoint_descriptor.c (modified) (2 diffs)
• uspace/drv/bus/usb/ohci/hw_struct/endpoint_descriptor.h (modified) (7 diffs)
• uspace/drv/bus/usb/ohci/hw_struct/transfer_descriptor.c (modified) (2 diffs)
• uspace/drv/bus/usb/ohci/hw_struct/transfer_descriptor.h (modified) (4 diffs)
• uspace/drv/bus/usb/ohci/ohci_batch.c (modified) (3 diffs)
• uspace/drv/bus/usb/ohci/ohci_regs.h (modified) (8 diffs)
• uspace/drv/bus/usb/ohci/root_hub.c (modified) (25 diffs)
• uspace/drv/bus/usb/usbhid/kbd/kbddev.c (modified) (7 diffs)
• uspace/drv/bus/usb/usbhid/kbd/kbddev.h (modified) (1 diff)
• uspace/drv/bus/usb/usbhid/mouse/mousedev.c (modified) (5 diffs)
• uspace/drv/bus/usb/usbhid/mouse/mousedev.h (modified) (2 diffs)
• uspace/drv/bus/usb/usbhub/port.c (modified) (1 diff)
• uspace/drv/bus/usb/usbhub/status.h (modified) (1 diff)
• uspace/drv/infrastructure/rootmac/rootmac.c (modified) (3 diffs)
• uspace/drv/infrastructure/rootpc/rootpc.c (modified) (2 diffs)
• uspace/lib/drv/generic/remote_usb.c (modified) (3 diffs)
• uspace/lib/drv/generic/remote_usbhc.c (modified) (8 diffs)
• uspace/lib/usbdev/src/pipesinit.c (modified) (4 diffs)
• uspace/lib/usbdev/src/request.c (modified) (8 diffs)
• uspace/lib/usbhid/src/hidreport.c (modified) (5 diffs)

HelenOS.config

@@ -588 +588 @@
 @ "ganged" Root hub ports are all powered or all off.
 @ "per_port" Powered status of every root hub port is independent.
-! [PLATFORM=ia32|PLATFORM=amd64] OHCI_POWER_SWITCH (choice)
+! [PLATFORM=ia32|PLATFORM=amd64|PLATFORM=ppc32] OHCI_POWER_SWITCH (choice)
 
 % GRUB boot loader architecture

boot/arch/ppc32/Makefile.inc

@@ -43 +43 @@
 
 RD_DRVS += \
-        infrastructure/rootmac
+        infrastructure/rootmac \
+        bus/pci/pciintel \
+        bus/usb/ohci \
+        bus/usb/usbflbk \
+        bus/usb/usbhub \
+        bus/usb/usbhid \
+        bus/usb/usbmast \
+        bus/usb/usbmid \
+        bus/usb/vhc
 
 SOURCES = \

defaults/ppc32/Makefile.config

@@ -44 +44 @@
 CONFIG_MOUNT_DATA = n
 
+# OHCI root hub power switch, ganged is enough
+OHCI_POWER_SWITCH = ganged
+

uspace/Makefile

@@ -165 +165 @@
         DIRS += \
                 drv/infrastructure/rootmac \
+                drv/bus/pci/pciintel \
                 srv/hw/bus/cuda_adb
 endif

uspace/drv/bus/pci/pciintel/pci.c

@@ -38 +38 @@
 
 #include <assert.h>
+#include <byteorder.h>
 #include <stdio.h>
 #include <errno.h>
@@ -231 +232 @@
         void *addr = bus->conf_data_port + (reg & 3);
         
-        pio_write_32(bus->conf_addr_port, conf_addr);
+        pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
         
         switch (len) {
         case 1:
+                /* No endianness change for 1 byte */
                 buf[0] = pio_read_8(addr);
                 break;
         case 2:
-                ((uint16_t *) buf)[0] = pio_read_16(addr);
+                ((uint16_t *) buf)[0] = uint16_t_le2host(pio_read_16(addr));
                 break;
         case 4:
-                ((uint32_t *) buf)[0] = pio_read_32(addr);
+                ((uint32_t *) buf)[0] = uint32_t_le2host(pio_read_32(addr));
                 break;
         }
@@ -254 +256 @@
         fibril_mutex_lock(&bus->conf_mutex);
         
-        uint32_t conf_addr;
-        conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
+        const uint32_t conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
         void *addr = bus->conf_data_port + (reg & 3);
         
-        pio_write_32(bus->conf_addr_port, conf_addr);
+        pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
         
         switch (len) {
         case 1:
+                /* No endianness change for 1 byte */
                 pio_write_8(addr, buf[0]);
                 break;
         case 2:
-                pio_write_16(addr, ((uint16_t *) buf)[0]);
+                pio_write_16(addr, host2uint16_t_le(((uint16_t *) buf)[0]));
                 break;
         case 4:
-                pio_write_32(addr, ((uint32_t *) buf)[0]);
+                pio_write_32(addr, host2uint32_t_le(((uint32_t *) buf)[0]));
                 break;
         }
@@ -650 +652 @@
         got_res = true;
         
+        
+        assert(hw_resources.count > 1);
+        assert(hw_resources.resources[0].type == IO_RANGE);
+        assert(hw_resources.resources[0].res.io_range.size >= 4);
+        
+        assert(hw_resources.resources[1].type == IO_RANGE);
+        assert(hw_resources.resources[1].res.io_range.size >= 4);
+        
         ddf_msg(LVL_DEBUG, "conf_addr = %" PRIx64 ".",
             hw_resources.resources[0].res.io_range.address);
-        
-        assert(hw_resources.count > 0);
-        assert(hw_resources.resources[0].type == IO_RANGE);
-        assert(hw_resources.resources[0].res.io_range.size == 8);
+        ddf_msg(LVL_DEBUG, "data_addr = %" PRIx64 ".",
+            hw_resources.resources[1].res.io_range.address);
         
         bus->conf_io_addr =
             (uint32_t) hw_resources.resources[0].res.io_range.address;
-        
-        if (pio_enable((void *)(uintptr_t)bus->conf_io_addr, 8,
+        bus->conf_io_data =
+            (uint32_t) hw_resources.resources[1].res.io_range.address;
+        
+        if (pio_enable((void *)(uintptr_t)bus->conf_io_addr, 4,
             &bus->conf_addr_port)) {
                 ddf_msg(LVL_ERROR, "Failed to enable configuration ports.");
@@ -666 +676 @@
                 goto fail;
         }
-        bus->conf_data_port = (char *) bus->conf_addr_port + 4;
+        if (pio_enable((void *)(uintptr_t)bus->conf_io_data, 4,
+            &bus->conf_data_port)) {
+                ddf_msg(LVL_ERROR, "Failed to enable configuration ports.");
+                rc = EADDRNOTAVAIL;
+                goto fail;
+        }
         
         /* Make the bus device more visible. It has no use yet. */

uspace/drv/bus/pci/pciintel/pci.h

@@ -46 +46 @@
         ddf_dev_t *dnode;
         uint32_t conf_io_addr;
+        uint32_t conf_io_data;
         void *conf_data_port;
         void *conf_addr_port;

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

@@ -162 +162 @@
                 qpos = "NOT FIRST";
         }
-        assert((prev_ed->next & ED_NEXT_PTR_MASK) == addr_to_phys(ep->ed));
+        assert(ed_next(prev_ed) == addr_to_phys(ep->ed));
         prev_ed->next = ep->ed->next;
         /* Make sure ED is updated */

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

@@ -111 +111 @@
         ohci_regs_t *registers = (ohci_regs_t *) regs;
         cmds[0].addr = (void *) &registers->interrupt_status;
+        cmds[1].value = OHCI_USED_INTERRUPTS;
         cmds[3].addr = (void *) &registers->interrupt_status;
 
@@ -241 +242 @@
         switch (ep->transfer_type) {
         case USB_TRANSFER_CONTROL:
-                instance->registers->control &= ~C_CLE;
+                OHCI_CLR(instance->registers->control, C_CLE);
                 endpoint_list_add_ep(list, ohci_ep);
-                instance->registers->control_current = 0;
-                instance->registers->control |= C_CLE;
+                OHCI_WR(instance->registers->control_current, 0);
+                OHCI_SET(instance->registers->control, C_CLE);
                 break;
         case USB_TRANSFER_BULK:
-                instance->registers->control &= ~C_BLE;
+                OHCI_CLR(instance->registers->control, C_BLE);
                 endpoint_list_add_ep(list, ohci_ep);
-                instance->registers->control |= C_BLE;
+                OHCI_WR(instance->registers->bulk_current, 0);
+                OHCI_SET(instance->registers->control, C_BLE);
                 break;
         case USB_TRANSFER_ISOCHRONOUS:
         case USB_TRANSFER_INTERRUPT:
-                instance->registers->control &= (~C_PLE & ~C_IE);
+                OHCI_CLR(instance->registers->control, C_PLE | C_IE);
                 endpoint_list_add_ep(list, ohci_ep);
-                instance->registers->control |= C_PLE | C_IE;
+                OHCI_SET(instance->registers->control, C_PLE | C_IE);
                 break;
         }
@@ -273 +275 @@
         switch (ep->transfer_type) {
         case USB_TRANSFER_CONTROL:
-                instance->registers->control &= ~C_CLE;
+                OHCI_CLR(instance->registers->control, C_CLE);
                 endpoint_list_remove_ep(list, ohci_ep);
-                instance->registers->control_current = 0;
-                instance->registers->control |= C_CLE;
+                OHCI_WR(instance->registers->control_current, 0);
+                OHCI_SET(instance->registers->control, C_CLE);
                 break;
         case USB_TRANSFER_BULK:
-                instance->registers->control &= ~C_BLE;
+                OHCI_CLR(instance->registers->control, C_BLE);
                 endpoint_list_remove_ep(list, ohci_ep);
-                instance->registers->control |= C_BLE;
+                OHCI_WR(instance->registers->bulk_current, 0);
+                OHCI_SET(instance->registers->control, C_BLE);
                 break;
         case USB_TRANSFER_ISOCHRONOUS:
         case USB_TRANSFER_INTERRUPT:
-                instance->registers->control &= (~C_PLE & ~C_IE);
+                OHCI_CLR(instance->registers->control, C_PLE | C_IE);
                 endpoint_list_remove_ep(list, ohci_ep);
-                instance->registers->control |= C_PLE | C_IE;
+                OHCI_SET(instance->registers->control, C_PLE | C_IE);
                 break;
         default:
@@ -308 +311 @@
         /* Check for root hub communication */
         if (batch->ep->address == instance->rh.address) {
+                usb_log_debug("OHCI root hub request.\n");
                 rh_request(&instance->rh, batch);
                 return EOK;
@@ -323 +327 @@
         {
         case USB_TRANSFER_CONTROL:
-                instance->registers->command_status |= CS_CLF;
+                OHCI_SET(instance->registers->command_status, CS_CLF);
                 break;
         case USB_TRANSFER_BULK:
-                instance->registers->command_status |= CS_BLF;
+                OHCI_SET(instance->registers->command_status, CS_BLF);
                 break;
         default:
@@ -342 +346 @@
 void hc_interrupt(hc_t *instance, uint32_t status)
 {
+        status = ohci_reg2host(status);
         assert(instance);
         if ((status & ~I_SF) == 0) /* ignore sof status */
@@ -352 +357 @@
                 fibril_mutex_lock(&instance->guard);
                 usb_log_debug2("HCCA: %p-%#" PRIx32 " (%p).\n", instance->hcca,
-                    instance->registers->hcca,
+                    OHCI_RD(instance->registers->hcca),
                     (void *) addr_to_phys(instance->hcca));
                 usb_log_debug2("Periodic current: %#" PRIx32 ".\n",
-                    instance->registers->periodic_current);
+                    OHCI_RD(instance->registers->periodic_current));
 
                 link_t *current = list_first(&instance->pending_batches);
@@ -410 +415 @@
 
         usb_log_debug("Requesting OHCI control.\n");
-        if (instance->registers->revision & R_LEGACY_FLAG) {
+        if (OHCI_RD(instance->registers->revision) & R_LEGACY_FLAG) {
                 /* Turn off legacy emulation, it should be enough to zero
                  * the lowest bit, but it caused problems. Thus clear all
@@ -419 +424 @@
                 (uint32_t*)((char*)instance->registers + LEGACY_REGS_OFFSET);
                 usb_log_debug("OHCI legacy register %p: %x.\n",
-                    ohci_emulation_reg, *ohci_emulation_reg);
+                    ohci_emulation_reg, OHCI_RD(*ohci_emulation_reg));
                 /* Zero everything but A20State */
-                *ohci_emulation_reg &= 0x100;
+                OHCI_CLR(*ohci_emulation_reg, ~0x100);
                 usb_log_debug(
                     "OHCI legacy register (should be 0 or 0x100) %p: %x.\n",
-                    ohci_emulation_reg, *ohci_emulation_reg);
+                    ohci_emulation_reg, OHCI_RD(*ohci_emulation_reg));
         }
 
         /* Interrupt routing enabled => smm driver is active */
-        if (instance->registers->control & C_IR) {
+        if (OHCI_RD(instance->registers->control) & C_IR) {
                 usb_log_debug("SMM driver: request ownership change.\n");
-                instance->registers->command_status |= CS_OCR;
+                OHCI_SET(instance->registers->command_status, CS_OCR);
                 /* Hope that SMM actually knows its stuff or we can hang here */
-                while (instance->registers->control & C_IR) {
+                while (OHCI_RD(instance->registers->control & C_IR)) {
                         async_usleep(1000);
                 }
@@ -440 +445 @@
                 return;
         }
-
         const unsigned hc_status = C_HCFS_GET(instance->registers->control);
         /* Interrupt routing disabled && status != USB_RESET => BIOS active */
@@ -449 +453 @@
                         return;
                 }
-                /* HC is suspended assert resume for 20ms, */
+                /* HC is suspended assert resume for 20ms */
                 C_HCFS_SET(instance->registers->control, C_HCFS_RESUME);
                 async_usleep(20000);
@@ -473 +477 @@
 
         /* Save contents of fm_interval register */
-        const uint32_t fm_interval = instance->registers->fm_interval;
+        const uint32_t fm_interval = OHCI_RD(instance->registers->fm_interval);
         usb_log_debug2("Old value of HcFmInterval: %x.\n", fm_interval);
 
@@ -479 +483 @@
         usb_log_debug2("HC reset.\n");
         size_t time = 0;
-        instance->registers->command_status = CS_HCR;
-        while (instance->registers->command_status & CS_HCR) {
+        OHCI_WR(instance->registers->command_status, CS_HCR);
+        while (OHCI_RD(instance->registers->command_status) & CS_HCR) {
                 async_usleep(10);
                 time += 10;
@@ -487 +491 @@
 
         /* Restore fm_interval */
-        instance->registers->fm_interval = fm_interval;
-        assert((instance->registers->command_status & CS_HCR) == 0);
+        OHCI_WR(instance->registers->fm_interval, fm_interval);
+        assert((OHCI_RD(instance->registers->command_status) & CS_HCR) == 0);
 
         /* hc is now in suspend state */
         usb_log_debug2("HC should be in suspend state(%x).\n",
-            instance->registers->control);
+            OHCI_RD(instance->registers->control));
 
         /* Use HCCA */
-        instance->registers->hcca = addr_to_phys(instance->hcca);
+        OHCI_WR(instance->registers->hcca, addr_to_phys(instance->hcca));
 
         /* Use queues */
-        instance->registers->bulk_head =
-            instance->lists[USB_TRANSFER_BULK].list_head_pa;
+        OHCI_WR(instance->registers->bulk_head,
+            instance->lists[USB_TRANSFER_BULK].list_head_pa);
         usb_log_debug2("Bulk HEAD set to: %p (%#" PRIx32 ").\n",
             instance->lists[USB_TRANSFER_BULK].list_head,
             instance->lists[USB_TRANSFER_BULK].list_head_pa);
 
-        instance->registers->control_head =
-            instance->lists[USB_TRANSFER_CONTROL].list_head_pa;
+        OHCI_WR(instance->registers->control_head,
+            instance->lists[USB_TRANSFER_CONTROL].list_head_pa);
         usb_log_debug2("Control HEAD set to: %p (%#" PRIx32 ").\n",
             instance->lists[USB_TRANSFER_CONTROL].list_head,
@@ -511 +515 @@
 
         /* Enable queues */
-        instance->registers->control |= (C_PLE | C_IE | C_CLE | C_BLE);
-        usb_log_debug2("All queues enabled(%x).\n",
-            instance->registers->control);
+        OHCI_SET(instance->registers->control, (C_PLE | C_IE | C_CLE | C_BLE));
+        usb_log_debug("Queues enabled(%x).\n",
+            OHCI_RD(instance->registers->control));
 
         /* Enable interrupts */
-        instance->registers->interrupt_enable = OHCI_USED_INTERRUPTS;
-        usb_log_debug2("Enabled interrupts: %x.\n",
-            instance->registers->interrupt_enable);
-        instance->registers->interrupt_enable = I_MI;
+        OHCI_WR(instance->registers->interrupt_enable, OHCI_USED_INTERRUPTS);
+        usb_log_debug("Enabled interrupts: %x.\n",
+            OHCI_RD(instance->registers->interrupt_enable));
+        OHCI_WR(instance->registers->interrupt_enable, I_MI);
 
         /* Set periodic start to 90% */
-        uint32_t frame_length = ((fm_interval >> FMI_FI_SHIFT) & FMI_FI_MASK);
-        instance->registers->periodic_start = (frame_length / 10) * 9;
+        const uint32_t frame_length =
+            (fm_interval >> FMI_FI_SHIFT) & FMI_FI_MASK;
+        OHCI_WR(instance->registers->periodic_start,
+            ((frame_length / 10) * 9) & PS_MASK << PS_SHIFT);
         usb_log_debug2("All periodic start set to: %x(%u - 90%% of %d).\n",
-            instance->registers->periodic_start,
-            instance->registers->periodic_start, frame_length);
-
+            OHCI_RD(instance->registers->periodic_start),
+            OHCI_RD(instance->registers->periodic_start), frame_length);
         C_HCFS_SET(instance->registers->control, C_HCFS_OPERATIONAL);
         usb_log_debug("OHCI HC up and running (ctl_reg=0x%x).\n",
-            instance->registers->control);
+            OHCI_RD(instance->registers->control));
 }
 /*----------------------------------------------------------------------------*/
@@ -591 +596 @@
 
         for (unsigned i = 0; i < 32; ++i) {
-                instance->hcca->int_ep[i] =
-                    instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa;
+                OHCI_WR(instance->hcca->int_ep[i],
+                    instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa);
         }
         usb_log_debug2("Interrupt HEADs set to: %p (%#" PRIx32 ").\n",

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

@@ -58 +58 @@
                 /* Mark as dead, used for dummy EDs at the beginning of
                  * endpoint lists. */
-                instance->status = ED_STATUS_K_FLAG;
+                OHCI_WR(instance->status, ED_STATUS_K_FLAG);
                 return;
         }
@@ -65 +65 @@
 
         /* Status: address, endpoint nr, direction mask and max packet size. */
-        instance->status = 0
-            | ((ep->address & ED_STATUS_FA_MASK) << ED_STATUS_FA_SHIFT)
+        OHCI_WR(instance->status,
+            ((ep->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);
+                << ED_STATUS_MPS_SHIFT));
 
         /* Low speed flag */
         if (ep->speed == USB_SPEED_LOW)
-                instance->status |= ED_STATUS_S_FLAG;
+                OHCI_SET(instance->status, ED_STATUS_S_FLAG);
 
         /* Isochronous format flag */
         if (ep->transfer_type == USB_TRANSFER_ISOCHRONOUS)
-                instance->status |= ED_STATUS_F_FLAG;
+                OHCI_SET(instance->status, ED_STATUS_F_FLAG);
 
         /* Set TD to the list */
         const uintptr_t pa = addr_to_phys(td);
-        instance->td_head = pa & ED_TDHEAD_PTR_MASK;
-        instance->td_tail = pa & ED_TDTAIL_PTR_MASK;
+        OHCI_WR(instance->td_head, pa & ED_TDHEAD_PTR_MASK);
+        OHCI_WR(instance->td_tail, pa & ED_TDTAIL_PTR_MASK);
 
         /* Set toggle bit */
         if (ep->toggle)
-                instance->td_head |= ED_TDHEAD_TOGGLE_CARRY;
+                OHCI_SET(instance->td_head, ED_TDHEAD_TOGGLE_CARRY);
 
 }

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

@@ -40 +40 @@
 #include <usb/host/endpoint.h>
 
+#include "../ohci_regs.h"
 #include "../utils/malloc32.h"
 #include "transfer_descriptor.h"
@@ -116 +117 @@
 {
         assert(instance);
-        return (instance->td_head & ED_TDHEAD_HALTED_FLAG)
-            || (instance->status & ED_STATUS_K_FLAG);
+        return (OHCI_RD(instance->td_head) & ED_TDHEAD_HALTED_FLAG)
+            || (OHCI_RD(instance->status) & ED_STATUS_K_FLAG);
+}
+
+static inline void ed_clear_halt(ed_t *instance)
+{
+        assert(instance);
+        OHCI_CLR(instance->td_head, ED_TDHEAD_HALTED_FLAG);
 }
 
@@ -128 +135 @@
 {
         assert(instance);
-        return (instance->td_head & ED_TDHEAD_PTR_MASK)
-            != (instance->td_tail & ED_TDTAIL_PTR_MASK);
+        return (OHCI_RD(instance->td_head) & ED_TDHEAD_PTR_MASK)
+            != (OHCI_RD(instance->td_tail) & ED_TDTAIL_PTR_MASK);
 }
 
@@ -141 +148 @@
         assert(instance);
         const uintptr_t pa = addr_to_phys(td);
-        instance->td_tail = pa & ED_TDTAIL_PTR_MASK;
+        OHCI_WR(instance->td_tail, pa & ED_TDTAIL_PTR_MASK);
+}
+
+static inline uint32_t ed_tail_td(const ed_t *instance)
+{
+        assert(instance);
+        return OHCI_RD(instance->td_tail) & ED_TDTAIL_PTR_MASK;
+}
+
+static inline uint32_t ed_head_td(const ed_t *instance)
+{
+        assert(instance);
+        return OHCI_RD(instance->td_head) & ED_TDHEAD_PTR_MASK;
 }
 
@@ -155 +174 @@
         const uint32_t pa = addr_to_phys(next);
         assert((pa & ED_NEXT_PTR_MASK) << ED_NEXT_PTR_SHIFT == pa);
-        instance->next = pa;
+        OHCI_WR(instance->next, pa);
+}
+
+static inline uint32_t ed_next(const ed_t *instance)
+{
+        assert(instance);
+        return OHCI_RD(instance->next) & ED_NEXT_PTR_MASK;
 }
 
@@ -166 +191 @@
 {
         assert(instance);
-        return (instance->td_head & ED_TDHEAD_TOGGLE_CARRY) ? 1 : 0;
+        return (OHCI_RD(instance->td_head) & ED_TDHEAD_TOGGLE_CARRY) ? 1 : 0;
 }
 
@@ -178 +203 @@
         assert(instance);
         if (toggle) {
-                instance->td_head |= ED_TDHEAD_TOGGLE_CARRY;
+                OHCI_SET(instance->td_head, ED_TDHEAD_TOGGLE_CARRY);
         } else {
                 /* Clear halted flag when reseting toggle TODO: Why? */
-                instance->td_head &= ~ED_TDHEAD_TOGGLE_CARRY;
-                instance->td_head &= ~ED_TDHEAD_HALTED_FLAG;
+                OHCI_CLR(instance->td_head, ED_TDHEAD_TOGGLE_CARRY);
+                OHCI_CLR(instance->td_head, ED_TDHEAD_HALTED_FLAG);
         }
 }

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

@@ -33 +33 @@
  */
 #include <usb/usb.h>
+#include <mem.h>
+#include "../utils/malloc32.h"
 #include "transfer_descriptor.h"
 
@@ -58 +60 @@
         bzero(instance, sizeof(td_t));
         /* Set PID and Error code */
-        instance->status = 0
-            | ((dir[direction] & TD_STATUS_DP_MASK) << TD_STATUS_DP_SHIFT)
-            | ((CC_NOACCESS2 & TD_STATUS_CC_MASK) << TD_STATUS_CC_SHIFT);
+        OHCI_WR(instance->status,
+            ((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) {
                 /* Set explicit toggle bit */
-                instance->status |= TD_STATUS_T_USE_TD_FLAG;
-                instance->status |= toggle ? TD_STATUS_T_FLAG : 0;
+                OHCI_SET(instance->status, TD_STATUS_T_USE_TD_FLAG);
+                OHCI_SET(instance->status, toggle ? TD_STATUS_T_FLAG : 0);
         }
 
         /* Alow less data on input. */
         if (dir == USB_DIRECTION_IN) {
-                instance->status |= TD_STATUS_ROUND_FLAG;
+                OHCI_SET(instance->status, TD_STATUS_ROUND_FLAG);
         }
 
         if (buffer != NULL) {
                 assert(size != 0);
-                instance->cbp = addr_to_phys(buffer);
-                instance->be = addr_to_phys(buffer + size - 1);
+                OHCI_WR(instance->cbp, addr_to_phys(buffer));
+                OHCI_WR(instance->be, addr_to_phys(buffer + size - 1));
         }
 
-        instance->next = addr_to_phys(next) & TD_NEXT_PTR_MASK;
+        OHCI_WR(instance->next, addr_to_phys(next) & TD_NEXT_PTR_MASK);
 
 }

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

@@ -38 +38 @@
 #include <stdint.h>
 
-#include "../utils/malloc32.h"
+#include "../ohci_regs.h"
 #include "completion_codes.h"
 
@@ -100 +100 @@
 {
         assert(instance);
-        const int cc =
-            (instance->status >> TD_STATUS_CC_SHIFT) & TD_STATUS_CC_MASK;
+        const int cc =(OHCI_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.
@@ -119 +119 @@
 {
         assert(instance);
-        const int cc =
-            (instance->status >> TD_STATUS_CC_SHIFT) & TD_STATUS_CC_MASK;
+        const int cc = (OHCI_RD(instance->status)
+            >> TD_STATUS_CC_SHIFT) & TD_STATUS_CC_MASK;
         return cc_to_rc(cc);
 }
@@ -136 +136 @@
                 return 0;
         /* Buffer end points to the last byte of transfer buffer, so add 1 */
-        return instance->be - instance->cbp + 1;
+        return OHCI_RD(instance->be) - OHCI_RD(instance->cbp) + 1;
 }
 #endif

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

@@ -199 +199 @@
                     ohci_batch->tds[i]->next, ohci_batch->tds[i]->be);
 
-                /* If the TD got all its data through, it will report 0 bytes
-                 * remain, the sole exception is INPUT with data rounding flag
-                 * (short), i.e. every INPUT. Nice thing is that short packets
-                 * will correctly report remaining data, thus making
-                 * this computation correct (short packets need to be produced
-                 * by the last TD)
-                 * NOTE: This also works for CONTROL transfer as
-                 * the first TD will return 0 remain.
-                 * NOTE: Short packets don't break the assumption that
-                 * we leave the very last(unused) TD behind.
-                 */
-                ohci_batch->usb_batch->transfered_size
-                    -= td_remain_size(ohci_batch->tds[i]);
-
                 ohci_batch->usb_batch->error = td_error(ohci_batch->tds[i]);
-                if (ohci_batch->usb_batch->error != EOK) {
+                if (ohci_batch->usb_batch->error == EOK) {
+                        /* If the TD got all its data through, it will report
+                         * 0 bytes remain, the sole exception is INPUT with
+                         * data rounding flag (short), i.e. every INPUT.
+                         * Nice thing is that short packets will correctly
+                         * report remaining data, thus making this computation
+                         * correct (short packets need to be produced by the
+                         * last TD)
+                         * NOTE: This also works for CONTROL transfer as
+                         * the first TD will return 0 remain.
+                         * NOTE: Short packets don't break the assumption that
+                         * we leave the very last(unused) TD behind.
+                         */
+                        ohci_batch->usb_batch->transfered_size
+                            -= td_remain_size(ohci_batch->tds[i]);
+                } else {
                         usb_log_debug("Batch %p found error TD(%zu):%08x.\n",
                             ohci_batch->usb_batch, i,
@@ -231 +232 @@
 
                         /* Check TD assumption */
-                        const uint32_t pa =
-                            addr_to_phys(ohci_batch->tds[leave_td]);
-                        assert((ohci_batch->ed->td_head & ED_TDHEAD_PTR_MASK)
-                            == pa);
-
+                        assert(ed_head_td(ohci_batch->ed) ==
+                            addr_to_phys(ohci_batch->tds[leave_td]));
+
+                        /* Set tail to the same TD */
                         ed_set_tail_td(ohci_batch->ed,
                             ohci_batch->tds[leave_td]);
 
                         /* Clear possible ED HALT */
-                        ohci_batch->ed->td_head &= ~ED_TDHEAD_HALTED_FLAG;
+                        ed_clear_halt(ohci_batch->ed);
                         break;
                 }
@@ -253 +253 @@
 
         /* Make sure that we are leaving the right TD behind */
-        const uint32_t pa = addr_to_phys(ohci_ep->td);
-        assert(pa == (ohci_batch->ed->td_head & ED_TDHEAD_PTR_MASK));
-        assert(pa == (ohci_batch->ed->td_tail & ED_TDTAIL_PTR_MASK));
+        assert(addr_to_phys(ohci_ep->td) == ed_head_td(ohci_batch->ed));
+        assert(addr_to_phys(ohci_ep->td) == ed_tail_td(ohci_batch->ed));
+//      const uint32_t pa = addr_to_phys(ohci_ep->td);
+//      assert(pa == (ohci_batch->ed->td_head & ED_TDHEAD_PTR_MASK));
+//      assert(pa == (ohci_batch->ed->td_tail & ED_TDTAIL_PTR_MASK));
 
         return true;

uspace/drv/bus/usb/ohci/ohci_regs.h

@@ -35 +35 @@
 #define DRV_OHCI_OHCI_REGS_H
 #include <sys/types.h>
+#include <byteorder.h>
+
+
+/* assume OHCI regs are le */
+#define host2ohci_reg(value) host2uint32_t_le(value)
+#define ohci_reg2host(value) uint32_t_le2host(value)
+
+#define OHCI_WR(reg, val) reg = host2uint32_t_le(val)
+#define OHCI_RD(reg) uint32_t_le2host(reg)
+#define OHCI_SET(reg, val) reg |= host2uint32_t_le(val)
+#define OHCI_CLR(reg, val) reg &= host2uint32_t_le(~val)
+
 
 #define LEGACY_REGS_OFFSET 0x100
@@ -42 +54 @@
         const ioport32_t revision;
 #define R_REVISION_MASK (0x3f)
-#define R_REVISION_SHIFT (0)
 #define R_LEGACY_FLAG   (0x80)
 
         ioport32_t control;
-#define C_CBSR_MASK (0x3) /* Control-bulk service ratio */
+/* Control-bulk service ratio */
 #define C_CBSR_1_1  (0x0)
 #define C_CBSR_1_2  (0x1)
 #define C_CBSR_1_3  (0x2)
 #define C_CBSR_1_4  (0x3)
-#define C_CBSR_SHIFT (0)
+#define C_CBSR_MASK (0x3)
+#define C_CBSR_SHIFT 0
 
 #define C_PLE (1 << 2)   /* Periodic list enable */
@@ -58 +70 @@
 #define C_BLE (1 << 5)   /* Bulk list enable */
 
-#define C_HCFS_MASK        (0x3) /* Host controller functional state */
+/* Host controller functional state */
 #define C_HCFS_RESET       (0x0)
 #define C_HCFS_RESUME      (0x1)
 #define C_HCFS_OPERATIONAL (0x2)
 #define C_HCFS_SUSPEND     (0x3)
-#define C_HCFS_SHIFT       (6)
-
-#define C_HCFS_GET(reg) \
-        ((reg >> C_HCFS_SHIFT) & C_HCFS_MASK)
-#define C_HCFS_SET(reg, hcfs_state) \
+#define C_HCFS_GET(reg) ((OHCI_RD(reg) >> 6) & 0x3)
+#define C_HCFS_SET(reg, value) \
 do { \
-        reg = (reg & ~(C_HCFS_MASK << C_HCFS_SHIFT)) \
-            | ((hcfs_state & C_HCFS_MASK) << C_HCFS_SHIFT); \
+        uint32_t r = OHCI_RD(reg); \
+        r &= ~(0x3 << 6); \
+        r |= (value & 0x3) << 6; \
+        OHCI_WR(reg, r); \
 } while (0)
 
-
-#define C_IR  (1 << 8)   /* Interrupt routing, make sure it's 0 */
-#define C_RWC (1 << 9)   /* Remote wakeup connected, host specific */
+#define C_IR  (1 << 8)  /* Interrupt routing, make sure it's 0 */
+#define C_RWC (1 << 9)  /* Remote wakeup connected, host specific */
 #define C_RWE (1 << 10)  /* Remote wakeup enable */
 
@@ -83 +93 @@
 #define CS_BLF (1 << 2)   /* Bulk list filled */
 #define CS_OCR (1 << 3)   /* Ownership change request */
+#if 0
 #define CS_SOC_MASK (0x3) /* Scheduling overrun count */
 #define CS_SOC_SHIFT (16)
+#endif
 
         /** Interupt enable/disable/status,
@@ -101 +113 @@
 #define I_RHSC (1 << 6)   /* Root hub status change */
 #define I_OC   (1 << 30)  /* Ownership change */
-#define I_MI   (1 << 31)  /* Master interrupt (all/any interrupts) */
+#define I_MI   (1 << 31)  /* Master interrupt (any/all) */
 
         /** HCCA pointer (see hw_struct hcca.h) */
@@ -145 +157 @@
         /** Remaining bit time in frame to start periodic transfers */
         ioport32_t periodic_start;
-#define PS_PS_MASK (0x3fff) /* bit time when periodic get priority (0x3e67) */
+#define PS_MASK 0x3fff
+#define PS_SHIFT 0
 
         /** Threshold for starting LS transaction */
@@ -153 +166 @@
         /** The first root hub control register */
         ioport32_t rh_desc_a;
-#define RHDA_NDS_MASK (0xff) /* Number of downstream ports, max 15 */
-#define RHDA_NDS_SHIFT (0)
-#define RHDA_PSM_FLAG  (1 << 8)  /* Power switching mode: 0-global, 1-per port*/
-#define RHDA_NPS_FLAG  (1 << 9)  /* No power switch: 1-power on, 0-use PSM*/
-#define RHDA_DT_FLAG   (1 << 10) /* 1-Compound device, must be 0 */
-#define RHDA_OCPM_FLAG (1 << 11) /* Over-current mode: 0-global, 1-per port */
-#define RHDA_NOCP_FLAG (1 << 12) /* OC control: 0-use OCPM, 1-OC off */
-#define RHDA_POTPGT_MASK (0xff)  /* Power on to power good time */
-#define RHDA_POTPGT_SHIFT (24)
+/** Number of downstream ports, max 15 */
+#define RHDA_NDS_MASK  (0xff)
+/** Power switching mode: 0-global, 1-per port*/
+#define RHDA_PSM_FLAG  (1 << 8)
+/** No power switch: 1-power on, 0-use PSM*/
+#define RHDA_NPS_FLAG  (1 << 9)
+/** 1-Compound device, must be 0 */
+#define RHDA_DT_FLAG   (1 << 10)
+/** Over-current mode: 0-global, 1-per port */
+#define RHDA_OCPM_FLAG (1 << 11)
+/** OC control: 0-use OCPM, 1-OC off */
+#define RHDA_NOCP_FLAG (1 << 12)
+/** Power on to power good time */
+#define RHDA_POTPGT_SHIFT   24
 
         /** The other root hub control register */
         ioport32_t rh_desc_b;
-#define RHDB_DR_MASK (0xffff) /* Device removable mask */
-#define RHDB_DR_SHIFT (0)
-#define RHDB_PCC_MASK (0xffff) /* Power control mask */
-#define RHDB_PCC_SHIFT (16)
-
-/* Port device removable status */
-#define RHDB_DR_FLAG(port) (((1 << port) & RHDB_DR_MASK) << RHDB_DR_SHIFT)
-/* Port power control status: 1-per port power control, 0-global power switch */
-#define RHDB_PPC_FLAG(port) (((1 << port) & RHDB_DR_MASK) << RHDB_DR_SHIFT)
+/** Device removable mask */
+#define RHDB_DR_SHIFT   0
+#define RHDB_DR_MASK    0xffff
+/** Power control mask */
+#define RHDB_PCC_MASK (0xffff)
+#define RHDB_PCC_SHIFT 16
 
         /** Root hub status register */
         ioport32_t rh_status;
-#define RHS_LPS_FLAG  (1 <<  0)/* read: 0,
-                                * write: 0-no effect,
-                                *        1-turn off port power for ports
-                                *        specified in PPCM(RHDB), or all ports,
-                                *        if power is set globally */
+/* read: 0,
+ * write: 0-no effect,
+ *        1-turn off port power for ports
+ *        specified in PPCM(RHDB), or all ports,
+ *        if power is set globally */
+#define RHS_LPS_FLAG  (1 <<  0)
 #define RHS_CLEAR_GLOBAL_POWER RHS_LPS_FLAG /* synonym for the above */
-#define RHS_OCI_FLAG  (1 <<  1)/* Over-current indicator, if per-port: 0 */
-#define RHS_DRWE_FLAG (1 << 15)/* read: 0-connect status change does not wake HC
-                                *       1-connect status change wakes HC
-                                * write: 1-set DRWE, 0-no effect */
+/** Over-current indicator, if per-port: 0 */
+#define RHS_OCI_FLAG  (1 <<  1)
+
+/* read: 0-connect status change does not wake HC
+ *       1-connect status change wakes HC
+ * write: 1-set DRWE, 0-no effect */
+#define RHS_DRWE_FLAG (1 << 15)
 #define RHS_SET_DRWE RHS_DRWE_FLAG
-#define RHS_LPSC_FLAG (1 << 16)/* read: 0,
-                                * write: 0-no effect
-                                *        1-turn on port power for ports
-                                *        specified in PPCM(RHDB), or all ports,
-                                *        if power is set globally */
+/* read: 0,
+ * write: 0-no effect
+ *        1-turn on port power for ports
+ *        specified in PPCM(RHDB), or all ports,
+ *        if power is set globally */
+#define RHS_LPSC_FLAG (1 << 16)
 #define RHS_SET_GLOBAL_POWER RHS_LPSC_FLAG /* synonym for the above */
-#define RHS_OCIC_FLAG (1 << 17)/* Over-current indicator change   */
+/** Over-current change indicator*/
+#define RHS_OCIC_FLAG (1 << 17)
 #define RHS_CLEAR_DRWE (1 << 31)
 
@@ -200 +221 @@
         ioport32_t rh_port_status[];
 #define RHPS_CCS_FLAG (1 << 0) /* r: current connect status,
-                                * w: 1-clear port enable, 0-nothing */
+                                               * w: 1-clear port enable, 0-N/S*/
 #define RHPS_CLEAR_PORT_ENABLE RHPS_CCS_FLAG
 #define RHPS_PES_FLAG (1 << 1) /* r: port enable status
-                                * w: 1-set port enable, 0-nothing */
+                                              * w: 1-set port enable, 0-N/S */
 #define RHPS_SET_PORT_ENABLE RHPS_PES_FLAG
 #define RHPS_PSS_FLAG (1 << 2) /* r: port suspend status
-                                * w: 1-set port suspend, 0-nothing */
+                                               * w: 1-set port suspend, 0-N/S */
 #define RHPS_SET_PORT_SUSPEND RHPS_PSS_FLAG
-#define RHPS_POCI_FLAG (1 << 3) /* r: port over-current (if reports are per-port
-                                 * w: 1-clear port suspend (start resume
-                                 *      if suspened)
-                                 *    0-nothing */
+#define RHPS_POCI_FLAG (1 << 3) /* r: port over-current
+                                                * (if reports are per-port
+                                                * w: 1-clear port suspend
+                                                *  (start resume if suspened)
+                                                *    0-nothing */
 #define RHPS_CLEAR_PORT_SUSPEND RHPS_POCI_FLAG
 #define RHPS_PRS_FLAG (1 << 4) /* r: port reset status
-                                * w: 1-set port reset, 0-nothing */
+                                               * w: 1-set port reset, 0-N/S */
 #define RHPS_SET_PORT_RESET RHPS_PRS_FLAG
 #define RHPS_PPS_FLAG (1 << 8) /* r: port power status
-                                * w: 1-set port power, 0-nothing */
+                                              * w: 1-set port power, 0-N/S */
 #define RHPS_SET_PORT_POWER RHPS_PPS_FLAG
 #define RHPS_LSDA_FLAG (1 << 9) /* r: low speed device attached
-                                 * w: 1-clear port power, 0-nothing */
+                                                * w: 1-clear port power, 0-N/S*/
 #define RHPS_CLEAR_PORT_POWER RHPS_LSDA_FLAG
-#define RHPS_CSC_FLAG  (1 << 16) /* connect status change Write-Clean */
+#define RHPS_CSC_FLAG  (1 << 16) /* connect status change WC */
 #define RHPS_PESC_FLAG (1 << 17) /* port enable status change WC */
 #define RHPS_PSSC_FLAG (1 << 18) /* port suspend status change WC */
 #define RHPS_OCIC_FLAG (1 << 19) /* port over-current change WC */
 #define RHPS_PRSC_FLAG (1 << 20) /* port reset status change WC */
-#define RHPS_CHANGE_WC_MASK 0x1f0000
+#define RHPS_CHANGE_WC_MASK (0x1f0000)
 } __attribute__((packed)) ohci_regs_t;
 #endif

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

@@ -33 +33 @@
  */
 #include <assert.h>
+#include <byteorder.h>
 #include <errno.h>
 #include <str_error.h>
 #include <fibril_synch.h>
 
+#include <usb/usb.h>
 #include <usb/debug.h>
 #include <usb/dev/request.h>
 #include <usb/classes/hub.h>
 
-#include "root_hub.h"
 #include <usb/classes/classes.h>
 #include <usb/classes/hub.h>
 #include <usb/dev/driver.h>
 #include "ohci_regs.h"
+#include "root_hub.h"
 
 /**
@@ -122 +124 @@
 {
         assert(request);
+        usb_log_debug("Sending interrupt vector(%zu) %hhx:%hhx.\n",
+            size, ((uint8_t*)&mask)[0], ((uint8_t*)&mask)[1]);
         usb_transfer_batch_finish_error(request, &mask, size, EOK);
         usb_transfer_batch_destroy(request);
@@ -150 +154 @@
 
         instance->registers = regs;
-        instance->port_count =
-            (instance->registers->rh_desc_a >> RHDA_NDS_SHIFT) & RHDA_NDS_MASK;
+        instance->port_count = OHCI_RD(regs->rh_desc_a) & RHDA_NDS_MASK;
+        usb_log_debug2("rh_desc_a: %x.\n", OHCI_RD(regs->rh_desc_a));
         if (instance->port_count > 15) {
                 usb_log_warning("OHCI specification does not allow more than 15"
@@ -163 +167 @@
 
 #if defined OHCI_POWER_SWITCH_no
+        usb_log_debug("OHCI rh: Set power mode to no power switching.\n");
         /* Set port power mode to no power-switching. (always on) */
-        instance->registers->rh_desc_a |= RHDA_NPS_FLAG;
+        OHCI_SET(regs->rh_desc_a, RHDA_NPS_FLAG);
 
         /* Set to no over-current reporting */
-        instance->registers->rh_desc_a |= RHDA_NOCP_FLAG;
+        OHCI_SET(regs->rh_desc_a, RHDA_NOCP_FLAG);
 
 #elif defined OHCI_POWER_SWITCH_ganged
-        /* Set port power mode to no ganged power-switching. */
-        instance->registers->rh_desc_a &= ~RHDA_NPS_FLAG;
-        instance->registers->rh_desc_a &= ~RHDA_PSM_FLAG;
-        instance->registers->rh_status = RHS_CLEAR_GLOBAL_POWER;
+        usb_log_debug("OHCI rh: Set power mode to ganged power switching.\n");
+        /* Set port power mode to ganged power-switching. */
+        OHCI_CLR(regs->rh_desc_a, RHDA_NPS_FLAG);
+        OHCI_CLR(regs->rh_desc_a, RHDA_PSM_FLAG);
+
+        /* Turn off power (hub driver will turn this back on)*/
+        OHCI_WR(regs->rh_status, RHS_CLEAR_GLOBAL_POWER);
 
         /* Set to global over-current */
-        instance->registers->rh_desc_a &= ~RHDA_NOCP_FLAG;
-        instance->registers->rh_desc_a &= ~RHDA_OCPM_FLAG;
+        OHCI_CLR(regs->rh_desc_a, RHDA_NOCP_FLAG);
+        OHCI_CLR(regs->rh_desc_a, RHDA_OCPM_FLAG);
 #else
-        /* Set port power mode to no per port power-switching. */
-        instance->registers->rh_desc_a &= ~RHDA_NPS_FLAG;
-        instance->registers->rh_desc_a |= RHDA_PSM_FLAG;
+        usb_log_debug("OHCI rh: Set power mode to per-port power switching.\n");
+        /* Set port power mode to per port power-switching. */
+        OHCI_CLR(regs->rh_desc_a, RHDA_NPS_FLAG);
+        OHCI_SET(regs->rh_desc_a, RHDA_PSM_FLAG);
 
         /* Control all ports by global switch and turn them off */
-        instance->registers->rh_desc_b &= (RHDB_PCC_MASK << RHDB_PCC_SHIFT);
-        instance->registers->rh_status = RHS_CLEAR_GLOBAL_POWER;
+        OHCI_CLR(regs->rh_desc_b, RHDB_PCC_MASK << RHDB_PCC_SHIFT);
+        OHCI_WR(regs->rh_status, RHS_CLEAR_GLOBAL_POWER);
 
         /* Return control to per port state */
-        instance->registers->rh_desc_b |=
-                ((1 << (instance->port_count + 1)) - 1) << RHDB_PCC_SHIFT;
+        OHCI_SET(regs->rh_desc_b, RHDB_PCC_MASK << RHDB_PCC_SHIFT);
 
         /* Set per port over-current */
-        instance->registers->rh_desc_a &= ~RHDA_NOCP_FLAG;
-        instance->registers->rh_desc_a |= RHDA_OCPM_FLAG;
+        OHCI_CLR(regs->rh_desc_a, RHDA_NOCP_FLAG);
+        OHCI_SET(regs->rh_desc_a, RHDA_OCPM_FLAG);
 #endif
 
@@ -226 +234 @@
                 fibril_mutex_lock(&instance->guard);
                 assert(instance->unfinished_interrupt_transfer == NULL);
-                uint16_t mask = create_interrupt_mask(instance);
+                const uint16_t mask = create_interrupt_mask(instance);
                 if (mask == 0) {
-                        usb_log_debug("No changes...\n");
+                        usb_log_debug("No changes(%hx)...\n", mask);
                         instance->unfinished_interrupt_transfer = request;
                 } else {
@@ -257 +265 @@
         if (instance->unfinished_interrupt_transfer) {
                 usb_log_debug("Finalizing interrupt transfer\n");
-                uint16_t mask = create_interrupt_mask(instance);
+                const uint16_t mask = create_interrupt_mask(instance);
                 interrupt_request(instance->unfinished_interrupt_transfer,
                     mask, instance->interrupt_mask_size);
@@ -282 +290 @@
         instance->hub_descriptor_size = size;
 
-        uint32_t hub_desc = instance->registers->rh_desc_a;
-        uint32_t port_desc = instance->registers->rh_desc_b;
+        const uint32_t hub_desc = OHCI_RD(instance->registers->rh_desc_a);
+        const uint32_t port_desc = OHCI_RD(instance->registers->rh_desc_b);
 
         /* bDescLength */
@@ -305 +313 @@
         instance->descriptors.hub[4] = 0;
         /* bPwrOn2PwrGood */
-        instance->descriptors.hub[5] =
-            (hub_desc >> RHDA_POTPGT_SHIFT) & RHDA_POTPGT_MASK;
+        instance->descriptors.hub[5] = hub_desc >> RHDA_POTPGT_SHIFT;
         /* bHubContrCurrent, root hubs don't need no power. */
         instance->descriptors.hub[6] = 0;
 
         /* Device Removable and some legacy 1.0 stuff*/
-        instance->descriptors.hub[7] =
-            (port_desc >> RHDB_DR_SHIFT) & RHDB_DR_MASK & 0xff;
+        instance->descriptors.hub[7] = (port_desc >> RHDB_DR_SHIFT) & 0xff;
         instance->descriptors.hub[8] = 0xff;
         if (instance->interrupt_mask_size == 2) {
                 instance->descriptors.hub[8] =
-                    (port_desc >> RHDB_DR_SHIFT) & RHDB_DR_MASK >> 8;
+                    (port_desc >> RHDB_DR_SHIFT) >> 8;
                 instance->descriptors.hub[9]  = 0xff;
                 instance->descriptors.hub[10] = 0xff;
@@ -341 +347 @@
             instance->interrupt_mask_size;
 
-        instance->descriptors.configuration.total_length =
+        instance->descriptors.configuration.total_length = uint16_host2usb(
             sizeof(usb_standard_configuration_descriptor_t) +
             sizeof(usb_standard_endpoint_descriptor_t) +
             sizeof(usb_standard_interface_descriptor_t) +
-            instance->hub_descriptor_size;
+            instance->hub_descriptor_size);
 }
 /*----------------------------------------------------------------------------*/
@@ -364 +370 @@
 
         /* Only local power source change and over-current change can happen */
-        if (instance->registers->rh_status & (RHS_LPSC_FLAG | RHS_OCIC_FLAG)) {
+        if (OHCI_RD(instance->registers->rh_status)
+            & (RHS_LPSC_FLAG | RHS_OCIC_FLAG)) {
                 mask |= 1;
         }
         for (size_t port = 1; port <= instance->port_count; ++port) {
                 /* Write-clean bits are those that indicate change */
-                if (RHPS_CHANGE_WC_MASK
-                    & instance->registers->rh_port_status[port - 1]) {
-
+                if (OHCI_RD(instance->registers->rh_port_status[port - 1])
+                    & RHPS_CHANGE_WC_MASK) {
                         mask |= (1 << port);
                 }
         }
-        /* USB is little endian */
-        return host2uint32_t_le(mask);
+        usb_log_debug2("OHCI root hub interrupt mask: %hx.\n", mask);
+        return uint16_host2usb(mask);
 }
 /*----------------------------------------------------------------------------*/
@@ -396 +402 @@
         usb_device_request_setup_packet_t *request_packet =
             (usb_device_request_setup_packet_t*)request->setup_buffer;
+
+        const uint16_t index = uint16_usb2host(request_packet->index);
 
         switch (request_packet->request_type)
@@ -406 +414 @@
                         TRANSFER_END(request, EOVERFLOW);
                 } else {
-                        uint32_t data = instance->registers->rh_status &
-                            (RHS_LPS_FLAG | RHS_LPSC_FLAG
-                                | RHS_OCI_FLAG | RHS_OCIC_FLAG);
+                        const uint32_t data =
+                            OHCI_RD(instance->registers->rh_status) &
+                                (RHS_LPS_FLAG | RHS_LPSC_FLAG
+                                    | RHS_OCI_FLAG | RHS_OCIC_FLAG);
                         TRANSFER_END_DATA(request, &data, sizeof(data));
                 }
@@ -420 +429 @@
                         TRANSFER_END(request, EOVERFLOW);
                 } else {
-                        unsigned port = request_packet->index;
+                        const unsigned port = index;
                         if (port < 1 || port > instance->port_count)
                                 TRANSFER_END(request, EINVAL);
-
-                        uint32_t data =
-                            instance->registers->rh_port_status[port - 1];
+                        /* Register format matches the format of port status
+                         * field */
+                        const uint32_t data = uint32_usb2host(OHCI_RD(
+                            instance->registers->rh_port_status[port - 1]));
                         TRANSFER_END_DATA(request, &data, sizeof(data));
                 }
@@ -434 +444 @@
                         TRANSFER_END(request, EOVERFLOW);
                 } else {
-                        uint16_t data =
+                        const uint16_t data =
                             uint16_host2usb(USB_DEVICE_STATUS_SELF_POWERED);
                         TRANSFER_END_DATA(request, &data, sizeof(data));
@@ -441 +451 @@
         case SETUP_REQUEST_TO_HOST(USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE):
                 /* Hubs are allowed to have only one interface */
-                if (request_packet->index != 0)
+                if (index != 0)
                         TRANSFER_END(request, EINVAL);
                 /* Fall through, as the answer will be the same: 0x0000 */
         case SETUP_REQUEST_TO_HOST(USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_ENDPOINT):
                 /* Endpoint 0 (default control) and 1 (interrupt) */
-                if (request_packet->index >= 2)
+                if (index >= 2)
                         TRANSFER_END(request, EINVAL);
 
@@ -455 +465 @@
                 } else {
                         /* Endpoints are OK. (We don't halt) */
-                        uint16_t data = 0;
+                        const uint16_t data = 0;
                         TRANSFER_END_DATA(request, &data, sizeof(data));
                 }
@@ -482 +492 @@
         usb_device_request_setup_packet_t *setup_request =
             (usb_device_request_setup_packet_t *) request->setup_buffer;
-        uint16_t setup_request_value = setup_request->value_high;
-        switch (setup_request_value)
+        /* "The wValue field specifies the descriptor type in the high byte
+         * and the descriptor index in the low byte (refer to Table 9-5)." */
+        const int desc_type = uint16_usb2host(setup_request->value) >> 8;
+        switch (desc_type)
         {
         case USB_DESCTYPE_HUB:
@@ -530 +542 @@
                     setup_request->value,
                     setup_request->request_type, setup_request->request,
-                    setup_request_value, setup_request->index,
+                    desc_type, setup_request->index,
                     setup_request->length);
                 TRANSFER_END(request, EINVAL);
@@ -556 +568 @@
         switch (feature)
         {
-        case USB_HUB_FEATURE_PORT_POWER:   //8
-                /* No power switching */
-                if (instance->registers->rh_desc_a & RHDA_NPS_FLAG)
-                        return EOK;
-                /* Ganged power switching */
-                if (!(instance->registers->rh_desc_a & RHDA_PSM_FLAG)) {
-                        instance->registers->rh_status = RHS_SET_GLOBAL_POWER;
-                        return EOK;
+        case USB_HUB_FEATURE_PORT_POWER:   /*8*/
+                {
+                        const uint32_t rhda =
+                            OHCI_RD(instance->registers->rh_desc_a);
+                        /* No power switching */
+                        if (rhda & RHDA_NPS_FLAG)
+                                return EOK;
+                        /* Ganged power switching, one port powers all */
+                        if (!(rhda & RHDA_PSM_FLAG)) {
+                                OHCI_WR(instance->registers->rh_status,
+                                    RHS_SET_GLOBAL_POWER);
+                                return EOK;
+                        }
                 }
-        case USB_HUB_FEATURE_PORT_ENABLE:  //1
-        case USB_HUB_FEATURE_PORT_SUSPEND: //2
-        case USB_HUB_FEATURE_PORT_RESET:   //4
-                /* Nice thing is that these shifts correspond to the position
-                 * of control bits in register */
-                instance->registers->rh_port_status[port - 1] = (1 << feature);
+                        /* Fall through */
+        case USB_HUB_FEATURE_PORT_ENABLE:  /*1*/
+        case USB_HUB_FEATURE_PORT_SUSPEND: /*2*/
+        case USB_HUB_FEATURE_PORT_RESET:   /*4*/
+                usb_log_debug2("Setting port POWER, ENABLE, SUSPEND or RESET "
+                    "on port %zu.\n", port);
+                OHCI_WR(instance->registers->rh_port_status[port - 1],
+                    1 << feature);
                 return EOK;
         default:
@@ -596 +615 @@
         switch (feature)
         {
-        case USB_HUB_FEATURE_PORT_POWER:          //8
-                /* No power switching */
-                if (instance->registers->rh_desc_a & RHDA_NPS_FLAG)
-                        return ENOTSUP;
-                /* Ganged power switching */
-                if (!(instance->registers->rh_desc_a & RHDA_PSM_FLAG)) {
-                        instance->registers->rh_status = RHS_CLEAR_GLOBAL_POWER;
+        case USB_HUB_FEATURE_PORT_POWER:          /*8*/
+                {
+                        const uint32_t rhda =
+                            OHCI_RD(instance->registers->rh_desc_a);
+                        /* No power switching */
+                        if (rhda & RHDA_NPS_FLAG)
+                                return ENOTSUP;
+                        /* Ganged power switching, one port powers all */
+                        if (!(rhda & RHDA_PSM_FLAG)) {
+                                OHCI_WR(instance->registers->rh_status,
+                                    RHS_CLEAR_GLOBAL_POWER);
+                                return EOK;
+                        }
+                        OHCI_WR(instance->registers->rh_port_status[port - 1],
+                            RHPS_CLEAR_PORT_POWER);
                         return EOK;
                 }
-                instance->registers->rh_port_status[port - 1] =
-                        RHPS_CLEAR_PORT_POWER;
+
+        case USB_HUB_FEATURE_PORT_ENABLE:         /*1*/
+                OHCI_WR(instance->registers->rh_port_status[port - 1],
+                    RHPS_CLEAR_PORT_ENABLE);
                 return EOK;
 
-        case USB_HUB_FEATURE_PORT_ENABLE:         //1
-                instance->registers->rh_port_status[port - 1] =
-                        RHPS_CLEAR_PORT_ENABLE;
+        case USB_HUB_FEATURE_PORT_SUSPEND:        /*2*/
+                OHCI_WR(instance->registers->rh_port_status[port - 1],
+                    RHPS_CLEAR_PORT_SUSPEND);
                 return EOK;
 
-        case USB_HUB_FEATURE_PORT_SUSPEND:        //2
-                instance->registers->rh_port_status[port - 1] =
-                        RHPS_CLEAR_PORT_SUSPEND;
-                return EOK;
-
-        case USB_HUB_FEATURE_C_PORT_CONNECTION:   //16
-        case USB_HUB_FEATURE_C_PORT_ENABLE:       //17
-        case USB_HUB_FEATURE_C_PORT_SUSPEND:      //18
-        case USB_HUB_FEATURE_C_PORT_OVER_CURRENT: //19
-        case USB_HUB_FEATURE_C_PORT_RESET:        //20
-                /* Nice thing is that these shifts correspond to the position
-                 * of control bits in register */
-                instance->registers->rh_port_status[port - 1] = (1 << feature);
+        case USB_HUB_FEATURE_C_PORT_CONNECTION:   /*16*/
+        case USB_HUB_FEATURE_C_PORT_ENABLE:       /*17*/
+        case USB_HUB_FEATURE_C_PORT_SUSPEND:      /*18*/
+        case USB_HUB_FEATURE_C_PORT_OVER_CURRENT: /*19*/
+        case USB_HUB_FEATURE_C_PORT_RESET:        /*20*/
+                usb_log_debug2("Clearing port C_CONNECTION, C_ENABLE, "
+                    "C_SUSPEND, C_OC or C_RESET on port %zu.\n", port);
+                /* Bit offsets correspond to the feature number */
+                OHCI_WR(instance->registers->rh_port_status[port - 1],
+                    1 << feature);
                 return EOK;
 
@@ -654 +680 @@
         case USB_HUB_REQ_TYPE_SET_PORT_FEATURE:
                 usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
-                int ret = set_feature_port(instance,
+                const int ret = set_feature_port(instance,
                     setup_request->value, setup_request->index);
                 TRANSFER_END(request, ret);
@@ -693 +719 @@
         case USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE:
                 usb_log_debug("USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE\n");
-                int ret = clear_feature_port(instance,
+                const int ret = clear_feature_port(instance,
                     setup_request->value, setup_request->index);
                 TRANSFER_END(request, ret);
@@ -706 +732 @@
                  * as root hubs do not support local power status feature.
                  * (OHCI pg. 127) */
-                if (setup_request->value == USB_HUB_FEATURE_C_HUB_OVER_CURRENT) {
-                        instance->registers->rh_status = RHS_OCIC_FLAG;
+                if (uint16_usb2host(setup_request->value)
+                    == USB_HUB_FEATURE_C_HUB_OVER_CURRENT) {
+                        OHCI_WR(instance->registers->rh_status, RHS_OCIC_FLAG);
                         TRANSFER_END(request, EOK);
                 }
@@ -771 +798 @@
                 if (request->buffer_size == 0)
                         TRANSFER_END(request, EOVERFLOW);
-                uint8_t config = 1;
+                const uint8_t config = 1;
                 TRANSFER_END_DATA(request, &config, sizeof(config));
 
@@ -790 +817 @@
                         TRANSFER_END(request, EINVAL);
 
-                instance->address = setup_request->value;
+                instance->address = uint16_usb2host(setup_request->value);
                 TRANSFER_END(request, EOK);
 
         case USB_DEVREQ_SET_CONFIGURATION:
                 usb_log_debug("USB_DEVREQ_SET_CONFIGURATION: %u\n",
-                    setup_request->value);
+                    uint16_usb2host(setup_request->value));
                 /* We have only one configuration, it's number is 1 */
                 if (uint16_usb2host(setup_request->value) != 1)

uspace/drv/bus/usb/usbhid/kbd/kbddev.c

@@ -71 +71 @@
 #include "../usbhid.h"
 
+static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
+static ddf_dev_ops_t kbdops = { .default_handler = default_connection_handler };
 /*----------------------------------------------------------------------------*/
 
@@ -187 +189 @@
                         break;
                 }
-                if (kbd_dev->console_sess == NULL) {
-                        kbd_dev->console_sess = sess;
+                if (kbd_dev->client_sess == NULL) {
+                        kbd_dev->client_sess = sess;
                         usb_log_debug("%s: OK\n", __FUNCTION__);
                         async_answer_0(icallid, EOK);
@@ -292 +294 @@
 {
         usb_log_debug2("Sending kbdev event %d/%d to the console\n", type, key);
-        if (kbd_dev->console_sess == NULL) {
+        if (kbd_dev->client_sess == NULL) {
                 usb_log_warning(
                     "Connection to console not ready, key discarded.\n");
@@ -298 +300 @@
         }
 
-        async_exch_t *exch = async_exchange_begin(kbd_dev->console_sess);
+        async_exch_t *exch = async_exchange_begin(kbd_dev->client_sess);
         if (exch != NULL) {
                 async_msg_2(exch, KBDEV_EVENT, type, key);
@@ -499 +501 @@
         /* Store the initialized HID device and HID ops
          * to the DDF function. */
-        fun->ops = &kbd_dev->ops;
+        fun->ops = &kbdops;
         fun->driver_data = kbd_dev;
 
@@ -576 +578 @@
         fibril_mutex_initialize(&kbd_dev->repeat_mtx);
         kbd_dev->initialized = USB_KBD_STATUS_UNINITIALIZED;
-        kbd_dev->ops.default_handler = default_connection_handler;
 
         /* Store link to HID device */
@@ -737 +738 @@
 
         /* Hangup session to the console. */
-        if (kbd_dev->console_sess)
-                async_hangup(kbd_dev->console_sess);
+        if (kbd_dev->client_sess)
+                async_hangup(kbd_dev->client_sess);
 
         //assert(!fibril_mutex_is_locked((*kbd_dev)->repeat_mtx));

uspace/drv/bus/usb/usbhid/kbd/kbddev.h

@@ -82 +82 @@
         unsigned lock_keys;
 
-        /** IPC session to the console device (for sending key events). */
-        async_sess_t *console_sess;
-
-        /** @todo What is this actually? */
-        ddf_dev_ops_t ops;
+        /** IPC session to client (for sending key events). */
+        async_sess_t *client_sess;
 
         /** Information for auto-repeat of keys. */

uspace/drv/bus/usb/usbhid/mouse/mousedev.c

@@ -54 +54 @@
 #define NAME "mouse"
 
-/*----------------------------------------------------------------------------*/
-
+static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
+
+static ddf_dev_ops_t ops = { .default_handler = default_connection_handler };
+
+/*----------------------------------------------------------------------------*/
 const usb_endpoint_description_t usb_hid_mouse_poll_endpoint_description = {
         .transfer_type = USB_TRANSFER_INTERRUPT,
@@ -221 +224 @@
                 assert(index < mouse_dev->buttons_count);
 
-                if (mouse_dev->buttons[index] == 0 && field->value != 0) {
+                if (mouse_dev->buttons[index] != field->value) {
                         async_exch_t *exch =
                             async_exchange_begin(mouse_dev->mouse_sess);
                         if (exch != NULL) {
                                 async_req_2_0(exch, MOUSEEV_BUTTON_EVENT,
-                                    field->usage, 1);
-                                async_exchange_end(exch);
-                                mouse_dev->buttons[index] = field->value;
-                        }
-
-                } else if (mouse_dev->buttons[index] != 0 && field->value == 0) {
-                        async_exch_t *exch =
-                            async_exchange_begin(mouse_dev->mouse_sess);
-                        if (exch != NULL) {
-                                async_req_2_0(exch, MOUSEEV_BUTTON_EVENT,
-                                    field->usage, 0);
+                                    field->usage, (field->value != 0) ? 1 : 0);
                                 async_exchange_end(exch);
                                 mouse_dev->buttons[index] = field->value;
@@ -279 +272 @@
         }
 
-        fun->ops = &mouse->ops;
+        fun->ops = &ops;
         fun->driver_data = mouse;
 
@@ -302 +295 @@
         }
         mouse->mouse_fun = fun;
-
         return EOK;
 }
@@ -379 +371 @@
         }
 
-        // set handler for incoming calls
-        mouse_dev->ops.default_handler = default_connection_handler;
-
         // TODO: how to know if the device supports the request???
         usbhid_req_set_idle(&hid_dev->usb_dev->ctrl_pipe,

uspace/drv/bus/usb/usbhid/mouse/mousedev.h

@@ -46 +46 @@
 /** Container for USB mouse device. */
 typedef struct {
-        /** IPC session to console (consumer). */
+        /** IPC session to consumer. */
         async_sess_t *mouse_sess;
 
@@ -53 +53 @@
         size_t buttons_count;
 
-        ddf_dev_ops_t ops;
         /* DDF mouse function */
         ddf_fun_t *mouse_fun;

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

@@ -353 +353 @@
                 .request = USB_HUB_REQUEST_GET_STATUS,
                 .value = 0,
-                .index = port->port_number,
+                .index = uint16_host2usb(port->port_number),
                 .length = sizeof(usb_port_status_t),
         };

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

@@ -42 +42 @@
  * should not be accessed directly, use supplied getter/setter methods.
  *
- * For more information refer to table 11-15 in
- * "Universal Serial Bus Specification Revision 1.1"
+ * For more information refer to tables 11-15 and 11-16 in
+ * "Universal Serial Bus Specification Revision 1.1" pages 274 and 277
+ * (290 and 293 in pdf)
  *
  */

uspace/drv/infrastructure/rootmac/rootmac.c

@@ -52 +52 @@
 } rootmac_fun_t;
 
-static hw_resource_t pci_conf_regs = {
-        .type = IO_RANGE,
-        .res.io_range = {
-                .address = 0xCF8,
-                .size = 8,
-                .endianness = LITTLE_ENDIAN
+static hw_resource_t pci_conf_regs[] = {
+        {
+                .type = IO_RANGE,
+                .res.io_range = {
+                        .address = 0xfec00000,
+                        .size = 4,
+                        .endianness = LITTLE_ENDIAN
+                }
+        },
+        {
+                .type = IO_RANGE,
+                .res.io_range = {
+                        .address = 0xfee00000,
+                        .size = 4,
+                        .endianness = LITTLE_ENDIAN
+                }
         }
 };
@@ -63 +73 @@
 static rootmac_fun_t pci_data = {
         .hw_resources = {
-                1,
-                &pci_conf_regs
+                2,
+                pci_conf_regs
         }
 };
@@ -128 +138 @@
 {
         /* Register functions */
-        if (!rootmac_add_fun(dev, "pci0", "pangea_pci", &pci_data))
+        if (!rootmac_add_fun(dev, "pci0", "intel_pci", &pci_data))
                 ddf_msg(LVL_ERROR, "Failed to add functions for Mac platform.");
         

uspace/drv/infrastructure/rootpc/rootpc.c

@@ -77 +77 @@
 };
 
-static hw_resource_t pci_conf_regs = {
-        .type = IO_RANGE,
-        .res.io_range = {
-                .address = 0xCF8,
-                .size = 8,
-                .endianness = LITTLE_ENDIAN
+static hw_resource_t pci_conf_regs[] = {
+        {
+                .type = IO_RANGE,
+                .res.io_range = {
+                        .address = 0xCF8,
+                        .size = 4,
+                        .endianness = LITTLE_ENDIAN
+                }
+        },
+        {
+                .type = IO_RANGE,
+                .res.io_range = {
+                        .address = 0xCFC,
+                        .size = 4,
+                        .endianness = LITTLE_ENDIAN
+                }
         }
 };
@@ -88 +98 @@
 static rootpc_fun_t pci_data = {
         .hw_resources = {
-                1,
-                &pci_conf_regs
+                sizeof(pci_conf_regs)/sizeof(pci_conf_regs[0]),
+                pci_conf_regs
         }
 };

uspace/lib/drv/generic/remote_usb.c

@@ -56 +56 @@
 {
         if (!exch)
-                return EINVAL;
+                return EBADMEM;
         sysarg_t addr;
         const int ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
@@ -75 +75 @@
 {
         if (!exch)
-                return EINVAL;
+                return EBADMEM;
         sysarg_t iface_no;
         const int ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
@@ -92 +92 @@
 {
         if (!exch)
-                return EINVAL;
+                return EBADMEM;
         devman_handle_t h;
         const int ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),

uspace/lib/drv/generic/remote_usbhc.c

@@ -165 +165 @@
 {
         if (!exch || !address)
-                return EINVAL;
+                return EBADMEM;
         sysarg_t new_address;
         const int ret = async_req_4_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
@@ -178 +178 @@
 {
         if (!exch)
-                return EINVAL;
+                return EBADMEM;
         return async_req_3_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
             IPC_M_USBHC_BIND_ADDRESS, address, handle);
@@ -187 +187 @@
 {
         if (!exch)
-                return EINVAL;
+                return EBADMEM;
         sysarg_t h;
         const int ret = async_req_2_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
@@ -199 +199 @@
 {
         if (!exch)
-                return EINVAL;
+                return EBADMEM;
         return async_req_2_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
             IPC_M_USBHC_RELEASE_ADDRESS, address);
@@ -209 +209 @@
 {
         if (!exch)
-                return EINVAL;
+                return EBADMEM;
         const usb_target_t target =
             {{ .address = address, .endpoint = endpoint }};
@@ -225 +225 @@
 {
         if (!exch)
-                return EINVAL;
+                return EBADMEM;
         return async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
             IPC_M_USBHC_UNREGISTER_ENDPOINT, address, endpoint, direction);
@@ -234 +234 @@
     size_t *rec_size)
 {
+        if (!exch)
+                return EBADMEM;
+
         if (size == 0 && setup == 0)
                 return EOK;
 
-        if (!exch)
-                return EINVAL;
         const usb_target_t target =
             {{ .address = address, .endpoint = endpoint }};
@@ -288 +289 @@
     usb_endpoint_t endpoint, uint64_t setup, const void *data, size_t size)
 {
+        if (!exch)
+                return EBADMEM;
+
         if (size == 0 && setup == 0)
                 return EOK;
 
-        if (!exch)
-                return EINVAL;
         const usb_target_t target =
             {{ .address = address, .endpoint = endpoint }};

uspace/lib/usbdev/src/pipesinit.c

@@ -154 +154 @@
     usb_endpoint_mapping_t *mapping, size_t mapping_count,
     usb_standard_interface_descriptor_t *interface,
-    usb_standard_endpoint_descriptor_t *endpoint,
+    usb_standard_endpoint_descriptor_t *endpoint_desc,
     usb_device_connection_t *wire)
 {
@@ -163 +163 @@
 
         /* Actual endpoint number is in bits 0..3 */
-        const usb_endpoint_t ep_no = endpoint->endpoint_address & 0x0F;
+        const usb_endpoint_t ep_no = endpoint_desc->endpoint_address & 0x0F;
 
         const usb_endpoint_description_t description = {
                 /* Endpoint direction is set by bit 7 */
-                .direction = (endpoint->endpoint_address & 128)
+                .direction = (endpoint_desc->endpoint_address & 128)
                     ? USB_DIRECTION_IN : USB_DIRECTION_OUT,
                 /* Transfer type is in bits 0..2 and
                  * the enum values corresponds 1:1 */
-                .transfer_type = endpoint->attributes & 3,
+                .transfer_type = endpoint_desc->attributes & 3,
 
                 /* Get interface characteristics. */
@@ -194 +194 @@
 
         int rc = usb_pipe_initialize(&ep_mapping->pipe, wire,
-            ep_no, description.transfer_type, endpoint->max_packet_size,
+            ep_no, description.transfer_type,
+            uint16_usb2host(endpoint_desc->max_packet_size),
             description.direction);
         if (rc != EOK) {
@@ -201 +202 @@
 
         ep_mapping->present = true;
-        ep_mapping->descriptor = endpoint;
+        ep_mapping->descriptor = endpoint_desc;
         ep_mapping->interface = interface;
 

uspace/lib/usbdev/src/request.c

@@ -114 +114 @@
   *     (in native endianness).
   * @param actual_data_size Actual size of transfered data
-  *     (in native endianness).
+  *        (in native endianness).
   * @return Error code.
   * @retval EBADMEM @p pipe is NULL.
@@ -147 +147 @@
                     | (request_type << 5) | recipient,
                 .request = request,
-                .value = value,
-                .index = index,
-                .length = (uint16_t) data_size,
+                .value = uint16_host2usb(value),
+                .index = uint16_host2usb(index),
+                .length = uint16_host2usb(data_size),
         };
 
@@ -375 +375 @@
         usb_standard_device_descriptor_t descriptor_tmp;
         int rc = usb_request_get_descriptor(pipe,
-            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE, 
+            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
             USB_DESCTYPE_DEVICE, 0, 0,
             &descriptor_tmp, sizeof(descriptor_tmp),
@@ -435 +435 @@
         /* Everything is okay, copy the descriptor. */
         memcpy(descriptor, &descriptor_tmp, sizeof(descriptor_tmp));
-
         return EOK;
 }
@@ -495 +494 @@
                 return ENOENT;
         }
-        if (bare_config.total_length < sizeof(bare_config)) {
+
+        const size_t total_length = uint16_usb2host(bare_config.total_length);
+        if (total_length < sizeof(bare_config)) {
                 return ELIMIT;
         }
 
-        void *buffer = malloc(bare_config.total_length);
+        void *buffer = malloc(total_length);
         if (buffer == NULL) {
                 return ENOMEM;
@@ -506 +507 @@
         size_t transferred = 0;
         rc = usb_request_get_full_configuration_descriptor(pipe, index,
-            buffer, bare_config.total_length, &transferred);
+            buffer, total_length, &transferred);
         if (rc != EOK) {
                 free(buffer);
@@ -512 +513 @@
         }
 
-        if (transferred != bare_config.total_length) {
+        if (transferred != total_length) {
                 free(buffer);
                 return ELIMIT;
@@ -522 +523 @@
 
         if (descriptor_size != NULL) {
-                *descriptor_size = bare_config.total_length;
+                *descriptor_size = total_length;
         }
 

uspace/lib/usbhid/src/hidreport.c

@@ -50 +50 @@
 #include <usb/hid/hidreport.h>
 
-static int usb_hid_get_report_descriptor(usb_device_t *dev, 
+static int usb_hid_get_report_descriptor(usb_device_t *dev,
     uint8_t **report_desc, size_t *size)
 {
@@ -69 +69 @@
          * First nested descriptor of the configuration descriptor.
          */
-        const uint8_t *d = 
-            usb_dp_get_nested_descriptor(&parser, &parser_data, 
+        const uint8_t *d =
+            usb_dp_get_nested_descriptor(&parser, &parser_data,
             dev->descriptors.configuration);
         
@@ -78 +78 @@
         int i = 0;
         while (d != NULL && i < dev->interface_no) {
-                d = usb_dp_get_sibling_descriptor(&parser, &parser_data, 
+                d = usb_dp_get_sibling_descriptor(&parser, &parser_data,
                     dev->descriptors.configuration, d);
                 ++i;
@@ -99 +99 @@
          */
         while (d != NULL && *(d + 1) != USB_DESCTYPE_HID) {
-                d = usb_dp_get_sibling_descriptor(&parser, &parser_data, 
+                d = usb_dp_get_sibling_descriptor(&parser, &parser_data,
                     iface_desc, d);
         }
@@ -114 +114 @@
         }
         
-        usb_standard_hid_descriptor_t *hid_desc = 
+        usb_standard_hid_descriptor_t *hid_desc =
             (usb_standard_hid_descriptor_t *)d;
         
-        uint16_t length =  hid_desc->report_desc_info.length;
+        uint16_t length = uint16_usb2host(hid_desc->report_desc_info.length);
         size_t actual_size = 0;