Changeset 5da18c7 in mainline

Timestamp:

2011-05-30T18:41:16Z (13 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

109d55c

Parents:

a2a3763 (diff), 8c74d15 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge development/ changes

Location:

uspace

Files:

• app/mkbd/main.c (modified) (7 diffs)
• doc/main_usb.h (added)
• drv/ehci-hcd/main.c (modified) (1 diff)
• drv/ehci-hcd/pci.c (modified) (7 diffs)
• drv/ehci-hcd/pci.h (modified) (1 diff)
• drv/ohci/root_hub.c (modified) (10 diffs)
• drv/uhci-rhd/port.h (modified) (2 diffs)
• drv/usbhid/usbhid.c (modified) (9 diffs)
• drv/usbhub/main.c (modified) (1 diff)
• drv/usbhub/port_status.h (modified) (20 diffs)
• drv/usbhub/ports.c (modified) (18 diffs)
• drv/usbhub/ports.h (modified) (1 diff)
• drv/usbhub/usbhub.c (modified) (24 diffs)
• drv/usbhub/usbhub.h (modified) (2 diffs)
• drv/usbhub/usbhub_private.h (modified) (6 diffs)
• drv/usbhub/utils.c (modified) (8 diffs)
• lib/usbhid/src/hiddescriptor.c (modified) (5 diffs)
• lib/usbhid/src/hidparser.c (modified) (10 diffs)
• lib/usbhid/src/hidpath.c (modified) (1 diff)
• srv/hid/console/console.c (modified) (2 diffs)

uspace/app/mkbd/main.c

@@ -71 +71 @@
                 usb_hid_free_report(*report);
                 *report = NULL;
-                printf("usb_hid_report_init() failed.\n");
+                //printf("usb_hid_report_init() failed.\n");
                 return rc;
         }
@@ -82 +82 @@
                 usb_hid_free_report(*report);
                 *report = NULL;
-                printf("usbhid_dev_get_report_descriptor_length() failed.\n");
+                //printf("usbhid_dev_get_report_descriptor_length() failed.\n");
                 return rc;
         }
@@ -89 +89 @@
                 usb_hid_free_report(*report);
                 *report = NULL;
-                printf("usbhid_dev_get_report_descriptor_length() returned 0.\n");
+                //printf("usbhid_dev_get_report_descriptor_length() returned 0.\n");
                 return EINVAL;  // TODO: other error code?
         }
@@ -108 +108 @@
                 *report = NULL;
                 free(desc);
-                printf("usbhid_dev_get_report_descriptor() failed.\n");
+                //printf("usbhid_dev_get_report_descriptor() failed.\n");
                 return rc;
         }
@@ -116 +116 @@
                 *report = NULL;
                 free(desc);
-                printf("usbhid_dev_get_report_descriptor() returned wrong size:"
-                    " %zu, expected: %zu.\n", actual_size, report_desc_size);
+//              printf("usbhid_dev_get_report_descriptor() returned wrong size:"
+//                  " %zu, expected: %zu.\n", actual_size, report_desc_size);
                 return EINVAL;  // TODO: other error code?
         }
@@ -128 +128 @@
         if (rc != EOK) {
                 free(desc);
-                printf("usb_hid_parse_report_descriptor() failed.\n");
+//              printf("usb_hid_parse_report_descriptor() failed.\n");
                 return rc;
         }
@@ -213 +213 @@
         
         char *devpath = argv[1];
-        //const char *devpath = "/hw/pci0/00:06.0/ohci-rh/usb00_a2/HID1/hid";
-        
-        int rc;
         
         devman_handle_t dev_handle = 0;
-        rc = devman_device_get_handle(devpath, &dev_handle, 0);
-        if (rc != EOK) {
-                printf("Failed to get handle from devman: %s.\n",
+        
+        int rc = usb_resolve_device_handle(devpath, NULL, NULL, &dev_handle);
+        if (rc != EOK) {
+                printf("Device not found or not of USB kind: %s.\n",
                     str_error(rc));
                 return rc;

uspace/drv/ehci-hcd/main.c

@@ -75 +75 @@
 }
 
-        uintptr_t mem_reg_base = 0;
-        size_t mem_reg_size = 0;
+        uintptr_t reg_base = 0;
+        size_t reg_size = 0;
         int irq = 0;
 
-        int ret =
-            pci_get_my_registers(device, &mem_reg_base, &mem_reg_size, &irq);
+        int ret = pci_get_my_registers(device, &reg_base, &reg_size, &irq);
         CHECK_RET_RETURN(ret,
             "Failed to get memory addresses for %" PRIun ": %s.\n",
             device->handle, str_error(ret));
         usb_log_info("Memory mapped regs at 0x%" PRIxn " (size %zu), IRQ %d.\n",
-            mem_reg_base, mem_reg_size, irq);
+            reg_base, reg_size, irq);
 
-        ret = pci_disable_legacy(device);
+        ret = pci_disable_legacy(device, reg_base, reg_size, irq);
         CHECK_RET_RETURN(ret,
             "Failed(%d) disable legacy USB: %s.\n", ret, str_error(ret));

uspace/drv/ehci-hcd/pci.c

@@ -55 +55 @@
 #define CMD_OFFSET 0x0
 #define STS_OFFSET 0x4
+#define INT_OFFSET 0x8
 #define CFG_OFFSET 0x40
 
 #define USBCMD_RUN 1
+#define USBSTS_HALTED (1 << 12)
 
 #define USBLEGSUP_OFFSET 0
@@ -64 +66 @@
 #define USBLEGCTLSTS_OFFSET 4
 
-#define DEFAULT_WAIT 10000
+#define DEFAULT_WAIT 1000
 #define WAIT_STEP 10
+
+#define PCI_READ(size) \
+do { \
+        const int parent_phone = \
+            devman_parent_device_connect(dev->handle, IPC_FLAG_BLOCKING);\
+        if (parent_phone < 0) {\
+                return parent_phone; \
+        } \
+        sysarg_t add = (sysarg_t)address; \
+        sysarg_t val; \
+        const int ret = \
+            async_req_2_1(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE), \
+                IPC_M_CONFIG_SPACE_READ_##size, add, &val); \
+        assert(value); \
+        *value = val; \
+        async_hangup(parent_phone); \
+        return ret; \
+} while(0)
+
+static int pci_read32(const ddf_dev_t *dev, int address, uint32_t *value)
+{
+        PCI_READ(32);
+}
+static int pci_read16(const ddf_dev_t *dev, int address, uint16_t *value)
+{
+        PCI_READ(16);
+}
+static int pci_read8(const ddf_dev_t *dev, int address, uint8_t *value)
+{
+        PCI_READ(8);
+}
+#define PCI_WRITE(size) \
+do { \
+        const int parent_phone = \
+            devman_parent_device_connect(dev->handle, IPC_FLAG_BLOCKING);\
+        if (parent_phone < 0) {\
+                return parent_phone; \
+        } \
+        sysarg_t add = (sysarg_t)address; \
+        sysarg_t val = value; \
+        const int ret = \
+            async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE), \
+                IPC_M_CONFIG_SPACE_WRITE_##size, add, val); \
+        async_hangup(parent_phone); \
+        return ret; \
+} while(0)
+
+static int pci_write32(const ddf_dev_t *dev, int address, uint32_t value)
+{
+        PCI_WRITE(32);
+}
+static int pci_write16(const ddf_dev_t *dev, int address, uint16_t value)
+{
+        PCI_WRITE(16);
+}
+static int pci_write8(const ddf_dev_t *dev, int address, uint8_t value)
+{
+        PCI_WRITE(8);
+}
 
 /** Get address of registers and IRQ for given device.
@@ -75 +136 @@
  * @return Error code.
  */
