Changes in / [3dfdcb7:ee7e7c93] in mainline

Files:

• HelenOS.config (modified) (2 diffs)
• uspace/drv/ehci-hcd/hc_iface.c (modified) (2 diffs)
• uspace/drv/ohci/root_hub.c (modified) (6 diffs)
• uspace/drv/uhci-rhd/port.h (modified) (2 diffs)
• uspace/drv/usbhid/generic/hiddev.c (modified) (2 diffs)
• uspace/drv/usbhid/kbd/kbddev.c (modified) (1 diff)
• uspace/drv/usbhid/multimedia/multimedia.c (modified) (1 diff)
• uspace/drv/usbhub/port_status.h (modified) (20 diffs)
• uspace/drv/usbhub/ports.c (modified) (22 diffs)
• uspace/drv/usbhub/ports.h (modified) (1 diff)
• uspace/drv/usbhub/usbhub.c (modified) (24 diffs)
• uspace/drv/usbhub/usbhub.h (modified) (3 diffs)
• uspace/drv/usbhub/usbhub_private.h (modified) (6 diffs)
• uspace/drv/usbhub/utils.c (modified) (8 diffs)
• uspace/drv/usbmouse/init.c (modified) (2 diffs)
• uspace/drv/usbmouse/mouse.c (modified) (1 diff)
• uspace/lib/drv/generic/driver.c (modified) (1 diff)
• uspace/lib/drv/include/usbhc_iface.h (modified) (1 diff)
• uspace/lib/usbdev/include/usb/dev/driver.h (modified) (1 diff)
• uspace/lib/usbdev/src/devdrv.c (modified) (1 diff)
• uspace/srv/hid/console/console.c (modified) (9 diffs)

HelenOS.config

@@ -570 +570 @@
 
 % USB release build (less logging)
-! CONFIG_USB_RELEASE_BUILD (y/n)
+! CONFIG_USB_RELEASE_BUILD (n/y)
 
 % Start virtual USB host controller
@@ -576 +576 @@
 
 % Polling UHCI & OHCI (no interrupts)
-! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_USBHC_NO_INTERRUPTS (n/y)
+! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_USBHC_NO_INTERRUPTS (y/n)
 
 % Run devman in kconsole (not recommended)

uspace/drv/ehci-hcd/hc_iface.c

@@ -48 +48 @@
             methodname, __FILE__, __LINE__)
 
