Changeset 54464f6a in mainline for uspace/drv/bus

Timestamp:

2011-11-11T19:48:33Z (14 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

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

Children:

50a01a9

Parents:

c2e50d7 (diff), 747ef72 (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 mainline changes

Location:

uspace/drv/bus

Files:

• pci/pciintel/pci.c (modified) (8 diffs)
• pci/pciintel/pci.h (modified) (1 diff)
• usb/ehci/hc_iface.c (modified) (2 diffs)
• usb/ohci/hc.c (modified) (3 diffs)
• usb/ohci/ohci.c (modified) (3 diffs)
• usb/uhci/hc.c (modified) (1 diff)
• usb/uhci/uhci.c (modified) (2 diffs)
• usb/usbflbk/main.c (modified) (2 diffs)
• usb/usbhid/generic/hiddev.c (modified) (16 diffs)
• usb/usbhid/kbd/kbddev.c (modified) (32 diffs)
• usb/usbhid/kbd/kbddev.h (modified) (1 diff)
• usb/usbhid/kbd/kbdrepeat.c (modified) (10 diffs)
• usb/usbhid/main.c (modified) (6 diffs)
• usb/usbhid/mouse/mousedev.c (modified) (19 diffs)
• usb/usbhid/multimedia/multimedia.c (modified) (10 diffs)
• usb/usbhid/subdrivers.c (modified) (1 diff)
• usb/usbhid/subdrivers.h (modified) (1 diff)
• usb/usbhid/usbhid.c (modified) (29 diffs)
• usb/usbhid/usbhid.h (modified) (2 diffs)
• usb/usbhub/port.c (modified) (2 diffs)
• usb/usbhub/port.h (modified) (1 diff)
• usb/usbhub/usbhub.c (modified) (1 diff)
• usb/usbmast/bo_trans.c (modified) (3 diffs)
• usb/usbmast/main.c (modified) (2 diffs)
• usb/usbmid/explore.c (modified) (7 diffs)
• usb/usbmid/main.c (modified) (5 diffs)
• usb/usbmid/usbmid.c (modified) (4 diffs)
• usb/usbmid/usbmid.h (modified) (1 diff)
• usb/vhc/connhost.c (modified) (7 diffs)
• usb/vhc/main.c (modified) (1 diff)

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

@@ -78 +78 @@
 #define PCI_BUS_FROM_FUN(fun) ((fun)->busptr)
 
+/** Max is 47, align to something nice. */
+#define ID_MAX_STR_LEN 50
+
 static hw_resource_list_t *pciintel_get_resources(ddf_fun_t *fnode)
 {
@@ -225 +228 @@
         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);
         
@@ -311 +313 @@
 void pci_fun_create_match_ids(pci_fun_t *fun)
 {
-        char *match_id_str;
         int rc;
-        
-        asprintf(&match_id_str, "pci/ven=%04x&dev=%04x",
+        char match_id_str[ID_MAX_STR_LEN];
+
+        /* Vendor ID & Device ID, length(incl \0) 22 */
+        rc = snprintf(match_id_str, ID_MAX_STR_LEN, "pci/ven=%04x&dev=%04x",
             fun->vendor_id, fun->device_id);
-
-        if (match_id_str == NULL) {
-                ddf_msg(LVL_ERROR, "Out of memory creating match ID.");
-                return;
+        if (rc < 0) {
+                ddf_msg(LVL_ERROR, "Failed creating match ID str: %s",
+                    str_error(rc));
         }
 
         rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 90);
         if (rc != EOK) {
-                ddf_msg(LVL_ERROR, "Failed adding match ID: %s",
+                ddf_msg(LVL_ERROR, "Failed adding match ID: %s", str_error(rc));
+        }
+
+        /* Class, subclass, prog IF, revision, length(incl \0) 47 */
+        rc = snprintf(match_id_str, ID_MAX_STR_LEN,
+            "pci/class=%02x&subclass=%02x&progif=%02x&revision=%02x",
+            fun->class_code, fun->subclass_code, fun->prog_if, fun->revision);
+        if (rc < 0) {
+                ddf_msg(LVL_ERROR, "Failed creating match ID str: %s",
                     str_error(rc));
         }
-        
-        free(match_id_str);
-        
-        /* TODO add more ids (with subsys ids, using class id etc.) */
+
+        rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 70);
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "Failed adding match ID: %s", str_error(rc));
+        }
+
+        /* Class, subclass, prog IF, length(incl \0) 35 */
+        rc = snprintf(match_id_str, ID_MAX_STR_LEN,
+            "pci/class=%02x&subclass=%02x&progif=%02x",
+            fun->class_code, fun->subclass_code, fun->prog_if);
+        if (rc < 0) {
+                ddf_msg(LVL_ERROR, "Failed creating match ID str: %s",
+                    str_error(rc));
+        }
+
+        rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 60);
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "Failed adding match ID: %s", str_error(rc));
+        }
+
+        /* Class, subclass, length(incl \0) 25 */
+        rc = snprintf(match_id_str, ID_MAX_STR_LEN,
+            "pci/class=%02x&subclass=%02x",
+            fun->class_code, fun->subclass_code);
+        if (rc < 0) {
+                ddf_msg(LVL_ERROR, "Failed creating match ID str: %s",
+                    str_error(rc));
+        }
+
+        rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 50);
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "Failed adding match ID: %s", str_error(rc));
+        }
+
+        /* Class, length(incl \0) 13 */
+        rc = snprintf(match_id_str, ID_MAX_STR_LEN, "pci/class=%02x",
+            fun->class_code);
+        if (rc < 0) {
+                ddf_msg(LVL_ERROR, "Failed creating match ID str: %s",
+                    str_error(rc));
+        }
+
+        rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 40);
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "Failed adding match ID: %s", str_error(rc));
+        }
+
+        /* TODO add subsys ids, but those exist only in header type 0 */
 }
 
@@ -481 +535 @@
                 for (fnum = 0; multi && fnum < 8; fnum++) {
                         pci_fun_init(fun, bus_num, dnum, fnum);
-                        fun->vendor_id = pci_conf_read_16(fun,
-                            PCI_VENDOR_ID);
-                        fun->device_id = pci_conf_read_16(fun,
-                            PCI_DEVICE_ID);
                         if (fun->vendor_id == 0xffff) {
                                 /*
@@ -511 +561 @@
                         
                         fnode = ddf_fun_create(bus->dnode, fun_inner, fun_name);
+                        free(fun_name);
                         if (fnode == NULL) {
                                 ddf_msg(LVL_ERROR, "Failed creating function.");
@@ -516 +567 @@
                         }
                         
-                        free(fun_name);
                         fun->fnode = fnode;
                         
@@ -691 +741 @@
         fun->dev = dev;
         fun->fn = fn;
+        fun->vendor_id = pci_conf_read_16(fun, PCI_VENDOR_ID);
+        fun->device_id = pci_conf_read_16(fun, PCI_DEVICE_ID);
+        fun->class_code = pci_conf_read_8(fun, PCI_BASE_CLASS);
+        fun->subclass_code = pci_conf_read_8(fun, PCI_SUB_CLASS);
+        fun->prog_if = pci_conf_read_8(fun, PCI_PROG_IF);
+        fun->revision = pci_conf_read_8(fun, PCI_REVISION_ID);
 }
 
@@ -711 +767 @@
 bool pci_alloc_resource_list(pci_fun_t *fun)
 {
-        fun->hw_resources.resources =
-            (hw_resource_t *) malloc(PCI_MAX_HW_RES * sizeof(hw_resource_t));
-        return fun->hw_resources.resources != NULL;
+        fun->hw_resources.resources = fun->resources;
+        return true;
 }
 
 void pci_clean_resource_list(pci_fun_t *fun)
 {
-        if (fun->hw_resources.resources != NULL) {
-                free(fun->hw_resources.resources);
-                fun->hw_resources.resources = NULL;
-        }
+        fun->hw_resources.resources = NULL;
 }
 

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

@@ -60 +60 @@
         int vendor_id;
         int device_id;
+        uint8_t class_code;
+        uint8_t subclass_code;
+        uint8_t prog_if;
+        uint8_t revision;
         hw_resource_list_t hw_resources;
+        hw_resource_t resources[PCI_MAX_HW_RES];
 } pci_fun_t;
 

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

@@ -56 +56 @@
  * @return Error code.
  */
-static int request_address(ddf_fun_t *fun, usb_speed_t speed,
-    usb_address_t *address)
+static int request_address(ddf_fun_t *fun, usb_address_t *address, bool strict,
+    usb_speed_t speed)
 {
         UNSUPPORTED("request_address");
@@ -120 +120 @@
  */
 static int register_endpoint(ddf_fun_t *fun,
-    usb_address_t address, usb_speed_t speed, usb_endpoint_t endpoint,
+    usb_address_t address, usb_endpoint_t endpoint,
     usb_transfer_type_t transfer_type, usb_direction_t direction,
     size_t max_packet_size, unsigned int interval)

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

@@ -127 +127 @@
         assert(hub_fun);
 
-        const usb_address_t hub_address =
-            usb_device_manager_get_free_address(
-                &instance->generic.dev_manager, USB_SPEED_FULL);
-        if (hub_address <= 0) {
+        /* Try to get address 1 for root hub. */
+        instance->rh.address = 1;
+        int ret = usb_device_manager_request_address(
+            &instance->generic.dev_manager, &instance->rh.address, false,
+            USB_SPEED_FULL);
+        if (ret != EOK) {
                 usb_log_error("Failed to get OHCI root hub address: %s\n",
-                    str_error(hub_address));
-                return hub_address;
-        }
-        instance->rh.address = hub_address;
-        usb_device_manager_bind(
-            &instance->generic.dev_manager, hub_address, hub_fun->handle);
+                    str_error(ret));
+                return ret;
+        }
+        usb_device_manager_bind_address(&instance->generic.dev_manager,
+            instance->rh.address, hub_fun->handle);
 
 #define CHECK_RET_UNREG_RETURN(ret, message...) \
@@ -143 +144 @@
         usb_log_error(message); \
         usb_endpoint_manager_remove_ep( \
-            &instance->generic.ep_manager, hub_address, 0, USB_DIRECTION_BOTH, \
-            NULL, NULL);\
-        usb_device_manager_release( \
-            &instance->generic.dev_manager, hub_address); \
+            &instance->generic.ep_manager, instance->rh.address, 0, \
+            USB_DIRECTION_BOTH, NULL, NULL); \
+        usb_device_manager_release_address( \
+            &instance->generic.dev_manager, instance->rh.address); \
         return ret; \
 } else (void)0
-        int ret = usb_endpoint_manager_add_ep(
-            &instance->generic.ep_manager, hub_address, 0, USB_DIRECTION_BOTH,
-            USB_TRANSFER_CONTROL, USB_SPEED_FULL, 64, 0, NULL, NULL);
+        ret = usb_endpoint_manager_add_ep(
+            &instance->generic.ep_manager, instance->rh.address, 0,
+            USB_DIRECTION_BOTH, USB_TRANSFER_CONTROL, USB_SPEED_FULL, 64,
+            0, NULL, NULL);
         CHECK_RET_UNREG_RETURN(ret,
             "Failed to register root hub control endpoint: %s.\n",
@@ -193 +195 @@
         list_initialize(&instance->pending_batches);
 
-        hcd_init(&instance->generic, BANDWIDTH_AVAILABLE_USB11,
-            bandwidth_count_usb11);
+        hcd_init(&instance->generic, USB_SPEED_FULL,
+            BANDWIDTH_AVAILABLE_USB11, bandwidth_count_usb11);
         instance->generic.private_data = instance;
         instance->generic.schedule = hc_schedule;

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

@@ -76 +76 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Get address of the device identified by handle.
- *
- * @param[in] dev DDF instance of the device to use.
- * @param[in] iid (Unused).
- * @param[in] call Pointer to the call that represents interrupt.
- */
-static int usb_iface_get_address(
-    ddf_fun_t *fun, devman_handle_t handle, usb_address_t *address)
+/** Get USB address assigned to root hub.
+ *
+ * @param[in] fun Root hub function.
+ * @param[out] address Store the address here.
+ * @return Error code.
+ */
+static int rh_get_my_address(ddf_fun_t *fun, usb_address_t *address)
 {
         assert(fun);
-        usb_device_manager_t *manager =
-            &dev_to_ohci(fun->dev)->hc.generic.dev_manager;
-
-        const usb_address_t addr =
-            usb_device_manager_find_address(manager, handle);
-        if (addr < 0) {
-                return addr;
-        }
 
         if (address != NULL) {
-                *address = addr;
+                *address = dev_to_ohci(fun->dev)->hc.rh.address;
         }
 
@@ -108 +99 @@
  * @return Error code.
  */
-static int usb_iface_get_hc_handle(
+static int rh_get_hc_handle(
     ddf_fun_t *fun, devman_handle_t *handle)
 {
@@ -122 +113 @@
 /** Root hub USB interface */
 static usb_iface_t usb_iface = {
-        .get_hc_handle = usb_iface_get_hc_handle,
-        .get_address = usb_iface_get_address
+        .get_hc_handle = rh_get_hc_handle,
+        .get_my_address = rh_get_my_address,
 };
 /*----------------------------------------------------------------------------*/

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

@@ -199 +199 @@
 #undef CHECK_RET_RETURN
 
-        hcd_init(&instance->generic, BANDWIDTH_AVAILABLE_USB11,
-            bandwidth_count_usb11);
+        hcd_init(&instance->generic, USB_SPEED_FULL,
+            BANDWIDTH_AVAILABLE_USB11, bandwidth_count_usb11);
 
         instance->generic.private_data = instance;

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

@@ -89 +89 @@
 };
 /*----------------------------------------------------------------------------*/
-/** Get address of the device identified by handle.
- *
- * @param[in] fun DDF instance of the function to use.
- * @param[in] handle DDF handle of the driver seeking its USB address.
- * @param[out] address Found address.
- */
-static int usb_iface_get_address(
-    ddf_fun_t *fun, devman_handle_t handle, usb_address_t *address)
-{
-        assert(fun);
-        usb_device_manager_t *manager =
-            &dev_to_uhci(fun->dev)->hc.generic.dev_manager;
-        const usb_address_t addr =
-            usb_device_manager_find_address(manager, handle);
-
-        if (addr < 0) {
-                return addr;
-        }
-
-        if (address != NULL) {
-                *address = addr;
-        }
-
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
 /** Gets handle of the respective hc.
  *
@@ -135 +109 @@
 static usb_iface_t usb_iface = {
         .get_hc_handle = usb_iface_get_hc_handle,
-        .get_address = usb_iface_get_address
 };
 /*----------------------------------------------------------------------------*/

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

@@ -74 +74 @@
 }
 
-/** Callback when new device is about to be removed.
- *
- * @param dev Representation of a generic DDF device.
- * @return Error code.
- */
-static int usbfallback_device_remove(usb_device_t *dev)
-{
-        return EOK;
-}
-
 /** Callback when new device is removed and recognized as gone by DDF.
  *
@@ -107 +97 @@
 static const usb_driver_ops_t usbfallback_driver_ops = {
         .device_add = usbfallback_device_add,
-        .device_rem = usbfallback_device_remove,
+        .device_rem = usbfallback_device_gone,
         .device_gone = usbfallback_device_gone,
 };

uspace/drv/bus/usb/usbhid/generic/hiddev.c

@@ -61 +61 @@
 
 /*----------------------------------------------------------------------------*/
-
 static size_t usb_generic_hid_get_event_length(ddf_fun_t *fun);
-
-static int usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer, 
+static int usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer,
     size_t size, size_t *act_size, int *event_nr, unsigned int flags);
-
 static int usb_generic_hid_client_connected(ddf_fun_t *fun);
-
 static size_t usb_generic_get_report_descriptor_length(ddf_fun_t *fun);
-
-static int usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc, 
+static int usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc,
     size_t size, size_t *actual_size);
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 static usbhid_iface_t usb_generic_iface = {
         .get_event = usb_generic_hid_get_event,
@@ -82 +75 @@
         .get_report_descriptor = usb_generic_get_report_descriptor
 };
-
+/*----------------------------------------------------------------------------*/
 static ddf_dev_ops_t usb_generic_hid_ops = {
         .interfaces[USBHID_DEV_IFACE] = &usb_generic_iface,
         .open = usb_generic_hid_client_connected
 };
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 static size_t usb_generic_hid_get_event_length(ddf_fun_t *fun)
 {
@@ -99 +90 @@
         }
 
-        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
+        const usb_hid_dev_t *hid_dev = fun->driver_data;
 
         usb_log_debug2("hid_dev: %p, Max input report size (%zu).\n",
@@ -106 +97 @@
         return hid_dev->max_input_report_size;
 }
-
-/*----------------------------------------------------------------------------*/
-
-static int usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer, 
+/*----------------------------------------------------------------------------*/
+static int usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer,
     size_t size, size_t *act_size, int *event_nr, unsigned int flags)
 {
@@ -120 +109 @@
         }
 
