Changes in / [2ac7af3:6d4d883] in mainline

Files:

• kernel/arch/ia64/src/drivers/ski.c (modified) (1 diff)
• kernel/generic/src/console/cmd.c (modified) (2 diffs)
• uspace/drv/bus/usb/ohci/hc.c (modified) (1 diff)
• uspace/drv/bus/usb/ohci/ohci_batch.c (modified) (12 diffs)
• uspace/drv/bus/usb/ohci/pci.c (modified) (1 diff)
• uspace/drv/bus/usb/ohci/root_hub.c (modified) (1 diff)
• uspace/drv/bus/usb/ohci/utils/malloc32.h (modified) (1 diff)
• uspace/drv/bus/usb/uhci/hc.c (modified) (1 diff)
• uspace/drv/bus/usb/uhci/pci.c (modified) (1 diff)
• uspace/drv/bus/usb/uhci/uhci_batch.c (modified) (1 diff)
• uspace/drv/bus/usb/uhci/utils/malloc32.h (modified) (2 diffs)
• uspace/drv/bus/usb/uhcirh/port.c (modified) (9 diffs)
• uspace/drv/bus/usb/uhcirh/port.h (modified) (2 diffs)
• uspace/drv/bus/usb/usbflbk/main.c (modified) (2 diffs)
• uspace/drv/bus/usb/usbhid/main.c (modified) (2 diffs)
• uspace/drv/bus/usb/usbhub/main.c (modified) (1 diff)
• uspace/drv/bus/usb/usbhub/port.c (modified) (22 diffs)
• uspace/drv/bus/usb/usbhub/port.h (modified) (4 diffs)
• uspace/drv/bus/usb/usbhub/usbhub.c (modified) (21 diffs)
• uspace/drv/bus/usb/usbhub/usbhub.h (modified) (2 diffs)
• uspace/drv/bus/usb/usbmast/main.c (modified) (4 diffs)
• uspace/drv/bus/usb/usbmid/main.c (modified) (2 diffs)
• uspace/drv/bus/usb/usbmouse/main.c (modified) (2 diffs)
• uspace/drv/bus/usb/vhc/hub.c (modified) (2 diffs)
• uspace/lib/c/generic/async.c (modified) (2 diffs)
• uspace/lib/ext2/libext2_filesystem.c (modified) (1 diff)
• uspace/lib/usb/include/usb/hc.h (modified) (1 diff)
• uspace/lib/usb/src/hc.c (modified) (1 diff)
• uspace/lib/usbdev/include/usb/dev/driver.h (modified) (3 diffs)
• uspace/lib/usbdev/include/usb/dev/hub.h (modified) (2 diffs)
• uspace/lib/usbdev/include/usb/dev/pipes.h (modified) (2 diffs)
• uspace/lib/usbdev/include/usb/dev/recognise.h (modified) (1 diff)
• uspace/lib/usbdev/src/devdrv.c (modified) (9 diffs)
• uspace/lib/usbdev/src/hub.c (modified) (14 diffs)
• uspace/lib/usbdev/src/pipes.c (modified) (3 diffs)
• uspace/lib/usbdev/src/pipesio.c (modified) (2 diffs)
• uspace/lib/usbdev/src/recognise.c (modified) (3 diffs)

kernel/arch/ia64/src/drivers/ski.c

@@ -219 +219 @@
                  * self-sufficient.
                  */
-                sysinfo_set_item_val("fb", NULL, true);
                 sysinfo_set_item_val("fb.kind", NULL, 6);
                 

kernel/generic/src/console/cmd.c

@@ -1177 +1177 @@
                 /* Execute the test */
                 test_quiet = true;
-                const char *test_ret = test->entry();
+                const char *ret = test->entry();
                 
                 /* Update and read thread accounting */
@@ -1185 +1185 @@
                 irq_spinlock_unlock(&TASK->lock, true);
                 