+/** Reserve default address.
+ *
+ * This function may block the caller.
+ *
+ * @param[in] fun Device function the action was invoked on.
+ * @param[in] speed Speed of the device for which the default address is
+ *      reserved.
+ * @return Error code.
+ */
+static int reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
+{
+        UNSUPPORTED("reserve_default_address");
+
+        return ENOTSUP;
+}
+
+/** Release default address.
+ *
+ * @param[in] fun Device function the action was invoked on.
+ * @return Error code.
+ */
+static int release_default_address(ddf_fun_t *fun)
+{
+        UNSUPPORTED("release_default_address");
+
+        return ENOTSUP;
+}
+
 /** Found free USB address.
  *
@@ -304 +332 @@
 /** Host controller interface implementation for EHCI. */
 usbhc_iface_t ehci_hc_iface = {
+        .reserve_default_address = reserve_default_address,
+        .release_default_address = release_default_address,
         .request_address = request_address,
         .bind_address = bind_address,

uspace/drv/ohci/root_hub.c

@@ -117 +117 @@
  */
 static const uint32_t hub_clear_feature_by_writing_one_mask =
-    RHS_CLEAR_PORT_POWER;
+   RHS_CLEAR_PORT_POWER;
 
 /**
@@ -412 +412 @@
         request->transfered_size = 4;
         uint32_t data = instance->registers->rh_port_status[port - 1];
-        memcpy(request->data_buffer, &data, 4);
+        memcpy(request->data_buffer,&data,4);
 #if 0
         int i;
@@ -445 +445 @@
         uint32_t data = mask & instance->registers->rh_status;
         //uint32_buffer[0] = mask & instance->registers->rh_status;
-        memcpy(request->data_buffer, &data, 4);
+        memcpy(request->data_buffer,&data,4);
 
         return EOK;
@@ -499 +499 @@
             | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
         bzero(bitmap, instance->interrupt_mask_size);
-        if ((instance->registers->rh_status & mask) != 0) {
+        if ((instance->registers->rh_status & mask) !=0 ) {
                 bitmap[0] = 1;
         }
@@ -925 +925 @@
  * @return
  */
-static int process_interrupt_mask_in_instance(rh_t *instance,
-    usb_transfer_batch_t * request) {
+static int process_interrupt_mask_in_instance(rh_t *instance, usb_transfer_batch_t * request) {
         memcpy(request->data_buffer, instance->interrupt_buffer,
             instance->interrupt_mask_size);
@@ -946 +945 @@
  * @return
  */
-static bool is_zeros(void *buffer, size_t size) {
+static bool is_zeros(void * buffer, size_t size) {
         if (!buffer) return true;
         if (!size) return true;

uspace/drv/uhci-rhd/port.h

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

uspace/drv/usbhid/generic/hiddev.c

@@ -99 +99 @@
         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
         
-        usb_log_debug2("hid_dev: %p, Max input report size (%zu).\n",
+        usb_log_debug2("hid_dev: %p, Max input report size (%d).\n",
             hid_dev, hid_dev->max_input_report_size);
         
@@ -226 +226 @@
         }
         
-        usb_log_debug("HID function created. Handle: %" PRIun "\n", fun->handle);
+        usb_log_debug("HID function created. Handle: %d\n", fun->handle);
         
         return EOK;

uspace/drv/usbhid/kbd/kbddev.c

@@ -798 +798 @@
         }
         
-        usb_log_debug("%s function created. Handle: %" PRIun "\n",
-            HID_KBD_FUN_NAME, fun->handle);
+        usb_log_debug("%s function created. Handle: %d\n", HID_KBD_FUN_NAME,
+            fun->handle);
         
         usb_log_debug("Adding DDF function to class %s...\n", 

uspace/drv/usbhid/multimedia/multimedia.c

@@ -211 +211 @@
         }
         
-        usb_log_debug("%s function created (jandle: %" PRIun ").\n",
-            NAME, fun->handle);
+        usb_log_debug("%s function created. Handle: %d\n", NAME, fun->handle);
         
         rc = ddf_fun_add_to_class(fun, "keyboard");

uspace/drv/usbhub/port_status.h

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

uspace/drv/usbhub/ports.c

@@ -47 +47 @@
 #include "port_status.h"
 
+
 /** Information for fibril for device discovery. */
 struct add_device_phase1 {
@@ -64 +65 @@
  * any function here and must be cleared by hand
  */
-static const int non_handled_changes[] = {
+static const int non_handled_changes[] =  {
         USB_HUB_FEATURE_C_PORT_ENABLE,
         USB_HUB_FEATURE_C_PORT_SUSPEND
@@ -70 +71 @@
 
 static void usb_hub_removed_device(
-    usb_hub_info_t *hub, uint16_t port);
-
-static void usb_hub_port_reset_completed(usb_hub_info_t *hub,
-    uint16_t port, uint32_t status);
-
-static void usb_hub_port_over_current(usb_hub_info_t *hub,
-    uint16_t port, uint32_t status);
+        usb_hub_info_t * hub, uint16_t port);
+
+static void usb_hub_port_reset_completed(usb_hub_info_t * hub,
+        uint16_t port, uint32_t status);
+
+static void usb_hub_port_over_current(usb_hub_info_t * hub,
+        uint16_t port, uint32_t status);
 
 static int get_port_status(usb_pipe_t *ctrl_pipe, size_t port,
@@ -95 +96 @@
  * @param port port number, starting from 1
  */
-void usb_hub_process_interrupt(usb_hub_info_t *hub,
-    uint16_t port) {
-        usb_log_debug("Interrupt at port %zu\n", (size_t) port);
+void usb_hub_process_interrupt(usb_hub_info_t * hub,
+        uint16_t port) {
+        usb_log_debug("interrupt at port %zu\n", (size_t) port);
         //determine type of change
         //usb_pipe_t *pipe = hub->control_pipe;
@@ -133 +134 @@
         if (usb_port_is_status(status, USB_HUB_FEATURE_C_PORT_OVER_CURRENT)) {
                 //check if it was not auto-resolved
-                usb_log_debug("Overcurrent change on port\n");
+                usb_log_debug("overcurrent change on port\n");
                 usb_hub_port_over_current(hub, port, status);
         }
@@ -140 +141 @@
                 usb_hub_port_reset_completed(hub, port, status);
         }
-        usb_log_debug("Status x%x : %d\n ", status, status);
+        usb_log_debug("status x%x : %d\n ", status, status);
 
         usb_port_status_set_bit(
-            &status, USB_HUB_FEATURE_C_PORT_CONNECTION, false);
+            &status, USB_HUB_FEATURE_C_PORT_CONNECTION,false);
         usb_port_status_set_bit(
-            &status, USB_HUB_FEATURE_C_PORT_RESET, false);
+            &status, USB_HUB_FEATURE_C_PORT_RESET,false);
         usb_port_status_set_bit(
-            &status, USB_HUB_FEATURE_C_PORT_OVER_CURRENT, false);
-
+            &status, USB_HUB_FEATURE_C_PORT_OVER_CURRENT,false);
+        
         //clearing not yet handled changes      
         unsigned int feature_idx;
-        for (feature_idx = 0;
-            feature_idx < non_handled_changes_count;
-            ++feature_idx) {
+        for(feature_idx = 0;feature_idx<non_handled_changes_count;
+            ++feature_idx){
                 unsigned int bit_idx = non_handled_changes[feature_idx];
-                if (status & (1 << bit_idx)) {
+                if(status & (1<<bit_idx)){
                         usb_log_info(
-                            "There was not yet handled change on port %d: %d"
+                            "there was not yet handled change on port %d: %d"
                             ";clearing it\n",
-                            port, bit_idx);
+                        port, bit_idx);
                         int opResult = usb_hub_clear_port_feature(
                             hub->control_pipe,
@@ -165 +165 @@
                         if (opResult != EOK) {
                                 usb_log_warning(
-                                    "Could not clear port flag %d: %s\n",
-                                    bit_idx, str_error(opResult)
+                                    "could not clear port flag %d: %d\n",
+                                    bit_idx, opResult
                                     );
                         }
                         usb_port_status_set_bit(
-                            &status, bit_idx, false);
+                            &status, bit_idx,false);
                 }
         }
-        if (status >> 16) {
-                usb_log_info("There is still some unhandled change %X\n",
+        if(status>>16){
+                usb_log_info("there is still some unhandled change %X\n",
                     status);
         }
 }
+
 
 /**
@@ -189 +190 @@
  */
 static void usb_hub_removed_device(
-    usb_hub_info_t *hub, uint16_t port) {
+        usb_hub_info_t * hub, uint16_t port) {
 
         int opResult = usb_hub_clear_port_feature(hub->control_pipe,
-            port, USB_HUB_FEATURE_C_PORT_CONNECTION);
+                port, USB_HUB_FEATURE_C_PORT_CONNECTION);
         if (opResult != EOK) {
-                usb_log_warning("Could not clear port-change-connection flag\n");
+                usb_log_warning("could not clear port-change-connection flag\n");
         }
         /** \TODO remove device from device manager - not yet implemented in
@@ -201 +202 @@
 
         //close address
-
-        usb_hub_port_t *the_port = hub->ports + port;
-
-        fibril_mutex_lock(&hub->port_mutex);
-
-        if (the_port->attached_device.address >= 0) {
-                usb_log_warning("Device unplug on `%s' (port %zu): " \
-                    "not implemented.\n", hub->usb_device->ddf_dev->name,
-                    (size_t) port);
-                the_port->attached_device.address = -1;
-                the_port->attached_device.handle = 0;
+        if(hub->ports[port].attached_device.address >= 0){
+                /*uncomment this code to use it when DDF allows device removal
+                opResult = usb_hc_unregister_device(
+                        &hub->connection,
+                        hub->attached_devs[port].address);
+                if(opResult != EOK) {
+                        dprintf(USB_LOG_LEVEL_WARNING, "could not release "
+                                "address of "
+                            "removed device: %d", opResult);
+                }
+                hub->attached_devs[port].address = 0;
+                hub->attached_devs[port].handle = 0;
+                 */
         } else {
                 usb_log_warning("Device removed before being registered.\n");
@@ -220 +223 @@
                  * port reset callback from new device wrapper.
                  */
+                usb_hub_port_t *the_port = hub->ports + port;
                 fibril_mutex_lock(&the_port->reset_mutex);
                 the_port->reset_completed = true;
@@ -226 +230 @@
                 fibril_mutex_unlock(&the_port->reset_mutex);
         }
-
-        fibril_mutex_unlock(&hub->port_mutex);
-}
+}
+
 
 /**
@@ -239 +242 @@
  * @param status
  */
-static void usb_hub_port_reset_completed(usb_hub_info_t *hub,
-    uint16_t port, uint32_t status) {
+static void usb_hub_port_reset_completed(usb_hub_info_t * hub,
+        uint16_t port, uint32_t status){
         usb_log_debug("Port %zu reset complete.\n", (size_t) port);
         if (usb_port_is_status(status, USB_HUB_FEATURE_PORT_ENABLE)) {
@@ -272 +275 @@
  * @param port port number, starting from 1
  */
-static void usb_hub_port_over_current(usb_hub_info_t *hub,
-    uint16_t port, uint32_t status) {
+static void usb_hub_port_over_current(usb_hub_info_t * hub,
+        uint16_t port, uint32_t status) {
         int opResult;
-        if (usb_port_is_status(status, USB_HUB_FEATURE_PORT_OVER_CURRENT)) {
+        if(usb_port_is_status(status, USB_HUB_FEATURE_PORT_OVER_CURRENT)){
                 opResult = usb_hub_clear_port_feature(hub->control_pipe,
-                    port, USB_HUB_FEATURE_PORT_POWER);
+                        port, USB_HUB_FEATURE_PORT_POWER);
                 if (opResult != EOK) {
-                        usb_log_error("Cannot power off port %d; %s\n",
-                            port, str_error(opResult));
+                        usb_log_error("cannot power off port %d;  %d\n",
+                                port, opResult);
                 }
-        } else {
+        }else{
                 opResult = usb_hub_set_port_feature(hub->control_pipe,
-                    port, USB_HUB_FEATURE_PORT_POWER);
+                        port, USB_HUB_FEATURE_PORT_POWER);
                 if (opResult != EOK) {
-                        usb_log_error("Cannot power on port %d; %s\n",
-                            port, str_error(opResult));
+                        usb_log_error("cannot power on port %d;  %d\n",
+                                port, opResult);
                 }
         }
@@ -300 +303 @@
  */
 static int get_port_status(usb_pipe_t *ctrl_pipe, size_t port,
-    usb_port_status_t *status) {
+    usb_port_status_t *status)
+{
         size_t recv_size;
         usb_device_request_setup_packet_t request;
@@ -307 +311 @@
         usb_hub_set_port_status_request(&request, port);
         int rc = usb_pipe_control_read(ctrl_pipe,
-            &request, sizeof (usb_device_request_setup_packet_t),
-            &status_tmp, sizeof (status_tmp), &recv_size);
+            &request, sizeof(usb_device_request_setup_packet_t),
+            &status_tmp, sizeof(status_tmp), &recv_size);
         if (rc != EOK) {
                 return rc;
@@ -333 +337 @@
  * @return Error code.
  */
-static int enable_port_callback(int port_no, void *arg) {
+static int enable_port_callback(int port_no, void *arg)
+{
         usb_hub_info_t *hub = arg;
         int rc;
@@ -341 +346 @@
         usb_hub_set_reset_port_request(&request, port_no);
         rc = usb_pipe_control_write(hub->control_pipe,
-            &request, sizeof (request), NULL, 0);
+            &request, sizeof(request), NULL, 0);
         if (rc != EOK) {
                 usb_log_warning("Port reset failed: %s.\n", str_error(rc));
@@ -371 +376 @@
  * @return 0 Always.
  */
-static int add_device_phase1_worker_fibril(void *arg) {
+static int add_device_phase1_worker_fibril(void *arg)
+{
         struct add_device_phase1 *data
             = (struct add_device_phase1 *) arg;
@@ -390 +396 @@
         }
 
-        fibril_mutex_lock(&data->hub->port_mutex);
         data->hub->ports[data->port].attached_device.handle = child_handle;
         data->hub->ports[data->port].attached_device.address = new_address;
-        fibril_mutex_unlock(&data->hub->port_mutex);
 
         usb_log_info("Detected new device on `%s' (port %zu), "
@@ -403 +407 @@
         free(arg);
 
-        fibril_mutex_lock(&data->hub->pending_ops_mutex);
-        assert(data->hub->pending_ops_count > 0);
-        data->hub->pending_ops_count--;
-        fibril_condvar_signal(&data->hub->pending_ops_cv);
-        fibril_mutex_unlock(&data->hub->pending_ops_mutex);
-
-
         return EOK;
 }
+
 
 /** Start device adding when connection change is detected.
@@ -423 +421 @@
  */
 static int create_add_device_fibril(usb_hub_info_t *hub, size_t port,
-    usb_speed_t speed) {
+    usb_speed_t speed)
+{
         struct add_device_phase1 *data
-            = malloc(sizeof (struct add_device_phase1));
+            = malloc(sizeof(struct add_device_phase1));
         if (data == NULL) {
                 return ENOMEM;
@@ -453 +452 @@
                 return ENOMEM;
         }
-        fibril_mutex_lock(&hub->pending_ops_mutex);
-        hub->pending_ops_count++;
-        fibril_mutex_unlock(&hub->pending_ops_mutex);
         fibril_add_ready(fibril);
 

uspace/drv/usbhub/ports.h

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

uspace/drv/usbhub/usbhub.c

@@ -56 +56 @@
 
 
-static usb_hub_info_t * usb_hub_info_create(usb_device_t *usb_dev);
-
-static int usb_hub_process_hub_specific_info(usb_hub_info_t *hub_info);
-
-static int usb_hub_set_configuration(usb_hub_info_t *hub_info);
-
-static int usb_hub_start_hub_fibril(usb_hub_info_t *hub_info);
-
-static int usb_process_hub_over_current(usb_hub_info_t *hub_info,
+static usb_hub_info_t * usb_hub_info_create(usb_device_t * usb_dev);
+
+static int usb_hub_process_hub_specific_info(usb_hub_info_t * hub_info);
+
+static int usb_hub_set_configuration(usb_hub_info_t * hub_info);
+
+static int usb_hub_start_hub_fibril(usb_hub_info_t * hub_info);
+
+static int usb_process_hub_over_current(usb_hub_info_t * hub_info,
     usb_hub_status_t status);
 
-static int usb_process_hub_local_power_change(usb_hub_info_t *hub_info,
+static int usb_process_hub_local_power_change(usb_hub_info_t * hub_info,
     usb_hub_status_t status);
 
-static void usb_hub_process_global_interrupt(usb_hub_info_t *hub_info);
-
-static void usb_hub_polling_terminated_callback(usb_device_t *device,
-    bool was_error, void *data);
+static void usb_hub_process_global_interrupt(usb_hub_info_t * hub_info);
+
+static void usb_hub_polling_terminted_callback(usb_device_t * device,
+    bool was_error, void * data);
 
 
@@ -90 +90 @@
  * @return error code
  */
-int usb_hub_add_device(usb_device_t *usb_dev) {
+int usb_hub_add_device(usb_device_t * usb_dev) {
         if (!usb_dev) return EINVAL;
-        usb_hub_info_t *hub_info = usb_hub_info_create(usb_dev);
+        usb_hub_info_t * hub_info = usb_hub_info_create(usb_dev);
         //create hc connection
         usb_log_debug("Initializing USB wire abstraction.\n");
@@ -99 +99 @@
             hub_info->usb_device->ddf_dev);
         if (opResult != EOK) {
-                usb_log_error("Could not initialize connection to device, "
-                    " %s\n",
-                    str_error(opResult));
+                usb_log_error("could not initialize connection to device, "
+                    "errno %d\n",
+                    opResult);
                 free(hub_info);
                 return opResult;
@@ -109 +109 @@
         opResult = usb_hub_set_configuration(hub_info);
         if (opResult != EOK) {
-                usb_log_error("Could not set hub configuration, %s\n",
-                    str_error(opResult));
+                usb_log_error("could not set hub configuration, errno %d\n",
+                    opResult);
                 free(hub_info);
                 return opResult;
@@ -117 +117 @@
         opResult = usb_hub_process_hub_specific_info(hub_info);
         if (opResult != EOK) {
-                usb_log_error("Could process hub specific info, %s\n",
-                    str_error(opResult));
+                usb_log_error("could process hub specific info, errno %d\n",
+                    opResult);
                 free(hub_info);
                 return opResult;
@@ -135 +135 @@
 
         opResult = usb_hub_start_hub_fibril(hub_info);
-        if (opResult != EOK)
+        if(opResult!=EOK)
                 free(hub_info);
         return opResult;
 }
+
 
 /** Callback for polling hub for changes.
@@ -192 +193 @@
  * @return basic usb_hub_info_t structure
  */
-static usb_hub_info_t * usb_hub_info_create(usb_device_t *usb_dev) {
-        usb_hub_info_t * result = malloc(sizeof (usb_hub_info_t));
+static usb_hub_info_t * usb_hub_info_create(usb_device_t * usb_dev) {
+        usb_hub_info_t * result = malloc(sizeof(usb_hub_info_t));
         if (!result) return NULL;
         result->usb_device = usb_dev;
@@ -199 +200 @@
         result->control_pipe = &usb_dev->ctrl_pipe;
         result->is_default_address_used = false;
-
-        result->ports = NULL;
-        result->port_count = (size_t) - 1;
-        fibril_mutex_initialize(&result->port_mutex);
-
-        fibril_mutex_initialize(&result->pending_ops_mutex);
-        fibril_condvar_initialize(&result->pending_ops_cv);
-        result->pending_ops_count = 0;
         return result;
 }
@@ -220 +213 @@
  * @return error code
  */
-static int usb_hub_process_hub_specific_info(usb_hub_info_t *hub_info) {
+static int usb_hub_process_hub_specific_info(usb_hub_info_t * hub_info) {
         // get hub descriptor
-        usb_log_debug("Creating serialized descriptor\n");
+        usb_log_debug("creating serialized descriptor\n");
         uint8_t serialized_descriptor[USB_HUB_MAX_DESCRIPTOR_SIZE];
         usb_hub_descriptor_t * descriptor;
@@ -234 +227 @@
 
         if (opResult != EOK) {
-                usb_log_error("Failed when receiving hub descriptor, "
-                    "%s\n",
-                    str_error(opResult));
+                usb_log_error("failed when receiving hub descriptor, "
+                    "badcode = %d\n",
+                    opResult);
                 free(serialized_descriptor);
                 return opResult;
         }
-        usb_log_debug2("Deserializing descriptor\n");
+        usb_log_debug2("deserializing descriptor\n");
         descriptor = usb_create_deserialized_hub_desriptor(
             serialized_descriptor);
@@ -251 +244 @@
         /// \TODO this is not semantically correct
         bool is_power_switched =
-            ((descriptor->hub_characteristics & 1) == 0);
+            ((descriptor->hub_characteristics & 1) ==0);
         bool has_individual_port_powering =
-            ((descriptor->hub_characteristics & 1) != 0);
+            ((descriptor->hub_characteristics & 1) !=0);
         hub_info->ports = malloc(
             sizeof (usb_hub_port_t) * (hub_info->port_count + 1));
-        if (!hub_info->ports) {
+        if(!hub_info->ports){
                 return ENOMEM;
         }
@@ -263 +256 @@
                 usb_hub_port_init(&hub_info->ports[port]);
         }
-        if (is_power_switched) {
-                usb_log_debug("Hub power switched\n");
-
-                if (!has_individual_port_powering) {
-                        usb_log_debug("Has_global powering\n");
+        if(is_power_switched){
+                usb_log_debug("is_power_switched\n");
+                
+                if(!has_individual_port_powering){
+                        usb_log_debug("!has_individual_port_powering\n");
                         opResult = usb_hub_set_feature(hub_info->control_pipe,
                             USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
                         if (opResult != EOK) {
-                                usb_log_error("Cannot power hub: %s\n",
+                                usb_log_error("cannot power hub: %s\n",
                                     str_error(opResult));
                         }
@@ -277 +270 @@
 
                 for (port = 1; port <= hub_info->port_count; ++port) {
-                        usb_log_debug("Powering port %zu.\n", port);
+                        usb_log_debug("Powering port %zu.\n",port);
                         opResult = usb_hub_set_port_feature(hub_info->control_pipe,
                             port, USB_HUB_FEATURE_PORT_POWER);
@@ -285 +278 @@
                         }
                 }
-
-        } else {
-                usb_log_debug("Power not switched, not going to be powered\n");
-        }
-        usb_log_debug2("Freeing data\n");
+                
+        }else{
+                usb_log_debug("!is_power_switched, not going to be powered\n");
+        }
+        usb_log_debug2("freeing data\n");
         free(descriptor);
         return EOK;
@@ -302 +295 @@
  * @return error code
  */
-static int usb_hub_set_configuration(usb_hub_info_t *hub_info) {
+static int usb_hub_set_configuration(usb_hub_info_t * hub_info) {
         //device descriptor
         usb_standard_device_descriptor_t *std_descriptor
             = &hub_info->usb_device->descriptors.device;
-        usb_log_debug("Hub has %d configurations\n",
+        usb_log_debug("hub has %d configurations\n",
             std_descriptor->configuration_count);
         if (std_descriptor->configuration_count < 1) {
-                usb_log_error("There are no configurations available\n");
+                usb_log_error("there are no configurations available\n");
                 return EINVAL;
         }
@@ -327 +320 @@
                 return opResult;
         }
-        usb_log_debug("\tUsed configuration %d\n",
+        usb_log_debug("\tused configuration %d\n",
             config_descriptor->configuration_number);
 
@@ -342 +335 @@
  * @return error code
  */
-static int usb_hub_start_hub_fibril(usb_hub_info_t *hub_info) {
+static int usb_hub_start_hub_fibril(usb_hub_info_t * hub_info){
         int rc;
 
         rc = usb_device_auto_poll(hub_info->usb_device, 0,
             hub_port_changes_callback, ((hub_info->port_count + 1) / 8) + 1,
-            usb_hub_polling_terminated_callback, hub_info);
+            usb_hub_polling_terminted_callback, hub_info);
         if (rc != EOK) {
                 usb_log_error("Failed to create polling fibril: %s.\n",
@@ -366 +359 @@
 //*********************************************
 
+
 /**
  * process hub over current change
@@ -374 +368 @@
  * @return error code
  */
-static int usb_process_hub_over_current(usb_hub_info_t *hub_info,
+static int usb_process_hub_over_current(usb_hub_info_t * hub_info,
     usb_hub_status_t status) {
         int opResult;
-        if (usb_hub_is_status(status, USB_HUB_FEATURE_HUB_OVER_CURRENT)) {
+        if (usb_hub_is_status(status,USB_HUB_FEATURE_HUB_OVER_CURRENT)){
                 //poweroff all ports
                 unsigned int port;
-                for (port = 1; port <= hub_info->port_count; ++port) {
+                for(port = 1;port <= hub_info->port_count;++port){
                         opResult = usb_hub_clear_port_feature(
-                            hub_info->control_pipe, port,
+                            hub_info->control_pipe,port,
                             USB_HUB_FEATURE_PORT_POWER);
                         if (opResult != EOK) {
                                 usb_log_warning(
-                                    "Cannot power off port %d;  %s\n",
-                                    port, str_error(opResult));
+                                    "cannot power off port %d;  %d\n",
+                                    port, opResult);
                         }
                 }
@@ -393 +387 @@
                 //power all ports
                 unsigned int port;
-                for (port = 1; port <= hub_info->port_count; ++port) {
+                for(port = 1;port <= hub_info->port_count;++port){
                         opResult = usb_hub_set_port_feature(
-                            hub_info->control_pipe, port,
+                            hub_info->control_pipe,port,
                             USB_HUB_FEATURE_PORT_POWER);
                         if (opResult != EOK) {
                                 usb_log_warning(
-                                    "Cannot power off port %d;  %s\n",
-                                    port, str_error(opResult));
+                                    "cannot power off port %d;  %d\n",
+                                    port, opResult);
                         }
                 }
@@ -415 +409 @@
  * @return error code
  */
-static int usb_process_hub_local_power_change(usb_hub_info_t *hub_info,
+static int usb_process_hub_local_power_change(usb_hub_info_t * hub_info,
     usb_hub_status_t status) {
         int opResult = EOK;
         opResult = usb_hub_clear_feature(hub_info->control_pipe,
             USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
-        if (opResult != EOK) {
-                usb_log_error("Cannnot clear hub power change flag: "
-                    "%s\n",
-                    str_error(opResult));
+                if (opResult != EOK) {
+                usb_log_error("cannnot clear hub power change flag: "
+                    "%d\n",
+                    opResult);
         }
         return opResult;
@@ -435 +429 @@
  * @param hub_info hub instance
  */
-static void usb_hub_process_global_interrupt(usb_hub_info_t *hub_info) {
-        usb_log_debug("Global interrupt on a hub\n");
+static void usb_hub_process_global_interrupt(usb_hub_info_t * hub_info) {
+        usb_log_debug("global interrupt on a hub\n");
         usb_pipe_t *pipe = hub_info->control_pipe;
         int opResult;
@@ -453 +447 @@
             );
         if (opResult != EOK) {
-                usb_log_error("Could not get hub status: %s\n",
-                    str_error(opResult));
+                usb_log_error("could not get hub status\n");
                 return;
         }
         if (rcvd_size != sizeof (usb_port_status_t)) {
-                usb_log_error("Received status has incorrect size\n");
+                usb_log_error("received status has incorrect size\n");
                 return;
         }
         //port reset
         if (
-            usb_hub_is_status(status, 16 + USB_HUB_FEATURE_C_HUB_OVER_CURRENT)) {
+            usb_hub_is_status(status,16+USB_HUB_FEATURE_C_HUB_OVER_CURRENT)) {
                 usb_process_hub_over_current(hub_info, status);
         }
         if (
-            usb_hub_is_status(status, 16 + USB_HUB_FEATURE_C_HUB_LOCAL_POWER)) {
+            usb_hub_is_status(status,16+USB_HUB_FEATURE_C_HUB_LOCAL_POWER)) {
                 usb_process_hub_local_power_change(hub_info, status);
         }
@@ -480 +473 @@
  * @param data pointer to usb_hub_info_t structure
  */
-static void usb_hub_polling_terminated_callback(usb_device_t *device,
-    bool was_error, void *data) {
-        usb_hub_info_t * hub = data;
-        assert(hub);
-
-        fibril_mutex_lock(&hub->pending_ops_mutex);
-
-        /* The device is dead. However there might be some pending operations
-         * that we need to wait for.
-         * One of them is device adding in progress.
-         * The respective fibril is probably waiting for status change
-         * in port reset (port enable) callback.
-         * Such change would never come (otherwise we would not be here).
-         * Thus, we would flush all pending port resets.
-         */
-        if (hub->pending_ops_count > 0) {
-                fibril_mutex_lock(&hub->port_mutex);
-                size_t port;
-                for (port = 0; port < hub->port_count; port++) {
-                        usb_hub_port_t *the_port = hub->ports + port;
-                        fibril_mutex_lock(&the_port->reset_mutex);
-                        the_port->reset_completed = true;
-                        the_port->reset_okay = false;
-                        fibril_condvar_broadcast(&the_port->reset_cv);
-                        fibril_mutex_unlock(&the_port->reset_mutex);
-                }
-                fibril_mutex_unlock(&hub->port_mutex);
-        }
-        /* And now wait for them. */
-        while (hub->pending_ops_count > 0) {
-                fibril_condvar_wait(&hub->pending_ops_cv,
-                    &hub->pending_ops_mutex);
-        }
-        fibril_mutex_unlock(&hub->pending_ops_mutex);
-
-        usb_device_destroy(hub->usb_device);
-
-        free(hub->ports);
-        free(hub);
+static void usb_hub_polling_terminted_callback(usb_device_t * device,
+    bool was_error, void * data){
+        usb_hub_info_t * hub_info = data;
+        if(!hub_info) return;
+        free(hub_info->ports);
+        free(hub_info);
 }
 

uspace/drv/usbhub/usbhub.h

@@ -51 +51 @@
 #include "ports.h"
 
+
+
 /** Information about attached hub. */
-struct usb_hub_info_t {
+struct usb_hub_info_t{
         /** Number of ports. */
         size_t port_count;
@@ -58 +60 @@
         /** attached device handles, for each port one */
         usb_hub_port_t *ports;
-
-        fibril_mutex_t port_mutex;
 
         /** connection to hcd */
@@ -89 +89 @@
         /** generic usb device data*/
         usb_device_t * usb_device;
-
-        /** Number of pending operations on the mutex to prevent shooting
-         * ourselves in the foot.
-         * When the hub is disconnected but we are in the middle of some
-         * operation, we cannot destroy this structure right away because
-         * the pending operation might use it.
-         */
-        size_t pending_ops_count;
-        /** Guard for pending_ops_count. */
-        fibril_mutex_t pending_ops_mutex;
-        /** Condition variable for pending_ops_count. */
-        fibril_condvar_t pending_ops_cv;
-
 };
 
-int usb_hub_add_device(usb_device_t *usb_dev);
+//int usb_hub_control_loop(void * hub_info_param);
+
+int usb_hub_add_device(usb_device_t * usb_dev);
 
 bool hub_port_changes_callback(usb_device_t *dev,

uspace/drv/usbhub/usbhub_private.h

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

uspace/drv/usbhub/utils.c

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

uspace/drv/usbmouse/init.c

@@ -39 +39 @@
 #include <usb/hid/hid.h>
 #include <usb/dev/request.h>
-#include <usb/hid/request.h>
 #include <errno.h>
 
@@ -127 +126 @@
         
         /* Set the boot protocol. */
-        rc = usbhid_req_set_protocol(&dev->ctrl_pipe, dev->interface_no,
-            USB_HID_PROTOCOL_BOOT);
+        rc = usb_control_request_set(&dev->ctrl_pipe,
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
+            USB_HIDREQ_SET_PROTOCOL, USB_HID_PROTOCOL_BOOT, dev->interface_no,
+            NULL, 0);
         if (rc != EOK) {
                 goto leave;

uspace/drv/usbmouse/mouse.c

@@ -117 +117 @@
         async_hangup(mouse->console_phone);
         mouse->console_phone = -1;
-
-        usb_device_destroy(dev);
 }
 

uspace/lib/drv/generic/driver.c

@@ -405 +405 @@
                                 /* The interface has not such method */
                                 printf("%s: driver_connection_gen error - "
-                                    "invalid interface method "
-                                    "(index %" PRIun ").\n",
+                                    "invalid interface method (%d).\n",
                                     driver->name, iface_method_idx);
                                 async_answer_0(callid, ENOTSUP);

uspace/lib/drv/include/usbhc_iface.h

@@ -212 +212 @@
 /** USB host controller communication interface. */
 typedef struct {
+        int (*reserve_default_address)(ddf_fun_t *, usb_speed_t);
+        int (*release_default_address)(ddf_fun_t *);
         int (*request_address)(ddf_fun_t *, usb_speed_t, usb_address_t *);
         int (*bind_address)(ddf_fun_t *, usb_address_t, devman_handle_t);

uspace/lib/usbdev/include/usb/dev/driver.h

@@ -168 +168 @@
 int usb_device_destroy_pipes(ddf_dev_t *, usb_endpoint_mapping_t *, size_t);
 int usb_device_create(ddf_dev_t *, usb_endpoint_description_t **, usb_device_t **, const char **);
-void usb_device_destroy(usb_device_t *);
 
 size_t usb_interface_count_alternates(uint8_t *, size_t, uint8_t);

uspace/lib/usbdev/src/devdrv.c

@@ -533 +533 @@
 }
 
-/** Destroy instance of a USB device.
- *
- * @param dev Device to be destroyed.
- */
-void usb_device_destroy(usb_device_t *dev)
-{
-        if (dev == NULL) {
-                return;
-        }
-
-        /* Ignore errors and hope for the best. */
-        usb_device_destroy_pipes(dev->ddf_dev, dev->pipes, dev->pipes_count);
-        if (dev->descriptors.configuration != NULL) {
-                free(dev->descriptors.configuration);
-        }
-
-        if (dev->alternate_interfaces != NULL) {
-                if (dev->alternate_interfaces->alternatives != NULL) {
-                        free(dev->alternate_interfaces->alternatives);
-                }
-                free(dev->alternate_interfaces);
-        }
-
-        free(dev);
-}
-
 /**
  * @}

uspace/srv/hid/console/console.c

@@ -57 +57 @@
 #include <io/style.h>
 #include <io/screenbuffer.h>
-#include <inttypes.h>
 
 #include "console.h"
@@ -68 +67 @@
 /** Interval for checking for new keyboard (1/4s). */
 #define HOTPLUG_WATCH_INTERVAL (1000 * 250)
-
-/* Kernel defines 32 but does not export it. */
-#define MAX_IPC_OUTGOING_PHONES 128
-/** To allow proper phone closing. */
-static ipc_callid_t driver_phones[MAX_IPC_OUTGOING_PHONES] = { 0 };
 
 /** Phone to the keyboard driver. */
@@ -96 +90 @@
                                        contents and related settings. */
 } console_t;
-
-
 
 /** Array of data for virtual consoles */
@@ -409 +401 @@
 }
 
-static void close_driver_phone(ipc_callid_t hash)
-{
-        int i;
-        for (i = 0; i < MAX_IPC_OUTGOING_PHONES; i++) {
-                if (driver_phones[i] == hash) {
-                        printf("Device %" PRIxn " gone.\n", hash);
-                        driver_phones[i] = 0;
-                        async_hangup(i);
-                        return;
-                }
-        }
-}
-
 /** Handler for keyboard */
 static void keyboard_events(ipc_callid_t iid, ipc_call_t *icall)
@@ -436 +415 @@
                 case IPC_M_PHONE_HUNGUP:
                         /* TODO: Handle hangup */
-                        close_driver_phone(iid);
                         return;
                 case KBD_EVENT:
@@ -480 +458 @@
                 case IPC_M_PHONE_HUNGUP:
                         /* TODO: Handle hangup */
-                        close_driver_phone(iid);
                         return;
                 case MEVENT_BUTTON:
@@ -738 +715 @@
 }
 
-static int async_connect_to_me_hack(int phone, sysarg_t arg1, sysarg_t arg2,
-sysarg_t arg3, async_client_conn_t client_receiver, ipc_callid_t *hash)
-{
-        sysarg_t task_hash;
-        sysarg_t phone_hash;
-        int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
-            NULL, NULL, NULL, &task_hash, &phone_hash);
-        if (rc != EOK)
-                return rc;
-
-        if (client_receiver != NULL)
-                async_new_connection(task_hash, phone_hash, phone_hash, NULL,
-                    client_receiver);
-
-        if (hash != NULL) {
-                *hash = phone_hash;
-        }
-
-        return EOK;
-}
-
 static int connect_keyboard_or_mouse(const char *devname,
     async_client_conn_t handler, const char *path)
@@ -773 +729 @@
         }
         
-        ipc_callid_t hash;
-        int rc = async_connect_to_me_hack(phone, SERVICE_CONSOLE, 0, phone,
-            handler, &hash);
+        int rc = async_connect_to_me(phone, SERVICE_CONSOLE, 0, 0, handler);
         if (rc != EOK) {
                 printf(NAME ": " \
@@ -783 +737 @@
         }
         
-        driver_phones[phone] = hash;
-
-        printf(NAME ": found %s \"%s\" (%" PRIxn ").\n", devname, path, hash);
+        printf(NAME ": found %s \"%s\".\n", devname, path);
 
         return phone;