-        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
+        const usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
 
         if (hid_dev->input_report_size > size) {
-                usb_log_debug("input_report_size > size (%zu, %zu)\n", 
+                usb_log_debug("input_report_size > size (%zu, %zu)\n",
                     hid_dev->input_report_size, size);
                 return EINVAL;  // TODO: other error code
@@ -129 +118 @@
 
         /*! @todo This should probably be somehow atomic. */
-        memcpy(buffer, hid_dev->input_report, 
+        memcpy(buffer, hid_dev->input_report,
             hid_dev->input_report_size);
         *act_size = hid_dev->input_report_size;
@@ -138 +127 @@
         return EOK;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 static size_t usb_generic_get_report_descriptor_length(ddf_fun_t *fun)
 {
@@ -150 +137 @@
         }
 
-        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
-
-        usb_log_debug2("hid_dev->report_desc_size = %zu\n", 
+        const usb_hid_dev_t *hid_dev = fun->driver_data;
+
+        usb_log_debug2("hid_dev->report_desc_size = %zu\n",
             hid_dev->report_desc_size);
 
         return hid_dev->report_desc_size;
 }
-
-/*----------------------------------------------------------------------------*/
-
-static int usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc, 
+/*----------------------------------------------------------------------------*/
+static int usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc,
     size_t size, size_t *actual_size)
 {
@@ -170 +155 @@
         }
 
-        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
+        const usb_hid_dev_t *hid_dev = fun->driver_data;
 
         if (hid_dev->report_desc_size > size) {
@@ -181 +166 @@
         return EOK;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 static int usb_generic_hid_client_connected(ddf_fun_t *fun)
 {
@@ -189 +172 @@
         return EOK;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 void usb_generic_hid_deinit(usb_hid_dev_t *hid_dev, void *data)
 {
         ddf_fun_t *fun = data;
-        const int ret = ddf_fun_unbind(fun);
-        if (ret != EOK) {
+        if (fun == NULL)
+                return;
+
+        if (ddf_fun_unbind(fun) != EOK) {
                 usb_log_error("Failed to unbind generic hid fun.\n");
                 return;
@@ -206 +189 @@
         ddf_fun_destroy(fun);
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 int usb_generic_hid_init(usb_hid_dev_t *hid_dev, void **data)
 {
@@ -216 +197 @@
 
         /* Create the exposed function. */
-        /** @todo Generate numbers for the devices? */
         usb_log_debug("Creating DDF function %s...\n", HID_GENERIC_FUN_NAME);
         ddf_fun_t *fun = ddf_fun_create(hid_dev->usb_dev->ddf_dev, fun_exposed, 
@@ -225 +205 @@
         }
 
+        /* This is nasty, both device and this function have the same
+         * driver data, thus destruction causes to double free */
+        fun->driver_data = hid_dev;
         fun->ops = &usb_generic_hid_ops;
 
@@ -231 +214 @@
                 usb_log_error("Could not bind DDF function: %s.\n",
                     str_error(rc));
+                fun->driver_data = NULL;
                 ddf_fun_destroy(fun);
                 return rc;
         }
-        /* This is nasty both device and this function have the same
-         * driver data, thus destruction would lead to double free */
-        fun->driver_data = hid_dev;
 
         usb_log_debug("HID function created. Handle: %" PRIun "\n", fun->handle);
@@ -243 +224 @@
         return EOK;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 bool usb_generic_hid_polling_callback(usb_hid_dev_t *hid_dev, void *data)
 {
         return true;
 }
-
 /**
  * @}

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

@@ -41 +41 @@
 #include <io/keycode.h>
 #include <io/console.h>
+#include <abi/ipc/methods.h>
 #include <ipc/kbdev.h>
 #include <async.h>
@@ -86 +87 @@
 
 /*----------------------------------------------------------------------------*/
-
 /** Keyboard polling endpoint description for boot protocol class. */
 const usb_endpoint_description_t usb_hid_kbd_poll_endpoint_description = {
@@ -101 +101 @@
 
 static void usb_kbd_set_led(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev);
-
-/*----------------------------------------------------------------------------*/
-
-enum {
-        USB_KBD_BOOT_REPORT_DESCRIPTOR_SIZE = 63
+/*----------------------------------------------------------------------------*/
+static const uint8_t USB_KBD_BOOT_REPORT_DESCRIPTOR[] = {
+        0x05, 0x01,  /* Usage Page (Generic Desktop), */
+        0x09, 0x06,  /* Usage (Keyboard), */
+        0xA1, 0x01,  /* Collection (Application), */
+        0x75, 0x01,  /*   Report Size (1), */
+        0x95, 0x08,  /*   Report Count (8), */
+        0x05, 0x07,  /*   Usage Page (Key Codes); */
+        0x19, 0xE0,  /*   Usage Minimum (224), */
+        0x29, 0xE7,  /*   Usage Maximum (231), */
+        0x15, 0x00,  /*   Logical Minimum (0), */
+        0x25, 0x01,  /*   Logical Maximum (1), */
+        0x81, 0x02,  /*   Input (Data, Variable, Absolute),  ; Modifier byte */
+        0x95, 0x01,  /*   Report Count (1), */
+        0x75, 0x08,  /*   Report Size (8), */
+        0x81, 0x01,  /*   Input (Constant),                  ; Reserved byte */
+        0x95, 0x05,  /*   Report Count (5), */
+        0x75, 0x01,  /*   Report Size (1), */
+        0x05, 0x08,  /*   Usage Page (Page# for LEDs), */
+        0x19, 0x01,  /*   Usage Minimum (1), */
+        0x29, 0x05,  /*   Usage Maxmimum (5), */
+        0x91, 0x02,  /*   Output (Data, Variable, Absolute),  ; LED report */
+        0x95, 0x01,  /*   Report Count (1), */
+        0x75, 0x03,  /*   Report Size (3), */
+        0x91, 0x01,  /*   Output (Constant),            ; LED report padding */
+        0x95, 0x06,  /*   Report Count (6), */
+        0x75, 0x08,  /*   Report Size (8), */
+        0x15, 0x00,  /*   Logical Minimum (0), */
+        0x25, 0xff,  /*   Logical Maximum (255), */
+        0x05, 0x07,  /*   Usage Page (Key Codes), */
+        0x19, 0x00,  /*   Usage Minimum (0), */
+        0x29, 0xff,  /*   Usage Maximum (255), */
+        0x81, 0x00,  /*   Input (Data, Array),   ; Key arrays (6 bytes) */
+        0xC0         /* End Collection */
 };
-
-static const uint8_t USB_KBD_BOOT_REPORT_DESCRIPTOR[
-    USB_KBD_BOOT_REPORT_DESCRIPTOR_SIZE] = {
-        0x05, 0x01,  // Usage Page (Generic Desktop),
-        0x09, 0x06,  // Usage (Keyboard),
-        0xA1, 0x01,  // Collection (Application),
-        0x75, 0x01,  //   Report Size (1),
-        0x95, 0x08,  //   Report Count (8),       
-        0x05, 0x07,  //   Usage Page (Key Codes);
-        0x19, 0xE0,  //   Usage Minimum (224),
-        0x29, 0xE7,  //   Usage Maximum (231),
-        0x15, 0x00,  //   Logical Minimum (0),
-        0x25, 0x01,  //   Logical Maximum (1),
-        0x81, 0x02,  //   Input (Data, Variable, Absolute),   ; Modifier byte
-        0x95, 0x01,  //   Report Count (1),
-        0x75, 0x08,  //   Report Size (8),
-        0x81, 0x01,  //   Input (Constant),                   ; Reserved byte
-        0x95, 0x05,  //   Report Count (5),
-        0x75, 0x01,  //   Report Size (1),
-        0x05, 0x08,  //   Usage Page (Page# for LEDs),
-        0x19, 0x01,  //   Usage Minimum (1),
-        0x29, 0x05,  //   Usage Maxmimum (5),
-        0x91, 0x02,  //   Output (Data, Variable, Absolute),  ; LED report
-        0x95, 0x01,  //   Report Count (1),
-        0x75, 0x03,  //   Report Size (3),
-        0x91, 0x01,  //   Output (Constant),              ; LED report padding
-        0x95, 0x06,  //   Report Count (6),
-        0x75, 0x08,  //   Report Size (8),
-        0x15, 0x00,  //   Logical Minimum (0),
-        0x25, 0xff,  //   Logical Maximum (255),
-        0x05, 0x07,  //   Usage Page (Key Codes),
-        0x19, 0x00,  //   Usage Minimum (0),
-        0x29, 0xff,  //   Usage Maximum (255),
-        0x81, 0x00,  //   Input (Data, Array),            ; Key arrays (6 bytes)
-        0xC0           // End Collection
-
-};
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 typedef enum usb_kbd_flags {
         USB_KBD_STATUS_UNINITIALIZED = 0,
@@ -152 +142 @@
         USB_KBD_STATUS_TO_DESTROY = -1
 } usb_kbd_flags;
-
 /*----------------------------------------------------------------------------*/
 /* IPC method handler                                                         */
 /*----------------------------------------------------------------------------*/
-
-static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
-
 /**
  * Default handler for IPC methods not handled by DDF.
  *
- * Currently recognizes only one method (IPC_M_CONNECT_TO_ME), in which case it
- * assumes the caller is the console and thus it stores IPC session to it for
- * later use by the driver to notify about key events.
+ * Currently recognizes only two methods (IPC_M_CONNECT_TO_ME and KBDEV_SET_IND)
+ * IPC_M_CONNECT_TO_ME assumes the caller is the console and  stores IPC
+ * session to it for later use by the driver to notify about key events.
+ * KBDEV_SET_IND sets LED keyboard indicators.
  *
  * @param fun Device function handling the call.
@@ -173 +160 @@
     ipc_callid_t icallid, ipc_call_t *icall)
 {
-        sysarg_t method = IPC_GET_IMETHOD(*icall);
-
-        usb_kbd_t *kbd_dev = (usb_kbd_t *) fun->driver_data;
-        if (kbd_dev == NULL) {
-                usb_log_debug("default_connection_handler: "
-                    "Missing parameter.\n");
+        if (fun == NULL || fun->driver_data == NULL) {
+                usb_log_error("%s: Missing parameter.\n", __FUNCTION__);
                 async_answer_0(icallid, EINVAL);
                 return;
         }
 
-        async_sess_t *sess =
-            async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
-        if (sess != NULL) {
+        const sysarg_t method = IPC_GET_IMETHOD(*icall);
+        usb_kbd_t *kbd_dev = fun->driver_data;
+
+        switch (method) {
+        case KBDEV_SET_IND:
+                kbd_dev->mods = IPC_GET_ARG1(*icall);
+                usb_kbd_set_led(kbd_dev->hid_dev, kbd_dev);
+                async_answer_0(icallid, EOK);
+                break;
+        /* This might be ugly but async_callback_receive_start makes no
+         * difference for incorrect call and malloc failure. */
+        case IPC_M_CONNECT_TO_ME: {
+                async_sess_t *sess =
+                    async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
+                /* Probably ENOMEM error, try again. */
+                if (sess == NULL) {
+                        usb_log_warning(
+                            "Failed to create start console session.\n");
+                        async_answer_0(icallid, EAGAIN);
+                        break;
+                }
                 if (kbd_dev->console_sess == NULL) {
                         kbd_dev->console_sess = sess;
-                        usb_log_debug("default_connection_handler: OK\n");
+                        usb_log_debug("%s: OK\n", __FUNCTION__);
                         async_answer_0(icallid, EOK);
                 } else {
-                        usb_log_debug("default_connection_handler: "
-                            "console session already set\n");
+                        usb_log_error("%s: console session already set\n",
+                           __FUNCTION__);
                         async_answer_0(icallid, ELIMIT);
                 }
-        } else {
-                switch (method) {
-                case KBDEV_SET_IND:
-                        kbd_dev->mods = IPC_GET_ARG1(*icall);
-                        usb_kbd_set_led(kbd_dev->hid_dev, kbd_dev);
-                        async_answer_0(icallid, EOK);
-                        break;
-                default:
-                        usb_log_debug("default_connection_handler: Wrong function.\n");
+                break;
+        }
+        default:
+                        usb_log_error("%s: Unknown method: %d.\n",
+                            __FUNCTION__, (int) method);
                         async_answer_0(icallid, EINVAL);
                         break;
-                }
-        }
-}
-
+        }
+
+}
 /*----------------------------------------------------------------------------*/
 /* Key processing functions                                                   */
@@ -226 +222 @@
  * @param kbd_dev Keyboard device structure.
  */
-static void usb_kbd_set_led(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev) 
+static void usb_kbd_set_led(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev)
 {
         if (kbd_dev->output_size == 0) {
@@ -274 +270 @@
         }
 
-        usb_log_debug("Output report buffer: %s\n", 
-            usb_debug_str_buffer(kbd_dev->output_buffer, kbd_dev->output_size, 
+        usb_log_debug("Output report buffer: %s\n",
+            usb_debug_str_buffer(kbd_dev->output_buffer, kbd_dev->output_size,
                 0));
 
-        usbhid_req_set_report(&hid_dev->usb_dev->ctrl_pipe, 
-            hid_dev->usb_dev->interface_no, USB_HID_REPORT_TYPE_OUTPUT, 
+        rc = usbhid_req_set_report(&hid_dev->usb_dev->ctrl_pipe,
+            hid_dev->usb_dev->interface_no, USB_HID_REPORT_TYPE_OUTPUT,
             kbd_dev->output_buffer, kbd_dev->output_size);
-}
-
+        if (rc != EOK) {
+                usb_log_warning("Failed to set kbd indicators.\n");
+        }
+}
 /*----------------------------------------------------------------------------*/
 /** Send key event.
@@ -291 +289 @@
  * @param key Key code
  */
-void usb_kbd_push_ev(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev, int type, 
-    unsigned int key)
+void usb_kbd_push_ev(usb_kbd_t *kbd_dev, int type, unsigned key)
 {
         usb_log_debug2("Sending kbdev event %d/%d to the console\n", type, key);
@@ -302 +299 @@
 
         async_exch_t *exch = async_exchange_begin(kbd_dev->console_sess);
-        async_msg_2(exch, KBDEV_EVENT, type, key);
-        async_exchange_end(exch);
-}
-
-/*----------------------------------------------------------------------------*/
-
-static inline int usb_kbd_is_lock(unsigned int key_code) 
+        if (exch != NULL) {
+                async_msg_2(exch, KBDEV_EVENT, type, key);
+                async_exchange_end(exch);
+        } else {
+                usb_log_warning("Failed to send key to console.\n");
+        }
+}
+/*----------------------------------------------------------------------------*/
+static inline int usb_kbd_is_lock(unsigned int key_code)
 {
         return (key_code == KC_NUM_LOCK
@@ -314 +313 @@
             || key_code == KC_CAPS_LOCK);
 }
-
+/*----------------------------------------------------------------------------*/
 static size_t find_in_array_int32(int32_t val, int32_t *arr, size_t arr_size)
 {
@@ -325 +324 @@
         return (size_t) -1;
 }
-
 /*----------------------------------------------------------------------------*/
 /**
@@ -342 +340 @@
  * @sa usb_kbd_push_ev(), usb_kbd_repeat_start(), usb_kbd_repeat_stop()
  */
-static void usb_kbd_check_key_changes(usb_hid_dev_t *hid_dev, 
+static void usb_kbd_check_key_changes(usb_hid_dev_t *hid_dev,
     usb_kbd_t *kbd_dev)
 {
-        unsigned int key;
-        size_t i;
 
         /*
@@ -356 +352 @@
          * whole input report.
          */
-        i = find_in_array_int32(ERROR_ROLLOVER, kbd_dev->keys,
+        size_t i = find_in_array_int32(ERROR_ROLLOVER, kbd_dev->keys,
             kbd_dev->key_count);
         if (i != (size_t) -1) {
-                usb_log_debug("Detected phantom state.\n");
+                usb_log_error("Detected phantom state.\n");
                 return;
         }
@@ -367 +363 @@
          */
         for (i = 0; i < kbd_dev->key_count; i++) {
-                int32_t old_key = kbd_dev->keys_old[i];
+                const int32_t old_key = kbd_dev->keys_old[i];
                 /* Find the old key among currently pressed keys. */
-                size_t pos = find_in_array_int32(old_key, kbd_dev->keys,
+                const size_t pos = find_in_array_int32(old_key, kbd_dev->keys,
                     kbd_dev->key_count);
                 /* If the key was not found, we need to signal release. */
                 if (pos == (size_t) -1) {
-                        key = usbhid_parse_scancode(old_key);
+                        const unsigned key = usbhid_parse_scancode(old_key);
                         if (!usb_kbd_is_lock(key)) {
                                 usb_kbd_repeat_stop(kbd_dev, key);
                         }
-                        usb_kbd_push_ev(hid_dev, kbd_dev, KEY_RELEASE, key);
+                        usb_kbd_push_ev(kbd_dev, KEY_RELEASE, key);
                         usb_log_debug2("Key released: %u "
                             "(USB code %" PRIu32 ")\n", key, old_key);
@@ -387 +383 @@
          */
         for (i = 0; i < kbd_dev->key_count; ++i) {
-                int32_t new_key = kbd_dev->keys[i];
+                const int32_t new_key = kbd_dev->keys[i];
                 /* Find the new key among already pressed keys. */
-                size_t pos = find_in_array_int32(new_key, kbd_dev->keys_old,
-                    kbd_dev->key_count);
+                const size_t pos = find_in_array_int32(new_key,
+                    kbd_dev->keys_old, kbd_dev->key_count);
                 /* If the key was not found, we need to signal press. */
                 if (pos == (size_t) -1) {
-                        key = usbhid_parse_scancode(kbd_dev->keys[i]);
+                        unsigned key = usbhid_parse_scancode(kbd_dev->keys[i]);
                         if (!usb_kbd_is_lock(key)) {
                                 usb_kbd_repeat_start(kbd_dev, key);
                         }
-                        usb_kbd_push_ev(hid_dev, kbd_dev, KEY_PRESS, key);
+                        usb_kbd_push_ev(kbd_dev, KEY_PRESS, key);
                         usb_log_debug2("Key pressed: %u "
                             "(USB code %" PRIu32 ")\n", key, new_key);
@@ -405 +401 @@
         memcpy(kbd_dev->keys_old, kbd_dev->keys, kbd_dev->key_count * 4);
 
+        // TODO Get rid of this
         char key_buffer[512];
         ddf_dump_buffer(key_buffer, 512,
@@ -410 +407 @@
         usb_log_debug2("Stored keys %s.\n", key_buffer);
 }
-
 /*----------------------------------------------------------------------------*/
 /* General kbd functions                                                      */
@@ -436 +432 @@
 
         usb_hid_report_path_t *path = usb_hid_report_path();
-        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
-
-        usb_hid_report_path_set_report_id (path, hid_dev->report_id);
-
-        // fill in the currently pressed keys
-
+        if (path == NULL) {
+                usb_log_error("Failed to create hid/kbd report path.\n");
+                return;
+        }
+
+        int ret =
+           usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
+        if (ret != EOK) {
+                usb_log_error("Failed to append to hid/kbd report path.\n");
+                return;
+        }
+
+        usb_hid_report_path_set_report_id(path, hid_dev->report_id);
+
+        /* Fill in the currently pressed keys. */
         usb_hid_report_field_t *field = usb_hid_report_get_sibling(
             &hid_dev->report, NULL, path,
@@ -449 +454 @@
 
         while (field != NULL) {
-                usb_log_debug2("FIELD (%p) - VALUE(%d) USAGE(%u)\n", 
+                usb_log_debug2("FIELD (%p) - VALUE(%d) USAGE(%u)\n",
                     field, field->value, field->usage);
-                
+
                 assert(i < kbd_dev->key_count);
 
-                // save the key usage
+                /* Save the key usage. */
                 if (field->value != 0) {
                         kbd_dev->keys[i] = field->usage;
@@ -474 +479 @@
         usb_kbd_check_key_changes(hid_dev, kbd_dev);
 }
-
 /*----------------------------------------------------------------------------*/
 /* HID/KBD structure manipulation                                             */
 /*----------------------------------------------------------------------------*/
-
-static void usb_kbd_mark_unusable(usb_kbd_t *kbd_dev)
-{
-        kbd_dev->initialized = USB_KBD_STATUS_TO_DESTROY;
-}
-
-/*----------------------------------------------------------------------------*/
-
-/**
- * Creates a new USB/HID keyboard structure.
- *
- * The structure returned by this function is not initialized. Use 
- * usb_kbd_init() to initialize it prior to polling.
- *
- * @return New uninitialized structure for representing a USB/HID keyboard or
- *         NULL if not successful (memory error).
- */
-static usb_kbd_t *usb_kbd_new(void)
-{
-        usb_kbd_t *kbd_dev = 
-            (usb_kbd_t *)calloc(1, sizeof(usb_kbd_t));
-
-        if (kbd_dev == NULL) {
-                usb_log_error("No memory!\n");
-                return NULL;
-        }
-
-        kbd_dev->console_sess = NULL;
-        kbd_dev->initialized = USB_KBD_STATUS_UNINITIALIZED;
-
-        return kbd_dev;
-}
-
-/*----------------------------------------------------------------------------*/
-
 static int usb_kbd_create_function(usb_kbd_t *kbd_dev)
 {
@@ -528 +497 @@
         }
 
-        /*
-         * Store the initialized HID device and HID ops
-         * to the DDF function.
-         */
+        /* Store the initialized HID device and HID ops
+         * to the DDF function. */
         fun->ops = &kbd_dev->ops;
         fun->driver_data = kbd_dev;
@@ -539 +506 @@
                 usb_log_error("Could not bind DDF function: %s.\n",
                     str_error(rc));
-                fun->driver_data = NULL; /* We need this later */
+                fun->driver_data = NULL; /* We did not allocate this. */
                 ddf_fun_destroy(fun);
                 return rc;
@@ -547 +514 @@
             HID_KBD_FUN_NAME, fun->handle);
 
-        usb_log_debug("Adding DDF function to category %s...\n", 
+        usb_log_debug("Adding DDF function to category %s...\n",
             HID_KBD_CLASS_NAME);
         rc = ddf_fun_add_to_category(fun, HID_KBD_CATEGORY_NAME);
@@ -554 +521 @@
                     "Could not add DDF function to category %s: %s.\n",
                     HID_KBD_CLASS_NAME, str_error(rc));
-                fun->driver_data = NULL; /* We need this later */
-                ddf_fun_destroy(fun);
+                if (ddf_fun_unbind(fun) == EOK) {
+                        fun->driver_data = NULL; /* We did not allocate this. */
+                        ddf_fun_destroy(fun);
+                } else {
+                        usb_log_error(
+                            "Failed to unbind `%s', will not destroy.\n",
+                            fun->name);
+                }
                 return rc;
         }
@@ -562 +535 @@
         return EOK;
 }
-
 /*----------------------------------------------------------------------------*/
 /* API functions                                                              */
@@ -591 +563 @@
 
         if (hid_dev == NULL) {
-                usb_log_error("Failed to init keyboard structure: no structure"
-                    " given.\n");
+                usb_log_error(
+                    "Failed to init keyboard structure: no structure given.\n");
                 return EINVAL;
         }
 
-        usb_kbd_t *kbd_dev = usb_kbd_new();
+        usb_kbd_t *kbd_dev = calloc(1, sizeof(usb_kbd_t));
         if (kbd_dev == NULL) {
-                usb_log_error("Error while creating USB/HID KBD device "
-                    "structure.\n");
-                return ENOMEM;  // TODO: some other code??
-        }
+                usb_log_error("Failed to allocate KBD device structure.\n");
+                return ENOMEM;
+        }
+        /* Default values */
+        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 */
         kbd_dev->hid_dev = hid_dev;
 
-        /*
-         * TODO: make more general
-         */
+        /* Modifiers and locks */
+        kbd_dev->mods = DEFAULT_ACTIVE_MODS;
+
+        /* Autorepeat */
+        kbd_dev->repeat.delay_before = DEFAULT_DELAY_BEFORE_FIRST_REPEAT;
+        kbd_dev->repeat.delay_between = DEFAULT_REPEAT_DELAY;
+
+
+        // TODO: make more general
         usb_hid_report_path_t *path = usb_hid_report_path();
-        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
+        if (path == NULL) {
+                usb_log_error("Failed to create kbd report path.\n");
+                usb_kbd_destroy(kbd_dev);
+                return ENOMEM;
+        }
+
+        int ret =
+            usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
+        if (ret != EOK) {
+                usb_log_error("Failed to append item to kbd report path.\n");
+                usb_hid_report_path_free(path);
+                usb_kbd_destroy(kbd_dev);
+                return ret;
+        }
 
         usb_hid_report_path_set_report_id(path, 0);
 
-        kbd_dev->key_count = usb_hid_report_size(
-            &hid_dev->report, 0, USB_HID_REPORT_TYPE_INPUT);
+        kbd_dev->key_count =
+            usb_hid_report_size(&hid_dev->report, 0, USB_HID_REPORT_TYPE_INPUT);
+
         usb_hid_report_path_free(path);
 
@@ -621 +616 @@
 
         kbd_dev->keys = calloc(kbd_dev->key_count, sizeof(int32_t));
-
         if (kbd_dev->keys == NULL) {
-                usb_log_error("No memory!\n");
-                free(kbd_dev);
+                usb_log_error("Failed to allocate key buffer.\n");
+                usb_kbd_destroy(kbd_dev);
                 return ENOMEM;
         }
 
-        kbd_dev->keys_old = 
-                (int32_t *)calloc(kbd_dev->key_count, sizeof(int32_t));
-
+        kbd_dev->keys_old = calloc(kbd_dev->key_count, sizeof(int32_t));
         if (kbd_dev->keys_old == NULL) {
-                usb_log_error("No memory!\n");
-                free(kbd_dev->keys);
-                free(kbd_dev);
+                usb_log_error("Failed to allocate old_key buffer.\n");
+                usb_kbd_destroy(kbd_dev);
                 return ENOMEM;
         }
 
-        /*
-         * Output report
-         */
+        /* Output report */
         kbd_dev->output_size = 0;
         kbd_dev->output_buffer = usb_hid_report_output(&hid_dev->report,
             &kbd_dev->output_size, 0);
         if (kbd_dev->output_buffer == NULL) {
-                usb_log_warning("Error creating output report buffer.\n");
-                free(kbd_dev->keys);
+                usb_log_error("Error creating output report buffer.\n");
+                usb_kbd_destroy(kbd_dev);
                 return ENOMEM;
         }
@@ -653 +642 @@
 
         kbd_dev->led_path = usb_hid_report_path();
-        usb_hid_report_path_append_item(
+        if (kbd_dev->led_path == NULL) {
+                usb_log_error("Failed to create kbd led report path.\n");
+                usb_kbd_destroy(kbd_dev);
+                return ENOMEM;
+        }
+
+        ret = usb_hid_report_path_append_item(
             kbd_dev->led_path, USB_HIDUT_PAGE_LED, 0);
+        if (ret != EOK) {
+                usb_log_error("Failed to append to kbd/led report path.\n");
+                usb_kbd_destroy(kbd_dev);
+                return ret;
+        }
 
         kbd_dev->led_output_size = usb_hid_report_size(
             &hid_dev->report, 0, USB_HID_REPORT_TYPE_OUTPUT);
 
-        usb_log_debug("Output report size (in items): %zu\n", 
+        usb_log_debug("Output report size (in items): %zu\n",
             kbd_dev->led_output_size);
 
-        kbd_dev->led_data = (int32_t *)calloc(
-            kbd_dev->led_output_size, sizeof(int32_t));
-
+        kbd_dev->led_data = calloc(kbd_dev->led_output_size, sizeof(int32_t));
         if (kbd_dev->led_data == NULL) {
-                usb_log_warning("Error creating buffer for LED output report."
-                    "\n");
-                free(kbd_dev->keys);
-                usb_hid_report_output_free(kbd_dev->output_buffer);
-                free(kbd_dev);
+                usb_log_error("Error creating buffer for LED output report.\n");
+                usb_kbd_destroy(kbd_dev);
                 return ENOMEM;
         }
 
-        /*
-         * Modifiers and locks
-         */
-        kbd_dev->modifiers = 0;
-        kbd_dev->mods = DEFAULT_ACTIVE_MODS;
-        kbd_dev->lock_keys = 0;
-
-        /*
-         * Autorepeat
-         */
-        kbd_dev->repeat.key_new = 0;
-        kbd_dev->repeat.key_repeated = 0;
-        kbd_dev->repeat.delay_before = DEFAULT_DELAY_BEFORE_FIRST_REPEAT;
-        kbd_dev->repeat.delay_between = DEFAULT_REPEAT_DELAY;
-
-        fibril_mutex_initialize(&kbd_dev->repeat_mtx);
-
-        // save the KBD device structure into the HID device structure
+        /* Set LEDs according to initial setup.
+         * Set Idle rate */
+        usb_kbd_set_led(hid_dev, kbd_dev);
+
+        usbhid_req_set_idle(&hid_dev->usb_dev->ctrl_pipe,
+            hid_dev->usb_dev->interface_no, IDLE_RATE);
+
+        /* Save the KBD device structure into the HID device structure. */
         *data = kbd_dev;
 
-        // set handler for incoming calls
-        kbd_dev->ops.default_handler = default_connection_handler;
-
-        /*
-         * Set LEDs according to initial setup.
-         * Set Idle rate
-         */
-        usb_kbd_set_led(hid_dev, kbd_dev);
-
-        usbhid_req_set_idle(&hid_dev->usb_dev->ctrl_pipe, 
-            hid_dev->usb_dev->interface_no, IDLE_RATE);
-
-        /*
-         * Create new fibril for auto-repeat
-         */
+        kbd_dev->initialized = USB_KBD_STATUS_INITIALIZED;
+        usb_log_debug("HID/KBD device structure initialized.\n");
+
+        usb_log_debug("Creating KBD function...\n");
+        ret = usb_kbd_create_function(kbd_dev);
+        if (ret != EOK) {
+                usb_kbd_destroy(kbd_dev);
+                return ret;
+        }
+
+        /* Create new fibril for auto-repeat. */
         fid_t fid = fibril_create(usb_kbd_repeat_fibril, kbd_dev);
         if (fid == 0) {
                 usb_log_error("Failed to start fibril for KBD auto-repeat");
+                usb_kbd_destroy(kbd_dev);
                 return ENOMEM;
         }
         fibril_add_ready(fid);
 
-        kbd_dev->initialized = USB_KBD_STATUS_INITIALIZED;
-        usb_log_debug("HID/KBD device structure initialized.\n");
-
-        usb_log_debug("Creating KBD function...\n");
-        int rc = usb_kbd_create_function(kbd_dev);
-        if (rc != EOK) {
-                usb_kbd_destroy(kbd_dev);
-                return rc;
-        }
-
         return EOK;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 bool usb_kbd_polling_callback(usb_hid_dev_t *hid_dev, void *data)
 {
-        if (hid_dev == NULL/* || buffer == NULL*/ || data == NULL) {
-                // do not continue polling (???)
+        if (hid_dev == NULL || data == NULL) {
+                /* This means something serious */
                 return false;
         }
 
-        usb_kbd_t *kbd_dev = (usb_kbd_t *)data;
-        assert(kbd_dev != NULL);
-
+        usb_kbd_t *kbd_dev = data;
         // TODO: add return value from this function
         usb_kbd_process_data(hid_dev, kbd_dev);
@@ -746 +714 @@
         return true;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 int usb_kbd_is_initialized(const usb_kbd_t *kbd_dev)
 {
         return (kbd_dev->initialized == USB_KBD_STATUS_INITIALIZED);
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 int usb_kbd_is_ready_to_destroy(const usb_kbd_t *kbd_dev)
 {
         return (kbd_dev->initialized == USB_KBD_STATUS_TO_DESTROY);
 }
-
 /*----------------------------------------------------------------------------*/
 /**
@@ -773 +736 @@
         }
 
-        // hangup session to the console
-        async_hangup(kbd_dev->console_sess);
+        /* Hangup session to the console. */
+        if (kbd_dev->console_sess)
+                async_hangup(kbd_dev->console_sess);
 
         //assert(!fibril_mutex_is_locked((*kbd_dev)->repeat_mtx));
@@ -781 +745 @@
         while (fibril_mutex_is_locked(&kbd_dev->repeat_mtx)) {}
 
-        // free all buffers
+        /* Free all buffers. */
         free(kbd_dev->keys);
         free(kbd_dev->keys_old);
         free(kbd_dev->led_data);
 
-        if (kbd_dev->led_path != NULL) {
-                usb_hid_report_path_free(kbd_dev->led_path);
-        }
-        if (kbd_dev->output_buffer != NULL) {
-                usb_hid_report_output_free(kbd_dev->output_buffer);
-        }
-
-        if (ddf_fun_unbind(kbd_dev->fun) != EOK) {
-                usb_log_warning("Failed to unbind kbd function.\n");
-        } else {
-                usb_log_debug2("%s unbound.\n", kbd_dev->fun->name);
-                kbd_dev->fun->driver_data = NULL;
-                ddf_fun_destroy(kbd_dev->fun);
-        }
-}
-
-/*----------------------------------------------------------------------------*/
-
+        usb_hid_report_path_free(kbd_dev->led_path);
+        usb_hid_report_output_free(kbd_dev->output_buffer);
+
+        if (kbd_dev->fun) {
+                if (ddf_fun_unbind(kbd_dev->fun) != EOK) {
+                        usb_log_warning("Failed to unbind %s.\n",
+                            kbd_dev->fun->name);
+                } else {
+                        usb_log_debug2("%s unbound.\n", kbd_dev->fun->name);
+                        kbd_dev->fun->driver_data = NULL;
+                        ddf_fun_destroy(kbd_dev->fun);
+                }
+        }
+        free(kbd_dev);
+}
+/*----------------------------------------------------------------------------*/
 void usb_kbd_deinit(usb_hid_dev_t *hid_dev, void *data)
 {
-        if (hid_dev == NULL) {
-                return;
-        }
-
         if (data != NULL) {
                 usb_kbd_t *kbd_dev = data;
                 if (usb_kbd_is_initialized(kbd_dev)) {
-                        usb_kbd_mark_unusable(kbd_dev);
-                        /* wait for autorepeat */
+                        kbd_dev->initialized = USB_KBD_STATUS_TO_DESTROY;
+                        /* Wait for autorepeat */
                         async_usleep(CHECK_DELAY);
-                        usb_kbd_destroy(kbd_dev);
-                }
-        }
-}
-
-/*----------------------------------------------------------------------------*/
-
+                }
+                usb_kbd_destroy(kbd_dev);
+        }
+}
+/*----------------------------------------------------------------------------*/
 int usb_kbd_set_boot_protocol(usb_hid_dev_t *hid_dev)
 {
+        assert(hid_dev);
         int rc = usb_hid_parse_report_descriptor(
             &hid_dev->report, USB_KBD_BOOT_REPORT_DESCRIPTOR,
-            USB_KBD_BOOT_REPORT_DESCRIPTOR_SIZE);
+            sizeof(USB_KBD_BOOT_REPORT_DESCRIPTOR));
 
         if (rc != EOK) {
@@ -846 +803 @@
         return EOK;
 }
-
 /**
  * @}

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

@@ -135 +135 @@
 void usb_kbd_destroy(usb_kbd_t *kbd_dev);
 
-void usb_kbd_push_ev(struct usb_hid_dev *hid_dev, usb_kbd_t *kbd_dev,
+void usb_kbd_push_ev(usb_kbd_t *kbd_dev,
     int type, unsigned int key);
 

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

@@ -45 +45 @@
 #include "kbddev.h"
 
-
-
-/*----------------------------------------------------------------------------*/
 /**
  * Main loop handling the auto-repeat of keys.
@@ -58 +55 @@
  * If the same key is still pressed, it uses the delay between repeats stored
  * in the keyboard structure to wait until the key should be repeated.
- * 
+ *
  * If the currently repeated key is not pressed any more (
- * usb_kbd_repeat_stop() was called), it stops repeating it and starts 
+ * usb_kbd_repeat_stop() was called), it stops repeating it and starts
  * checking again.
  *
  * @note For accessing the keyboard device auto-repeat information a fibril
  *       mutex (repeat_mtx) from the @a kbd structure is used.
- * 
+ *
  * @param kbd Keyboard device structure.
  */
@@ -75 +72 @@
 
         while (true) {
-                // check if the kbd structure is usable
+                /* Check if the kbd structure is usable. */
                 if (!usb_kbd_is_initialized(kbd)) {
                         usb_log_warning("kbd not ready, exiting autorepeat.\n");
                         return;
                 }
-                
+
                 fibril_mutex_lock(&kbd->repeat_mtx);
 
                 if (kbd->repeat.key_new > 0) {
                         if (kbd->repeat.key_new == kbd->repeat.key_repeated) {
-                                usb_log_debug2("Repeating key: %u.\n", 
+                                usb_log_debug2("Repeating key: %u.\n",
                                     kbd->repeat.key_repeated);
-                                // ugly hack with the NULL
-                                usb_kbd_push_ev(NULL, kbd, KEY_PRESS, 
+                                usb_kbd_push_ev(kbd, KEY_PRESS,
                                     kbd->repeat.key_repeated);
                                 delay = kbd->repeat.delay_between;
@@ -106 +102 @@
                 }
                 fibril_mutex_unlock(&kbd->repeat_mtx);
-                
                 async_usleep(delay);
         }
 }
-
 /*----------------------------------------------------------------------------*/
 /**
@@ -116 +110 @@
  *
  * Starts the loop for checking changes in auto-repeat.
- * 
+ *
  * @param arg User-specified argument. Expects pointer to the keyboard device
  *            structure representing the keyboard.
@@ -132 +126 @@
         }
 
-        usb_kbd_t *kbd = (usb_kbd_t *)arg;
+        usb_kbd_t *kbd = arg;
 
         usb_kbd_repeat_loop(kbd);
@@ -138 +132 @@
         return EOK;
 }
-
 /*----------------------------------------------------------------------------*/
 /**
@@ -156 +149 @@
         fibril_mutex_unlock(&kbd->repeat_mtx);
 }
-
 /*----------------------------------------------------------------------------*/
 /**
@@ -162 +154 @@
  *
  * @note Only one key is repeated at any time, but this function may be called
- *       even with key that is not currently repeated (in that case nothing 
+ *       even with key that is not currently repeated (in that case nothing
  *       happens).
  *
@@ -176 +168 @@
         fibril_mutex_unlock(&kbd->repeat_mtx);
 }
-
 /**
  * @}

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

@@ -49 +49 @@
 
 /**
- * Function for adding a new device of type USB/HID/keyboard.
+ * Callback for passing a new device to the driver.
  *
- * This functions initializes required structures from the device's descriptors
- * and starts new fibril for polling the keyboard for events and another one for
- * handling auto-repeat of keys.
+ * @note Currently, only boot-protocol keyboards are supported by this driver.
  *
- * During initialization, the keyboard is switched into boot protocol, the idle
- * rate is set to 0 (infinity), resulting in the keyboard only reporting event
- * when a key is pressed or released. Finally, the LED lights are turned on 
- * according to the default setup of lock keys.
- *
- * @note By default, the keyboards is initialized with Num Lock turned on and 
- *       other locks turned off.
- * @note Currently supports only boot-protocol keyboards.
- *
- * @param dev Device to add.
+ * @param dev Structure representing the new device.
  * @return Error code.
  */
-static int usb_hid_try_add_device(usb_device_t *dev)
+static int usb_hid_device_add(usb_device_t *dev)
 {
-        assert(dev != NULL);
+        usb_log_debug("%s\n", __FUNCTION__);
 
-        /* Initialize device (get and process descriptors, get address, etc.) */
-        usb_log_debug("Initializing USB/HID device...\n");
+        if (dev == NULL) {
+                usb_log_error("Wrong parameter given for add_device().\n");
+                return EINVAL;
+        }
 
+        if (dev->interface_no < 0) {
+                usb_log_error("Failed to add HID device: endpoints not found."
+                    "\n");
+                return ENOTSUP;
+        }
         usb_hid_dev_t *hid_dev =
             usb_device_data_alloc(dev, sizeof(usb_hid_dev_t));
         if (hid_dev == NULL) {
-                usb_log_error("Error while creating USB/HID device "
-                    "structure.\n");
+                usb_log_error("Failed to create USB/HID device structure.\n");
                 return ENOMEM;
         }
 
         int rc = usb_hid_init(hid_dev, dev);
-
         if (rc != EOK) {
                 usb_log_error("Failed to initialize USB/HID device.\n");
@@ -92 +86 @@
         usb_log_debug("USB/HID device structure initialized.\n");
 
-        /*
-         * 1) subdriver vytvori vlastnu ddf_fun, vlastne ddf_dev_ops, ktore da
-         *    do nej.
-         * 2) do tych ops do .interfaces[DEV_IFACE_USBHID (asi)] priradi 
-         *    vyplnenu strukturu usbhid_iface_t.
-         * 3) klientska aplikacia - musi si rucne vytvorit telefon
-         *    (devman_device_connect() - cesta k zariadeniu (/hw/pci0/...) az 
-         *    k tej fcii.
-         *    pouzit usb/classes/hid/iface.h - prvy int je telefon
-         */
-
         /* Start automated polling function.
          * This will create a separate fibril that will query the device
-         * for the data continuously 
-         */
+         * for the data continuously. */
        rc = usb_device_auto_poll(dev,
            /* Index of the polling pipe. */
@@ -113 +95 @@
            usb_hid_polling_callback,
            /* How much data to request. */
-           dev->pipes[hid_dev->poll_pipe_index].pipe->max_packet_size,
+           dev->pipes[hid_dev->poll_pipe_index].pipe.max_packet_size,
            /* Callback when the polling ends. */
            usb_hid_polling_ended_callback,
@@ -126 +108 @@
         }
         hid_dev->running = true;
-
-        /*
-         * Hurrah, device is initialized.
-         */
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-/**
- * Callback for passing a new device to the driver.
- *
- * @note Currently, only boot-protocol keyboards are supported by this driver.
- *
- * @param dev Structure representing the new device.
- * @return Error code.
- */
-static int usb_hid_device_add(usb_device_t *dev)
-{
-        usb_log_debug("usb_hid_device_add()\n");
-
-        if (dev == NULL) {
-                usb_log_warning("Wrong parameter given for add_device().\n");
-                return EINVAL;
-        }
-
-        if (dev->interface_no < 0) {
-                usb_log_warning("Device is not a supported HID device.\n");
-                usb_log_error("Failed to add HID device: endpoints not found."
-                    "\n");
-                return ENOTSUP;
-        }
-
-        int rc = usb_hid_try_add_device(dev);
-
-        if (rc != EOK) {
-                usb_log_warning("Device is not a supported HID device.\n");
-                usb_log_error("Failed to add HID device: %s.\n",
-                    str_error(rc));
-                return rc;
-        }
 
         usb_log_info("HID device `%s' ready to use.\n", dev->ddf_dev->name);
@@ -179 +122 @@
 static int usb_hid_device_rem(usb_device_t *dev)
 {
-        return EOK;
+        // TODO: Stop device polling
+        // TODO: Call deinit (stops autorepeat too)
+        return ENOTSUP;
 }
 /*----------------------------------------------------------------------------*/
@@ -190 +135 @@
 static int usb_hid_device_gone(usb_device_t *dev)
 {
+        assert(dev);
+        assert(dev->driver_data);
         usb_hid_dev_t *hid_dev = dev->driver_data;
-        unsigned tries = 10;
-        while (hid_dev->running) {
+        unsigned tries = 100;
+        /* Wait for fail. */
+        while (hid_dev->running && tries--) {
                 async_usleep(100000);
-                if (!tries--) {
-                        usb_log_error("Can't remove hub, still running.\n");
-                        return EBUSY;
-                }
+        }
+        if (hid_dev->running) {
+                usb_log_error("Can't remove hid, still running.\n");
+                return EBUSY;
         }
 
-        assert(!hid_dev->running);
         usb_hid_deinit(hid_dev);
         usb_log_debug2("%s destruction complete.\n", dev->ddf_dev->name);

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

@@ -55 +55 @@
 #define ARROWS_PER_SINGLE_WHEEL 3
 
-#define NAME  "mouse"
+#define NAME "mouse"
 
 /*----------------------------------------------------------------------------*/
@@ -77 +77 @@
 
 /*----------------------------------------------------------------------------*/
-
-enum {
-        USB_MOUSE_BOOT_REPORT_DESCRIPTOR_SIZE = 63
-};
-
-static const uint8_t USB_MOUSE_BOOT_REPORT_DESCRIPTOR[
-    USB_MOUSE_BOOT_REPORT_DESCRIPTOR_SIZE] = {
+static const uint8_t USB_MOUSE_BOOT_REPORT_DESCRIPTOR[] = {
         0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
         0x09, 0x02,                    // USAGE (Mouse)
@@ -123 +117 @@
     ipc_callid_t icallid, ipc_call_t *icall)
 {
-        usb_mouse_t *mouse_dev = (usb_mouse_t *) fun->driver_data;
+        usb_mouse_t *mouse_dev = fun->driver_data;
 
         if (mouse_dev == NULL) {
-                usb_log_debug("default_connection_handler: Missing "
-                    "parameters.\n");
+                usb_log_debug("%s: Missing parameters.\n", __FUNCTION__);
                 async_answer_0(icallid, EINVAL);
                 return;
         }
 
-        usb_log_debug("default_connection_handler: fun->name: %s\n",
-                      fun->name);
-        usb_log_debug("default_connection_handler: mouse_sess: %p, "
-            "wheel_sess: %p\n", mouse_dev->mouse_sess, mouse_dev->wheel_sess);
-
-        async_sess_t **sess_ptr =
-            (str_cmp(fun->name, HID_MOUSE_FUN_NAME) == 0) ?
+        usb_log_debug("%s: fun->name: %s\n", __FUNCTION__, fun->name);
+        usb_log_debug("%s: mouse_sess: %p, wheel_sess: %p\n",
+            __FUNCTION__, mouse_dev->mouse_sess, mouse_dev->wheel_sess);
+
+        async_sess_t **sess_ptr = (fun == mouse_dev->mouse_fun) ?
             &mouse_dev->mouse_sess : &mouse_dev->wheel_sess;
 
@@ -146 +137 @@
                 if (*sess_ptr == NULL) {
                         *sess_ptr = sess;
-                        usb_log_debug("Console session to mouse set ok (%p).\n",
-                            sess);
+                        usb_log_debug("Console session to %s set ok (%p).\n",
+                            fun->name, sess);
                         async_answer_0(icallid, EOK);
                 } else {
-                        usb_log_debug("default_connection_handler: Console "
-                            "session to mouse already set.\n");
+                        usb_log_error("Console session to %s already set.\n",
+                            fun->name);
                         async_answer_0(icallid, ELIMIT);
                 }
         } else {
-                usb_log_debug("default_connection_handler: Invalid function.\n");
+                usb_log_debug("%s: Invalid function.\n", __FUNCTION__);
                 async_answer_0(icallid, EINVAL);
-        }
-}
-
-/*----------------------------------------------------------------------------*/
-
-static usb_mouse_t *usb_mouse_new(void)
-{
-        usb_mouse_t *mouse = calloc(1, sizeof(usb_mouse_t));
-        if (mouse == NULL) {
-                return NULL;
-        }
-        mouse->mouse_sess = NULL;
-        mouse->wheel_sess = NULL;
-
-        return mouse;
-}
-
-/*----------------------------------------------------------------------------*/
-
-static void usb_mouse_destroy(usb_mouse_t *mouse_dev)
-{
-        assert(mouse_dev != NULL);
-
-        // hangup session to the console
-        if (mouse_dev->mouse_sess != NULL)
-                async_hangup(mouse_dev->mouse_sess);
-
-        if (mouse_dev->wheel_sess != NULL)
-                async_hangup(mouse_dev->wheel_sess);
-        int ret = ddf_fun_unbind(mouse_dev->mouse_fun);
-        if (ret != EOK) {
-                usb_log_error("Failed to unbind mouse function.\n");
-        } else {
-                ddf_fun_destroy(mouse_dev->mouse_fun);
-                /* Prevent double free */
-                mouse_dev->wheel_fun->driver_data = NULL;
-        }
-
-        ret = ddf_fun_unbind(mouse_dev->wheel_fun);
-        if (ret != EOK) {
-                usb_log_error("Failed to unbind wheel function.\n");
-        } else {
-                ddf_fun_destroy(mouse_dev->wheel_fun);
         }
 }
@@ -215 +163 @@
         }
 
-        int count = ((wheel < 0) ? -wheel : wheel) * ARROWS_PER_SINGLE_WHEEL;
-        int i;
-
-        for (i = 0; i < count; i++) {
+        const unsigned count =
+            ((wheel < 0) ? -wheel : wheel) * ARROWS_PER_SINGLE_WHEEL;
+        for (unsigned i = 0; i < count; i++) {
                 /* Send arrow press and release. */
                 usb_log_debug2("Sending key %d to the console\n", key);
@@ -267 +214 @@
         }
 
-        int shift_x = get_mouse_axis_move_value(hid_dev->report_id,
+        const int shift_x = get_mouse_axis_move_value(hid_dev->report_id,
             &hid_dev->report, USB_HIDUT_USAGE_GENERIC_DESKTOP_X);
-        int shift_y = get_mouse_axis_move_value(hid_dev->report_id,
+        const int shift_y = get_mouse_axis_move_value(hid_dev->report_id,
             &hid_dev->report, USB_HIDUT_USAGE_GENERIC_DESKTOP_Y);
-        int wheel = get_mouse_axis_move_value(hid_dev->report_id,
+        const int wheel = get_mouse_axis_move_value(hid_dev->report_id,
             &hid_dev->report, USB_HIDUT_USAGE_GENERIC_DESKTOP_WHEEL);
 
@@ -277 +224 @@
                 async_exch_t *exch =
                     async_exchange_begin(mouse_dev->mouse_sess);
-                async_req_2_0(exch, MOUSEEV_MOVE_EVENT, shift_x, shift_y);
-                async_exchange_end(exch);
+                if (exch != NULL) {
+                        async_req_2_0(exch, MOUSEEV_MOVE_EVENT, shift_x, shift_y);
+                        async_exchange_end(exch);
+                }
         }
 
@@ -284 +233 @@
                 usb_mouse_send_wheel(mouse_dev, wheel);
 
-        /*
-         * Buttons
-         */
+        /* Buttons */
         usb_hid_report_path_t *path = usb_hid_report_path();
-        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_BUTTON, 0);
+        if (path == NULL) {
+                usb_log_warning("Failed to create USB HID report path.\n");
+                return true;
+        }
+        int ret =
+           usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_BUTTON, 0);
+        if (ret != EOK) {
+                usb_hid_report_path_free(path);
+                usb_log_warning("Failed to add buttons to report path.\n");
+                return true;
+        }
         usb_hid_report_path_set_report_id(path, hid_dev->report_id);
 
@@ -298 +255 @@
                 usb_log_debug2(NAME " VALUE(%X) USAGE(%X)\n", field->value,
                     field->usage);
-                
-                if (mouse_dev->buttons[field->usage - field->usage_minimum] == 0
-                    && field->value != 0) {
+                assert(field->usage > field->usage_minimum);
+                const unsigned index = field->usage - field->usage_minimum;
+                assert(index < mouse_dev->buttons_count);
+
+                if (mouse_dev->buttons[index] == 0 && field->value != 0) {
                         async_exch_t *exch =
                             async_exchange_begin(mouse_dev->mouse_sess);
-                        async_req_2_0(exch, MOUSEEV_BUTTON_EVENT, field->usage, 1);
-                        async_exchange_end(exch);
-                        
-                        mouse_dev->buttons[field->usage - field->usage_minimum]
-                            = field->value;
-                } else if (mouse_dev->buttons[field->usage - field->usage_minimum] != 0
-                    && field->value == 0) {
+                        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);
-                        async_req_2_0(exch, MOUSEEV_BUTTON_EVENT, field->usage, 0);
-                        async_exchange_end(exch);
-
-                        mouse_dev->buttons[field->usage - field->usage_minimum] =
-                           field->value;
+                        if (exch != NULL) {
+                                async_req_2_0(exch, MOUSEEV_BUTTON_EVENT,
+                                    field->usage, 0);
+                                async_exchange_end(exch);
+                                mouse_dev->buttons[index] = field->value;
+                        }
                 }
 
@@ -329 +290 @@
         return true;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
+#define FUN_UNBIND_DESTROY(fun) \
+if (fun) { \
+        if (ddf_fun_unbind((fun)) == EOK) { \
+                (fun)->driver_data = NULL; \
+                ddf_fun_destroy((fun)); \
+        } else { \
+                usb_log_error("Could not unbind function `%s', it " \
+                    "will not be destroyed.\n", (fun)->name); \
+        } \
+} else (void)0
+/*----------------------------------------------------------------------------*/
 static int usb_mouse_create_function(usb_hid_dev_t *hid_dev, usb_mouse_t *mouse)
 {
@@ -339 +309 @@
         /* Create the exposed function. */
         usb_log_debug("Creating DDF function %s...\n", HID_MOUSE_FUN_NAME);
-        ddf_fun_t *fun = ddf_fun_create(hid_dev->usb_dev->ddf_dev, fun_exposed, 
+        ddf_fun_t *fun = ddf_fun_create(hid_dev->usb_dev->ddf_dev, fun_exposed,
             HID_MOUSE_FUN_NAME);
         if (fun == NULL) {
-                usb_log_error("Could not create DDF function node.\n");
+                usb_log_error("Could not create DDF function node `%s'.\n",
+                    HID_MOUSE_FUN_NAME);
                 return ENOMEM;
         }
@@ -351 +322 @@
         int rc = ddf_fun_bind(fun);
         if (rc != EOK) {
-                usb_log_error("Could not bind DDF function: %s.\n",
-                    str_error(rc));
-                return rc;
-        }
-
-        usb_log_debug("Adding DDF function to category %s...\n", 
-            HID_MOUSE_CATEGORY);
+                usb_log_error("Could not bind DDF function `%s': %s.\n",
+                    fun->name, str_error(rc));
+                fun->driver_data = NULL;
+                ddf_fun_destroy(fun);
+                return rc;
+        }
+
+        usb_log_debug("Adding DDF function `%s' to category %s...\n",
+            fun->name, HID_MOUSE_CATEGORY);
         rc = ddf_fun_add_to_category(fun, HID_MOUSE_CATEGORY);
         if (rc != EOK) {
@@ -363 +336 @@
                     "Could not add DDF function to category %s: %s.\n",
                     HID_MOUSE_CATEGORY, str_error(rc));
+                FUN_UNBIND_DESTROY(fun);
                 return rc;
         }
@@ -370 +344 @@
          * Special function for acting as keyboard (wheel)
          */
-        usb_log_debug("Creating DDF function %s...\n", 
+        usb_log_debug("Creating DDF function %s...\n",
                       HID_MOUSE_WHEEL_FUN_NAME);
-        fun = ddf_fun_create(hid_dev->usb_dev->ddf_dev, fun_exposed, 
+        fun = ddf_fun_create(hid_dev->usb_dev->ddf_dev, fun_exposed,
             HID_MOUSE_WHEEL_FUN_NAME);
         if (fun == NULL) {
-                usb_log_error("Could not create DDF function node.\n");
+                usb_log_error("Could not create DDF function node `%s'.\n",
+                    HID_MOUSE_WHEEL_FUN_NAME);
+                FUN_UNBIND_DESTROY(mouse->mouse_fun);
+                mouse->mouse_fun = NULL;
                 return ENOMEM;
         }
@@ -388 +365 @@
         rc = ddf_fun_bind(fun);
         if (rc != EOK) {
-                usb_log_error("Could not bind DDF function: %s.\n",
-                    str_error(rc));
+                usb_log_error("Could not bind DDF function `%s': %s.\n",
+                    fun->name, str_error(rc));
+                FUN_UNBIND_DESTROY(mouse->mouse_fun);
+                mouse->mouse_fun = NULL;
+
+                fun->driver_data = NULL;
+                ddf_fun_destroy(fun);
                 return rc;
         }
@@ -400 +382 @@
                     "Could not add DDF function to category %s: %s.\n",
                     HID_MOUSE_WHEEL_CATEGORY, str_error(rc));
+
+                FUN_UNBIND_DESTROY(mouse->mouse_fun);
+                mouse->mouse_fun = NULL;
+                FUN_UNBIND_DESTROY(fun);
                 return rc;
         }
@@ -448 +434 @@
         return highest_button;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 int usb_mouse_init(usb_hid_dev_t *hid_dev, void **data)
 {
@@ -461 +445 @@
         }
 
-        usb_mouse_t *mouse_dev = usb_mouse_new();
+        usb_mouse_t *mouse_dev = calloc(1, sizeof(usb_mouse_t));
         if (mouse_dev == NULL) {
                 usb_log_error("Error while creating USB/HID Mouse device "
@@ -484 +468 @@
         }
 
-
-        // save the Mouse device structure into the HID device structure
-        *data = mouse_dev;
-
         // 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, 
+        usbhid_req_set_idle(&hid_dev->usb_dev->ctrl_pipe,
             hid_dev->usb_dev->interface_no, IDLE_RATE);
 
         int rc = usb_mouse_create_function(hid_dev, mouse_dev);
         if (rc != EOK) {
-                usb_mouse_destroy(mouse_dev);
-                return rc;
-        }
+                free(mouse_dev->buttons);
+                free(mouse_dev);
+                return rc;
+        }
+
+        /* Save the Mouse device structure into the HID device structure. */
+        *data = mouse_dev;
 
         return EOK;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, void *data)
 {
         if (hid_dev == NULL || data == NULL) {
-                usb_log_error("Missing argument to the mouse polling callback."
-                    "\n");
+                usb_log_error(
+                    "Missing argument to the mouse polling callback.\n");
                 return false;
         }
 
-        usb_mouse_t *mouse_dev = (usb_mouse_t *)data;
-                
+        usb_mouse_t *mouse_dev = data;
+
         return usb_mouse_process_report(hid_dev, mouse_dev);
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 void usb_mouse_deinit(usb_hid_dev_t *hid_dev, void *data)
 {
-        if (data != NULL) {
-                usb_mouse_destroy(data);
-        }
-}
-
-/*----------------------------------------------------------------------------*/
-
+        if (data == NULL)
+                return;
+
+        usb_mouse_t *mouse_dev = data;
+
+        /* Hangup session to the console */
+        if (mouse_dev->mouse_sess != NULL) {
+                const int ret = async_hangup(mouse_dev->mouse_sess);
+                if (ret != EOK)
+                        usb_log_warning("Failed to hang up mouse session: "
+                            "%p, %s.\n", mouse_dev->mouse_sess, str_error(ret));
+        }
+
+        if (mouse_dev->wheel_sess != NULL) {
+                const int ret = async_hangup(mouse_dev->wheel_sess);
+                if (ret != EOK)
+                        usb_log_warning("Failed to hang up wheel session: "
+                            "%p, %s.\n", mouse_dev->wheel_sess, str_error(ret));
+        }
+
+        FUN_UNBIND_DESTROY(mouse_dev->mouse_fun);
+        FUN_UNBIND_DESTROY(mouse_dev->wheel_fun);
+
+        free(mouse_dev->buttons);
+        free(mouse_dev);
+}
+/*----------------------------------------------------------------------------*/
 int usb_mouse_set_boot_protocol(usb_hid_dev_t *hid_dev)
 {
         int rc = usb_hid_parse_report_descriptor(
             &hid_dev->report, USB_MOUSE_BOOT_REPORT_DESCRIPTOR,
-            USB_MOUSE_BOOT_REPORT_DESCRIPTOR_SIZE);
+            sizeof(USB_MOUSE_BOOT_REPORT_DESCRIPTOR));
 
         if (rc != EOK) {

uspace/drv/bus/usb/usbhid/multimedia/multimedia.c

@@ -67 +67 @@
         /** IPC session to the console device (for sending key events). */
         async_sess_t *console_sess;
-        /** DDF function */
-        ddf_fun_t *fun;
 } usb_multimedia_t;
 
 
 /*----------------------------------------------------------------------------*/
-/** 
+/**
  * Default handler for IPC methods not handled by DDF.
  *
@@ -88 +86 @@
 {
         usb_log_debug(NAME " default_connection_handler()\n");
-
-        usb_multimedia_t *multim_dev = (usb_multimedia_t *)fun->driver_data;
-
-        if (multim_dev == NULL) {
+        if (fun == NULL || fun->driver_data == NULL) {
                 async_answer_0(icallid, EINVAL);
                 return;
         }
+
+        usb_multimedia_t *multim_dev = fun->driver_data;
 
         async_sess_t *sess =
@@ -109 +106 @@
                 async_answer_0(icallid, EINVAL);
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 static ddf_dev_ops_t multimedia_ops = {
         .default_handler = default_connection_handler
 };
-
 /*----------------------------------------------------------------------------*/
 /**
@@ -127 +121 @@
  *       sends also these keys to application (otherwise it cannot use those
  *       keys at all).
- * 
- * @param hid_dev 
- * @param lgtch_dev 
- * @param type Type of the event (press / release). Recognized values: 
+ *
+ * @param hid_dev
+ * @param multim_dev
+ * @param type Type of the event (press / release). Recognized values:
  *             KEY_PRESS, KEY_RELEASE
  * @param key Key code of the key according to HID Usage Tables.
  */
-static void usb_multimedia_push_ev(usb_hid_dev_t *hid_dev, 
+static void usb_multimedia_push_ev(
     usb_multimedia_t *multim_dev, int type, unsigned int key)
 {
-        assert(hid_dev != NULL);
         assert(multim_dev != NULL);
 
-        kbd_event_t ev;
-
-        ev.type = type;
-        ev.key = key;
-        ev.mods = 0;
-        ev.c = 0;
+        const kbd_event_t ev = {
+                .type = type,
+                .key = key,
+                .mods = 0,
+                .c = 0,
+        };
 
         usb_log_debug2(NAME " Sending key %d to the console\n", ev.key);
@@ -155 +148 @@
 
         async_exch_t *exch = async_exchange_begin(multim_dev->console_sess);
-        async_msg_4(exch, KBDEV_EVENT, ev.type, ev.key, ev.mods, ev.c);
-        async_exchange_end(exch);
-}
-
-/*----------------------------------------------------------------------------*/
-
+        if (exch != NULL) {
+                async_msg_4(exch, KBDEV_EVENT, ev.type, ev.key, ev.mods, ev.c);
+                async_exchange_end(exch);
+        } else {
+                usb_log_warning("Failed to send multimedia key.\n");
+        }
+}
+/*----------------------------------------------------------------------------*/
 int usb_multimedia_init(struct usb_hid_dev *hid_dev, void **data)
 {
         if (hid_dev == NULL || hid_dev->usb_dev == NULL) {
-                return EINVAL; /*! @todo Other return code? */
+                return EINVAL;
         }
 
@@ -187 +182 @@
 
         multim_dev->console_sess = NULL;
-        multim_dev->fun = fun;
 
         //todo Autorepeat?
@@ -199 +193 @@
         }
 
-        usb_log_debug("%s function created (handle: %" PRIun ").\n",
-            NAME, fun->handle);
+        usb_log_debug(NAME " function created (handle: %" PRIun ").\n",
+            fun->handle);
 
         rc = ddf_fun_add_to_category(fun, "keyboard");
@@ -207 +201 @@
                     "Could not add DDF function to category 'keyboard': %s.\n",
                     str_error(rc));
-                ddf_fun_destroy(fun);
+                if (ddf_fun_unbind(fun) != EOK) {
+                        usb_log_error("Failed to unbind %s, won't destroy.\n",
+                            fun->name);
+                } else {
+                        ddf_fun_destroy(fun);
+                }
                 return rc;
         }
 
         /* Save the KBD device structure into the HID device structure. */
-        *data = multim_dev;
+        *data = fun;
 
         usb_log_debug(NAME " HID/multimedia structure initialized.\n");
         return EOK;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 void usb_multimedia_deinit(struct usb_hid_dev *hid_dev, void *data)
 {
-        if (hid_dev == NULL) {
-                return;
-        }
-
-        if (data != NULL) {
-                usb_multimedia_t *multim_dev = (usb_multimedia_t *)data;
-                // hangup session to the console
-                async_hangup(multim_dev->console_sess);
-                const int ret = ddf_fun_unbind(multim_dev->fun);
-                if (ret != EOK) {
-                        usb_log_error("Failed to unbind multim function.\n");
+        ddf_fun_t *fun = data;
+        if (fun != NULL && fun->driver_data != NULL) {
+                usb_multimedia_t *multim_dev = fun->driver_data;
+                /* Hangup session to the console */
+                if (multim_dev->console_sess)
+                        async_hangup(multim_dev->console_sess);
+                if (ddf_fun_unbind(fun) != EOK) {
+                        usb_log_error("Failed to unbind %s, won't destroy.\n",
+                            fun->name);
                 } else {
-                        usb_log_debug2("%s unbound.\n", multim_dev->fun->name);
-                        ddf_fun_destroy(multim_dev->fun);
+                        usb_log_debug2("%s unbound.\n", fun->name);
+                        /* This frees multim_dev too as it was stored in
+                         * fun->data */
+                        ddf_fun_destroy(fun);
                 }
-        }
-}
-
-/*----------------------------------------------------------------------------*/
-
+        } else {
+                usb_log_error(
+                    "Failed to deinit multimedia subdriver, data missing.\n");
+        }
+}
+/*----------------------------------------------------------------------------*/
 bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data)
 {
         // TODO: checks
-        if (hid_dev == NULL || data == NULL) {
+        ddf_fun_t *fun = data;
+        if (hid_dev == NULL || fun == NULL || fun->driver_data == NULL) {
                 return false;
         }
 
-        usb_multimedia_t *multim_dev = (usb_multimedia_t *)data;
+        usb_multimedia_t *multim_dev = fun->driver_data;
 
         usb_hid_report_path_t *path = usb_hid_report_path();
-        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
+        if (path == NULL)
+                return true; /* This might be a temporary failure. */
+
+        int ret =
+            usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
+        if (ret != EOK) {
+                usb_hid_report_path_free(path);
+                return true; /* This might be a temporary failure. */
+        }
 
         usb_hid_report_path_set_report_id(path, hid_dev->report_id);
@@ -261 +268 @@
             USB_HID_REPORT_TYPE_INPUT);
 
-        /*! @todo Is this iterating OK if done multiple times? 
-         *  @todo The parsing is not OK
-         */
+        //FIXME Is this iterating OK if done multiple times?
+        //FIXME The parsing is not OK. (what's wrong?)
         while (field != NULL) {
-                if(field->value != 0) {
-                        usb_log_debug(NAME " KEY VALUE(%X) USAGE(%X)\n", 
+                if (field->value != 0) {
+                        usb_log_debug(NAME " KEY VALUE(%X) USAGE(%X)\n",
                             field->value, field->usage);
-                        unsigned int key = 
+                        const unsigned key =
                             usb_multimedia_map_usage(field->usage);
-                        const char *key_str = 
+                        const char *key_str =
                             usbhid_multimedia_usage_to_str(field->usage);
                         usb_log_info("Pressed key: %s\n", key_str);
-                        usb_multimedia_push_ev(hid_dev, multim_dev, KEY_PRESS, 
-                                               key);
+                        usb_multimedia_push_ev(multim_dev, KEY_PRESS, key);
                 }
 
                 field = usb_hid_report_get_sibling(
                     &hid_dev->report, field, path, USB_HID_PATH_COMPARE_END
-                    | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
+                    | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
                     USB_HID_REPORT_TYPE_INPUT);
         }
@@ -287 +292 @@
         return true;
 }
-
 /**
  * @}

uspace/drv/bus/usb/usbhid/subdrivers.c

@@ -98 +98 @@
                 }
         },
-        {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL, NULL}}
 };
 
-const int USB_HID_MAX_SUBDRIVERS =
+const size_t USB_HID_MAX_SUBDRIVERS =
     sizeof(usb_hid_subdrivers) / sizeof(usb_hid_subdrivers[0]);
 

uspace/drv/bus/usb/usbhid/subdrivers.h

@@ -84 +84 @@
 
 extern const usb_hid_subdriver_mapping_t usb_hid_subdrivers[];
-extern const int USB_HID_MAX_SUBDRIVERS;
+extern const size_t USB_HID_MAX_SUBDRIVERS;
 
 /*----------------------------------------------------------------------------*/

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

@@ -51 +51 @@
 #include "subdrivers.h"
 
-/*----------------------------------------------------------------------------*/
-
 /* Array of endpoints expected on the device, NULL terminated. */
 const usb_endpoint_description_t *usb_hid_endpoints[] = {
@@ -60 +58 @@
         NULL
 };
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 static int usb_hid_set_boot_kbd_subdriver(usb_hid_dev_t *hid_dev)
 {
@@ -78 +74 @@
         return EOK;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 static int usb_hid_set_boot_mouse_subdriver(usb_hid_dev_t *hid_dev)
 {
@@ -92 +86 @@
         hid_dev->subdriver_count = 1;
         // TODO 2 should be mouse, but find a better way
-        hid_dev->subdrivers[2] = usb_hid_subdrivers[0].subdriver;
+        hid_dev->subdrivers[0] = usb_hid_subdrivers[2].subdriver;
 
         return EOK;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 static int usb_hid_set_generic_hid_subdriver(usb_hid_dev_t *hid_dev)
 {
-        assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
+        assert(hid_dev != NULL);
+        assert(hid_dev->subdriver_count == 0);
 
         hid_dev->subdrivers = malloc(sizeof(usb_hid_subdriver_t));
@@ -117 +110 @@
         return EOK;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 static bool usb_hid_ids_match(const usb_hid_dev_t *hid_dev,
     const usb_hid_subdriver_mapping_t *mapping)
@@ -128 +119 @@
         return (hid_dev->usb_dev->descriptors.device.vendor_id
             == mapping->vendor_id
-            && hid_dev->usb_dev->descriptors.device.product_id 
+            && hid_dev->usb_dev->descriptors.device.product_id
             == mapping->product_id);
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 static bool usb_hid_path_matches(usb_hid_dev_t *hid_dev,
     const usb_hid_subdriver_mapping_t *mapping)
@@ -145 +134 @@
                 return false;
         }
-        int i = 0;
-        while (mapping->usage_path[i].usage != 0
-            || mapping->usage_path[i].usage_page != 0) {
+
+        for (int i = 0; mapping->usage_path[i].usage != 0
+            || mapping->usage_path[i].usage_page != 0; ++i) {
                 if (usb_hid_report_path_append_item(usage_path,
                     mapping->usage_path[i].usage_page,
@@ -155 +144 @@
                         return false;
                 }
-                ++i;
         }
 
@@ -165 +153 @@
         do {
                 usb_log_debug("Trying report id %u\n", report_id);
-
                 if (report_id != 0) {
                         usb_hid_report_path_set_report_id(usage_path,
@@ -171 +158 @@
                 }
 
-                usb_hid_report_field_t *field = usb_hid_report_get_sibling(
-                    &hid_dev->report, NULL, usage_path, mapping->compare,
-                    USB_HID_REPORT_TYPE_INPUT);
+                const 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);
@@ -190 +178 @@
         return matches;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 static int usb_hid_save_subdrivers(usb_hid_dev_t *hid_dev,
-    const usb_hid_subdriver_t **subdrivers, int count)
-{
-        int i;
-
-        if (count <= 0) {
+    const usb_hid_subdriver_t **subdrivers, unsigned count)
+{
+        assert(hid_dev);
+        assert(subdrivers);
+
+        if (count == 0) {
                 hid_dev->subdriver_count = 0;
                 hid_dev->subdrivers = NULL;
@@ -210 +197 @@
         }
 
-        for (i = 0; i < count; ++i) {
-                hid_dev->subdrivers[i].init = subdrivers[i]->init;
-                hid_dev->subdrivers[i].deinit = subdrivers[i]->deinit;
-                hid_dev->subdrivers[i].poll = subdrivers[i]->poll;
-                hid_dev->subdrivers[i].poll_end = subdrivers[i]->poll_end;
+        for (unsigned i = 0; i < count; ++i) {
+                hid_dev->subdrivers[i] = *subdrivers[i];
         }
 
@@ -227 +211 @@
         return EOK;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 static int usb_hid_find_subdrivers(usb_hid_dev_t *hid_dev)
 {
@@ -235 +217 @@
 
         const usb_hid_subdriver_t *subdrivers[USB_HID_MAX_SUBDRIVERS];
-
-        int i = 0, count = 0;
-        const usb_hid_subdriver_mapping_t *mapping = &usb_hid_subdrivers[i];
-
-        bool ids_matched;
-        bool matched;
-
-        while (count < USB_HID_MAX_SUBDRIVERS &&
-            (mapping->usage_path != NULL
-            || mapping->vendor_id >= 0 || mapping->product_id >= 0)) {
-                // check the vendor & product ID
+        unsigned count = 0;
+
+        for (unsigned i = 0; i < USB_HID_MAX_SUBDRIVERS; ++i) {
+                const usb_hid_subdriver_mapping_t *mapping =
+                    &usb_hid_subdrivers[i];
+                /* Check the vendor & product ID. */
                 if (mapping->vendor_id >= 0 && mapping->product_id < 0) {
-                        usb_log_warning("Missing Product ID for Vendor ID %d\n",
-                            mapping->vendor_id);
-                        return EINVAL;
+                        usb_log_warning("Mapping[%d]: Missing Product ID for "
+                            "Vendor ID %d\n", i, mapping->vendor_id);
                 }
                 if (mapping->product_id >= 0 && mapping->vendor_id < 0) {
-                        usb_log_warning("Missing Vendor ID for Product ID %d\n",
-                            mapping->product_id);
-                        return EINVAL;
-                }
-
-                ids_matched = false;
-                matched = false;
-
-                if (mapping->vendor_id >= 0) {
-                        assert(mapping->product_id >= 0);
+                        usb_log_warning("Mapping[%d]: Missing Vendor ID for "
+                            "Product ID %d\n", i, mapping->product_id);
+                }
+
+                bool matched = false;
+
+                /* Check ID match. */
+                if (mapping->vendor_id >= 0 && mapping->product_id >= 0) {
                         usb_log_debug("Comparing device against vendor ID %u"
                             " and product ID %u.\n", mapping->vendor_id,
@@ -267 +241 @@
                         if (usb_hid_ids_match(hid_dev, mapping)) {
                                 usb_log_debug("IDs matched.\n");
-                                ids_matched = true;
+                                matched = true;
                         }
                 }
 
+                /* Check usage match. */
                 if (mapping->usage_path != NULL) {
                         usb_log_debug("Comparing device against usage path.\n");
                         if (usb_hid_path_matches(hid_dev, mapping)) {
-                                // does not matter if IDs were matched
+                                /* Does not matter if IDs were matched. */
                                 matched = true;
                         }
-                } else {
-                        // matched only if IDs were matched and there is no path
-                        matched = ids_matched;
                 }
 
@@ -286 +258 @@
                         subdrivers[count++] = &mapping->subdriver;
                 }
-
-                mapping = &usb_hid_subdrivers[++i];
         }
 
         /* We have all subdrivers determined, save them into the hid device */
-        // TODO Dowe really need this complicated stuff if there is
-        // max_subdrivers limitation?
         return usb_hid_save_subdrivers(hid_dev, subdrivers, count);
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 static int usb_hid_check_pipes(usb_hid_dev_t *hid_dev, const usb_device_t *dev)
 {
@@ -303 +269 @@
         assert(dev);
 
-        if (dev->pipes[USB_HID_KBD_POLL_EP_NO].present) {
-                usb_log_debug("Found keyboard endpoint.\n");
-                // save the pipe index
-                hid_dev->poll_pipe_index = USB_HID_KBD_POLL_EP_NO;
-        } else if (dev->pipes[USB_HID_MOUSE_POLL_EP_NO].present) {
-                usb_log_debug("Found mouse endpoint.\n");
-                // save the pipe index
-                hid_dev->poll_pipe_index = USB_HID_MOUSE_POLL_EP_NO;
-        } else if (dev->pipes[USB_HID_GENERIC_POLL_EP_NO].present) {
-                usb_log_debug("Found generic HID endpoint.\n");
-                // save the pipe index
-                hid_dev->poll_pipe_index = USB_HID_GENERIC_POLL_EP_NO;
-        } else {
-                usb_log_error("None of supported endpoints found - probably"
-                    " not a supported device.\n");
-                return ENOTSUP;
-        }
-
-        return EOK;
-}
-
-/*----------------------------------------------------------------------------*/
-
+        static const struct {
+                unsigned ep_number;
+                const char* description;
+        } endpoints[] = {
+                {USB_HID_KBD_POLL_EP_NO, "Keyboard endpoint"},
+                {USB_HID_MOUSE_POLL_EP_NO, "Mouse endpoint"},
+                {USB_HID_GENERIC_POLL_EP_NO, "Generic HID endpoint"},
+        };
+
+        for (unsigned i = 0; i < sizeof(endpoints)/sizeof(endpoints[0]); ++i) {
+                if (endpoints[i].ep_number >= dev->pipes_count) {
+                        return EINVAL;
+                }
+                if (dev->pipes[endpoints[i].ep_number].present) {
+                        usb_log_debug("Found: %s.\n", endpoints[i].description);
+                        hid_dev->poll_pipe_index = endpoints[i].ep_number;
+                        return EOK;
+                }
+        }
+        return ENOTSUP;
+}
+/*----------------------------------------------------------------------------*/
 static int usb_hid_init_report(usb_hid_dev_t *hid_dev)
 {
@@ -357 +322 @@
         return EOK;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
+/*
+ * This functions initializes required structures from the device's descriptors
+ * and starts new fibril for polling the keyboard for events and another one for
+ * handling auto-repeat of keys.
+ *
+ * During initialization, the keyboard is switched into boot protocol, the idle
+ * rate is set to 0 (infinity), resulting in the keyboard only reporting event
+ * when a key is pressed or released. Finally, the LED lights are turned on 
+ * according to the default setup of lock keys.
+ *
+ * @note By default, the keyboards is initialized with Num Lock turned on and 
+ *       other locks turned off.
+ *
+ * @param hid_dev Device to initialize, non-NULL.
+ * @param dev USB device, non-NULL.
+ * @return Error code.
+ */
 int usb_hid_init(usb_hid_dev_t *hid_dev, usb_device_t *dev)
 {
-        int rc, i;
+        assert(hid_dev);
+        assert(dev);
 
         usb_log_debug("Initializing HID structure...\n");
-
-        if (hid_dev == NULL) {
-                usb_log_error("Failed to init HID structure: no structure given"
-                    ".\n");
-                return EINVAL;
-        }
-
-        if (dev == NULL) {
-                usb_log_error("Failed to init HID structure: no USB device"
-                    " given.\n");
-                return EINVAL;
-        }
 
         usb_hid_report_init(&hid_dev->report);
@@ -384 +353 @@
         hid_dev->poll_pipe_index = -1;
 
-        rc = usb_hid_check_pipes(hid_dev, dev);
+        int rc = usb_hid_check_pipes(hid_dev, dev);
         if (rc != EOK) {
                 return rc;
@@ -390 +359 @@
 
         /* Get the report descriptor and parse it. */
-        rc = usb_hid_process_report_descriptor(hid_dev->usb_dev,
-            &hid_dev->report, &hid_dev->report_desc, &hid_dev->report_desc_size);
-
-        bool fallback = false;
-
+        rc = usb_hid_process_report_descriptor(
+            hid_dev->usb_dev, &hid_dev->report, &hid_dev->report_desc,
+            &hid_dev->report_desc_size);
+
+        /* If report parsing went well, find subdrivers. */
         if (rc == EOK) {
-                // try to find subdrivers that may want to handle this device
-                rc = usb_hid_find_subdrivers(hid_dev);
-                if (rc != EOK || hid_dev->subdriver_count == 0) {
-                        // try to fall back to the boot protocol if available
-                        usb_log_info("No subdrivers found to handle this"
-                            " device.\n");
-                        fallback = true;
-                        assert(hid_dev->subdrivers == NULL);
-                        assert(hid_dev->subdriver_count == 0);
-                }
+                usb_hid_find_subdrivers(hid_dev);
         } else {
-                usb_log_error("Failed to parse Report descriptor.\n");
-                // try to fall back to the boot protocol if available
-                fallback = true;
-        }
-
-        if (fallback) {
-                // fall back to boot protocol
+                usb_log_error("Failed to parse report descriptor: fallback.\n");
+                hid_dev->subdrivers = NULL;
+                hid_dev->subdriver_count = 0;
+        }
+
+        usb_log_debug("Subdriver count(before trying boot protocol): %d\n",
+            hid_dev->subdriver_count);
+
+        /* No subdrivers, fall back to the boot protocol if available. */
+        if (hid_dev->subdriver_count == 0) {
+                assert(hid_dev->subdrivers == NULL);
+                usb_log_info("No subdrivers found to handle device, trying "
+                    "boot protocol.\n");
+
                 switch (hid_dev->poll_pipe_index) {
                 case USB_HID_KBD_POLL_EP_NO:
@@ -419 +386 @@
                         rc = usb_kbd_set_boot_protocol(hid_dev);
                         if (rc == EOK) {
-                                rc = usb_hid_set_boot_kbd_subdriver(hid_dev);
+                                usb_hid_set_boot_kbd_subdriver(hid_dev);
                         }
                         break;
@@ -426 +393 @@
                         rc = usb_mouse_set_boot_protocol(hid_dev);
                         if (rc == EOK) {
-                                rc = usb_hid_set_boot_mouse_subdriver(hid_dev);
+                                usb_hid_set_boot_mouse_subdriver(hid_dev);
                         }
                         break;
@@ -432 +399 @@
                         assert(hid_dev->poll_pipe_index
                             == USB_HID_GENERIC_POLL_EP_NO);
-
                         usb_log_info("Falling back to generic HID driver.\n");
-                        rc = usb_hid_set_generic_hid_subdriver(hid_dev);
-                }
-        }
-
-        if (rc != EOK) {
-                usb_log_error("No subdriver for handling this device could be"
-                    " initialized: %s.\n", str_error(rc));
-                usb_log_debug("Subdriver count: %d\n",
-                    hid_dev->subdriver_count);
-        } else {
-                bool ok = false;
-
-                usb_log_debug("Subdriver count: %d\n",
-                    hid_dev->subdriver_count);
-
-                for (i = 0; i < hid_dev->subdriver_count; ++i) {
-                        if (hid_dev->subdrivers[i].init != NULL) {
-                                usb_log_debug("Initializing subdriver %d.\n",i);
-                                rc = hid_dev->subdrivers[i].init(hid_dev,
-                                    &hid_dev->subdrivers[i].data);
-                                if (rc != EOK) {
-                                        usb_log_warning("Failed to initialize"
-                                            " HID subdriver structure.\n");
-                                } else {
-                                        // at least one subdriver initialized
-                                        ok = true;
-                                }
+                        usb_hid_set_generic_hid_subdriver(hid_dev);
+                }
+        }
+
+        usb_log_debug("Subdriver count(after trying boot protocol): %d\n",
+            hid_dev->subdriver_count);
+
+        /* Still no subdrivers? */
+        if (hid_dev->subdriver_count == 0) {
+                assert(hid_dev->subdrivers == NULL);
+                usb_log_error(
+                    "No subdriver for handling this device could be found.\n");
+                return ENOTSUP;
+        }
+
+        /*
+         * 1) subdriver vytvori vlastnu ddf_fun, vlastne ddf_dev_ops, ktore da
+         *    do nej.
+         * 2) do tych ops do .interfaces[DEV_IFACE_USBHID (asi)] priradi 
+         *    vyplnenu strukturu usbhid_iface_t.
+         * 3) klientska aplikacia - musi si rucne vytvorit telefon
+         *    (devman_device_connect() - cesta k zariadeniu (/hw/pci0/...) az 
+         *    k tej fcii.
+         *    pouzit usb/classes/hid/iface.h - prvy int je telefon
+         */
+        bool ok = false;
+        for (unsigned i = 0; i < hid_dev->subdriver_count; ++i) {
+                if (hid_dev->subdrivers[i].init != NULL) {
+                        usb_log_debug("Initializing subdriver %d.\n",i);
+                        const int pret = hid_dev->subdrivers[i].init(hid_dev,
+                            &hid_dev->subdrivers[i].data);
+                        if (pret != EOK) {
+                                usb_log_warning("Failed to initialize"
+                                    " HID subdriver structure: %s.\n",
+                                    str_error(pret));
+                                rc = pret;
                         } else {
+                                /* At least one subdriver initialized. */
                                 ok = true;
                         }
-                }
-
-                rc = (ok) ? EOK : -1;   // what error to report
-        }
-
-
-        if (rc == EOK) {
-                // save max input report size and allocate space for the report
+                } else {
+                        /* Does not need initialization. */
+                        ok = true;
+                }
+        }
+
+        if (ok) {
+                /* Save max input report size and
+                 * allocate space for the report */
                 rc = usb_hid_init_report(hid_dev);
                 if (rc != EOK) {
@@ -481 +458 @@
         return rc;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 bool usb_hid_polling_callback(usb_device_t *dev, uint8_t *buffer,
     size_t buffer_size, void *arg)
@@ -516 +491 @@
         bool cont = false;
         /* Continue if at least one of the subdrivers want to continue */
-        for (int i = 0; i < hid_dev->subdriver_count; ++i) {
+        for (unsigned i = 0; i < hid_dev->subdriver_count; ++i) {
                 if (hid_dev->subdrivers[i].poll != NULL) {
                         cont = cont || hid_dev->subdrivers[i].poll(
@@ -525 +500 @@
         return cont;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 void usb_hid_polling_ended_callback(usb_device_t *dev, bool reason, void *arg)
 {
@@ -535 +508 @@
         usb_hid_dev_t *hid_dev = arg;
 
-        for (int i = 0; i < hid_dev->subdriver_count; ++i) {
+        for (unsigned i = 0; i < hid_dev->subdriver_count; ++i) {
                 if (hid_dev->subdrivers[i].poll_end != NULL) {
                         hid_dev->subdrivers[i].poll_end(
@@ -544 +517 @@
         hid_dev->running = false;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 void usb_hid_new_report(usb_hid_dev_t *hid_dev)
 {
         ++hid_dev->report_nr;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 int usb_hid_report_number(const usb_hid_dev_t *hid_dev)
 {
         return hid_dev->report_nr;
 }
-
-/*----------------------------------------------------------------------------*/
-
+/*----------------------------------------------------------------------------*/
 void usb_hid_deinit(usb_hid_dev_t *hid_dev)
 {
@@ -570 +537 @@
             hid_dev->subdrivers, hid_dev->subdriver_count);
 
-        for (int i = 0; i < hid_dev->subdriver_count; ++i) {
+        for (unsigned i = 0; i < hid_dev->subdriver_count; ++i) {
                 if (hid_dev->subdrivers[i].deinit != NULL) {
                         hid_dev->subdrivers[i].deinit(hid_dev,

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

@@ -104 +104 @@
 
         /** Index of the polling pipe in usb_hid_endpoints array. */
-        int poll_pipe_index;
+        unsigned poll_pipe_index;
 
         /** Subdrivers. */
@@ -110 +110 @@
 
         /** Number of subdrivers. */
-        int subdriver_count;
+        unsigned subdriver_count;
 
         /** Report descriptor. */

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

@@ -401 +401 @@
 {
         usb_hub_port_t *port = arg;
+        assert(port);
         const int rc =
             usb_hub_port_set_feature(port, USB_HUB_FEATURE_PORT_RESET);
@@ -440 +441 @@
             data->port, &new_address, NULL, NULL, &child_fun);
 
-        if (rc != EOK) {
+        if (rc == EOK) {
+                fibril_mutex_lock(&data->port->mutex);
+                data->port->attached_device.fun = child_fun;
+                data->port->attached_device.address = new_address;
+                fibril_mutex_unlock(&data->port->mutex);
+
+                usb_log_info("Detected new device on `%s' (port %zu), "
+                    "address %d (handle %" PRIun ").\n",
+                    data->hub->usb_device->ddf_dev->name,
+                    data->port->port_number, new_address, child_fun->handle);
+        } else {
                 usb_log_error("Failed registering device on port %zu: %s.\n",
                     data->port->port_number, str_error(rc));
-                goto leave;
-        }
-
-        fibril_mutex_lock(&data->port->mutex);
-        data->port->attached_device.fun = child_fun;
-        data->port->attached_device.address = new_address;
-        fibril_mutex_unlock(&data->port->mutex);
-
-        usb_log_info("Detected new device on `%s' (port %zu), "
-            "address %d (handle %" PRIun ").\n",
-            data->hub->usb_device->ddf_dev->name, data->port->port_number,
-            new_address, child_fun->handle);
-
-leave:
+        }
+
+
         fibril_mutex_lock(&data->hub->pending_ops_mutex);
         assert(data->hub->pending_ops_count > 0);

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

@@ -44 +44 @@
 /** Information about single port on a hub. */
 typedef struct {
-        /* Port number as reporteed in descriptors. */
+        /* Port number as reported in descriptors. */
         size_t port_number;
         /** Device communication pipe. */

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

@@ -170 +170 @@
 int usb_hub_device_remove(usb_device_t *usb_dev)
 {
-        assert(usb_dev);
-        usb_hub_dev_t *hub_dev = usb_dev->driver_data;
-        assert(hub_dev);
-        //TODO: Cascade the call here.
-        //TODO: Enable after cascading is implemented.
         return ENOTSUP;
-        if (!hub_dev->power_switched) {
-                /* That is all we can do. */
-                return EOK;
-        }
-        int ret = EOK;
-        usb_log_info("Hub is about to be removed, powering down all ports.\n");
-        for (size_t port = 0; port < hub_dev->port_count; ++port) {
-                usb_log_debug("Powering down port %zu.\n", port);
-                int pret = usb_hub_port_clear_feature(
-                    &hub_dev->ports[port], USB_HUB_FEATURE_PORT_POWER);
-                if (pret != EOK) {
-                        usb_log_error("Cannot power down port %zu: %s.\n",
-                            hub_dev->ports[port].port_number, str_error(pret));
-                        ret = pret;
-                } else {
-                        if (!hub_dev->per_port_power) {
-                                usb_log_debug("Ganged power switching mode, "
-                                   "one port is enough.\n");
-                                break;
-                        }
-                }
-        }
-        return ret;
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/bus/usb/usbmast/bo_trans.c

@@ -67 +67 @@
         int retval = EOK;
         size_t act_size;
-        usb_pipe_t *bulk_in_pipe = mfun->mdev->usb_dev->pipes[BULK_IN_EP].pipe;
-        usb_pipe_t *bulk_out_pipe = mfun->mdev->usb_dev->pipes[BULK_OUT_EP].pipe;
+        usb_pipe_t *bulk_in_pipe = &mfun->mdev->usb_dev->pipes[BULK_IN_EP].pipe;
+        usb_pipe_t *bulk_out_pipe = &mfun->mdev->usb_dev->pipes[BULK_OUT_EP].pipe;
         usb_direction_t ddir;
         void *dbuf;
@@ -118 +118 @@
                 if (ddir == USB_DIRECTION_IN) {
                         usb_pipe_clear_halt(&mfun->mdev->usb_dev->ctrl_pipe,
-                            mfun->mdev->usb_dev->pipes[BULK_IN_EP].pipe);
+                            &mfun->mdev->usb_dev->pipes[BULK_IN_EP].pipe);
                 } else {
                         usb_pipe_clear_halt(&mfun->mdev->usb_dev->ctrl_pipe,
-                            mfun->mdev->usb_dev->pipes[BULK_OUT_EP].pipe);
+                            &mfun->mdev->usb_dev->pipes[BULK_OUT_EP].pipe);
                 }
         } else if (rc != EOK) {
@@ -216 +216 @@
         usb_massstor_reset(mdev);
         usb_pipe_clear_halt(&mdev->usb_dev->ctrl_pipe,
-            mdev->usb_dev->pipes[BULK_IN_EP].pipe);
+            &mdev->usb_dev->pipes[BULK_IN_EP].pipe);
         usb_pipe_clear_halt(&mdev->usb_dev->ctrl_pipe,
-            mdev->usb_dev->pipes[BULK_OUT_EP].pipe);
+            &mdev->usb_dev->pipes[BULK_OUT_EP].pipe);
 }
 

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

@@ -114 +114 @@
 {
         //TODO: flush buffers, or whatever.
+        //TODO: remove device
         return ENOTSUP;
 }
@@ -139 +140 @@
 
         usb_log_info("Initializing mass storage `%s'.\n", dev->ddf_dev->name);
-        usb_log_debug(" Bulk in endpoint: %d [%zuB].\n",
-            dev->pipes[BULK_IN_EP].pipe->endpoint_no,
-            (size_t) dev->pipes[BULK_IN_EP].descriptor->max_packet_size);
+        usb_log_debug("Bulk in endpoint: %d [%zuB].\n",
+            dev->pipes[BULK_IN_EP].pipe.endpoint_no,
+            dev->pipes[BULK_IN_EP].pipe.max_packet_size);
         usb_log_debug("Bulk out endpoint: %d [%zuB].\n",
-            dev->pipes[BULK_OUT_EP].pipe->endpoint_no,
-            (size_t) dev->pipes[BULK_OUT_EP].descriptor->max_packet_size);
+            dev->pipes[BULK_OUT_EP].pipe.endpoint_no,
+            dev->pipes[BULK_OUT_EP].pipe.max_packet_size);
 
         usb_log_debug("Get LUN count...\n");

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

@@ -57 +57 @@
 {
         list_foreach(*list, l) {
-                usbmid_interface_t *iface
-                    = list_get_instance(l, usbmid_interface_t, link);
+                usbmid_interface_t *iface = usbmid_interface_from_link(l);
                 if (iface->interface_no == interface_no) {
                         return true;
@@ -82 +81 @@
         };
 
-        usb_dp_parser_t parser = {
+        static const usb_dp_parser_t parser = {
                 .nesting = usb_dp_standard_descriptor_nesting
         };
 
         const uint8_t *interface_ptr =
-            usb_dp_get_nested_descriptor(&parser, &data, data.data);
-        if (interface_ptr == NULL) {
-                return;
-        }
-
-        do {
-                if (interface_ptr[1] != USB_DESCTYPE_INTERFACE) {
-                        goto next_descriptor;
-                }
-
-                usb_standard_interface_descriptor_t *interface
+            usb_dp_get_nested_descriptor(&parser, &data, config_descriptor);
+
+        /* Walk all descriptors nested in the current configuration decriptor;
+         * i.e. all interface descriptors. */
+        for (;interface_ptr != NULL;
+            interface_ptr = usb_dp_get_sibling_descriptor(
+                &parser, &data, config_descriptor, interface_ptr))
+        {
+                /* The second byte is DESCTYPE byte in all desriptors. */
+                if (interface_ptr[1] != USB_DESCTYPE_INTERFACE)
+                        continue;
+
+                const usb_standard_interface_descriptor_t *interface
                     = (usb_standard_interface_descriptor_t *) interface_ptr;
 
                 /* Skip alternate interfaces. */
-                if (!interface_in_list(list, interface->interface_number)) {
-                        usbmid_interface_t *iface
-                            = malloc(sizeof(usbmid_interface_t));
-                        if (iface == NULL) {
-                                break;
-                        }
-                        link_initialize(&iface->link);
-                        iface->fun = NULL;
-                        iface->interface_no = interface->interface_number;
-                        iface->interface = interface;
-
-                        list_append(&iface->link, list);
-                }
-
-                /* TODO: add the alternatives and create match ids from them
-                 * as well.
-                 */
-
-next_descriptor:
-                interface_ptr = usb_dp_get_sibling_descriptor(&parser, &data,
-                    data.data, interface_ptr);
-
-        } while (interface_ptr != NULL);
-
+                if (interface_in_list(list, interface->interface_number)) {
+                        /* TODO: add the alternatives and create match ids
+                         * for them. */
+                        continue;
+                }
+                usbmid_interface_t *iface = malloc(sizeof(usbmid_interface_t));
+                if (iface == NULL) {
+                        //TODO: Do something about that failure.
+                        break;
+                }
+
+                link_initialize(&iface->link);
+                iface->fun = NULL;
+                iface->interface_no = interface->interface_number;
+                iface->interface = interface;
+
+                list_append(&iface->link, list);
+        }
 }
 
@@ -139 +134 @@
         int rc;
 
-        int dev_class = dev->descriptors.device.device_class;
+        unsigned dev_class = dev->descriptors.device.device_class;
         if (dev_class != USB_CLASS_USE_INTERFACE) {
                 usb_log_warning(
-                    "Device class: %d (%s), but expected class 0.\n",
-                    dev_class, usb_str_class(dev_class));
+                    "Device class: %u (%s), but expected class %u.\n",
+                    dev_class, usb_str_class(dev_class),
+                    USB_CLASS_USE_INTERFACE);
                 usb_log_error("Not multi interface device, refusing.\n");
                 return false;
         }
 
-        /* Short cuts to save on typing ;-). */
+        /* Shortcuts to save on typing ;-). */
         const void *config_descriptor_raw = dev->descriptors.configuration;
         size_t config_descriptor_size = dev->descriptors.configuration_size;
@@ -163 +159 @@
         }
 
+        /* Create driver soft-state. */
         usb_mid_t *usb_mid = usb_device_data_alloc(dev, sizeof(usb_mid_t));
         if (!usb_mid) {
@@ -169 +166 @@
         }
 
-        /* Create control function */
+        /* Create control function. */
         usb_mid->ctl_fun = ddf_fun_create(dev->ddf_dev, fun_exposed, "ctl");
         if (usb_mid->ctl_fun == NULL) {
@@ -175 +172 @@
                 return false;
         }
-
         usb_mid->ctl_fun->ops = &mid_device_ops;
 
+        /* Bind control function. */
         rc = ddf_fun_bind(usb_mid->ctl_fun);
         if (rc != EOK) {
@@ -192 +189 @@
             &usb_mid->interface_list);
 
+        /* Start child function for every interface. */
         list_foreach(usb_mid->interface_list, link) {
-                usbmid_interface_t *iface = list_get_instance(link,
-                    usbmid_interface_t, link);
+                usbmid_interface_t *iface = usbmid_interface_from_link(link);
 
                 usb_log_info("Creating child for interface %d (%s).\n",
-                    (int) iface->interface_no,
+                    iface->interface_no,
                     usb_str_class(iface->interface->interface_class));
 

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

@@ -68 +68 @@
 /** Callback when a MID device is about to be removed from the host.
  *
- * @param gen_dev Generic DDF device representing the removed device.
+ * @param dev USB device representing the removed device.
  * @return Error code.
  */
@@ -74 +74 @@
 {
         assert(dev);
-        int ret = ENOTSUP;
         usb_mid_t *usb_mid = dev->driver_data;
         assert(usb_mid);
 
-        /* Signal all interface functions */
-        list_foreach(usb_mid->interface_list, item) {
+        /* Remove ctl function */
+        int ret = ddf_fun_unbind(usb_mid->ctl_fun);
+        if (ret != EOK) {
+                usb_log_error("Failed to unbind USB MID ctl function: %s.\n",
+                    str_error(ret));
+                return ret;
+        }
+        ddf_fun_destroy(usb_mid->ctl_fun);
+
+        /* Remove all children */
+        while (!list_empty(&usb_mid->interface_list)) {
+                link_t *item = list_first(&usb_mid->interface_list);
+                list_remove(item);
+
                 usbmid_interface_t *iface = usbmid_interface_from_link(item);
 
-                usb_log_info("Signaling remove to child for interface "
-                    "%d (%s).\n", iface->interface_no,
+                usb_log_info("Removing child for interface %d (%s).\n",
+                    iface->interface_no,
                     usb_str_class(iface->interface->interface_class));
-                // TODO cascade the call.
+
+                /* Tell the child to go off-line. */
+                int pret = ddf_fun_offline(iface->fun);
+                if (pret != EOK) {
+                        usb_log_warning("Failed to turn off child for interface"
+                            " %d (%s): %s\n", iface->interface_no,
+                            usb_str_class(iface->interface->interface_class),
+                            str_error(pret));
+                        ret = pret;
+                }
+
+                /* Now remove the child. */
+                pret = usbmid_interface_destroy(iface);
+                if (pret != EOK) {
+                        usb_log_error("Failed to destroy child for interface "
+                            "%d (%s): %s\n", iface->interface_no,
+                            usb_str_class(iface->interface->interface_class),
+                            str_error(pret));
+                        ret = pret;
+                }
         }
         return ret;
@@ -92 +122 @@
 /** Callback when a MID device was removed from the host.
  *
- * @param gen_dev Generic DDF device representing the removed device.
+ * @param dev USB device representing the removed device.
  * @return Error code.
  */
@@ -98 +128 @@
 {
         assert(dev);
+        usb_mid_t *usb_mid = dev->driver_data;
+        assert(usb_mid);
+
         usb_log_info("USB MID gone: `%s'.\n", dev->ddf_dev->name);
 
         /* Remove ctl function */
-        usb_mid_t *usb_mid = dev->driver_data;
         int ret = ddf_fun_unbind(usb_mid->ctl_fun);
         if (ret != EOK) {
@@ -117 +149 @@
                 usbmid_interface_t *iface = usbmid_interface_from_link(item);
 
-                usb_log_info("Removing child for interface %d (%s).\n",
+                usb_log_info("Child for interface %d (%s) gone.\n",
                     iface->interface_no,
                     usb_str_class(iface->interface->interface_class));

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

@@ -62 +62 @@
 /** DDF interface of the child - interface function. */
 static usb_iface_t child_usb_iface = {
-        .get_hc_handle = usb_iface_get_hc_handle_hub_child_impl,
-        .get_address = usb_iface_get_address_hub_impl,
-        .get_interface = usb_iface_get_interface_impl
+        .get_hc_handle = usb_iface_get_hc_handle_device_impl,
+        .get_my_address = usb_iface_get_my_address_forward_impl,
+        .get_interface = usb_iface_get_interface_impl,
 };
 
@@ -110 +110 @@
          * class name something humanly understandable.
          */
-        rc = asprintf(&child_name, "%s%d",
+        rc = asprintf(&child_name, "%s%hhu",
             usb_str_class(interface_descriptor->interface_class),
-            (int) interface_descriptor->interface_number);
+            interface_descriptor->interface_number);
         if (rc < 0) {
                 return ENOMEM;
@@ -123 +123 @@
                 return ENOMEM;
         }
-
-        iface->fun = child;
-
-        child->driver_data = iface;
-        child->ops = &child_device_ops;
 
         rc = usb_device_create_match_ids_from_interface(device_descriptor,
@@ -143 +138 @@
         }
 
+        iface->fun = child;
+        child->driver_data = iface;
+        child->ops = &child_device_ops;
+
         return EOK;
 }

uspace/drv/bus/usb/usbmid/usbmid.h

@@ -51 +51 @@
         ddf_fun_t *fun;
         /** Interface descriptor. */
-        usb_standard_interface_descriptor_t *interface;
+        const usb_standard_interface_descriptor_t *interface;
         /** Interface number. */
         int interface_no;

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

@@ -57 +57 @@
  * @return Error code.
  */
-static int request_address(ddf_fun_t *fun, usb_speed_t speed,
-    usb_address_t *address)
-{
-        VHC_DATA(vhc, fun);
-
-        usb_address_t addr = usb_device_manager_get_free_address(
-            &vhc->dev_manager, USB_SPEED_HIGH);
-        if (addr < 0) {
-                return addr;
-        }
-
-        if (address != NULL) {
-                *address = addr;
-        }
-
-        return EOK;
+static int request_address(ddf_fun_t *fun, usb_address_t *address, bool strict,
+    usb_speed_t speed)
+{
+        VHC_DATA(vhc, fun);
+
+        assert(address);
+        return usb_device_manager_request_address(
+            &vhc->dev_manager, address, strict, speed);
 }
 
@@ -88 +80 @@
         usb_log_debug("Binding handle %" PRIun " to address %d.\n",
             handle, address);
-        usb_device_manager_bind(&vhc->dev_manager, address, handle);
+        usb_device_manager_bind_address(&vhc->dev_manager, address, handle);
 
         return EOK;
@@ -118 +110 @@
         VHC_DATA(vhc, fun);
         usb_log_debug("Releasing address %d...\n", address);
-        usb_device_manager_release(&vhc->dev_manager, address);
+        usb_device_manager_release_address(&vhc->dev_manager, address);
 
         return ENOTSUP;
@@ -136 +128 @@
  */
 static int register_endpoint(ddf_fun_t *fun,
-    usb_address_t address, usb_speed_t speed, usb_endpoint_t endpoint,
+    usb_address_t address, usb_endpoint_t endpoint,
     usb_transfer_type_t transfer_type, usb_direction_t direction,
     size_t max_packet_size, unsigned int interval)
@@ -479 +471 @@
 }
 
-static int tell_address(ddf_fun_t *fun, devman_handle_t handle,
-    usb_address_t *address)
+static int tell_address(ddf_fun_t *fun, usb_address_t *address)
 {
         UNSUPPORTED("tell_address");
@@ -497 +488 @@
 }
 
-static int tell_address_rh(ddf_fun_t *root_hub_fun, devman_handle_t handle,
-    usb_address_t *address)
+static int tell_address_rh(ddf_fun_t *root_hub_fun, usb_address_t *address)
 {
         VHC_DATA(vhc, root_hub_fun);
 
-        if (handle == 0) {
-                handle = root_hub_fun->handle;
-        }
+        devman_handle_t handle = root_hub_fun->handle;
 
         usb_log_debug("tell_address_rh(handle=%" PRIun ")\n", handle);
@@ -532 +520 @@
 usb_iface_t vhc_usb_iface = {
         .get_hc_handle = usb_iface_get_hc_handle_hc_impl,
-        .get_address = tell_address
+        .get_my_address = tell_address
 };
 
 usb_iface_t rh_usb_iface = {
         .get_hc_handle = usb_iface_get_hc_handle_rh_impl,
-        .get_address = tell_address_rh
+        .get_my_address = tell_address_rh
 };
 

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

@@ -80 +80 @@
                 return rc;
         }
-        usb_device_manager_init(&data->dev_manager);
+        usb_device_manager_init(&data->dev_manager, USB_SPEED_MAX);
 
         ddf_fun_t *hc = ddf_fun_create(dev, fun_exposed, "hc");