-                if (test_ret != NULL) {
-                        printf("%s\n", test_ret);
+                if (ret != NULL) {
+                        printf("%s\n", ret);
                         ret = false;
                         break;

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

@@ -571 +571 @@
         usb_log_debug2("OHCI HCCA initialized at %p.\n", instance->hcca);
 
-        for (unsigned i = 0; i < 32; ++i) {
+        unsigned i = 0;
+        for (; i < 32; ++i) {
                 instance->hcca->int_ep[i] =
                     instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa;

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

@@ -52 +52 @@
         if (!ohci_batch)
                 return;
+        unsigned i = 0;
         if (ohci_batch->tds) {
-                for (unsigned i = 0; i < ohci_batch->td_count; ++i) {
+                for (; i< ohci_batch->td_count; ++i) {
                         if (i != ohci_batch->leave_td)
                                 free32(ohci_batch->tds[i]);
@@ -106 +107 @@
         ohci_batch->tds[0] = ohci_endpoint_get(usb_batch->ep)->td;
         ohci_batch->leave_td = 0;
-
-        for (unsigned i = 1; i <= ohci_batch->td_count; ++i) {
+        unsigned i = 1;
+        for (; i <= ohci_batch->td_count; ++i) {
                 ohci_batch->tds[i] = malloc32(sizeof(td_t));
                 CHECK_NULL_DISPOSE_RET(ohci_batch->tds[i],
@@ -159 +160 @@
         usb_log_debug("Batch %p checking %zu td(s) for completion.\n",
             ohci_batch->usb_batch, ohci_batch->td_count);
-        usb_log_debug2("ED: %08x:%08x:%08x:%08x.\n",
+        usb_log_debug2("ED: %x:%x:%x:%x.\n",
             ohci_batch->ed->status, ohci_batch->ed->td_head,
             ohci_batch->ed->td_tail, ohci_batch->ed->next);
@@ -166 +167 @@
         for (; i < ohci_batch->td_count; ++i) {
                 assert(ohci_batch->tds[i] != NULL);
-                usb_log_debug("TD %zu: %08x:%08x:%08x:%08x.\n", i,
+                usb_log_debug("TD %zu: %x:%x:%x:%x.\n", i,
                     ohci_batch->tds[i]->status, ohci_batch->tds[i]->cbp,
                     ohci_batch->tds[i]->next, ohci_batch->tds[i]->be);
@@ -174 +175 @@
                 ohci_batch->usb_batch->error = td_error(ohci_batch->tds[i]);
                 if (ohci_batch->usb_batch->error != EOK) {
-                        usb_log_debug("Batch %p found error TD(%zu):%08x.\n",
+                        usb_log_debug("Batch %p found error TD(%zu):%x.\n",
                             ohci_batch->usb_batch, i,
                             ohci_batch->tds[i]->status);
@@ -195 +196 @@
         ohci_batch->usb_batch->transfered_size =
             ohci_batch->usb_batch->buffer_size;
-        for (--i;i < ohci_batch->td_count; ++i) {
+        for (--i;i < ohci_batch->td_count; ++i)
                 ohci_batch->usb_batch->transfered_size
                     -= td_remain_size(ohci_batch->tds[i]);
-        }
 
         /* Clear possible ED HALT */
@@ -234 +234 @@
         assert(ohci_batch->usb_batch);
         assert(dir == USB_DIRECTION_IN || dir == USB_DIRECTION_OUT);
-        usb_log_debug("Using ED(%p): %08x:%08x:%08x:%08x.\n", ohci_batch->ed,
+        usb_log_debug("Using ED(%p): %x:%x:%x:%x.\n", ohci_batch->ed,
             ohci_batch->ed->status, ohci_batch->ed->td_tail,
             ohci_batch->ed->td_head, ohci_batch->ed->next);
@@ -251 +251 @@
                 ohci_batch->usb_batch->setup_size, toggle);
         td_set_next(ohci_batch->tds[0], ohci_batch->tds[1]);
-        usb_log_debug("Created CONTROL SETUP TD: %08x:%08x:%08x:%08x.\n",
+        usb_log_debug("Created CONTROL SETUP TD: %x:%x:%x:%x.\n",
             ohci_batch->tds[0]->status, ohci_batch->tds[0]->cbp,
             ohci_batch->tds[0]->next, ohci_batch->tds[0]->be);
@@ -269 +269 @@
                 td_set_next(ohci_batch->tds[td_current],
                     ohci_batch->tds[td_current + 1]);
-                usb_log_debug("Created CONTROL DATA TD: %08x:%08x:%08x:%08x.\n",
+                usb_log_debug("Created CONTROL DATA TD: %x:%x:%x:%x.\n",
                     ohci_batch->tds[td_current]->status,
                     ohci_batch->tds[td_current]->cbp,
@@ -286 +286 @@
         td_set_next(ohci_batch->tds[td_current],
             ohci_batch->tds[td_current + 1]);
-        usb_log_debug("Created CONTROL STATUS TD: %08x:%08x:%08x:%08x.\n",
+        usb_log_debug("Created CONTROL STATUS TD: %x:%x:%x:%x.\n",
             ohci_batch->tds[td_current]->status,
             ohci_batch->tds[td_current]->cbp,
@@ -312 +312 @@
         assert(ohci_batch->usb_batch);
         assert(dir == USB_DIRECTION_IN || dir == USB_DIRECTION_OUT);
-        usb_log_debug("Using ED(%p): %08x:%08x:%08x:%08x.\n", ohci_batch->ed,
+        usb_log_debug("Using ED(%p): %x:%x:%x:%x.\n", ohci_batch->ed,
             ohci_batch->ed->status, ohci_batch->ed->td_tail,
             ohci_batch->ed->td_head, ohci_batch->ed->next);
@@ -328 +328 @@
                     ohci_batch->tds[td_current + 1]);
 
-                usb_log_debug("Created DATA TD: %08x:%08x:%08x:%08x.\n",
+                usb_log_debug("Created DATA TD: %x:%x:%x:%x.\n",
                     ohci_batch->tds[td_current]->status,
                     ohci_batch->tds[td_current]->cbp,

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

@@ -85 +85 @@
         bool irq_found = false;
 
-        for (size_t i = 0; i < hw_resources.count; i++) {
+        size_t i;
+        for (i = 0; i < hw_resources.count; i++) {
                 hw_resource_t *res = &hw_resources.resources[i];
                 switch (res->type) {

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

@@ -351 +351 @@
                 mask |= 1;
         }
-        for (size_t port = 1; port <= instance->port_count; ++port) {
+        size_t port = 1;
+        for (; port <= instance->port_count; ++port) {
                 /* Write-clean bits are those that indicate change */
                 if (RHPS_CHANGE_WC_MASK

uspace/drv/bus/usb/ohci/utils/malloc32.h

@@ -69 +69 @@
  */
 static inline void free32(void *addr)
-        { free(addr); }
+        { if (addr) free(addr); }
 #endif
 /**

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

@@ -299 +299 @@
         const uint32_t queue = LINK_POINTER_QH(
                 addr_to_phys(instance->transfers_interrupt.queue_head));
-
-        for (unsigned i = 0; i < UHCI_FRAME_LIST_COUNT; ++i) {
+        unsigned i = 0;
+        for(; i < UHCI_FRAME_LIST_COUNT; ++i) {
                 instance->frame_list[i] = queue;
         }

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

@@ -82 +82 @@
         bool irq_found = false;
 
-        for (size_t i = 0; i < hw_resources.count; i++) {
+        size_t i;
+        for (i = 0; i < hw_resources.count; i++) {
                 const hw_resource_t *res = &hw_resources.resources[i];
                 switch (res->type) {

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

@@ -167 +167 @@
             uhci_batch->td_count);
         uhci_batch->usb_batch->transfered_size = 0;
-
-        for (size_t i = 0;i < uhci_batch->td_count; ++i) {
+        size_t i = 0;
+        for (;i < uhci_batch->td_count; ++i) {
                 if (td_is_active(&uhci_batch->tds[i])) {
                         return false;

uspace/drv/bus/usb/uhci/utils/malloc32.h

@@ -62 +62 @@
 }
 /*----------------------------------------------------------------------------*/
-/** DMA malloc simulator
+/** Physical mallocator simulator
  *
  * @param[in] size Size of the required memory space
- * @return Address of the aligned and big enough memory place, NULL on failure.
+ * @return Address of the alligned and big enough memory place, NULL on failure.
  */
-static inline void * malloc32(size_t size)
-{
+static inline void * malloc32(size_t size) {
         /* This works only when the host has less than 4GB of memory as
          * physical address needs to fit into 32 bits */
@@ -84 +83 @@
 }
 /*----------------------------------------------------------------------------*/
-/** DMA malloc simulator
+/** Physical mallocator simulator
  *
  * @param[in] addr Address of the place allocated by malloc32
  */
-static inline void free32(void *addr)
-        { free(addr); }
+static inline void free32(void *addr) {
+        if (!addr)
+                return;
+        free(addr);
+}
 /*----------------------------------------------------------------------------*/
 /** Create 4KB page mapping

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

@@ -37 +37 @@
 #include <str_error.h>
 #include <async.h>
-#include <devman.h>
 
 #include <usb/usb.h>    /* usb_address_t */
+#include <usb/dev/hub.h>    /* usb_hc_new_device_wrapper */
 #include <usb/debug.h>
 
 #include "port.h"
 
-#define MAX_ERROR_COUNT 5
-
 static int uhci_port_check(void *port);
-static int uhci_port_reset_enable(void *arg);
+static int uhci_port_reset_enable(int portno, void *arg);
 static int uhci_port_new_device(uhci_port_t *port, usb_speed_t speed);
 static int uhci_port_remove_device(uhci_port_t *port);
@@ -102 +100 @@
         port->number = number;
         port->wait_period_usec = usec;
-        port->attached_device.fun = NULL;
-        port->attached_device.address = -1;
+        port->attached_device = 0;
         port->rh = rh;
 
@@ -153 +150 @@
         assert(instance);
 
-        unsigned allowed_failures = MAX_ERROR_COUNT;
-#define CHECK_RET_FAIL(ret, msg...) \
-        if (ret != EOK) { \
-                usb_log_error(msg); \
-                if (!(allowed_failures-- > 0)) { \
-                        usb_log_fatal( \
-                           "Maximum number of failures reached, " \
-                           "bailing out.\n"); \
-                        return ret; \
-                } \
-                continue; \
-        } else (void)0
-
         while (1) {
                 async_usleep(instance->wait_period_usec);
@@ -183 +167 @@
                     instance->id_string, port_status);
 
-                int ret = usb_hc_connection_open(&instance->hc_connection);
-                CHECK_RET_FAIL(ret, "%s: Failed to connect to HC %s.\n",
-                    instance->id_string, str_error(ret));
-
                 /* Remove any old device */
-                if (instance->attached_device.fun) {
+                if (instance->attached_device) {
+                        usb_log_debug2("%s: Removing device.\n",
+                            instance->id_string);
                         uhci_port_remove_device(instance);
                 }
 
+                int ret =
+                    usb_hc_connection_open(&instance->hc_connection);
+                if (ret != EOK) {
+                        usb_log_error("%s: Failed to connect to HC.",
+                            instance->id_string);
+                        continue;
+                }
+
                 if ((port_status & STATUS_CONNECTED) != 0) {
-                        /* New device, this will take care of WC bits */
+                        /* New device */
                         const usb_speed_t speed =
                             ((port_status & STATUS_LOW_SPEED) != 0) ?
@@ -206 +196 @@
 
                 ret = usb_hc_connection_close(&instance->hc_connection);
-                CHECK_RET_FAIL(ret, "%s: Failed to disconnect from hc: %s.\n",
-                    instance->id_string, str_error(ret));
+                if (ret != EOK) {
+                        usb_log_error("%s: Failed to disconnect.",
+                            instance->id_string);
+                }
         }
         return EOK;
@@ -220 +212 @@
  * Resets and enables the ub port.
  */
-int uhci_port_reset_enable(void *arg)
+int uhci_port_reset_enable(int portno, void *arg)
 {
         uhci_port_t *port = arg;
@@ -264 +256 @@
         usb_log_debug("%s: Detected new device.\n", port->id_string);
 
-        int ret, count = MAX_ERROR_COUNT;
+        int ret, count = 0;
+        usb_address_t dev_addr;
         do {
                 ret = usb_hc_new_device_wrapper(port->rh, &port->hc_connection,
-                    speed, uhci_port_reset_enable, port,
-                    &port->attached_device.address, NULL, NULL,
-                    &port->attached_device.fun);
-        } while (ret != EOK && count-- > 0);
+                    speed, uhci_port_reset_enable, port->number, port,
+                    &dev_addr, &port->attached_device, NULL, NULL, NULL);
+        } while (ret != EOK && ++count < 4);
 
         if (ret != EOK) {
@@ -279 +271 @@
         }
 
-        usb_log_info("%s: New device, address %d (handle %" PRIun ").\n",
-            port->id_string, port->attached_device.address,
-            port->attached_device.fun->handle);
+        usb_log_info("New device at port %u, address %d (handle %" PRIun ").\n",
+            port->number, dev_addr, port->attached_device);
         return EOK;
 }
@@ -287 +278 @@
 /** Remove device.
  *
- * @param[in] port Port instance to use.
- * @return Error code.
+ * @param[in] port Memory structure to use.
+ * @return Error code.
+ *
+ * Does not work, DDF does not support device removal.
+ * Does not even free used USB address (it would be dangerous if tis driver
+ * is still running).
  */
 int uhci_port_remove_device(uhci_port_t *port)
 {
-        assert(port);
-        /* There is nothing to remove. */
-        if (port->attached_device.fun == NULL) {
-                usb_log_warning("%s: Removed a ghost device.\n",
-                    port->id_string);
-                assert(port->attached_device.address == -1);
-                return EOK;
-        }
-
-        usb_log_debug("%s: Removing device.\n", port->id_string);
-
-        /* Stop driver first */
-        int ret = ddf_fun_unbind(port->attached_device.fun);
-        if (ret != EOK) {
-                usb_log_error("%s: Failed to remove child function: %s.\n",
-                   port->id_string, str_error(ret));
-                return ret;
-        }
-        ddf_fun_destroy(port->attached_device.fun);
-        port->attached_device.fun = NULL;
-
-        /* Driver stopped, free used address */
-        ret = usb_hc_unregister_device(&port->hc_connection,
-            port->attached_device.address);
-        if (ret != EOK) {
-                usb_log_error("%s: Failed to unregister address of removed "
-                    "device: %s.\n", port->id_string, str_error(ret));
-                return ret;
-        }
-        port->attached_device.address = -1;
-
-        usb_log_info("%s: Removed attached device.\n", port->id_string);
-        return EOK;
+        usb_log_error("%s: Don't know how to remove device %" PRIun ".\n",
+            port->id_string, port->attached_device);
+        port->attached_device = 0;
+        return ENOTSUP;
 }
 /*----------------------------------------------------------------------------*/

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

@@ -39 +39 @@
 #include <ddf/driver.h>
 #include <usb/hc.h> /* usb_hc_connection_t */
-#include <usb/dev/hub.h>
 
 typedef uint16_t port_status_t;
@@ -63 +62 @@
         usb_hc_connection_t hc_connection;
         ddf_dev_t *rh;
-        usb_hub_attached_device_t attached_device;
+        devman_handle_t attached_device;
         fid_t checker;
 } uhci_port_t;

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

@@ -46 +46 @@
  * @return Error code.
  */
-static int usbfallback_device_add(usb_device_t *dev)
+static int usbfallback_add_device(usb_device_t *dev)
 {
         int rc;
@@ -74 +74 @@
 /** USB fallback driver ops. */
 static usb_driver_ops_t usbfallback_driver_ops = {
-        .device_add = usbfallback_device_add,
+        .add_device = usbfallback_add_device,
 };
 

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

@@ -150 +150 @@
  * @retval EREFUSED if the device is not supported.
  */
-static int usb_hid_device_add(usb_device_t *dev)
+static int usb_hid_add_device(usb_device_t *dev)
 {
-        usb_log_debug("usb_hid_device_add()\n");
+        usb_log_debug("usb_hid_add_device()\n");
         
         if (dev == NULL) {
@@ -185 +185 @@
  * supports unplug, more callbacks will be added. */
 static usb_driver_ops_t usb_hid_driver_ops = {
-        .device_add = usb_hid_device_add,
+        .add_device = usb_hid_add_device,
 };
 

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

@@ -59 +59 @@
  * USB hub driver operations
  *
- * The most important one is device_add, which is set to usb_hub_device_add.
+ * The most important one is add_device, which is set to usb_hub_add_device.
  */
 static usb_driver_ops_t usb_hub_driver_ops = {
-        .device_add = usb_hub_device_add,
-        .device_gone = usb_hub_device_gone,
+        .add_device = usb_hub_add_device
 };
 

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

@@ -50 +50 @@
 /** Information for fibril for device discovery. */
 struct add_device_phase1 {
-        usb_hub_dev_t *hub;
+        usb_hub_info_t *hub;
         usb_hub_port_t *port;
         usb_speed_t speed;
 };
 
-static int usb_hub_port_device_gone(usb_hub_port_t *port, usb_hub_dev_t *hub);
+static void usb_hub_port_removed_device(usb_hub_port_t *port,
+    usb_hub_info_t *hub);
 static void usb_hub_port_reset_completed(usb_hub_port_t *port,
     usb_port_status_t status);
 static int get_port_status(usb_hub_port_t *port, usb_port_status_t *status);
-static int enable_port_callback(void *arg);
+static int enable_port_callback(int port_no, void *arg);
 static int add_device_phase1_worker_fibril(void *arg);
-static int create_add_device_fibril(usb_hub_port_t *port, usb_hub_dev_t *hub,
+static int create_add_device_fibril(usb_hub_port_t *port, usb_hub_info_t *hub,
     usb_speed_t speed);
 
-int usb_hub_port_fini(usb_hub_port_t *port, usb_hub_dev_t *hub)
-{
-        assert(port);
-        if (port->attached_device.fun)
-                return usb_hub_port_device_gone(port, hub);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
 /**
  * Clear feature on hub port.
  *
- * @param port Port structure.
- * @param feature Feature selector.
+ * @param hc Host controller telephone
+ * @param address Hub address
+ * @param port_index Port
+ * @param feature Feature selector
  * @return Operation result
  */
@@ -83 +78 @@
 {
         assert(port);
-        const usb_device_request_setup_packet_t clear_request = {
+        usb_device_request_setup_packet_t clear_request = {
                 .request_type = USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE,
                 .request = USB_DEVREQ_CLEAR_FEATURE,
@@ -95 +90 @@
 /*----------------------------------------------------------------------------*/
 /**
- * Set feature on hub port.
- *
- * @param port Port structure.
- * @param feature Feature selector.
+ * Clear feature on hub port.
+ *
+ * @param hc Host controller telephone
+ * @param address Hub address
+ * @param port_index Port
+ * @param feature Feature selector
  * @return Operation result
  */
@@ -105 +102 @@
 {
         assert(port);
-        const usb_device_request_setup_packet_t clear_request = {
+        usb_device_request_setup_packet_t clear_request = {
                 .request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE,
                 .request = USB_DEVREQ_SET_FEATURE,
@@ -116 +113 @@
 }
 /*----------------------------------------------------------------------------*/
-/**
- * Mark reset process as failed due to external reasons
- *
- * @param port Port structure
- */
 void usb_hub_port_reset_fail(usb_hub_port_t *port)
 {
@@ -132 +124 @@
 /*----------------------------------------------------------------------------*/
 /**
- * Process interrupts on given port
+ * Process interrupts on given hub port
  *
  * Accepts connection, over current and port reset change.
- * @param port port structure
  * @param hub hub representation
- */
-void usb_hub_port_process_interrupt(usb_hub_port_t *port, usb_hub_dev_t *hub)
+ * @param port port number, starting from 1
+ */
+void usb_hub_port_process_interrupt(usb_hub_port_t *port, usb_hub_info_t *hub)
 {
         assert(port);
@@ -179 +171 @@
                          * to that handler, it shall ACK the change too. */
                         if (!(status & USB_HUB_PORT_C_STATUS_ENABLED)) {
-                                usb_hub_port_device_gone(port, hub);
+                                usb_hub_port_removed_device(port, hub);
                         }
                 }
@@ -188 +180 @@
                 usb_log_info("Port %zu, disabled because of errors.\n",
                    port->port_number);
-                usb_hub_port_device_gone(port, hub);
+                usb_hub_port_removed_device(port, hub);
                 const int rc = usb_hub_port_clear_feature(port,
                         USB_HUB_FEATURE_C_PORT_ENABLE);
@@ -246 +238 @@
             port->port_number, status);
 }
-/*----------------------------------------------------------------------------*/
+
 /**
  * routine called when a device on port has been removed
@@ -253 +245 @@
  * Otherwise does not do anything, because DDF does not allow to remove device
  * from it`s device tree.
- * @param port port structure
  * @param hub hub representation
- */
-int usb_hub_port_device_gone(usb_hub_port_t *port, usb_hub_dev_t *hub)
+ * @param port port number, starting from 1
+ */
+static void usb_hub_port_removed_device(usb_hub_port_t *port,
+    usb_hub_info_t *hub)
 {
         assert(port);
         assert(hub);
-        if (port->attached_device.address < 0) {
+        if (port->attached_device.address >= 0) {
+                fibril_mutex_lock(&port->mutex);
+                port->attached_device.address = -1;
+                port->attached_device.handle = 0;
+                fibril_mutex_unlock(&port->mutex);
+                usb_log_info("Removed device on port %zu.\n",
+                    port->port_number);
+        } else {
                 usb_log_warning(
                     "Device on port %zu removed before being registered.\n",
@@ -271 +271 @@
                  */
                 usb_hub_port_reset_fail(port);
-                return EOK;
-        }
-
-        fibril_mutex_lock(&port->mutex);
-        assert(port->attached_device.fun);
-        usb_log_debug("Removing device on port %zu.\n", port->port_number);
-        int ret = ddf_fun_unbind(port->attached_device.fun);
-        if (ret != EOK) {
-                usb_log_error("Failed to unbind child function on port"
-                    " %zu: %s.\n", port->port_number, str_error(ret));
-                fibril_mutex_unlock(&port->mutex);
-                return ret;
-        }
-
-        ddf_fun_destroy(port->attached_device.fun);
-        port->attached_device.fun = NULL;
-
-        ret = usb_hc_unregister_device(&hub->connection,
-            port->attached_device.address);
-        if (ret != EOK) {
-                usb_log_warning("Failed to unregister address of the removed "
-                    "device: %s.\n", str_error(ret));
-        }
-        port->attached_device.address = -1;
-        fibril_mutex_unlock(&port->mutex);
-        usb_log_info("Removed device on port %zu.\n", port->port_number);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
+        }
+}
+
 /**
  * Process port reset change
@@ -305 +279 @@
  * After this change port should be enabled, unless some problem occurred.
  * This functions triggers second phase of enabling new device.
- * @param port Port structure
- * @param status Port status mask
- */
-void usb_hub_port_reset_completed(usb_hub_port_t *port,
+ * @param hub
+ * @param port
+ * @param status
+ */
+static void usb_hub_port_reset_completed(usb_hub_port_t *port,
     usb_port_status_t status)
 {
@@ -338 +313 @@
 /** Retrieve port status.
  *
- * @param[in] port Port structure
+ * @param[in] ctrl_pipe Control pipe to use.
+ * @param[in] port Port number (starting at 1).
  * @param[out] status Where to store the port status.
  * @return Error code.
@@ -382 +358 @@
  *
  * @param port_no Port number (starting at 1).
- * @param arg Custom argument, points to @c usb_hub_dev_t.
+ * @param arg Custom argument, points to @c usb_hub_info_t.
  * @return Error code.
  */
-static int enable_port_callback(void *arg)
+static int enable_port_callback(int port_no, void *arg)
 {
         usb_hub_port_t *port = arg;
@@ -404 +380 @@
         fibril_mutex_unlock(&port->mutex);
 
-        return port->reset_okay ? EOK : ESTALL;
-}
-/*----------------------------------------------------------------------------*/
+        if (port->reset_okay) {
+                return EOK;
+        } else {
+                return ESTALL;
+        }
+}
+
 /** Fibril for adding a new device.
  *
@@ -415 +395 @@
  * @return 0 Always.
  */
-int add_device_phase1_worker_fibril(void *arg)
+static int add_device_phase1_worker_fibril(void *arg)
 {
         struct add_device_phase1 *data = arg;
@@ -421 +401 @@
 
         usb_address_t new_address;
-        ddf_fun_t *child_fun;
+        devman_handle_t child_handle;
 
         const int rc = usb_hc_new_device_wrapper(data->hub->usb_device->ddf_dev,
-            &data->hub->connection, data->speed, enable_port_callback,
-            data->port, &new_address, NULL, NULL, &child_fun);
+            &data->hub->connection, data->speed,
+            enable_port_callback, (int) data->port->port_number,
+            data->port, &new_address, &child_handle,
+            NULL, NULL, NULL);
 
         if (rc != EOK) {
@@ -434 +416 @@
 
         fibril_mutex_lock(&data->port->mutex);
-        data->port->attached_device.fun = child_fun;
+        data->port->attached_device.handle = child_handle;
         data->port->attached_device.address = new_address;
         fibril_mutex_unlock(&data->port->mutex);
@@ -441 +423 @@
             "address %d (handle %" PRIun ").\n",
             data->hub->usb_device->ddf_dev->name, data->port->port_number,
-            new_address, child_fun->handle);
+            new_address, child_handle);
 
 leave:
@@ -452 +434 @@
         free(arg);
 
-        return rc;
-}
-/*----------------------------------------------------------------------------*/
+        return EOK;
+}
+
 /** Start device adding when connection change is detected.
  *
@@ -464 +446 @@
  * @return Error code.
  */
-static int create_add_device_fibril(usb_hub_port_t *port, usb_hub_dev_t *hub,
+static int create_add_device_fibril(usb_hub_port_t *port, usb_hub_info_t *hub,
     usb_speed_t speed)
 {
@@ -470 +452 @@
         assert(port);
         struct add_device_phase1 *data
-            = malloc(sizeof(struct add_device_phase1));
+            = malloc(sizeof (struct add_device_phase1));
         if (data == NULL) {
                 return ENOMEM;

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

@@ -40 +40 @@
 #include <usb/classes/hub.h>
 
-typedef struct usb_hub_dev usb_hub_dev_t;
+typedef struct usb_hub_info_t usb_hub_info_t;
 
 /** Information about single port on a hub. */
@@ -58 +58 @@
 
         /** Information about attached device. */
-        usb_hub_attached_device_t attached_device;
+        usb_hc_attached_device_t attached_device;
 } usb_hub_port_t;
 
@@ -70 +70 @@
         assert(port);
         port->attached_device.address = -1;
-        port->attached_device.fun = NULL;
+        port->attached_device.handle = 0;
         port->port_number = port_number;
         port->control_pipe = control_pipe;
@@ -76 +76 @@
         fibril_condvar_initialize(&port->reset_cv);
 }
-int usb_hub_port_fini(usb_hub_port_t *port, usb_hub_dev_t *hub);
+
+void usb_hub_port_reset_fail(usb_hub_port_t *port);
+void usb_hub_port_process_interrupt(usb_hub_port_t *port, usb_hub_info_t *hub);
 int usb_hub_port_clear_feature(
     usb_hub_port_t *port, usb_hub_class_feature_t feature);
 int usb_hub_port_set_feature(
     usb_hub_port_t *port, usb_hub_class_feature_t feature);
-void usb_hub_port_reset_fail(usb_hub_port_t *port);
-void usb_hub_port_process_interrupt(usb_hub_port_t *port, usb_hub_dev_t *hub);
 
 #endif

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

@@ -68 +68 @@
 
 static int usb_set_first_configuration(usb_device_t *usb_device);
-static usb_hub_dev_t * usb_hub_dev_create(usb_device_t *usb_dev);
-static int usb_hub_process_hub_specific_info(usb_hub_dev_t *hub_dev);
-static void usb_hub_over_current(const usb_hub_dev_t *hub_dev,
+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 void usb_hub_over_current(const usb_hub_info_t *hub_info,
     usb_hub_status_t status);
-static void usb_hub_global_interrupt(const usb_hub_dev_t *hub_dev);
+static void usb_hub_global_interrupt(const usb_hub_info_t *hub_info);
 static void usb_hub_polling_terminated_callback(usb_device_t *device,
     bool was_error, void *data);
+
 /**
  * Initialize hub device driver fibril
@@ -83 +84 @@
  * @return error code
  */
-int usb_hub_device_gone(usb_device_t *usb_dev)
-{
-        assert(usb_dev);
-        usb_hub_dev_t *hub = usb_dev->driver_data;
-        assert(hub);
-        unsigned tries = 10;
-        while (hub->running) {
-                async_usleep(100000);
-                if (!tries--) {
-                        usb_log_error("Can't remove hub, still running.\n");
-                        return EINPROGRESS;
-                }
-        }
-
-        assert(!hub->running);
-
-        for (size_t port = 0; port < hub->port_count; ++port) {
-                if (hub->ports[port].attached_device.fun) {
-                        const int ret =
-                            usb_hub_port_fini(&hub->ports[port], hub);
-                        if (ret != EOK)
-                                return ret;
-                }
-        }
-        free(hub->ports);
-
-        const int ret = ddf_fun_unbind(hub->hub_fun);
-        if (ret != EOK) {
-                usb_log_error("Failed to unbind '%s' function: %s.\n",
-                   HUB_FNC_NAME, str_error(ret));
-                return ret;
-        }
-        ddf_fun_destroy(hub->hub_fun);
-
-        free(hub);
-        usb_dev->driver_data = NULL;
-        usb_log_info("USB hub driver, stopped and cleaned.\n");
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-/**
- * Initialize hub device driver fibril
- *
- * Creates hub representation and fibril that periodically checks hub's status.
- * Hub representation is passed to the fibril.
- * @param usb_dev generic usb device information
- * @return error code
- */
-int usb_hub_device_add(usb_device_t *usb_dev)
+int usb_hub_add_device(usb_device_t *usb_dev)
 {
         assert(usb_dev);
         /* Create driver soft-state structure */
-        usb_hub_dev_t *hub_dev = usb_hub_dev_create(usb_dev);
-        if (hub_dev == NULL) {
+        usb_hub_info_t *hub_info = usb_hub_info_create(usb_dev);
+        if (hub_info == NULL) {
                 usb_log_error("Failed to create hun driver structure.\n");
                 return ENOMEM;
@@ -144 +97 @@
         usb_log_debug("Initializing USB wire abstraction.\n");
         int opResult = usb_hc_connection_initialize_from_device(
-            &hub_dev->connection, hub_dev->usb_device->ddf_dev);
+            &hub_info->connection, hub_info->usb_device->ddf_dev);
         if (opResult != EOK) {
                 usb_log_error("Could not initialize connection to device: %s\n",
                     str_error(opResult));
-                free(hub_dev);
+                free(hub_info);
                 return opResult;
         }
@@ -157 +110 @@
                 usb_log_error("Could not set hub configuration: %s\n",
                     str_error(opResult));
-                free(hub_dev);
-                return opResult;
-        }
-
-        /* Get port count and create attached_devices. */
-        opResult = usb_hub_process_hub_specific_info(hub_dev);
+                free(hub_info);
+                return opResult;
+        }
+
+        //get port count and create attached_devs
+        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));
-                free(hub_dev);
+                free(hub_info);
                 return opResult;
         }
 
         usb_log_debug("Creating DDF function '" HUB_FNC_NAME "'.\n");
-        hub_dev->hub_fun = ddf_fun_create(hub_dev->usb_device->ddf_dev,
+        ddf_fun_t *hub_fun = ddf_fun_create(hub_info->usb_device->ddf_dev,
             fun_exposed, HUB_FNC_NAME);
-        if (hub_dev->hub_fun == NULL) {
+        if (hub_fun == NULL) {
                 usb_log_error("Failed to create hub function.\n");
-                free(hub_dev);
+                free(hub_info);
                 return ENOMEM;
         }
 
-        opResult = ddf_fun_bind(hub_dev->hub_fun);
+        opResult = ddf_fun_bind(hub_fun);
         if (opResult != EOK) {
                 usb_log_error("Failed to bind hub function: %s.\n",
                    str_error(opResult));
-                free(hub_dev);
-                ddf_fun_destroy(hub_dev->hub_fun);
-                return opResult;
-        }
-
-        opResult = usb_device_auto_poll(hub_dev->usb_device, 0,
-            hub_port_changes_callback, ((hub_dev->port_count + 1 + 8) / 8),
-            usb_hub_polling_terminated_callback, hub_dev);
-        if (opResult != EOK) {
-                /* Function is already bound */
-                ddf_fun_unbind(hub_dev->hub_fun);
-                ddf_fun_destroy(hub_dev->hub_fun);
-                free(hub_dev);
+                free(hub_info);
+                ddf_fun_destroy(hub_fun);
+                return opResult;
+        }
+
+        opResult = 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);
+        if (opResult != EOK) {
+                ddf_fun_destroy(hub_fun);
+                free(hub_info);
                 usb_log_error("Failed to create polling fibril: %s.\n",
                     str_error(opResult));
                 return opResult;
         }
-        hub_dev->running = true;
         usb_log_info("Controlling hub '%s' (%zu ports).\n",
-            hub_dev->usb_device->ddf_dev->name, hub_dev->port_count);
+            hub_info->usb_device->ddf_dev->name, hub_info->port_count);
 
         return EOK;
@@ -212 +162 @@
  * @param change_bitmap Bitmap of changed ports.
  * @param change_bitmap_size Size of the bitmap in bytes.
- * @param arg Custom argument, points to @c usb_hub_dev_t.
+ * @param arg Custom argument, points to @c usb_hub_info_t.
  * @return Whether to continue polling.
  */
@@ -219 +169 @@
 {
         usb_log_debug("hub_port_changes_callback\n");
-        usb_hub_dev_t *hub = arg;
+        usb_hub_info_t *hub = arg;
         assert(hub);
 
@@ -234 +184 @@
 
         /* N + 1 bit indicates change on port N */
-        for (size_t port = 0; port < hub->port_count + 1; port++) {
-                const size_t bit = port + 1;
-                const bool change = (change_bitmap[bit / 8] >> (bit % 8)) & 1;
+        size_t port = 1;
+        for (; port < hub->port_count + 1; port++) {
+                const bool change = (change_bitmap[port / 8] >> (port % 8)) & 1;
                 if (change) {
                         usb_hub_port_process_interrupt(&hub->ports[port], hub);
@@ -245 +195 @@
 /*----------------------------------------------------------------------------*/
 /**
- * create usb_hub_dev_t structure
+ * create usb_hub_info_t structure
  *
  * Does only basic copying of known information into new structure.
  * @param usb_dev usb device structure
- * @return basic usb_hub_dev_t structure
- */
-static usb_hub_dev_t * usb_hub_dev_create(usb_device_t *usb_dev)
+ * @return basic usb_hub_info_t structure
+ */
+static usb_hub_info_t * usb_hub_info_create(usb_device_t *usb_dev)
 {
         assert(usb_dev);
-        usb_hub_dev_t *hub_dev = malloc(sizeof(usb_hub_dev_t));
-        if (!hub_dev)
+        usb_hub_info_t *info = malloc(sizeof(usb_hub_info_t));
+        if (!info)
             return NULL;
 
-        hub_dev->usb_device = usb_dev;
-
-        hub_dev->ports = NULL;
-        hub_dev->port_count = 0;
-        hub_dev->pending_ops_count = 0;
-        hub_dev->running = false;
-        fibril_mutex_initialize(&hub_dev->pending_ops_mutex);
-        fibril_condvar_initialize(&hub_dev->pending_ops_cv);
-        usb_dev->driver_data = hub_dev;
-
-        return hub_dev;
-}
-/*----------------------------------------------------------------------------*/
-/**
- * Load hub-specific information into hub_dev structure and process if needed
+        info->usb_device = usb_dev;
+
+        info->ports = NULL;
+        info->port_count = -1;
+        fibril_mutex_initialize(&info->pending_ops_mutex);
+        fibril_condvar_initialize(&info->pending_ops_cv);
+        info->pending_ops_count = 0;
+
+        return info;
+}
+/*----------------------------------------------------------------------------*/
+/**
+ * Load hub-specific information into hub_info structure and process if needed
  *
  * Read port count and initialize structures holding per port information.
@@ -278 +226 @@
  * This function is hub-specific and should be run only after the hub is
  * configured using usb_set_first_configuration function.
- * @param hub_dev hub representation
+ * @param hub_info hub representation
  * @return error code
  */
-static int usb_hub_process_hub_specific_info(usb_hub_dev_t *hub_dev)
-{
-        assert(hub_dev);
+static int usb_hub_process_hub_specific_info(usb_hub_info_t *hub_info)
+{
+        assert(hub_info);
 
         /* Get hub descriptor. */
         usb_log_debug("Retrieving descriptor\n");
-        usb_pipe_t *control_pipe = &hub_dev->usb_device->ctrl_pipe;
+        usb_pipe_t *control_pipe = &hub_info->usb_device->ctrl_pipe;
 
         usb_hub_descriptor_header_t descriptor;
@@ -294 +242 @@
             USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_DEVICE,
             USB_DESCTYPE_HUB, 0, 0, &descriptor,
-            sizeof(usb_hub_descriptor_header_t), &received_size);
+            sizeof(usb_hub_descriptor_t), &received_size);
         if (opResult != EOK) {
                 usb_log_error("Failed to receive hub descriptor: %s.\n",
@@ -302 +250 @@
 
         usb_log_debug("Setting port count to %d.\n", descriptor.port_count);
-        hub_dev->port_count = descriptor.port_count;
-
-        hub_dev->ports = calloc(hub_dev->port_count, sizeof(usb_hub_port_t));
-        if (!hub_dev->ports) {
+        hub_info->port_count = descriptor.port_count;
+
+        // TODO: +1 hack is no longer necessary
+        hub_info->ports =
+            malloc(sizeof(usb_hub_port_t) * (hub_info->port_count + 1));
+        if (!hub_info->ports) {
                 return ENOMEM;
         }
 
-        for (size_t port = 0; port < hub_dev->port_count; ++port) {
-                usb_hub_port_init(
-                    &hub_dev->ports[port], port + 1, control_pipe);
+        size_t port;
+        for (port = 0; port < hub_info->port_count + 1; ++port) {
+                usb_hub_port_init(&hub_info->ports[port], port, control_pipe);
         }
 
@@ -321 +271 @@
                     & HUB_CHAR_POWER_PER_PORT_FLAG;
 
-                for (size_t port = 0; port < hub_dev->port_count; ++port) {
+                for (port = 1; port <= hub_info->port_count; ++port) {
                         usb_log_debug("Powering port %zu.\n", port);
                         opResult = usb_hub_port_set_feature(
-                            &hub_dev->ports[port], USB_HUB_FEATURE_PORT_POWER);
+                            &hub_info->ports[port], USB_HUB_FEATURE_PORT_POWER);
                         if (opResult != EOK) {
                                 usb_log_error("Cannot power on port %zu: %s.\n",
@@ -364 +314 @@
         }
 
-        if (usb_device->descriptors.configuration_size
-            < sizeof(usb_standard_configuration_descriptor_t)) {
-            usb_log_error("Configuration descriptor is not big enough"
-                " to fit standard configuration descriptor.\n");
-            return EOVERFLOW;
-        }
-
-        // TODO: Make sure that the cast is correct
+        // TODO: Make sure that there is enough data and the cast is correct
         usb_standard_configuration_descriptor_t *config_descriptor
             = (usb_standard_configuration_descriptor_t *)
@@ -394 +337 @@
  *
  * This means either to power off the hub or power it on.
- * @param hub_dev hub instance
+ * @param hub_info hub instance
  * @param status hub status bitmask
  * @return error code
  */
-static void usb_hub_over_current(const usb_hub_dev_t *hub_dev,
+static void usb_hub_over_current(const usb_hub_info_t *hub_info,
     usb_hub_status_t status)
 {
@@ -408 +351 @@
                 /* Over-current condition is gone, it is safe to turn the
                  * ports on. */
-                for (size_t port = 0; port < hub_dev->port_count; ++port) {
+                size_t port;
+                for (port = 1; port <= hub_info->port_count; ++port) {
                         const int opResult = usb_hub_port_set_feature(
-                            &hub_dev->ports[port], USB_HUB_FEATURE_PORT_POWER);
-                        // TODO: consider power policy here
+                            &hub_info->ports[port], USB_HUB_FEATURE_PORT_POWER);
                         if (opResult != EOK) {
                                 usb_log_warning(
@@ -421 +364 @@
         }
         const int opResult = usb_request_clear_feature(
-            &hub_dev->usb_device->ctrl_pipe, USB_REQUEST_TYPE_CLASS,
+            &hub_info->usb_device->ctrl_pipe, USB_REQUEST_TYPE_CLASS,
             USB_REQUEST_RECIPIENT_DEVICE,
             USB_HUB_FEATURE_C_HUB_LOCAL_POWER, 0);
@@ -435 +378 @@
  *
  * The change can be either in the over-current condition or local-power change.
- * @param hub_dev hub instance
- */
-static void usb_hub_global_interrupt(const usb_hub_dev_t *hub_dev)
-{
-        assert(hub_dev);
-        assert(hub_dev->usb_device);
+ * @param hub_info hub instance
+ */
+static void usb_hub_global_interrupt(const usb_hub_info_t *hub_info)
+{
+        assert(hub_info);
+        assert(hub_info->usb_device);
         usb_log_debug("Global interrupt on a hub\n");
-        usb_pipe_t *control_pipe = &hub_dev->usb_device->ctrl_pipe;
+        usb_pipe_t *control_pipe = &hub_info->usb_device->ctrl_pipe;
 
         usb_hub_status_t status;
@@ -463 +406 @@
         /* Handle status changes */
         if (status & USB_HUB_STATUS_C_OVER_CURRENT) {
-                usb_hub_over_current(hub_dev, status);
+                usb_hub_over_current(hub_info, status);
         }
 
@@ -495 +438 @@
  * callback called from hub polling fibril when the fibril terminates
  *
- * Does not perform cleanup, just marks the hub as not running.
+ * Should perform a cleanup - deletes hub_info.
  * @param device usb device afected
  * @param was_error indicates that the fibril is stoped due to an error
- * @param data pointer to usb_hub_dev_t structure
+ * @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_dev_t *hub = data;
+        usb_hub_info_t *hub = data;
         assert(hub);
 
@@ -517 +460 @@
          */
         if (hub->pending_ops_count > 0) {
-                for (size_t port = 0; port < hub->port_count; ++port) {
+                size_t port;
+                for (port = 0; port < hub->port_count; port++) {
                         usb_hub_port_reset_fail(&hub->ports[port]);
                 }
@@ -527 +471 @@
         }
         fibril_mutex_unlock(&hub->pending_ops_mutex);
-        hub->running = false;
+
+        usb_device_destroy(hub->usb_device);
+
+        free(hub->ports);
+        free(hub);
 }
 /**

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

@@ -52 +52 @@
 
 /** Information about attached hub. */
-struct usb_hub_dev {
+struct usb_hub_info_t {
         /** Number of ports. */
         size_t port_count;
-        /** Port structures, one for each port */
+
+        /** Attached device handles, for each port one */
         usb_hub_port_t *ports;
+
         /** Connection to hcd */
         usb_hc_connection_t connection;
+
         /** Generic usb device data*/
         usb_device_t *usb_device;
@@ -73 +76 @@
         /** Condition variable for pending_ops_count. */
         fibril_condvar_t pending_ops_cv;
-        /** Pointer to devman usbhub function. */
-        ddf_fun_t *hub_fun;
-        /** Status indicator */
-        bool running;
 };
 
-int usb_hub_device_add(usb_device_t *usb_dev);
-int usb_hub_device_gone(usb_device_t *usb_dev);
+int usb_hub_add_device(usb_device_t *usb_dev);
 
 bool hub_port_changes_callback(usb_device_t *dev,

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

@@ -87 +87 @@
  * @return Error code.
  */
-static int usbmast_device_add(usb_device_t *dev)
+static int usbmast_add_device(usb_device_t *dev)
 {
         int rc;
@@ -94 +94 @@
 
         /* Allocate softstate */
-        dev->driver_data = mdev = malloc(sizeof(usbmast_dev_t));
+        mdev = ddf_dev_data_alloc(dev->ddf_dev, sizeof(usbmast_dev_t));
         if (mdev == NULL) {
                 usb_log_error("Failed allocating softstate.\n");
@@ -103 +103 @@
         mdev->usb_dev = dev;
 
-        usb_log_info("Initializing mass storage `%s'.\n", dev->ddf_dev->name);
+        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,
@@ -294 +295 @@
 /** USB mass storage driver ops. */
 static usb_driver_ops_t usbmast_driver_ops = {
-        .device_add = usbmast_device_add,
+        .add_device = usbmast_add_device,
 };
 

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

@@ -49 +49 @@
  * @return Error code.
  */
-static int usbmid_device_add(usb_device_t *dev)
+static int usbmid_add_device(usb_device_t *dev)
 {
         usb_log_info("Taking care of new MID `%s'.\n", dev->ddf_dev->name);
@@ -68 +68 @@
 /** USB MID driver ops. */
 static usb_driver_ops_t mid_driver_ops = {
-        .device_add = usbmid_device_add,
+        .add_device = usbmid_add_device,
 };
 

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

@@ -50 +50 @@
  *
  */
-static int usbmouse_device_add(usb_device_t *dev)
+static int usbmouse_add_device(usb_device_t *dev)
 {
         int rc = usb_mouse_create(dev);
@@ -80 +80 @@
 /** USB mouse driver ops. */
 static usb_driver_ops_t mouse_driver_ops = {
-        .device_add = usbmouse_device_add,
+        .add_device = usbmouse_add_device,
 };
 

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

@@ -81 +81 @@
 }
 
-static int pretend_port_rest(void *unused2)
+static int pretend_port_rest(int unused, void *unused2)
 {
         return EOK;
@@ -114 +114 @@
 
         ddf_fun_t *hub_dev;
-        rc = usb_hc_new_device_wrapper(hc_dev->dev, &hc_conn, USB_SPEED_FULL,
-            pretend_port_rest, NULL, NULL, &rh_ops, hc_dev, &hub_dev);
+        rc = usb_hc_new_device_wrapper(hc_dev->dev, &hc_conn,
+            USB_SPEED_FULL,
+            pretend_port_rest, 0, NULL,
+            NULL, NULL, &rh_ops, hc_dev, &hub_dev);
         if (rc != EOK) {
                 usb_log_fatal("Failed to create root hub: %s.\n",

uspace/lib/c/generic/async.c

@@ -1846 +1846 @@
         
         fibril_mutex_lock(&async_sess_mutex);
-
-        int rc = async_hangup_internal(sess->phone);
         
         while (!list_empty(&sess->exch_list)) {
@@ -1860 +1858 @@
         }
 
+        int rc = async_hangup_internal(sess->phone);
         free(sess);
         

uspace/lib/ext2/libext2_filesystem.c

@@ -259 +259 @@
             bg_ref->block_group);
         
-        rc = ext2_filesystem_put_block_group_ref(bg_ref);
-        if (rc != EOK) {
-                free(newref);
-                return rc;
-        }
-
         inode_size = ext2_superblock_get_inode_size(fs->superblock);
         block_size = ext2_superblock_get_block_size(fs->superblock);

uspace/lib/usb/include/usb/hc.h

@@ -53 +53 @@
 
 int usb_hc_connection_initialize_from_device(usb_hc_connection_t *,
-    const ddf_dev_t *);
+    ddf_dev_t *);
 int usb_hc_connection_initialize(usb_hc_connection_t *, devman_handle_t);
 

uspace/lib/usb/src/hc.c

@@ -50 +50 @@
  */
 int usb_hc_connection_initialize_from_device(usb_hc_connection_t *connection,
-    const ddf_dev_t *device)
+    ddf_dev_t *device)
 {
         assert(connection);

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

@@ -96 +96 @@
         usb_device_descriptors_t descriptors;
 
-        /** Generic DDF device backing this one. RO: DO NOT TOUCH!*/
+        /** Generic DDF device backing this one. */
         ddf_dev_t *ddf_dev;
         /** Custom driver data.
@@ -112 +112 @@
 /** USB driver ops. */
 typedef struct {
-        /** Callback when a new device was added to the system. */
-        int (*device_add)(usb_device_t *);
-        /** Callback when a device is about to be removed from the system. */
-        int (*device_rem)(usb_device_t *);
-        /** Callback when a device was removed from the system. */
-        int (*device_gone)(usb_device_t *);
+        /** Callback when new device is about to be controlled by the driver. */
+        int (*add_device)(usb_device_t *);
 } usb_driver_ops_t;
 
@@ -167 +163 @@
 
 int usb_device_retrieve_descriptors(usb_pipe_t *, usb_device_descriptors_t *);
-int usb_device_create_pipes(const ddf_dev_t *, usb_device_connection_t *,
+int usb_device_create_pipes(ddf_dev_t *, usb_device_connection_t *,
     usb_endpoint_description_t **, uint8_t *, size_t, int, int,
     usb_endpoint_mapping_t **, size_t *);
-int usb_device_destroy_pipes(const ddf_dev_t *, usb_endpoint_mapping_t *, size_t);
+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 *);

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

@@ -38 +38 @@
 #define LIBUSBDEV_HUB_H_
 
-#include <ddf/driver.h>
 #include <sys/types.h>
 #include <usb/hc.h>
 
 int usb_hc_new_device_wrapper(ddf_dev_t *, usb_hc_connection_t *, usb_speed_t,
-    int (*)(void *), void *, usb_address_t *, ddf_dev_ops_t *, void *,
-    ddf_fun_t **);
+    int (*)(int, void *), int, void *,
+    usb_address_t *, devman_handle_t *,
+    ddf_dev_ops_t *, void *, ddf_fun_t **);
 
 /** Info about device attached to host controller.
@@ -55 +55 @@
         /** Device address. */
         usb_address_t address;
-        /** DDF function (external) of the device. */
-        ddf_fun_t *fun;
-} usb_hub_attached_device_t;
+        /** Devman handle of the device. */
+        devman_handle_t handle;
+} usb_hc_attached_device_t;
 
 usb_address_t usb_hc_request_address(usb_hc_connection_t *, usb_speed_t);
 int usb_hc_register_device(usb_hc_connection_t *,
-    const usb_hub_attached_device_t *);
+    const usb_hc_attached_device_t *);
 int usb_hc_unregister_device(usb_hc_connection_t *, usb_address_t);
 

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

@@ -159 +159 @@
     usb_device_connection_t *, usb_hc_connection_t *);
 int usb_device_connection_initialize_from_device(usb_device_connection_t *,
-    const ddf_dev_t *);
+    ddf_dev_t *);
 int usb_device_connection_initialize(usb_device_connection_t *,
     devman_handle_t, usb_address_t);
 
-int usb_device_get_assigned_interface(const ddf_dev_t *);
+int usb_device_get_assigned_interface(ddf_dev_t *);
 
 int usb_pipe_initialize(usb_pipe_t *, usb_device_connection_t *,
@@ -185 +185 @@
 int usb_pipe_control_read(usb_pipe_t *, const void *, size_t,
     void *, size_t, size_t *);
-int usb_pipe_control_write(usb_pipe_t *, const void *, size_t,
-    const void *, size_t);
+int usb_pipe_control_write(usb_pipe_t *, void *, size_t,
+    void *, size_t);
 
 #endif

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

@@ -51 +51 @@
 
 int usb_device_register_child_in_devman(usb_address_t, devman_handle_t,
-    ddf_dev_t *, ddf_dev_ops_t *, void *, ddf_fun_t **);
+    ddf_dev_t *, devman_handle_t *, ddf_dev_ops_t *, void *, ddf_fun_t **);
 
 #endif

uspace/lib/usbdev/src/devdrv.c

@@ -41 +41 @@
 #include <assert.h>
 
-static int generic_device_add(ddf_dev_t *);
-static int generic_device_remove(ddf_dev_t *);
-static int generic_device_gone(ddf_dev_t *);
+static int generic_add_device(ddf_dev_t *);
 
 static driver_ops_t generic_driver_ops = {
-        .add_device = generic_device_add,
-        .dev_remove = generic_device_remove,
-        .dev_gone = generic_device_gone,
+        .add_device = generic_add_device
 };
 static driver_t generic_driver = {
@@ -127 +123 @@
         return EOK;
 }
-/*----------------------------------------------------------------------------*/
-/** Callback when a new device is supposed to be controlled by this driver.
- *
- * This callback is a wrapper for USB specific version of @c device_add.
+
+/** Callback when new device is supposed to be controlled by this driver.
+ *
+ * This callback is a wrapper for USB specific version of @c add_device.
  *
  * @param gen_dev Device structure as prepared by DDF.
  * @return Error code.
  */
-int generic_device_add(ddf_dev_t *gen_dev)
+int generic_add_device(ddf_dev_t *gen_dev)
 {
         assert(driver);
         assert(driver->ops);
-        assert(driver->ops->device_add);
+        assert(driver->ops->add_device);
 
         int rc;
@@ -151 +147 @@
                 return rc;
         }
-        gen_dev->driver_data = dev;
-
-        return driver->ops->device_add(dev);
-}
-/*----------------------------------------------------------------------------*/
-/** Callback when a device is supposed to be removed from the system.
- *
- * This callback is a wrapper for USB specific version of @c device_remove.
- *
- * @param gen_dev Device structure as prepared by DDF.
- * @return Error code.
- */
-int generic_device_remove(ddf_dev_t *gen_dev)
-{
-        assert(driver);
-        assert(driver->ops);
-        if (driver->ops->device_rem == NULL)
-                return ENOTSUP;
-        /* Just tell the driver to stop whatever it is doing, keep structures */
-        return driver->ops->device_rem(gen_dev->driver_data);
-}
-/*----------------------------------------------------------------------------*/
-/** Callback when a device was removed from the system.
- *
- * This callback is a wrapper for USB specific version of @c device_gone.
- *
- * @param gen_dev Device structure as prepared by DDF.
- * @return Error code.
- */
-int generic_device_gone(ddf_dev_t *gen_dev)
-{
-        assert(driver);
-        assert(driver->ops);
-        if (driver->ops->device_gone == NULL)
-                return ENOTSUP;
-        const int ret = driver->ops->device_gone(gen_dev->driver_data);
-        if (ret == EOK)
-                usb_device_destroy(gen_dev->driver_data);
-
-        return ret;
-}
-/*----------------------------------------------------------------------------*/
+
+        return driver->ops->add_device(dev);
+}
+
 /** Destroy existing pipes of a USB device.
  *
@@ -317 +275 @@
  * @return Error code.
  */
-int usb_device_create_pipes(const ddf_dev_t *dev, usb_device_connection_t *wire,
+int usb_device_create_pipes(ddf_dev_t *dev, usb_device_connection_t *wire,
     usb_endpoint_description_t **endpoints,
     uint8_t *config_descr, size_t config_descr_size,
@@ -391 +349 @@
         }
 
-        if (usb_hc_connection_close(&hc_conn) != EOK)
-                usb_log_warning("usb_device_create_pipes(): "
-                    "Failed to close connection.\n");
+        usb_hc_connection_close(&hc_conn);
 
         *pipes_ptr = pipes;
@@ -415 +371 @@
         }
 
-        if (usb_hc_connection_close(&hc_conn) != EOK)
-                usb_log_warning("usb_device_create_pipes(): "
-                    "Failed to close connection.\n");
+        usb_hc_connection_close(&hc_conn);
 
         /*
@@ -441 +395 @@
  * @param[in] pipes_count Number of endpoints.
  */
-int usb_device_destroy_pipes(const ddf_dev_t *dev,
+int usb_device_destroy_pipes(ddf_dev_t *dev,
     usb_endpoint_mapping_t *pipes, size_t pipes_count)
 {
@@ -472 +426 @@
         }
 
-        if (usb_hc_connection_close(&hc_conn) != EOK)
-                usb_log_warning("usb_device_destroy_pipes(): "
-                    "Failed to close connection.\n");
+        usb_hc_connection_close(&hc_conn);
 
         free(pipes);
@@ -593 +545 @@
         /* Ignore errors and hope for the best. */
         usb_device_destroy_pipes(dev->ddf_dev, dev->pipes, dev->pipes_count);
-        free(dev->descriptors.configuration);
+        if (dev->descriptors.configuration != NULL) {
+                free(dev->descriptors.configuration);
+        }
 
         if (dev->alternate_interfaces != NULL) {
-                free(dev->alternate_interfaces->alternatives);
-        }
-        free(dev->alternate_interfaces);
+                if (dev->alternate_interfaces->alternatives != NULL) {
+                        free(dev->alternate_interfaces->alternatives);
+                }
+                free(dev->alternate_interfaces);
+        }
 
         free(dev);

uspace/lib/usbdev/src/hub.c

@@ -37 +37 @@
 #include <usb/dev/request.h>
 #include <usb/dev/recognise.h>
-#include <usb/debug.h>
 #include <usbhc_iface.h>
 #include <errno.h>
@@ -58 +57 @@
                 assert((conn)); \
                 if (!usb_hc_connection_is_opened((conn))) { \
-                        usb_log_error("Connection not open.\n"); \
-                        return ENOTCONN; \
+                        return ENOENT; \
                 } \
         } while (false)
@@ -97 +95 @@
  */
 int usb_hc_register_device(usb_hc_connection_t * connection,
-    const usb_hub_attached_device_t *attached_device)
+    const usb_hc_attached_device_t *attached_device)
 {
         CHECK_CONNECTION(connection);
@@ -107 +105 @@
         int rc = async_req_3_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
             IPC_M_USBHC_BIND_ADDRESS,
-            attached_device->address, attached_device->fun->handle);
+            attached_device->address, attached_device->handle);
         async_exchange_end(exch);
         
@@ -157 +155 @@
  * The @p enable_port function is expected to enable signaling on given
  * port.
- * The argument can have arbitrary meaning and it is not touched at all
- * by this function (it is passed as is to the @p enable_port function).
+ * The two arguments to it can have arbitrary meaning
+ * (the @p port_no is only a suggestion)
+ * and are not touched at all by this function
+ * (they are passed as is to the @p enable_port function).
  *
  * If the @p enable_port fails (i.e. does not return EOK), the device
@@ -175 +175 @@
  * @param[in] enable_port Function for enabling signaling through the port the
  *      device is attached to.
+ * @param[in] port_no Port number (passed through to @p enable_port).
  * @param[in] arg Any data argument to @p enable_port.
  * @param[out] assigned_address USB address of the device.
+ * @param[out] assigned_handle Devman handle of the new device.
  * @param[in] dev_ops Child device ops.
  * @param[in] new_dev_data Arbitrary pointer to be stored in the child
@@ -192 +194 @@
 int usb_hc_new_device_wrapper(ddf_dev_t *parent, usb_hc_connection_t *connection,
     usb_speed_t dev_speed,
-    int (*enable_port)(void *arg), void *arg, usb_address_t *assigned_address,
+    int (*enable_port)(int port_no, void *arg), int port_no, void *arg,
+    usb_address_t *assigned_address, devman_handle_t *assigned_handle,
     ddf_dev_ops_t *dev_ops, void *new_dev_data, ddf_fun_t **new_fun)
 {
@@ -221 +224 @@
         usb_address_t dev_addr = usb_hc_request_address(&hc_conn, dev_speed);
         if (dev_addr < 0) {
-                rc = EADDRNOTAVAIL;
-                goto close_connection;
+                usb_hc_connection_close(&hc_conn);
+                return EADDRNOTAVAIL;
         }
 
@@ -276 +279 @@
          * device address.
          */
-        rc = enable_port(arg);
+        rc = enable_port(port_no, arg);
         if (rc != EOK) {
                 goto leave_release_default_address;
@@ -317 +320 @@
          */
         /* FIXME: create device_register that will get opened ctrl pipe. */
-        ddf_fun_t *child_fun;
+        devman_handle_t child_handle;
         rc = usb_device_register_child_in_devman(dev_addr, dev_conn.hc_handle,
-            parent, dev_ops, new_dev_data, &child_fun);
+            parent, &child_handle,
+            dev_ops, new_dev_data, new_fun);
         if (rc != EOK) {
                 rc = ESTALL;
@@ -328 +332 @@
          * And now inform the host controller about the handle.
          */
-        usb_hub_attached_device_t new_device = {
+        usb_hc_attached_device_t new_device = {
                 .address = dev_addr,
-                .fun = child_fun,
+                .handle = child_handle
         };
         rc = usb_hc_register_device(&hc_conn, &new_device);
@@ -337 +341 @@
                 goto leave_release_free_address;
         }
-
+        
+        usb_hc_connection_close(&hc_conn);
 
         /*
@@ -345 +350 @@
                 *assigned_address = dev_addr;
         }
-        if (new_fun != NULL) {
-                *new_fun = child_fun;
-        }
-
-        rc = EOK;
-        goto close_connection;
+        if (assigned_handle != NULL) {
+                *assigned_handle = child_handle;
+        }
+
+        return EOK;
+
+
 
         /*
@@ -362 +368 @@
         usb_hc_unregister_device(&hc_conn, dev_addr);
 
-close_connection:
-        if (usb_hc_connection_close(&hc_conn) != EOK)
-                usb_log_warning("usb_hc_new_device_wrapper(): Failed to close "
-                    "connection.\n");
+        usb_hc_connection_close(&hc_conn);
 
         return rc;

uspace/lib/usbdev/src/pipes.c

@@ -52 +52 @@
  * @return USB address or error code.
  */
-static usb_address_t get_my_address(async_sess_t *sess, const ddf_dev_t *dev)
+static usb_address_t get_my_address(async_sess_t *sess, ddf_dev_t *dev)
 {
         async_exch_t *exch = async_exchange_begin(sess);
@@ -78 +78 @@
  * @return Interface number (negative code means any).
  */
-int usb_device_get_assigned_interface(const ddf_dev_t *device)
+int usb_device_get_assigned_interface(ddf_dev_t *device)
 {
         async_sess_t *parent_sess =
@@ -108 +108 @@
  */
 int usb_device_connection_initialize_from_device(
-    usb_device_connection_t *connection, const ddf_dev_t *dev)
+    usb_device_connection_t *connection, ddf_dev_t *dev)
 {
         assert(connection);

uspace/lib/usbdev/src/pipesio.c

@@ -469 +469 @@
  */
 static int usb_pipe_control_write_no_check(usb_pipe_t *pipe,
-    const void *setup_buffer, size_t setup_buffer_size,
-    const void *data_buffer, size_t data_buffer_size)
+    void *setup_buffer, size_t setup_buffer_size,
+    void *data_buffer, size_t data_buffer_size)
 {
         /* Ensure serialization over the phone. */
@@ -536 +536 @@
  */
 int usb_pipe_control_write(usb_pipe_t *pipe,
-    const void *setup_buffer, size_t setup_buffer_size,
-    const void *data_buffer, size_t data_buffer_size)
+    void *setup_buffer, size_t setup_buffer_size,
+    void *data_buffer, size_t data_buffer_size)
 {
         assert(pipe);

uspace/lib/usbdev/src/recognise.c

@@ -339 +339 @@
  * @param[in] hc_handle Handle of the host controller.
  * @param[in] parent Parent device.
+ * @param[out] child_handle Handle of the child device.
  * @param[in] dev_ops Child device ops.
  * @param[in] dev_data Arbitrary pointer to be stored in the child
@@ -347 +348 @@
  */
 int usb_device_register_child_in_devman(usb_address_t address,
-    devman_handle_t hc_handle, ddf_dev_t *parent,
+    devman_handle_t hc_handle,
+    ddf_dev_t *parent, devman_handle_t *child_handle,
     ddf_dev_ops_t *dev_ops, void *dev_data, ddf_fun_t **child_fun)
 {
@@ -412 +414 @@
         }
 
+        if (child_handle != NULL) {
+                *child_handle = child->handle;
+        }
+
         if (child_fun != NULL) {
                 *child_fun = child;