-int pci_get_my_registers(ddf_dev_t *dev,
+int pci_get_my_registers(const ddf_dev_t *dev,
     uintptr_t *mem_reg_address, size_t *mem_reg_size, int *irq_no)
 {
         assert(dev != NULL);
 
-        int parent_phone = devman_parent_device_connect(dev->handle,
-            IPC_FLAG_BLOCKING);
+        const int parent_phone =
+            devman_parent_device_connect(dev->handle, IPC_FLAG_BLOCKING);
         if (parent_phone < 0) {
                 return parent_phone;
@@ -145 +206 @@
  * @return Error code.
  */
-int pci_enable_interrupts(ddf_dev_t *device)
-{
-        int parent_phone =
+int pci_enable_interrupts(const ddf_dev_t *device)
+{
+        const int parent_phone =
             devman_parent_device_connect(device->handle, IPC_FLAG_BLOCKING);
         if (parent_phone < 0) {
                 return parent_phone;
         }
-        bool enabled = hw_res_enable_interrupt(parent_phone);
+        const bool enabled = hw_res_enable_interrupt(parent_phone);
         async_hangup(parent_phone);
         return enabled ? EOK : EIO;
@@ -162 +223 @@
  * @return Error code.
  */
-int pci_disable_legacy(ddf_dev_t *device)
+int pci_disable_legacy(
+    const ddf_dev_t *device, uintptr_t reg_base, size_t reg_size, int irq)
 {
         assert(device);
-        int parent_phone = devman_parent_device_connect(device->handle,
-                IPC_FLAG_BLOCKING);
-        if (parent_phone < 0) {
-                return parent_phone;
-        }
-
-#define CHECK_RET_HANGUP_RETURN(ret, message...) \
+        (void) pci_read16;
+        (void) pci_read8;
+        (void) pci_write16;
+
+#define CHECK_RET_RETURN(ret, message...) \
         if (ret != EOK) { \
                 usb_log_error(message); \
-                async_hangup(parent_phone); \
                 return ret; \
         } else (void)0
 
-
-        /* read register space BASE BAR */
-        sysarg_t address = 0x10;
-        sysarg_t value;
-
-        int ret = async_req_2_1(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
-            IPC_M_CONFIG_SPACE_READ_32, address, &value);
-        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to read PCI config space.\n",
-            ret);
-        usb_log_info("Register space BAR at %p:%" PRIxn ".\n",
-            (void *) address, value);
-
-        /* clear lower byte, it's not part of the BASE address */
-        uintptr_t registers = (value & 0xffffff00);
-        usb_log_info("Memory registers BASE address:%p.\n", (void *) registers);
-
-        /* if nothing setup the hc, we don't need to turn it off */
-        if (registers == 0)
-                return ENOTSUP;
-
-        /* map EHCI registers */
-        void *regs = as_get_mappable_page(4096);
-        ret = physmem_map((void*)(registers & PAGE_SIZE_MASK), regs, 1,
-            AS_AREA_READ | AS_AREA_WRITE);
-        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to map registers %p:%p.\n",
-            ret, regs, (void *) registers);
-
-        /* calculate value of BASE */
-        registers = (registers & 0xf00) | (uintptr_t)regs;
+        /* Map EHCI registers */
+        void *regs = NULL;
+        int ret = pio_enable((void*)reg_base, reg_size, &regs);
+        CHECK_RET_RETURN(ret, "Failed(%d) to map registers %p.\n",
+            ret, (void *) reg_base);
 
         const uint32_t hcc_params =
-            *(uint32_t*)(registers + HCC_PARAMS_OFFSET);
+            *(uint32_t*)(regs + HCC_PARAMS_OFFSET);
         usb_log_debug("Value of hcc params register: %x.\n", hcc_params);
 
         /* Read value of EHCI Extended Capabilities Pointer
-         * (points to PCI config space) */
-        uint32_t eecp =
+         * position of EEC registers (points to PCI config space) */
+        const uint32_t eecp =
             (hcc_params >> HCC_PARAMS_EECP_OFFSET) & HCC_PARAMS_EECP_MASK;
         usb_log_debug("Value of EECP: %x.\n", eecp);
 
-        /* Read the second EEC. i.e. Legacy Support and Control register */
-        /* TODO: Check capability type here */
-        ret = async_req_2_1(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
-            IPC_M_CONFIG_SPACE_READ_32, eecp + USBLEGCTLSTS_OFFSET, &value);
-        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to read USBLEGCTLSTS.\n", ret);
-        usb_log_debug("USBLEGCTLSTS: %" PRIxn ".\n", value);
-
         /* Read the first EEC. i.e. Legacy Support register */
-        /* TODO: Check capability type here */
-        ret = async_req_2_1(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
-            IPC_M_CONFIG_SPACE_READ_32, eecp + USBLEGSUP_OFFSET, &value);
-        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to read USBLEGSUP.\n", ret);
-        usb_log_debug2("USBLEGSUP: %" PRIxn ".\n", value);
+        uint32_t usblegsup;
+        ret = pci_read32(device, eecp + USBLEGSUP_OFFSET, &usblegsup);
+        CHECK_RET_RETURN(ret, "Failed(%d) to read USBLEGSUP.\n", ret);
+        usb_log_debug("USBLEGSUP: %" PRIxn ".\n", usblegsup);
 
         /* Request control from firmware/BIOS, by writing 1 to highest byte.
          * (OS Control semaphore)*/
-        ret = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
-           IPC_M_CONFIG_SPACE_WRITE_8, eecp + USBLEGSUP_OFFSET + 3, 1);
-        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to request OS EHCI control.\n",
-            ret);
+        usb_log_debug("Requesting OS control.\n");
+        ret = pci_write8(device, eecp + USBLEGSUP_OFFSET + 3, 1);
+        CHECK_RET_RETURN(ret, "Failed(%d) to request OS EHCI control.\n", ret);
 
         size_t wait = 0;
         /* Wait for BIOS to release control. */
-        while ((wait < DEFAULT_WAIT) && (value & USBLEGSUP_BIOS_CONTROL)) {
+        ret = pci_read32(device, eecp + USBLEGSUP_OFFSET, &usblegsup);
+        while ((wait < DEFAULT_WAIT) && (usblegsup & USBLEGSUP_BIOS_CONTROL)) {
                 async_usleep(WAIT_STEP);
-                ret = async_req_2_1(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
-                    IPC_M_CONFIG_SPACE_READ_32, eecp + USBLEGSUP_OFFSET, &value);
+                ret = pci_read32(device, eecp + USBLEGSUP_OFFSET, &usblegsup);
                 wait += WAIT_STEP;
         }
 
 
-        if ((value & USBLEGSUP_BIOS_CONTROL) == 0) {
+        if ((usblegsup & USBLEGSUP_BIOS_CONTROL) == 0) {
                 usb_log_info("BIOS released control after %zu usec.\n", wait);
         } else {
@@ -255 +281 @@
                 usb_log_warning( "BIOS failed to release control after "
                     "%zu usecs, force it.\n", wait);
-                ret = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
-                    IPC_M_CONFIG_SPACE_WRITE_32, eecp + USBLEGSUP_OFFSET,
+                ret = pci_write32(device, eecp + USBLEGSUP_OFFSET,
                     USBLEGSUP_OS_CONTROL);
-                CHECK_RET_HANGUP_RETURN(ret,
-                    "Failed(%d) to force OS EHCI control.\n", ret);
-        }
-
-        /* Zero SMI enables in legacy control register.
-         * It would prevent pre-OS code from interfering. */
-        ret = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
-           IPC_M_CONFIG_SPACE_WRITE_32, eecp + USBLEGCTLSTS_OFFSET,
-           0xe0000000);
-        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) zero USBLEGCTLSTS.\n", ret);
-
-        /* Read again Legacy Support and Control register */
-        ret = async_req_2_1(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
-            IPC_M_CONFIG_SPACE_READ_32, eecp + USBLEGCTLSTS_OFFSET, &value);
-        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to read USBLEGCTLSTS.\n", ret);
-        usb_log_debug2("USBLEGCTLSTS: %" PRIxn ".\n", value);
+                CHECK_RET_RETURN(ret, "Failed(%d) to force OS control.\n", ret);
+                /* Check capability type here, A value of 01h
+                 * identifies the capability as Legacy Support.
+                 * This extended capability requires one
+                 * additional 32-bit register for control/status information,
+                 * and this register is located at offset EECP+04h
+                 * */
+                if ((usblegsup & 0xff) == 1) {
+                        /* Read the second EEC
+                         * Legacy Support and Control register */
+                        uint32_t usblegctlsts;
+                        ret = pci_read32(
+                            device, eecp + USBLEGCTLSTS_OFFSET, &usblegctlsts);
+                        CHECK_RET_RETURN(ret,
+                            "Failed(%d) to get USBLEGCTLSTS.\n", ret);
+                        usb_log_debug("USBLEGCTLSTS: %" PRIxn ".\n",
+                            usblegctlsts);
+                        /* Zero SMI enables in legacy control register.
+                         * It should prevent pre-OS code from interfering. */
+                        ret = pci_write32(device, eecp + USBLEGCTLSTS_OFFSET,
+                            0xe0000000); /* three upper bits are WC */
+                        CHECK_RET_RETURN(ret,
+                            "Failed(%d) zero USBLEGCTLSTS.\n", ret);
+                        udelay(10);
+                        ret = pci_read32(
+                            device, eecp + USBLEGCTLSTS_OFFSET, &usblegctlsts);
+                        CHECK_RET_RETURN(ret,
+                            "Failed(%d) to get USBLEGCTLSTS 2.\n", ret);
+                        usb_log_debug("Zeroed USBLEGCTLSTS: %" PRIxn ".\n",
+                            usblegctlsts);
+                }
+        }
+
 
         /* Read again Legacy Support register */
-        ret = async_req_2_1(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
-            IPC_M_CONFIG_SPACE_READ_32, eecp + USBLEGSUP_OFFSET, &value);
-        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to read USBLEGSUP.\n", ret);
-        usb_log_debug2("USBLEGSUP: %" PRIxn ".\n", value);
+        ret = pci_read32(device, eecp + USBLEGSUP_OFFSET, &usblegsup);
+        CHECK_RET_RETURN(ret, "Failed(%d) to read USBLEGSUP.\n", ret);
+        usb_log_debug("USBLEGSUP: %" PRIxn ".\n", usblegsup);
 
         /*
@@ -286 +327 @@
 
         /* Get size of capability registers in memory space. */
-        uint8_t operation_offset = *(uint8_t*)registers;
+        const unsigned operation_offset = *(uint8_t*)regs;
         usb_log_debug("USBCMD offset: %d.\n", operation_offset);
 
         /* Zero USBCMD register. */
         volatile uint32_t *usbcmd =
-            (uint32_t*)((uint8_t*)registers + operation_offset + CMD_OFFSET);
+            (uint32_t*)((uint8_t*)regs + operation_offset + CMD_OFFSET);
         volatile uint32_t *usbsts =
-            (uint32_t*)((uint8_t*)registers + operation_offset + STS_OFFSET);
-        volatile uint32_t *usbconfigured =
-            (uint32_t*)((uint8_t*)registers + operation_offset + CFG_OFFSET);
+            (uint32_t*)((uint8_t*)regs + operation_offset + STS_OFFSET);
+        volatile uint32_t *usbconf =
+            (uint32_t*)((uint8_t*)regs + operation_offset + CFG_OFFSET);
+        volatile uint32_t *usbint =
+            (uint32_t*)((uint8_t*)regs + operation_offset + INT_OFFSET);
         usb_log_debug("USBCMD value: %x.\n", *usbcmd);
         if (*usbcmd & USBCMD_RUN) {
+                *usbsts = 0x3f; /* ack all interrupts */
+                *usbint = 0; /* disable all interrutps */
+                *usbconf = 0; /* relase control of RH ports */
+
                 *usbcmd = 0;
-                while (!(*usbsts & (1 << 12))); /*wait until hc is halted */
-                *usbconfigured = 0;
+                /* Wait until hc is halted */
+                while ((*usbsts & USBSTS_HALTED) == 0);
                 usb_log_info("EHCI turned off.\n");
         } else {
                 usb_log_info("EHCI was not running.\n");
         }
-        usb_log_debug("Registers: %x(0x00080000):%x(0x00001000):%x(0x0).\n",
-            *usbcmd, *usbsts, *usbconfigured);
-
-        async_hangup(parent_phone);
+        usb_log_debug("Registers: \n"
+            "\t USBCMD: %x(0x00080000 = at least 1ms between interrupts)\n"
+            "\t USBSTS: %x(0x00001000 = HC halted)\n"
+            "\t USBINT: %x(0x0 = no interrupts).\n"
+            "\t CONFIG: %x(0x0 = ports controlled by companion hc).\n",
+            *usbcmd, *usbsts, *usbint, *usbconf);
+
         return ret;
-#undef CHECK_RET_HANGUP_RETURN
+#undef CHECK_RET_RETURN
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/ehci-hcd/pci.h

@@ -38 +38 @@
 #include <ddf/driver.h>
 
-int pci_get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
-int pci_enable_interrupts(ddf_dev_t *);
-int pci_disable_legacy(ddf_dev_t *);
+int pci_get_my_registers(const ddf_dev_t *, uintptr_t *, size_t *, int *);
+int pci_enable_interrupts(const ddf_dev_t *);
+int pci_disable_legacy(const ddf_dev_t *, uintptr_t, size_t, int);
 
 #endif

uspace/drv/ohci/root_hub.c

@@ -57 +57 @@
         .device_version = 0,
         .length = sizeof (usb_standard_device_descriptor_t),
-        /// \TODO this value is guessed
         .max_packet_size = 8,
         .vendor_id = 0x16db,
@@ -117 +116 @@
  */
 static const uint32_t hub_clear_feature_by_writing_one_mask =
-   RHS_CLEAR_PORT_POWER;
+    RHS_CLEAR_PORT_POWER;
 
 /**
@@ -412 +411 @@
         request->transfered_size = 4;
         uint32_t data = instance->registers->rh_port_status[port - 1];
-        memcpy(request->data_buffer,&data,4);
+        memcpy(request->data_buffer, &data, 4);
 #if 0
         int i;
@@ -445 +444 @@
         uint32_t data = mask & instance->registers->rh_status;
         //uint32_buffer[0] = mask & instance->registers->rh_status;
-        memcpy(request->data_buffer,&data,4);
+        memcpy(request->data_buffer, &data, 4);
 
         return EOK;
@@ -468 +467 @@
 
         usb_hub_bm_request_type_t request_type = request_packet->request_type;
-        if (buffer_size < 4/*request_packet->length*/) {///\TODO
+        if (buffer_size < 4) {
                 usb_log_warning("requested more data than buffer size\n");
                 return EINVAL;
@@ -499 +498 @@
             | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
         bzero(bitmap, instance->interrupt_mask_size);
-        if ((instance->registers->rh_status & mask) !=0 ) {
+        if ((instance->registers->rh_status & mask) != 0) {
                 bitmap[0] = 1;
         }
@@ -678 +677 @@
             (instance->registers->rh_port_status[port - 1] | (1 << feature))
             & (~port_clear_feature_valid_mask);
-        /// \TODO any error?
-
         return EOK;
 }
@@ -707 +704 @@
             & (~port_clear_feature_valid_mask))
             | (1 << feature);
-        /// \TODO any error?
 
         return EOK;
@@ -925 +921 @@
  * @return
  */
-static int process_interrupt_mask_in_instance(rh_t *instance, usb_transfer_batch_t * request) {
+static int process_interrupt_mask_in_instance(rh_t *instance,
+    usb_transfer_batch_t * request) {
         memcpy(request->data_buffer, instance->interrupt_buffer,
             instance->interrupt_mask_size);
@@ -945 +942 @@
  * @return
  */
-static bool is_zeros(void * buffer, size_t size) {
+static bool is_zeros(void *buffer, size_t size) {
         if (!buffer) return true;
         if (!size) return true;

uspace/drv/uhci-rhd/port.h

@@ -55 +55 @@
 
 /** UHCI port structure */
-typedef struct uhci_port
-{
+typedef struct uhci_port {
         const char *id_string;
         port_status_t *address;
@@ -68 +67 @@
 
 int uhci_port_init(
-  uhci_port_t *port, port_status_t *address, unsigned number,
-  unsigned usec, ddf_dev_t *rh);
+    uhci_port_t *port, port_status_t *address, unsigned number,
+    unsigned usec, ddf_dev_t *rh);
 
 void uhci_port_fini(uhci_port_t *port);

uspace/drv/usbhid/usbhid.c

@@ -78 +78 @@
         }
         
+        assert(hid_dev->subdriver_count >= 0);
+        
         // set the init callback
-        hid_dev->subdrivers[0].init = usb_kbd_init;
+        hid_dev->subdrivers[hid_dev->subdriver_count].init = usb_kbd_init;
         
         // set the polling callback
-        hid_dev->subdrivers[0].poll = usb_kbd_polling_callback;
+        hid_dev->subdrivers[hid_dev->subdriver_count].poll = 
+            usb_kbd_polling_callback;
         
         // set the polling ended callback
-        hid_dev->subdrivers[0].poll_end = NULL;
+        hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
         
         // set the deinit callback
-        hid_dev->subdrivers[0].deinit = usb_kbd_deinit;
+        hid_dev->subdrivers[hid_dev->subdriver_count].deinit = usb_kbd_deinit;
         
         // set subdriver count
-        hid_dev->subdriver_count = 1;
+        ++hid_dev->subdriver_count;
         
         return EOK;
@@ -108 +111 @@
         }
         
+        assert(hid_dev->subdriver_count >= 0);
+        
         // set the init callback
-        hid_dev->subdrivers[0].init = usb_mouse_init;
+        hid_dev->subdrivers[hid_dev->subdriver_count].init = usb_mouse_init;
         
         // set the polling callback
-        hid_dev->subdrivers[0].poll = usb_mouse_polling_callback;
+        hid_dev->subdrivers[hid_dev->subdriver_count].poll = 
+            usb_mouse_polling_callback;
         
         // set the polling ended callback
-        hid_dev->subdrivers[0].poll_end = NULL;
+        hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
         
         // set the deinit callback
-        hid_dev->subdrivers[0].deinit = usb_mouse_deinit;
+        hid_dev->subdrivers[hid_dev->subdriver_count].deinit = usb_mouse_deinit;
         
         // set subdriver count
-        hid_dev->subdriver_count = 1;
+        ++hid_dev->subdriver_count;
         
         return EOK;
@@ -138 +144 @@
         }
         
+        assert(hid_dev->subdriver_count >= 0);
+        
         // set the init callback
-        hid_dev->subdrivers[0].init = usb_generic_hid_init;
+        hid_dev->subdrivers[hid_dev->subdriver_count].init =
+            usb_generic_hid_init;
         
         // set the polling callback
-        hid_dev->subdrivers[0].poll = usb_generic_hid_polling_callback;
+        hid_dev->subdrivers[hid_dev->subdriver_count].poll = 
+            usb_generic_hid_polling_callback;
         
         // set the polling ended callback
-        hid_dev->subdrivers[0].poll_end = NULL;
+        hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
         
         // set the deinit callback
-        hid_dev->subdrivers[0].deinit = NULL;
+        hid_dev->subdrivers[hid_dev->subdriver_count].deinit = NULL;
         
         // set subdriver count
-        hid_dev->subdriver_count = 1;
+        ++hid_dev->subdriver_count;
         
         return EOK;
@@ -196 +206 @@
         }
         
-        if (mapping->report_id >= 0) {
-                usb_hid_report_path_set_report_id(usage_path, 
-                    mapping->report_id);
-        }
+//      if (mapping->report_id >= 0) {
+//              usb_hid_report_path_set_report_id(usage_path, 
+//                  mapping->report_id);
+//      }
         
         assert(hid_dev->report != NULL);
@@ -206 +216 @@
 //      size_t size = usb_hid_report_size(hid_dev->report, 0, 
 //          USB_HID_REPORT_TYPE_INPUT);
-        size_t size = 0;
-        usb_hid_report_field_t *field = usb_hid_report_get_sibling (hid_dev->report,
-                NULL, usage_path, mapping->compare, USB_HID_REPORT_TYPE_INPUT);
-        while(field != NULL) {
-                size++;
-                field = usb_hid_report_get_sibling (hid_dev->report,
-                                        field, usage_path, mapping->compare, 
-                            USB_HID_REPORT_TYPE_INPUT);
-        }
-        
-        usb_log_debug("Size of the input report: %zuB\n", size);
+//      size_t size = 0;
+        
+        bool matches = false;
+
+//      usb_hid_report_description_t *report_des = 
+//              usb_hid_report_find_description(hid_dev->report,
+//              mapping->report_id, USB_HID_REPORT_TYPE_INPUT);
+        uint8_t report_id = mapping->report_id;
+
+        /*while(report_des != NULL)*/do {
+
+//              if((mapping->report_id) == 0 && (report_des->report_id != 0)) {
+//                      usb_hid_report_path_set_report_id(usage_path,
+//                              report_des->report_id);
+//              }
+                                             
+                usb_log_debug("Trying report id %u\n", report_id);
+                
+                if (report_id != 0) {
+                        usb_hid_report_path_set_report_id(usage_path,
+                                report_id);
+                }
+
+                usb_hid_report_field_t *field = usb_hid_report_get_sibling(
+                    hid_dev->report,
+                    NULL, usage_path, mapping->compare, 
+                    USB_HID_REPORT_TYPE_INPUT);
+                
+                usb_log_debug("Field: %p\n", field);
+
+                if (field != NULL) {
+//                      size++;
+//                      field = usb_hid_report_get_sibling(hid_dev->report,
+//                          field, usage_path, mapping->compare, 
+//                          USB_HID_REPORT_TYPE_INPUT);
+                        matches = true;
+                        break;
+                }
+                
+                report_id = usb_hid_get_next_report_id(
+                    hid_dev->report, report_id,
+                    USB_HID_REPORT_TYPE_INPUT);
+
+//              if((mapping->report_id == 0) && (report_des->report_id != 0)) {
+//                      uint8_t report_id = usb_hid_get_next_report_id(
+//                              hid_dev->report, report_des->report_id,
+//                              USB_HID_REPORT_TYPE_INPUT);
+
+//                      if(report_id == 0) {
+//                              break;
+//                      }
+
+//                      report_des = usb_hid_report_find_description(
+//                              hid_dev->report, report_id, 
+//                              USB_HID_REPORT_TYPE_INPUT);
+//              }
+//              else {
+//                      break;
+//              }
+        } while (!matches && report_id != 0);
+        
+//      usb_log_debug("Size of the input report: %zu\n", size);
         usb_hid_report_path_free(usage_path);
         
-        return (size > 0);
+        return matches;
 }
 
@@ -368 +429 @@
         
         do {
+                usb_log_debug("Getting size of the report.\n");
                 size = usb_hid_report_byte_size(hid_dev->report, report_id, 
                     USB_HID_REPORT_TYPE_INPUT);
                 usb_log_debug("Report ID: %u, size: %zu\n", report_id, size);
                 max_size = (size > max_size) ? size : max_size;
+                usb_log_debug("Getting next report ID\n");
                 report_id = usb_hid_get_next_report_id(hid_dev->report, 
                     report_id, USB_HID_REPORT_TYPE_INPUT);
@@ -501 +564 @@
                     hid_dev->subdriver_count);
                 //usb_hid_free(&hid_dev);
+                
         } else {
                 bool ok = false;
@@ -527 +591 @@
         }
         
-        // save max input report size and allocate space for the report
-        rc = usb_hid_init_report(hid_dev);
-        if (rc != EOK) {
-                usb_log_error("Failed to initialize input report buffer.\n");
-        }
+        
+        if (rc == EOK) {
+                // save max input report size and allocate space for the report
+                rc = usb_hid_init_report(hid_dev);
+                if (rc != EOK) {
+                        usb_log_error("Failed to initialize input report buffer"
+                            ".\n");
+                }
+        }
+        
         
         return rc;
@@ -554 +623 @@
         usb_log_debug("Max input report size: %zu, buffer size: %zu\n",
             hid_dev->max_input_report_size, buffer_size);
-        assert(hid_dev->max_input_report_size >= buffer_size);
-        
-//      if (/*!allocated*/
-//          /*|| *//*hid_dev->input_report_size < buffer_size*/) {
-//              uint8_t *input_old = hid_dev->input_report;
-//              uint8_t *input_new = (uint8_t *)malloc(buffer_size);
-                
-//              if (input_new == NULL) {
-//                      usb_log_error("Failed to allocate space for input "
-//                          "buffer. This event may not be reported\n");
-//                      memset(hid_dev->input_report, 0, 
-//                          hid_dev->input_report_size);
-//              } else {
-//                      memcpy(input_new, input_old, 
-//                          hid_dev->input_report_size);
-//                      hid_dev->input_report = input_new;
-//                      if (allocated) {
-//                              free(input_old);
-//                      }
-//                      usb_hid_new_report();
-//              }
-//      }
-        
-        /*! @todo This should probably be atomic. */
-        memcpy(hid_dev->input_report, buffer, buffer_size);
-        hid_dev->input_report_size = buffer_size;
-        usb_hid_new_report(hid_dev);
+        //assert(hid_dev->max_input_report_size >= buffer_size);
+        if (hid_dev->max_input_report_size >= buffer_size) {
+                /*! @todo This should probably be atomic. */
+                memcpy(hid_dev->input_report, buffer, buffer_size);
+                hid_dev->input_report_size = buffer_size;
+                usb_hid_new_report(hid_dev);
+        }
         
         bool cont = false;

uspace/drv/usbhub/main.c

@@ -87 +87 @@
 
         usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME);
-        
+
         return usb_driver_main(&usb_hub_driver);
 }

uspace/drv/usbhub/port_status.h

@@ -64 +64 @@
  */
 static inline void usb_hub_set_port_status_request(
-        usb_device_request_setup_packet_t * request, uint16_t port
-        ) {
+    usb_device_request_setup_packet_t *request, uint16_t port) {
         request->index = port;
         request->request_type = USB_HUB_REQ_TYPE_GET_PORT_STATUS;
@@ -79 +78 @@
  */
 static inline void usb_hub_set_hub_status_request(
-        usb_device_request_setup_packet_t * request
-        ) {
+    usb_device_request_setup_packet_t *request) {
         request->index = 0;
         request->request_type = USB_HUB_REQ_TYPE_GET_HUB_STATUS;
@@ -95 +93 @@
 static inline usb_device_request_setup_packet_t *
 usb_hub_create_port_status_request(uint16_t port) {
-        usb_device_request_setup_packet_t * result =
-                malloc(sizeof(usb_device_request_setup_packet_t));
+        usb_device_request_setup_packet_t *result =
+            malloc(sizeof (usb_device_request_setup_packet_t));
         usb_hub_set_port_status_request(result, port);
         return result;
@@ -108 +106 @@
  */
 static inline void usb_hub_set_enable_port_feature_request(
-        usb_device_request_setup_packet_t * request, uint16_t port,
-        uint16_t feature_selector
-        ) {
+    usb_device_request_setup_packet_t *request, uint16_t port,
+    uint16_t feature_selector) {
         request->index = port;
         request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
@@ -125 +122 @@
  */
 static inline void usb_hub_set_disable_port_feature_request(
-        usb_device_request_setup_packet_t * request, uint16_t port,
-        uint16_t feature_selector
-        ) {
+    usb_device_request_setup_packet_t *request, uint16_t port,
+    uint16_t feature_selector
+    ) {
         request->index = port;
         request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
@@ -141 +138 @@
  */
 static inline void usb_hub_set_enable_port_request(
-        usb_device_request_setup_packet_t * request, uint16_t port
-        ) {
+    usb_device_request_setup_packet_t *request, uint16_t port
+    ) {
         request->index = port;
         request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
@@ -157 +154 @@
 static inline usb_device_request_setup_packet_t *
 usb_hub_create_enable_port_request(uint16_t port) {
-        usb_device_request_setup_packet_t * result =
-                malloc(sizeof(usb_device_request_setup_packet_t));
+        usb_device_request_setup_packet_t *result =
+            malloc(sizeof (usb_device_request_setup_packet_t));
         usb_hub_set_enable_port_request(result, port);
         return result;
@@ -169 +166 @@
  */
 static inline void usb_hub_set_disable_port_request(
-        usb_device_request_setup_packet_t * request, uint16_t port
-        ) {
+    usb_device_request_setup_packet_t *request, uint16_t port
+    ) {
         request->index = port;
         request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
@@ -185 +182 @@
 static inline usb_device_request_setup_packet_t *
 usb_hub_create_disable_port_request(uint16_t port) {
-        usb_device_request_setup_packet_t * result =
-                malloc(sizeof(usb_device_request_setup_packet_t));
+        usb_device_request_setup_packet_t *result =
+            malloc(sizeof (usb_device_request_setup_packet_t));
         usb_hub_set_disable_port_request(result, port);
         return result;
@@ -197 +194 @@
  */
 static inline void usb_hub_set_reset_port_request(
-        usb_device_request_setup_packet_t * request, uint16_t port
-        ) {
+    usb_device_request_setup_packet_t *request, uint16_t port
+    ) {
         request->index = port;
         request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
@@ -213 +210 @@
 static inline usb_device_request_setup_packet_t *
 usb_hub_create_reset_port_request(uint16_t port) {
-        usb_device_request_setup_packet_t * result =
-                malloc(sizeof(usb_device_request_setup_packet_t));
+        usb_device_request_setup_packet_t *result =
+            malloc(sizeof (usb_device_request_setup_packet_t));
         usb_hub_set_reset_port_request(result, port);
         return result;
@@ -225 +222 @@
  */
 static inline void usb_hub_set_power_port_request(
-        usb_device_request_setup_packet_t * request, uint16_t port
-        ) {
+    usb_device_request_setup_packet_t *request, uint16_t port
+    ) {
         request->index = port;
         request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
@@ -240 +237 @@
  */
 static inline void usb_hub_unset_power_port_request(
-        usb_device_request_setup_packet_t * request, uint16_t port
-        ) {
+    usb_device_request_setup_packet_t *request, uint16_t port
+    ) {
         request->index = port;
         request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
@@ -257 +254 @@
  */
 static inline bool usb_port_is_status(usb_port_status_t status, int idx) {
-        return (status&(1 << idx))!=0;
+        return (status & (1 << idx)) != 0;
 }
 
@@ -268 +265 @@
  */
 static inline void usb_port_status_set_bit(
-        usb_port_status_t * status, int idx, bool value) {
+    usb_port_status_t * status, int idx, bool value) {
         (*status) = value ?
-                ((*status) | (1 << (idx))) :
-                ((*status)&(~(1 << (idx))));
+            ((*status) | (1 << (idx))) :
+            ((*status)&(~(1 << (idx))));
 }
 
@@ -282 +279 @@
  */
 static inline bool usb_hub_is_status(usb_hub_status_t status, int idx) {
-        return (status&(1 << idx))!=0;
+        return (status & (1 << idx)) != 0;
 }
 
@@ -293 +290 @@
  */
 static inline void usb_hub_status_set_bit(
-        usb_hub_status_t * status, int idx, bool value) {
+    usb_hub_status_t *status, int idx, bool value) {
         (*status) = value ?
-                ((*status) | (1 << (idx))) :
-                ((*status)&(~(1 << (idx))));
-}
-
-
-#if 0
-/**
- * connection status geter for port status
- * 
- * @param status
- * @return true if there is something connected
- */
-static inline bool usb_port_dev_connected(usb_port_status_t * status) {
-        return usb_port_get_bit(status, 0);
-}
-
-/**
- * set device connected bit in port status
- *
- * @param status
- * @param connected value of the bit
- */
-static inline void usb_port_set_dev_connected(usb_port_status_t * status, bool connected) {
-        usb_port_set_bit(status, 0, connected);
-}
-
-//port enabled
-
-/**
- * port enabled getter for port status
- * 
- * @param status
- * @return true if the port is enabled
- */
-static inline bool usb_port_enabled(usb_port_status_t * status) {
-        return usb_port_get_bit(status, 1);
-}
-
-/**
- * set port enabled bit in port status
- *
- * @param status
- * @param enabled value of the bit
- */
-static inline void usb_port_set_enabled(usb_port_status_t * status, bool enabled) {
-        usb_port_set_bit(status, 1, enabled);
-}
-
-//port suspended
-/**
- * port suspended getter for port status
- *
- * @param status
- * @return true if port is suspended
- */
-static inline bool usb_port_suspended(usb_port_status_t * status) {
-        return usb_port_get_bit(status, 2);
-}
-
-/**
- * set port suspended bit in port status
- *
- * @param status
- * @param suspended value of the bit
- */
-static inline void usb_port_set_suspended(usb_port_status_t * status, bool suspended) {
-        usb_port_set_bit(status, 2, suspended);
-}
-
-//over currect
-/**
- * over current condition indicator getter for port status
- *
- * @param status
- * @return true if there is opver-current condition on the hub
- */
-static inline bool usb_port_over_current(usb_port_status_t * status) {
-        return usb_port_get_bit(status, 3);
-}
-
-/**
- * set over current indicator bit in port status
- *
- * @param status
- * @param value value of the bit
- */
-static inline void usb_port_set_over_current(usb_port_status_t * status, bool value) {
-        usb_port_set_bit(status, 3, value);
-}
-
-//port reset
-/**
- * port reset indicator getter for port status
- * 
- * @param status
- * @return true if port is reset
- */
-static inline bool usb_port_reset(usb_port_status_t * status) {
-        return usb_port_get_bit(status, 4);
-}
-
-/**
- * set port reset bit in port status
- *
- * @param status
- * @param value value of the bit
- */
-static inline void usb_port_set_reset(usb_port_status_t * status, bool value) {
-        usb_port_set_bit(status, 4, value);
-}
-
-//powered
-/**
- * power state getter for port status
- *
- * @param status
- * @return true if port is powered
- */
-static inline bool usb_port_powered(usb_port_status_t * status) {
-        return usb_port_get_bit(status, 8);
-}
-
-/**
- * set port powered bit in port status
- *
- * @param status
- * @param powered value of the bit
- */
-static inline void usb_port_set_powered(usb_port_status_t * status, bool powered) {
-        usb_port_set_bit(status, 8, powered);
-}
-
-#endif
-
-//low speed device attached
+            ((*status) | (1 << (idx))) :
+            ((*status)&(~(1 << (idx))));
+}
+
 /**
  * low speed device on the port indicator
@@ -446 +312 @@
  * @param low_speed value of the bit
  */
-static inline void usb_port_set_low_speed(usb_port_status_t * status, bool low_speed) {
+static inline void usb_port_set_low_speed(usb_port_status_t *status, bool low_speed) {
         usb_port_status_set_bit(status, 9, low_speed);
 }
 
 //high speed device attached
+
 /**
  * high speed device on the port indicator
@@ -467 +334 @@
  * @param high_speed value of the bit
  */
-static inline void usb_port_set_high_speed(usb_port_status_t * status, bool high_speed) {
+static inline void usb_port_set_high_speed(usb_port_status_t *status, bool high_speed) {
         usb_port_status_set_bit(status, 10, high_speed);
 }
@@ -485 +352 @@
 }
 
-#if 0
-//connect change
-/**
- * port connect change indicator
- *
- * @param status
- * @return true if connection has changed
- */
-static inline bool usb_port_connect_change(usb_port_status_t * status) {
-        return usb_port_get_bit(status, 16);
-}
-
-/**
- * set connection change bit in port status
- * @param status
- * @param change value of the bit
- */
-static inline void usb_port_set_connect_change(usb_port_status_t * status, bool change) {
-        usb_port_set_bit(status, 16, change);
-}
-
-//port enable change
-/**
- * port enable change for port status
- *
- * @param status
- * @return true if the port has been enabled/disabled
- */
-static inline bool usb_port_enabled_change(usb_port_status_t * status) {
-        return usb_port_get_bit(status, 17);
-}
-
-/**
- * set port enable change bit in port status
- *
- * @param status
- * @param change value of the bit
- */
-static inline void usb_port_set_enabled_change(usb_port_status_t * status, bool change) {
-        usb_port_set_bit(status, 17, change);
-}
-
-//suspend change
-/**
- * port suspend change for port status
- * 
- * @param status
- * @return ture if suspend status has changed
- */
-static inline bool usb_port_suspend_change(usb_port_status_t * status) {
-        return usb_port_get_bit(status, 18);
-}
-
-/**
- * set port suspend change bit in port status
- *
- * @param status
- * @param change value of the bit
- */
-static inline void usb_port_set_suspend_change(usb_port_status_t * status, bool change) {
-        usb_port_set_bit(status, 18, change);
-}
-
-//over current change
-/**
- * over current change indicator
- * 
- * @param status
- * @return true if over-current condition on port has changed
- */
-static inline bool usb_port_overcurrent_change(usb_port_status_t * status) {
-        return usb_port_get_bit(status, 19);
-}
-
-/**
- * set port over current change bit in port status
- *
- * @param status
- * @param change value of the bit
- */
-static inline void usb_port_set_overcurrent_change(usb_port_status_t * status, bool change) {
-        usb_port_set_bit(status, 19, change);
-}
-
-//reset change
-/**
- * port reset change indicator
- * @param status
- * @return true if port has been reset
- */
-static inline bool usb_port_reset_completed(usb_port_status_t * status) {
-        return usb_port_get_bit(status, 20);
-}
-
-/**
- * set port reset completed bit in port status
- *
- * @param status
- * @param change value of the bit
- */
-static inline void usb_port_set_reset_completed(usb_port_status_t * status, bool completed) {
-        usb_port_set_bit(status, 20, completed);
-}
-
-//local power status
-/**
- * local power lost indicator for hub status
- * 
- * @param status
- * @return true if hub is not powered
- */
-static inline bool usb_hub_local_power_lost(usb_hub_status_t * status) {
-        return usb_hub_get_bit(status, 0);
-}
-
-/**
- * set hub power lost bit in hub status
- *
- * @param status
- * @param change value of the bit
- */
-static inline void usb_hub_set_local_power_lost(usb_port_status_t * status,
-        bool power_lost) {
-        usb_hub_set_bit(status, 0, power_lost);
-}
-
-//over current ocndition
-/**
- * hub over-current indicator
- *
- * @param status
- * @return true if over-current condition occurred on hub
- */
-static inline bool usb_hub_over_current(usb_hub_status_t * status) {
-        return usb_hub_get_bit(status, 1);
-}
-
-/**
- * set hub over current bit in hub status
- *
- * @param status
- * @param change value of the bit
- */
-static inline void usb_hub_set_over_current(usb_port_status_t * status,
-        bool over_current) {
-        usb_hub_set_bit(status, 1, over_current);
-}
-
-//local power change
-/**
- * hub power change indicator
- *
- * @param status
- * @return true if local power status has been changed - power has been
- * dropped or re-established
- */
-static inline bool usb_hub_local_power_change(usb_hub_status_t * status) {
-        return usb_hub_get_bit(status, 16);
-}
-
-/**
- * set hub power change bit in hub status
- *
- * @param status
- * @param change value of the bit
- */
-static inline void usb_hub_set_local_power_change(usb_port_status_t * status,
-        bool change) {
-        usb_hub_set_bit(status, 16, change);
-}
-
-//local power status
-/**
- * hub over-current condition change indicator
- *
- * @param status
- * @return true if over-current condition has changed
- */
-static inline bool usb_hub_over_current_change(usb_hub_status_t * status) {
-        return usb_hub_get_bit(status, 17);
-}
-
-/**
- * set hub over current change bit in hub status
- *
- * @param status
- * @param change value of the bit
- */
-static inline void usb_hub_set_over_current_change(usb_port_status_t * status,
-        bool change) {
-        usb_hub_set_bit(status, 17, change);
-}
-#endif
 
 

uspace/drv/usbhub/ports.c

@@ -47 +47 @@
 #include "port_status.h"
 
-
 /** Information for fibril for device discovery. */
 struct add_device_phase1 {
@@ -65 +64 @@
  * any function here and must be cleared by hand
  */
-static const int non_handled_changes[] =  {
+static const int non_handled_changes[] = {
         USB_HUB_FEATURE_C_PORT_ENABLE,
         USB_HUB_FEATURE_C_PORT_SUSPEND
@@ -71 +70 @@
 
 static void usb_hub_removed_device(
-        usb_hub_info_t * hub, uint16_t port);
-
-static void usb_hub_port_reset_completed(usb_hub_info_t * hub,
-        uint16_t port, uint32_t status);
-
-static void usb_hub_port_over_current(usb_hub_info_t * hub,
-        uint16_t port, uint32_t status);
+    usb_hub_info_t *hub, uint16_t port);
+
+static void usb_hub_port_reset_completed(usb_hub_info_t *hub,
+    uint16_t port, uint32_t status);
+
+static void usb_hub_port_over_current(usb_hub_info_t *hub,
+    uint16_t port, uint32_t status);
 
 static int get_port_status(usb_pipe_t *ctrl_pipe, size_t port,
@@ -96 +95 @@
  * @param port port number, starting from 1
  */
-void usb_hub_process_interrupt(usb_hub_info_t * hub,
-        uint16_t port) {
-        usb_log_debug("interrupt at port %zu\n", (size_t) port);
+void usb_hub_process_interrupt(usb_hub_info_t *hub,
+    uint16_t port) {
+        usb_log_debug("Interrupt at port %zu\n", (size_t) port);
         //determine type of change
         //usb_pipe_t *pipe = hub->control_pipe;
@@ -134 +133 @@
         if (usb_port_is_status(status, USB_HUB_FEATURE_C_PORT_OVER_CURRENT)) {
                 //check if it was not auto-resolved
-                usb_log_debug("overcurrent change on port\n");
+                usb_log_debug("Overcurrent change on port\n");
                 usb_hub_port_over_current(hub, port, status);
         }
@@ -141 +140 @@
                 usb_hub_port_reset_completed(hub, port, status);
         }
-        usb_log_debug("status x%x : %d\n ", status, status);
+        usb_log_debug("Status x%x : %d\n ", status, status);
 
         usb_port_status_set_bit(
-            &status, USB_HUB_FEATURE_C_PORT_CONNECTION,false);
+            &status, USB_HUB_FEATURE_C_PORT_CONNECTION, false);
         usb_port_status_set_bit(
-            &status, USB_HUB_FEATURE_C_PORT_RESET,false);
+            &status, USB_HUB_FEATURE_C_PORT_RESET, false);
         usb_port_status_set_bit(
-            &status, USB_HUB_FEATURE_C_PORT_OVER_CURRENT,false);
-        
+            &status, USB_HUB_FEATURE_C_PORT_OVER_CURRENT, false);
+
         //clearing not yet handled changes      
         unsigned int feature_idx;
-        for(feature_idx = 0;feature_idx<non_handled_changes_count;
-            ++feature_idx){
+        for (feature_idx = 0;
+            feature_idx < non_handled_changes_count;
+            ++feature_idx) {
                 unsigned int bit_idx = non_handled_changes[feature_idx];
-                if(status & (1<<bit_idx)){
+                if (status & (1 << bit_idx)) {
                         usb_log_info(
-                            "there was not yet handled change on port %d: %d"
+                            "There was not yet handled change on port %d: %d"
                             ";clearing it\n",
-                        port, bit_idx);
+                            port, bit_idx);
                         int opResult = usb_hub_clear_port_feature(
                             hub->control_pipe,
@@ -165 +165 @@
                         if (opResult != EOK) {
                                 usb_log_warning(
-                                    "could not clear port flag %d: %d\n",
-                                    bit_idx, opResult
+                                    "Could not clear port flag %d: %s\n",
+                                    bit_idx, str_error(opResult)
                                     );
                         }
                         usb_port_status_set_bit(
-                            &status, bit_idx,false);
+                            &status, bit_idx, false);
                 }
         }
-        if(status>>16){
-                usb_log_info("there is still some unhandled change %X\n",
+        if (status >> 16) {
+                usb_log_info("There is still some unhandled change %X\n",
                     status);
         }
 }
-
 
 /**
@@ -190 +189 @@
  */
 static void usb_hub_removed_device(
-        usb_hub_info_t * hub, uint16_t port) {
+    usb_hub_info_t *hub, uint16_t port) {
 
         int opResult = usb_hub_clear_port_feature(hub->control_pipe,
-                port, USB_HUB_FEATURE_C_PORT_CONNECTION);
+            port, USB_HUB_FEATURE_C_PORT_CONNECTION);
         if (opResult != EOK) {
-                usb_log_warning("could not clear port-change-connection flag\n");
+                usb_log_warning("Could not clear port-change-connection flag\n");
         }
         /** \TODO remove device from device manager - not yet implemented in
@@ -231 +230 @@
 }
 
-
 /**
  * Process port reset change
@@ -241 +239 @@
  * @param status
  */
-static void usb_hub_port_reset_completed(usb_hub_info_t * hub,
-        uint16_t port, uint32_t status){
+static void usb_hub_port_reset_completed(usb_hub_info_t *hub,
+    uint16_t port, uint32_t status) {
         usb_log_debug("Port %zu reset complete.\n", (size_t) port);
         if (usb_port_is_status(status, USB_HUB_FEATURE_PORT_ENABLE)) {
@@ -274 +272 @@
  * @param port port number, starting from 1
  */
-static void usb_hub_port_over_current(usb_hub_info_t * hub,
-        uint16_t port, uint32_t status) {
+static void usb_hub_port_over_current(usb_hub_info_t *hub,
+    uint16_t port, uint32_t status) {
         int opResult;
-        if(usb_port_is_status(status, USB_HUB_FEATURE_PORT_OVER_CURRENT)){
+        if (usb_port_is_status(status, USB_HUB_FEATURE_PORT_OVER_CURRENT)) {
                 opResult = usb_hub_clear_port_feature(hub->control_pipe,
-                        port, USB_HUB_FEATURE_PORT_POWER);
+                    port, USB_HUB_FEATURE_PORT_POWER);
                 if (opResult != EOK) {
-                        usb_log_error("cannot power off port %d;  %d\n",
-                                port, opResult);
+                        usb_log_error("Cannot power off port %d; %s\n",
+                            port, str_error(opResult));
                 }
-        }else{
+        } else {
                 opResult = usb_hub_set_port_feature(hub->control_pipe,
-                        port, USB_HUB_FEATURE_PORT_POWER);
+                    port, USB_HUB_FEATURE_PORT_POWER);
                 if (opResult != EOK) {
-                        usb_log_error("cannot power on port %d;  %d\n",
-                                port, opResult);
+                        usb_log_error("Cannot power on port %d; %s\n",
+                            port, str_error(opResult));
                 }
         }
@@ -302 +300 @@
  */
 static int get_port_status(usb_pipe_t *ctrl_pipe, size_t port,
-    usb_port_status_t *status)
-{
+    usb_port_status_t *status) {
         size_t recv_size;
         usb_device_request_setup_packet_t request;
@@ -310 +307 @@
         usb_hub_set_port_status_request(&request, port);
         int rc = usb_pipe_control_read(ctrl_pipe,
-            &request, sizeof(usb_device_request_setup_packet_t),
-            &status_tmp, sizeof(status_tmp), &recv_size);
+            &request, sizeof (usb_device_request_setup_packet_t),
+            &status_tmp, sizeof (status_tmp), &recv_size);
         if (rc != EOK) {
                 return rc;
@@ -336 +333 @@
  * @return Error code.
  */
-static int enable_port_callback(int port_no, void *arg)
-{
+static int enable_port_callback(int port_no, void *arg) {
         usb_hub_info_t *hub = arg;
         int rc;
@@ -345 +341 @@
         usb_hub_set_reset_port_request(&request, port_no);
         rc = usb_pipe_control_write(hub->control_pipe,
-            &request, sizeof(request), NULL, 0);
+            &request, sizeof (request), NULL, 0);
         if (rc != EOK) {
                 usb_log_warning("Port reset failed: %s.\n", str_error(rc));
@@ -375 +371 @@
  * @return 0 Always.
  */
-static int add_device_phase1_worker_fibril(void *arg)
-{
+static int add_device_phase1_worker_fibril(void *arg) {
         struct add_device_phase1 *data
             = (struct add_device_phase1 *) arg;
@@ -418 +413 @@
 }
 
-
 /** Start device adding when connection change is detected.
  *
@@ -429 +423 @@
  */
 static int create_add_device_fibril(usb_hub_info_t *hub, size_t port,
-    usb_speed_t speed)
-{
+    usb_speed_t speed) {
         struct add_device_phase1 *data
-            = malloc(sizeof(struct add_device_phase1));
+            = malloc(sizeof (struct add_device_phase1));
         if (data == NULL) {
                 return ENOMEM;

uspace/drv/usbhub/ports.h

@@ -70 +70 @@
 
 
-void usb_hub_process_interrupt(usb_hub_info_t * hub,
+void usb_hub_process_interrupt(usb_hub_info_t *hub,
         uint16_t port);
 

uspace/drv/usbhub/usbhub.c

@@ -56 +56 @@
 
 
-static usb_hub_info_t * usb_hub_info_create(usb_device_t * usb_dev);
-
-static int usb_hub_process_hub_specific_info(usb_hub_info_t * hub_info);
-
-static int usb_hub_set_configuration(usb_hub_info_t * hub_info);
-
-static int usb_hub_start_hub_fibril(usb_hub_info_t * hub_info);
-
-static int usb_process_hub_over_current(usb_hub_info_t * hub_info,
+static usb_hub_info_t * usb_hub_info_create(usb_device_t *usb_dev);
+
+static int usb_hub_process_hub_specific_info(usb_hub_info_t *hub_info);
+
+static int usb_hub_set_configuration(usb_hub_info_t *hub_info);
+
+static int usb_hub_start_hub_fibril(usb_hub_info_t *hub_info);
+
+static int usb_process_hub_over_current(usb_hub_info_t *hub_info,
     usb_hub_status_t status);
 
-static int usb_process_hub_local_power_change(usb_hub_info_t * hub_info,
+static int usb_process_hub_local_power_change(usb_hub_info_t *hub_info,
     usb_hub_status_t status);
 
-static void usb_hub_process_global_interrupt(usb_hub_info_t * hub_info);
-
-static void usb_hub_polling_terminated_callback(usb_device_t * device,
-    bool was_error, void * data);
+static void usb_hub_process_global_interrupt(usb_hub_info_t *hub_info);
+
+static void usb_hub_polling_terminated_callback(usb_device_t *device,
+    bool was_error, void *data);
 
 
@@ -90 +90 @@
  * @return error code
  */
-int usb_hub_add_device(usb_device_t * usb_dev) {
+int usb_hub_add_device(usb_device_t *usb_dev) {
         if (!usb_dev) return EINVAL;
-        usb_hub_info_t * hub_info = usb_hub_info_create(usb_dev);
+        usb_hub_info_t *hub_info = usb_hub_info_create(usb_dev);
         //create hc connection
         usb_log_debug("Initializing USB wire abstraction.\n");
@@ -99 +99 @@
             hub_info->usb_device->ddf_dev);
         if (opResult != EOK) {
-                usb_log_error("could not initialize connection to device, "
-                    "errno %d\n",
-                    opResult);
+                usb_log_error("Could not initialize connection to device, "
+                    " %s\n",
+                    str_error(opResult));
                 free(hub_info);
                 return opResult;
@@ -109 +109 @@
         opResult = usb_hub_set_configuration(hub_info);
         if (opResult != EOK) {
-                usb_log_error("could not set hub configuration, errno %d\n",
-                    opResult);
+                usb_log_error("Could not set hub configuration, %s\n",
+                    str_error(opResult));
                 free(hub_info);
                 return opResult;
@@ -117 +117 @@
         opResult = usb_hub_process_hub_specific_info(hub_info);
         if (opResult != EOK) {
-                usb_log_error("could process hub specific info, errno %d\n",
-                    opResult);
+                usb_log_error("Could process hub specific info, %s\n",
+                    str_error(opResult));
                 free(hub_info);
                 return opResult;
@@ -135 +135 @@
 
         opResult = usb_hub_start_hub_fibril(hub_info);
-        if(opResult!=EOK)
+        if (opResult != EOK)
                 free(hub_info);
         return opResult;
 }
-
 
 /** Callback for polling hub for changes.
@@ -193 +192 @@
  * @return basic usb_hub_info_t structure
  */
-static usb_hub_info_t * usb_hub_info_create(usb_device_t * usb_dev) {
-        usb_hub_info_t * result = malloc(sizeof(usb_hub_info_t));
+static usb_hub_info_t * usb_hub_info_create(usb_device_t *usb_dev) {
+        usb_hub_info_t * result = malloc(sizeof (usb_hub_info_t));
         if (!result) return NULL;
         result->usb_device = usb_dev;
@@ -202 +201 @@
 
         result->ports = NULL;
-        result->port_count = (size_t) -1;
+        result->port_count = (size_t) - 1;
         fibril_mutex_initialize(&result->port_mutex);
 
@@ -221 +220 @@
  * @return error code
  */
-static int usb_hub_process_hub_specific_info(usb_hub_info_t * hub_info) {
+static int usb_hub_process_hub_specific_info(usb_hub_info_t *hub_info) {
         // get hub descriptor
-        usb_log_debug("creating serialized descriptor\n");
+        usb_log_debug("Creating serialized descriptor\n");
         uint8_t serialized_descriptor[USB_HUB_MAX_DESCRIPTOR_SIZE];
         usb_hub_descriptor_t * descriptor;
@@ -235 +234 @@
 
         if (opResult != EOK) {
-                usb_log_error("failed when receiving hub descriptor, "
-                    "badcode = %d\n",
-                    opResult);
+                usb_log_error("Failed when receiving hub descriptor, "
+                    "%s\n",
+                    str_error(opResult));
                 free(serialized_descriptor);
                 return opResult;
         }
-        usb_log_debug2("deserializing descriptor\n");
+        usb_log_debug2("Deserializing descriptor\n");
         descriptor = usb_create_deserialized_hub_desriptor(
             serialized_descriptor);
@@ -250 +249 @@
         usb_log_debug("setting port count to %d\n", descriptor->ports_count);
         hub_info->port_count = descriptor->ports_count;
-        /// \TODO this is not semantically correct
         bool is_power_switched =
-            ((descriptor->hub_characteristics & 1) ==0);
+            ((descriptor->hub_characteristics & 1) == 0);
         bool has_individual_port_powering =
-            ((descriptor->hub_characteristics & 1) !=0);
+            ((descriptor->hub_characteristics & 1) != 0);
         hub_info->ports = malloc(
             sizeof (usb_hub_port_t) * (hub_info->port_count + 1));
-        if(!hub_info->ports){
+        if (!hub_info->ports) {
                 return ENOMEM;
         }
@@ -264 +262 @@
                 usb_hub_port_init(&hub_info->ports[port]);
         }
-        if(is_power_switched){
-                usb_log_debug("is_power_switched\n");
-                
-                if(!has_individual_port_powering){
-                        usb_log_debug("!has_individual_port_powering\n");
+        if (is_power_switched) {
+                usb_log_debug("Hub power switched\n");
+
+                if (!has_individual_port_powering) {
+                        usb_log_debug("Has_global powering\n");
                         opResult = usb_hub_set_feature(hub_info->control_pipe,
                             USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
                         if (opResult != EOK) {
-                                usb_log_error("cannot power hub: %s\n",
+                                usb_log_error("Cannot power hub: %s\n",
                                     str_error(opResult));
                         }
@@ -278 +276 @@
 
                 for (port = 1; port <= hub_info->port_count; ++port) {
-                        usb_log_debug("Powering port %zu.\n",port);
+                        usb_log_debug("Powering port %zu.\n", port);
                         opResult = usb_hub_set_port_feature(hub_info->control_pipe,
                             port, USB_HUB_FEATURE_PORT_POWER);
@@ -286 +284 @@
                         }
                 }
-                
-        }else{
-                usb_log_debug("!is_power_switched, not going to be powered\n");
-        }
-        usb_log_debug2("freeing data\n");
+
+        } else {
+                usb_log_debug("Power not switched, not going to be powered\n");
+        }
+        usb_log_debug2("Freeing data\n");
         free(descriptor);
         return EOK;
@@ -303 +301 @@
  * @return error code
  */
-static int usb_hub_set_configuration(usb_hub_info_t * hub_info) {
+static int usb_hub_set_configuration(usb_hub_info_t *hub_info) {
         //device descriptor
         usb_standard_device_descriptor_t *std_descriptor
             = &hub_info->usb_device->descriptors.device;
-        usb_log_debug("hub has %d configurations\n",
+        usb_log_debug("Hub has %d configurations\n",
             std_descriptor->configuration_count);
         if (std_descriptor->configuration_count < 1) {
-                usb_log_error("there are no configurations available\n");
+                usb_log_error("There are no configurations available\n");
                 return EINVAL;
         }
@@ -328 +326 @@
                 return opResult;
         }
-        usb_log_debug("\tused configuration %d\n",
+        usb_log_debug("\tUsed configuration %d\n",
             config_descriptor->configuration_number);
 
@@ -343 +341 @@
  * @return error code
  */
-static int usb_hub_start_hub_fibril(usb_hub_info_t * hub_info){
+static int usb_hub_start_hub_fibril(usb_hub_info_t *hub_info) {
         int rc;
 
@@ -367 +365 @@
 //*********************************************
 
-
 /**
  * process hub over current change
@@ -376 +373 @@
  * @return error code
  */
-static int usb_process_hub_over_current(usb_hub_info_t * hub_info,
+static int usb_process_hub_over_current(usb_hub_info_t *hub_info,
     usb_hub_status_t status) {
         int opResult;
-        if (usb_hub_is_status(status,USB_HUB_FEATURE_HUB_OVER_CURRENT)){
+        if (usb_hub_is_status(status, USB_HUB_FEATURE_HUB_OVER_CURRENT)) {
                 //poweroff all ports
                 unsigned int port;
-                for(port = 1;port <= hub_info->port_count;++port){
+                for (port = 1; port <= hub_info->port_count; ++port) {
                         opResult = usb_hub_clear_port_feature(
-                            hub_info->control_pipe,port,
+                            hub_info->control_pipe, port,
                             USB_HUB_FEATURE_PORT_POWER);
                         if (opResult != EOK) {
                                 usb_log_warning(
-                                    "cannot power off port %d;  %d\n",
-                                    port, opResult);
+                                    "Cannot power off port %d;  %s\n",
+                                    port, str_error(opResult));
                         }
                 }
@@ -395 +392 @@
                 //power all ports
                 unsigned int port;
-                for(port = 1;port <= hub_info->port_count;++port){
+                for (port = 1; port <= hub_info->port_count; ++port) {
                         opResult = usb_hub_set_port_feature(
-                            hub_info->control_pipe,port,
+                            hub_info->control_pipe, port,
                             USB_HUB_FEATURE_PORT_POWER);
                         if (opResult != EOK) {
                                 usb_log_warning(
-                                    "cannot power off port %d;  %d\n",
-                                    port, opResult);
+                                    "Cannot power off port %d;  %s\n",
+                                    port, str_error(opResult));
                         }
                 }
@@ -417 +414 @@
  * @return error code
  */
-static int usb_process_hub_local_power_change(usb_hub_info_t * hub_info,
+static int usb_process_hub_local_power_change(usb_hub_info_t *hub_info,
     usb_hub_status_t status) {
         int opResult = EOK;
         opResult = usb_hub_clear_feature(hub_info->control_pipe,
             USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
-                if (opResult != EOK) {
-                usb_log_error("cannnot clear hub power change flag: "
-                    "%d\n",
-                    opResult);
+        if (opResult != EOK) {
+                usb_log_error("Cannnot clear hub power change flag: "
+                    "%s\n",
+                    str_error(opResult));
         }
         return opResult;
@@ -437 +434 @@
  * @param hub_info hub instance
  */
-static void usb_hub_process_global_interrupt(usb_hub_info_t * hub_info) {
-        usb_log_debug("global interrupt on a hub\n");
+static void usb_hub_process_global_interrupt(usb_hub_info_t *hub_info) {
+        usb_log_debug("Global interrupt on a hub\n");
         usb_pipe_t *pipe = hub_info->control_pipe;
         int opResult;
@@ -455 +452 @@
             );
         if (opResult != EOK) {
-                usb_log_error("could not get hub status\n");
+                usb_log_error("Could not get hub status: %s\n",
+                    str_error(opResult));
                 return;
         }
         if (rcvd_size != sizeof (usb_port_status_t)) {
-                usb_log_error("received status has incorrect size\n");
+                usb_log_error("Received status has incorrect size\n");
                 return;
         }
         //port reset
         if (
-            usb_hub_is_status(status,16+USB_HUB_FEATURE_C_HUB_OVER_CURRENT)) {
+            usb_hub_is_status(status, 16 + USB_HUB_FEATURE_C_HUB_OVER_CURRENT)) {
                 usb_process_hub_over_current(hub_info, status);
         }
         if (
-            usb_hub_is_status(status,16+USB_HUB_FEATURE_C_HUB_LOCAL_POWER)) {
+            usb_hub_is_status(status, 16 + USB_HUB_FEATURE_C_HUB_LOCAL_POWER)) {
                 usb_process_hub_local_power_change(hub_info, status);
         }
@@ -481 +479 @@
  * @param data pointer to usb_hub_info_t structure
  */
-static void usb_hub_polling_terminated_callback(usb_device_t * device,
-    bool was_error, void * data){
+static void usb_hub_polling_terminated_callback(usb_device_t *device,
+    bool was_error, void *data) {
         usb_hub_info_t * hub = data;
         assert(hub);

uspace/drv/usbhub/usbhub.h

@@ -51 +51 @@
 #include "ports.h"
 
-
-
 /** Information about attached hub. */
-struct usb_hub_info_t{
+struct usb_hub_info_t {
         /** Number of ports. */
         size_t port_count;
@@ -106 +104 @@
 };
 
-//int usb_hub_control_loop(void * hub_info_param);
-
-int usb_hub_add_device(usb_device_t * usb_dev);
+int usb_hub_add_device(usb_device_t *usb_dev);
 
 bool hub_port_changes_callback(usb_device_t *dev,

uspace/drv/usbhub/usbhub_private.h

@@ -65 +65 @@
  */
 static inline void usb_hub_set_descriptor_request(
-usb_device_request_setup_packet_t * request
-){
+    usb_device_request_setup_packet_t * request
+    ) {
         request->index = 0;
         request->request_type = USB_HUB_REQ_TYPE_GET_DESCRIPTOR;
@@ -87 +87 @@
     int port_index,
     usb_hub_class_feature_t feature) {
-        
+
         usb_device_request_setup_packet_t clear_request = {
                 .request_type = USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE,
@@ -96 +96 @@
         clear_request.value = feature;
         return usb_pipe_control_write(pipe, &clear_request,
-            sizeof(clear_request), NULL, 0);
+            sizeof (clear_request), NULL, 0);
 }
 
@@ -120 +120 @@
         clear_request.value = feature;
         return usb_pipe_control_write(pipe, &clear_request,
-            sizeof(clear_request), NULL, 0);
+            sizeof (clear_request), NULL, 0);
 }
-
 
 /**
@@ -142 +141 @@
         clear_request.value = feature;
         return usb_pipe_control_write(pipe, &clear_request,
-            sizeof(clear_request), NULL, 0);
+            sizeof (clear_request), NULL, 0);
 }
 
@@ -163 +162 @@
         clear_request.value = feature;
         return usb_pipe_control_write(pipe, &clear_request,
-            sizeof(clear_request), NULL, 0);
+            sizeof (clear_request), NULL, 0);
 }
 

uspace/drv/usbhub/utils.c

@@ -62 +62 @@
  * @return newly created serializd descriptor pointer
  */
-void * usb_create_serialized_hub_descriptor(usb_hub_descriptor_t * descriptor) {
+void * usb_create_serialized_hub_descriptor(usb_hub_descriptor_t *descriptor) {
         //base size
         size_t size = 7;
         //variable size according to port count
-        size_t var_size = (descriptor->ports_count+7)/8;
+        size_t var_size = (descriptor->ports_count + 7) / 8;
         size += 2 * var_size;
         uint8_t * result = malloc(size);
         //size
-        if(result)
-                usb_serialize_hub_descriptor(descriptor,result);
+        if (result)
+                usb_serialize_hub_descriptor(descriptor, result);
         return result;
 }
@@ -82 +82 @@
  * @param serialized_descriptor
  */
-void usb_serialize_hub_descriptor(usb_hub_descriptor_t * descriptor,
+void usb_serialize_hub_descriptor(usb_hub_descriptor_t *descriptor,
     void * serialized_descriptor) {
         //base size
@@ -88 +88 @@
         size_t size = 7;
         //variable size according to port count
-        size_t var_size = (descriptor->ports_count+7)/8;
+        size_t var_size = (descriptor->ports_count + 7) / 8;
         size += 2 * var_size;
         //size
@@ -110 +110 @@
 }
 
-
 /**
  * create deserialized desriptor structure out of serialized descriptor
@@ -121 +120 @@
  */
 usb_hub_descriptor_t * usb_create_deserialized_hub_desriptor(
-void * serialized_descriptor) {
+    void *serialized_descriptor) {
         uint8_t * sdescriptor = serialized_descriptor;
 
@@ -130 +129 @@
         }
 
-        usb_hub_descriptor_t * result = malloc(sizeof(usb_hub_descriptor_t));
-        if(result)
-                usb_deserialize_hub_desriptor(serialized_descriptor,result);
+        usb_hub_descriptor_t * result = malloc(sizeof (usb_hub_descriptor_t));
+        if (result)
+                usb_deserialize_hub_desriptor(serialized_descriptor, result);
         return result;
 }
@@ -144 +143 @@
  */
 void usb_deserialize_hub_desriptor(
-void * serialized_descriptor, usb_hub_descriptor_t * descriptor) {
+    void * serialized_descriptor, usb_hub_descriptor_t *descriptor) {
         uint8_t * sdescriptor = serialized_descriptor;
         descriptor->ports_count = sdescriptor[2];
@@ -151 +150 @@
         descriptor->pwr_on_2_good_time = sdescriptor[5];
         descriptor->current_requirement = sdescriptor[6];
-        size_t var_size = (descriptor->ports_count+7) / 8;
+        size_t var_size = (descriptor->ports_count + 7) / 8;
         //descriptor->devices_removable = (uint8_t*) malloc(var_size);
 

uspace/lib/usbhid/src/hiddescriptor.c

@@ -187 +187 @@
 
                 field = malloc(sizeof(usb_hid_report_field_t));
+                if(field == NULL) {
+                        return ENOMEM;
+                }
+
                 memset(field, 0, sizeof(usb_hid_report_field_t));
                 list_initialize(&field->link);
@@ -216 +220 @@
                         }
                         else {
-                                usage = report_item->usages[
+                                usage = report_item->usages[
                                         report_item->usages_count- 1]; 
                         }
@@ -241 +245 @@
 
                 field->size = report_item->size;
-                
-                size_t offset_byte = (report_item->offset + (i *
-                        report_item->size)) / 8; 
-
-                size_t offset_bit = 8 - ((report_item->offset + (i *
-                        report_item->size)) % 8) - report_item->size;
-
-                field->offset = 8 * offset_byte + offset_bit;
-                if(report_item->id != 0) {
+
+                if(report_item->type == USB_HID_REPORT_TYPE_INPUT) {
+                        int offset = report_item->offset + report_item->size * i;
+                        int field_offset = (offset/8)*8 + (offset/8 + 1) * 8 - 
+                                offset - report_item->size;
+                        if(field_offset < 0) {
+                                field->offset = 0;
+                        }
+                        else {
+                                field->offset = field_offset;
+                        }
+                }
+                else {
+                        field->offset = report_item->offset + (i * report_item->size);
+                }
+
+
+                if(report->use_report_ids != 0) {
                         field->offset += 8;
                         report->use_report_ids = 1;
                 }
+
                 field->item_flags = report_item->item_flags;
 
@@ -315 +329 @@
                 usb_hid_report_type_t type) {
 
+        if(report == NULL) {
+                return NULL;
+        }
+
         link_t *report_it = report->reports.next;
         usb_hid_report_description_t *report_des = NULL;
@@ -322 +340 @@
                                 usb_hid_report_description_t, link);
 
-                if((report_des->report_id == report_id) && 
+                // if report id not set, return the first of the type
+                if(((report_des->report_id == report_id) || (report_id == 0)) && 
                    (report_des->type == type)) { 
                         return report_des;

uspace/lib/usbhid/src/hidparser.c

@@ -153 +153 @@
 
 
-        report_des = usb_hid_report_find_description(report, *report_id, type);
+        report_des = usb_hid_report_find_description(report, *report_id, 
+                type);
+
         if(report_des == NULL) {
                 return EINVAL;
@@ -167 +169 @@
                 if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) {
                         
-                        if(USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) {
+                        if(USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0){
 
                                 // array
@@ -174 +176 @@
                 
                                 item->usage = USB_HID_EXTENDED_USAGE(
-                                    item->usages[item->value - item->physical_minimum]);
-
-                                item->usage_page = USB_HID_EXTENDED_USAGE_PAGE(
-                                    item->usages[item->value - item->physical_minimum]);
-
-                                usb_hid_report_set_last_item (item->collection_path, 
-                                    USB_HID_TAG_CLASS_GLOBAL, item->usage_page);
-
-                                usb_hid_report_set_last_item (item->collection_path, 
+                                    item->usages[
+                                    item->value - item->physical_minimum]);
+
+                                item->usage_page = 
+                                    USB_HID_EXTENDED_USAGE_PAGE(
+                                    item->usages[
+                                    item->value - item->physical_minimum]);
+
+                                usb_hid_report_set_last_item (
+                                    item->collection_path, 
+                                    USB_HID_TAG_CLASS_GLOBAL, 
+                                    item->usage_page);
+
+                                usb_hid_report_set_last_item (
+                                    item->collection_path, 
                                     USB_HID_TAG_CLASS_LOCAL, item->usage);
                                 
@@ -188 +196 @@
                         else {
                                 // variable item
-                                item->value = usb_hid_translate_data(item, data);                               
-                        }                               
+                                item->value = usb_hid_translate_data(item, 
+                                    data);                              
+                        }                       
                 }
                 list_item = list_item->next;
@@ -213 +222 @@
         
         int32_t value=0;
-        int32_t mask;
-        const uint8_t *foo;
+        int32_t mask=0;
+        const uint8_t *foo=0;
 
         // now only shot tags are allowed
@@ -240 +249 @@
         if((size_t)(offset/8) != (size_t)((offset+item->size-1)/8)) {
                 
-                part_size = ((offset+item->size)%8);
+                part_size = 0;
 
                 size_t i=0;
@@ -246 +255 @@
                         if(i == (size_t)(offset/8)) {
                                 // the higher one
+                                part_size = 8 - (offset % 8);
                                 foo = data + i;
                                 mask =  ((1 << (item->size-part_size))-1);
-                                value = (*foo & mask) << part_size;
+                                value = (*foo & mask);
                         }
                         else if(i == ((offset+item->size-1)/8)){
                                 // the lower one
                                 foo = data + i;
-                                mask =  ((1 << part_size)-1) << (8-part_size);
-                                value += ((*foo & mask) >> (8-part_size));
+                                mask = ((1 << (item->size - part_size)) - 1) 
+                                        << (8 - (item->size - part_size));
+
+                                value = (((*foo & mask) >> (8 - 
+                                    (item->size - part_size))) << part_size ) 
+                                    + value;
                         }
                         else {
-                                value = value << 8;
-                                value += *(data + 1);
+                                value = (*(data + 1) << (part_size + 8)) + value;
+                                part_size += 8;
                         }
                 }
@@ -375 +389 @@
                 report_item = list_get_instance(item, usb_hid_report_field_t, link);
 
-                if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) {
-                                        
-                        // array
-                        value = usb_hid_translate_data_reverse(report_item, 
-                                report_item->value);
-
-                        offset = report_item->offset;
-                        length = report_item->size;
-                }
-                else {
-                        // variable item
-                        value  = usb_hid_translate_data_reverse(report_item, 
-                                report_item->value);
-
-                        offset = report_item->offset;
-                        length = report_item->size;
-                }
-
+                value = usb_hid_translate_data_reverse(report_item, 
+                        report_item->value);
+
+                offset = report_des->bit_length - report_item->offset - 1;
+                length = report_item->size;
+                
                 usb_log_debug("\ttranslated value: %x\n", value);
 
@@ -603 +605 @@
         
         if(report_id > 0) {
-                report_it = usb_hid_report_find_description(report, report_id, 
-                        type)->link.next;               
+                report_des = usb_hid_report_find_description(report, report_id, 
+                        type);
+                if(report_des == NULL) {
+                        return 0;
+                }
+                else {
+                        report_it = report_des->link.next;
+                }       
         }
         else {
@@ -617 +625 @@
                         return report_des->report_id;
                 }
+
+                report_it = report_it->next;
         }
 

uspace/lib/usbhid/src/hidpath.c

@@ -211 +211 @@
 
         if(report_path->report_id != path->report_id) {
-                return 1;
+                if(path->report_id != 0) {
+                        return 1;
+                }
         }
 

uspace/srv/hid/console/console.c

@@ -768 +768 @@
         
         int phone = fd_phone(fd);
+        close(fd);
         if (phone < 0) {
                 printf(NAME ": Failed to connect to input device\n");
@@ -777 +778 @@
             handler, &hash);
         if (rc != EOK) {
+                async_hangup(phone);
                 printf(NAME ": " \
                     "Failed to create callback from input device: %s.\n",