Changes in / [fa8f1f7:8373f53] in mainline

Files:

• .bzrignore (modified) (1 diff)
• boot/arch/amd64/Makefile.inc (modified) (1 diff)
• uspace/Makefile (modified) (2 diffs)
• uspace/drv/ohci/Makefile (deleted)
• uspace/drv/ohci/batch.c (deleted)
• uspace/drv/ohci/batch.h (deleted)
• uspace/drv/ohci/hc_iface.c (deleted)
• uspace/drv/ohci/iface.h (deleted)
• uspace/drv/ohci/main.c (deleted)
• uspace/drv/ohci/ohci.ma (deleted)
• uspace/drv/ohci/ohci_hc.c (deleted)
• uspace/drv/ohci/ohci_hc.h (deleted)
• uspace/drv/ohci/ohci_regs.h (deleted)
• uspace/drv/ohci/ohci_rh.c (deleted)
• uspace/drv/ohci/ohci_rh.h (deleted)
• uspace/drv/ohci/pci.c (deleted)
• uspace/drv/ohci/pci.h (deleted)
• uspace/drv/usbhid/hiddev.c (modified) (1 diff)
• uspace/drv/usbhid/hiddev.h (modified) (1 diff)
• uspace/drv/usbhid/kbddev.c (modified) (10 diffs)
• uspace/drv/usbhid/kbddev.h (modified) (2 diffs)
• uspace/drv/usbhid/kbdrepeat.c (modified) (1 diff)
• uspace/drv/usbhub/main.c (modified) (1 diff)
• uspace/drv/usbhub/usbhub.c (modified) (27 diffs)
• uspace/drv/usbhub/usbhub.h (modified) (4 diffs)
• uspace/drv/usbhub/usbhub_private.h (modified) (4 diffs)
• uspace/drv/usbhub/utils.c (modified) (3 diffs)
• uspace/lib/usb/include/usb/devdrv.h (modified) (1 diff)
• uspace/lib/usb/src/devdrv.c (modified) (2 diffs)

.bzrignore

@@ -84 +84 @@
 ./uspace/drv/test1/test1
 ./uspace/drv/test2/test2
-./uspace/drv/ohci/ohci
 ./uspace/drv/ehci-hcd/ehci-hcd
 ./uspace/drv/uhci-hcd/uhci-hcd

boot/arch/amd64/Makefile.inc

@@ -44 +44 @@
         ns8250 \
         ehci-hcd \
-        ohci \
         uhci-hcd \
         uhci-rhd \

uspace/Makefile

@@ -118 +118 @@
                 srv/hw/irc/i8259 \
                 drv/ehci-hcd \
-                drv/ohci \
                 drv/uhci-hcd \
                 drv/uhci-rhd \
@@ -138 +137 @@
                 srv/hw/irc/i8259 \
                 drv/ehci-hcd \
-                drv/ohci \
                 drv/uhci-hcd \
                 drv/uhci-rhd \

uspace/drv/usbhid/hiddev.c

@@ -440 +440 @@
         if (rc != EOK) {
                 /* TODO: end session?? */
-                usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
                 usb_log_error("Failed to process descriptors: %s.\n",
                     str_error(rc));

uspace/drv/usbhid/hiddev.h

@@ -32 +32 @@
 /** @file
  * Generic USB HID device structure and API.
- *
- * @todo Add function for parsing report - this is generic HID function, not
- *       keyboard-specific, as the report parser is also generic.
- * @todo Add function for polling as that is also a generic HID process.
- * @todo Add interrupt in pipe to the structure.
  */
 

uspace/drv/usbhid/kbddev.c

@@ -94 +94 @@
         .flags = 0
 };
-
-typedef enum usbhid_kbd_flags {
-        USBHID_KBD_STATUS_UNINITIALIZED = 0,
-        USBHID_KBD_STATUS_INITIALIZED = 1,
-        USBHID_KBD_STATUS_TO_DESTROY = -1
-} usbhid_kbd_flags;
 
 /*----------------------------------------------------------------------------*/
@@ -238 +232 @@
         
         assert(kbd_dev->hid_dev != NULL);
-        assert(kbd_dev->hid_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
+        assert(kbd_dev->hid_dev->initialized);
         usbhid_req_set_report(kbd_dev->hid_dev, USB_HID_REPORT_TYPE_OUTPUT, 
             buffer, BOOTP_BUFFER_OUT_SIZE);
@@ -571 +565 @@
                                     uint8_t *buffer, size_t actual_size)
 {
-        assert(kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
+        assert(kbd_dev->initialized);
         assert(kbd_dev->hid_dev->parser != NULL);
         
@@ -625 +619 @@
         
         kbd_dev->console_phone = -1;
-        kbd_dev->initialized = USBHID_KBD_STATUS_UNINITIALIZED;
+        kbd_dev->initialized = 0;
         
         return kbd_dev;
@@ -631 +625 @@
 
 /*----------------------------------------------------------------------------*/
-
-static void usbhid_kbd_mark_unusable(usbhid_kbd_t *kbd_dev)
-{
-        kbd_dev->initialized = USBHID_KBD_STATUS_TO_DESTROY;
+/**
+ * Properly destroys the USB/HID keyboard structure.
+ *
+ * @param kbd_dev Pointer to the structure to be destroyed.
+ */
+static void usbhid_kbd_free(usbhid_kbd_t **kbd_dev)
+{
+        if (kbd_dev == NULL || *kbd_dev == NULL) {
+                return;
+        }
+        
+        // hangup phone to the console
+        async_hangup((*kbd_dev)->console_phone);
+        
+        if ((*kbd_dev)->hid_dev != NULL) {
+                usbhid_dev_free(&(*kbd_dev)->hid_dev);
+                assert((*kbd_dev)->hid_dev == NULL);
+        }
+        
+        if ((*kbd_dev)->repeat_mtx != NULL) {
+                /* TODO: replace by some check and wait */
+                assert(!fibril_mutex_is_locked((*kbd_dev)->repeat_mtx));
+                free((*kbd_dev)->repeat_mtx);
+        }
+
+        free(*kbd_dev);
+        *kbd_dev = NULL;
 }
 
@@ -676 +693 @@
         }
         
-        if (kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED) {
+        if (kbd_dev->initialized) {
                 usb_log_warning("Keyboard structure already initialized.\n");
                 return EINVAL;
@@ -689 +706 @@
         }
         
-        assert(kbd_dev->hid_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
+        assert(kbd_dev->hid_dev->initialized);
         
         // save the size of the report (boot protocol report by default)
@@ -741 +758 @@
         usbhid_req_set_idle(kbd_dev->hid_dev, IDLE_RATE);
         
-        kbd_dev->initialized = USBHID_KBD_STATUS_INITIALIZED;
+        kbd_dev->initialized = 1;
         usb_log_info("HID/KBD device structure initialized.\n");
         
@@ -855 +872 @@
         usbhid_kbd_poll(kbd_dev);
         
-        // as there is another fibril using this device, so we must leave the
-        // structure to it, but mark it for destroying.
-        usbhid_kbd_mark_unusable(kbd_dev);
         // at the end, properly destroy the KBD structure
-//      usbhid_kbd_free(&kbd_dev);
-//      assert(kbd_dev == NULL);
+        usbhid_kbd_free(&kbd_dev);
+        assert(kbd_dev == NULL);
 
         return EOK;
@@ -982 +996 @@
 }
 
-/*----------------------------------------------------------------------------*/
-
-int usbhid_kbd_is_usable(const usbhid_kbd_t *kbd_dev)
-{
-        return (kbd_dev->initialized == USBHID_KBD_STATUS_INITIALIZED);
-}
-
-/*----------------------------------------------------------------------------*/
-/**
- * Properly destroys the USB/HID keyboard structure.
- *
- * @param kbd_dev Pointer to the structure to be destroyed.
- */
-void usbhid_kbd_free(usbhid_kbd_t **kbd_dev)
-{
-        if (kbd_dev == NULL || *kbd_dev == NULL) {
-                return;
-        }
-        
-        // hangup phone to the console
-        async_hangup((*kbd_dev)->console_phone);
-        
-        if ((*kbd_dev)->hid_dev != NULL) {
-                usbhid_dev_free(&(*kbd_dev)->hid_dev);
-                assert((*kbd_dev)->hid_dev == NULL);
-        }
-        
-        if ((*kbd_dev)->repeat_mtx != NULL) {
-                /* TODO: replace by some check and wait */
-                assert(!fibril_mutex_is_locked((*kbd_dev)->repeat_mtx));
-                free((*kbd_dev)->repeat_mtx);
-        }
-
-        free(*kbd_dev);
-        *kbd_dev = NULL;
-}
-
 /**
  * @}

uspace/drv/usbhid/kbddev.h

@@ -101 +101 @@
         fibril_mutex_t *repeat_mtx;
         
-        /** State of the structure (for checking before use). 
-         * 
-         * 0 - not initialized
-         * 1 - initialized
-         * -1 - ready for destroying
-         */
+        /** State of the structure (for checking before use). */
         int initialized;
 } usbhid_kbd_t;
@@ -113 +108 @@
 
 int usbhid_kbd_try_add_device(ddf_dev_t *dev);
-
-int usbhid_kbd_is_usable(const usbhid_kbd_t *kbd_dev);
-
-void usbhid_kbd_free(usbhid_kbd_t **kbd_dev);
 
 void usbhid_kbd_push_ev(usbhid_kbd_t *kbd_dev, int type, unsigned int key);

uspace/drv/usbhid/kbdrepeat.c

@@ -77 +77 @@
 
         while (true) {
-                // check if the kbd structure is usable
-                if (!usbhid_kbd_is_usable(kbd)) {
-                        usbhid_kbd_free(&kbd);
-                        assert(kbd == NULL);
-                        return;
-                }
-                
                 fibril_mutex_lock(kbd->repeat_mtx);
 

uspace/drv/usbhub/main.c

@@ -36 +36 @@
 #include <stdio.h>
 
-#include <usb/devdrv.h>
-#include <usb/classes/classes.h>
-
 #include "usbhub.h"
 #include "usbhub_private.h"
 
 
-usb_endpoint_description_t hub_status_change_endpoint_description = {
-        .transfer_type = USB_TRANSFER_INTERRUPT,
-        .direction = USB_DIRECTION_IN,
-        .interface_class = USB_CLASS_HUB,
-        .interface_subclass = 0,
-        .interface_protocol = 0,
-        .flags = 0
+usb_general_list_t usb_hub_list;
+fibril_mutex_t usb_hub_list_lock;
+
+static driver_ops_t hub_driver_ops = {
+        .add_device = usb_add_hub_device,
 };
 
-
-static usb_driver_ops_t usb_hub_driver_ops = {
-        .add_device = usb_hub_add_device
+static driver_t hub_driver = {
+        .name = "usbhub",
+        .driver_ops = &hub_driver_ops
 };
-
-static usb_driver_t usb_hub_driver = {
-        .name = "usbhub",
-        .ops = &usb_hub_driver_ops
-};
-
 
 int main(int argc, char *argv[])
 {
         usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
-        usb_log_info("starting hub driver\n");
+        dprintf(USB_LOG_LEVEL_INFO, "starting hub driver");
 
+        //this is probably not needed anymore
+        fibril_mutex_initialize(&usb_hub_list_lock);
+        fibril_mutex_lock(&usb_hub_list_lock);
+        usb_lst_init(&usb_hub_list);
+        fibril_mutex_unlock(&usb_hub_list_lock);
         
-        usb_hub_driver.endpoints = (usb_endpoint_description_t**)
-                        malloc(2 * sizeof(usb_endpoint_description_t*));
-        usb_hub_driver.endpoints[0] = &hub_status_change_endpoint_description;
-        usb_hub_driver.endpoints[1] = NULL;
-
-        return usb_driver_main(&usb_hub_driver);
+        return ddf_driver_main(&hub_driver);
 }
 

uspace/drv/usbhub/usbhub.c

@@ -53 +53 @@
 #include "usb/classes/classes.h"
 
+static ddf_dev_ops_t hub_device_ops = {
+        .interfaces[USB_DEV_IFACE] = &usb_iface_hub_impl
+};
+
+/** Hub status-change endpoint description
+ *
+ * For more see usb hub specification in 11.15.1 of
+ */
+static usb_endpoint_description_t status_change_endpoint_description = {
+        .transfer_type = USB_TRANSFER_INTERRUPT,
+        .direction = USB_DIRECTION_IN,
+        .interface_class = USB_CLASS_HUB,
+        .interface_subclass = 0,
+        .interface_protocol = 0,
+        .flags = 0
+};
+
 int usb_hub_control_loop(void * hub_info_param){
         usb_hub_info_t * hub_info = (usb_hub_info_t*)hub_info_param;
@@ -61 +78 @@
                 async_usleep(1000 * 1000 );/// \TODO proper number once
         }
-        usb_log_error("something in ctrl loop went wrong, errno %d\n",errorCode);
+        usb_log_error("something in ctrl loop went wrong, errno %d",errorCode);
 
         return 0;
@@ -74 +91 @@
 
 /**
- * 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_info_t structure
- */
-static usb_hub_info_t * usb_hub_info_create(usb_device_t * usb_dev) {
-        usb_hub_info_t * result = usb_new(usb_hub_info_t);
-        if(!result) return NULL;
-        result->usb_device = usb_dev;
-        result->status_change_pipe = usb_dev->pipes[0].pipe;
-        result->control_pipe = &usb_dev->ctrl_pipe;
+ * Initialize connnections to host controller, device, and device
+ * control endpoint
+ * @param hub
+ * @param device
+ * @return
+ */
+static int usb_hub_init_communication(usb_hub_info_t * hub){
+        usb_log_debug("Initializing hub USB communication (hub->device->handle=%zu).\n", hub->device->handle);
+        int opResult;
+        opResult = usb_device_connection_initialize_from_device(
+                        &hub->device_connection,
+                        hub->device);
+        if(opResult != EOK){
+                usb_log_error("could not initialize connection to hc, errno %d",opResult);
+                return opResult;
+        }
+        usb_log_debug("Initializing USB wire abstraction.\n");
+        opResult = usb_hc_connection_initialize_from_device(&hub->connection,
+                        hub->device);
+        if(opResult != EOK){
+                usb_log_error("could not initialize connection to device, errno %d",
+                                opResult);
+                return opResult;
+        }
+        usb_log_debug("Initializing default control pipe.\n");
+        opResult = usb_endpoint_pipe_initialize_default_control(&hub->endpoints.control,
+            &hub->device_connection);
+        if(opResult != EOK){
+                usb_log_error("could not initialize connection to device endpoint, errno %d",
+                                opResult);
+                return opResult;
+        }
+
+        opResult = usb_endpoint_pipe_probe_default_control(&hub->endpoints.control);
+        if (opResult != EOK) {
+                usb_log_error("failed probing endpoint 0, %d", opResult);
+                return opResult;
+        }
+
+        return EOK;
+}
+
+/**
+ * When entering this function, hub->endpoints.control should be active.
+ * @param hub
+ * @return
+ */
+static int usb_hub_process_configuration_descriptors(
+        usb_hub_info_t * hub){
+        if(hub==NULL) {
+                return EINVAL;
+        }
+        int opResult;
+        
+        //device descriptor
+        usb_standard_device_descriptor_t std_descriptor;
+        opResult = usb_request_get_device_descriptor(&hub->endpoints.control,
+            &std_descriptor);
+        if(opResult!=EOK){
+                usb_log_error("could not get device descriptor, %d",opResult);
+                return opResult;
+        }
+        usb_log_info("hub has %d configurations",
+                        std_descriptor.configuration_count);
+        if(std_descriptor.configuration_count<1){
+                usb_log_error("THERE ARE NO CONFIGURATIONS AVAILABLE");
+                //shouldn`t I return?
+        }
+
+        /* Retrieve full configuration descriptor. */
+        uint8_t *descriptors = NULL;
+        size_t descriptors_size = 0;
+        opResult = usb_request_get_full_configuration_descriptor_alloc(
+            &hub->endpoints.control, 0,
+            (void **) &descriptors, &descriptors_size);
+        if (opResult != EOK) {
+                usb_log_error("Could not get configuration descriptor: %s.\n",
+                    str_error(opResult));
+                return opResult;
+        }
+        usb_standard_configuration_descriptor_t *config_descriptor
+            = (usb_standard_configuration_descriptor_t *) descriptors;
+
+        /* Set configuration. */
+        opResult = usb_request_set_configuration(&hub->endpoints.control,
+            config_descriptor->configuration_number);
+
+        if (opResult != EOK) {
+                usb_log_error("Failed to set hub configuration: %s.\n",
+                    str_error(opResult));
+                return opResult;
+        }
+        usb_log_debug("\tused configuration %d",
+                        config_descriptor->configuration_number);
+
+        usb_endpoint_mapping_t endpoint_mapping[1] = {
+                {
+                        .pipe = &hub->endpoints.status_change,
+                        .description = &status_change_endpoint_description,
+                        .interface_no =
+                            usb_device_get_assigned_interface(hub->device)
+                }
+        };
+        opResult = usb_endpoint_pipe_initialize_from_configuration(
+            endpoint_mapping, 1,
+            descriptors, descriptors_size,
+            &hub->device_connection);
+        if (opResult != EOK) {
+                usb_log_error("Failed to initialize status change pipe: %s",
+                    str_error(opResult));
+                return opResult;
+        }
+        if (!endpoint_mapping[0].present) {
+                usb_log_error("Not accepting device, " \
+                    "cannot understand what is happenning");
+                return EREFUSED;
+        }
+
+        free(descriptors);
+        return EOK;
+        
+}
+
+
+/**
+ * Create hub representation from device information.
+ * @param device
+ * @return pointer to created structure or NULL in case of error
+ */
+usb_hub_info_t * usb_create_hub_info(ddf_dev_t * device) {
+        usb_hub_info_t* result = usb_new(usb_hub_info_t);
+        result->device = device;
+        int opResult;
+        opResult = usb_hub_init_communication(result);
+        if(opResult != EOK){
+                free(result);
+                return NULL;
+        }
+
+        //result->device = device;
+        result->port_count = -1;
+        result->device = device;
         result->is_default_address_used = false;
-        return result;
-}
-
-/**
- * Load hub-specific information into hub_info structure.
- *
- * Particularly read port count and initialize structure holding port
- * information.
- * This function is hub-specific and should be run only after the hub is
- * configured using usb_hub_set_configuration function.
- * @param hub_info pointer to structure with usb hub data
- * @return error code
- */
-static int usb_hub_get_hub_specific_info(usb_hub_info_t * hub_info){
+
+        //result->usb_device = usb_new(usb_hcd_attached_device_info_t);
+        size_t received_size;
+
         // get hub descriptor
-        usb_log_debug("creating serialized descriptor\n");
+        usb_log_debug("creating serialized descripton");
         void * serialized_descriptor = malloc(USB_HUB_MAX_DESCRIPTOR_SIZE);
         usb_hub_descriptor_t * descriptor;
-
-        /* this was one fix of some bug, should not be needed anymore
-        int opResult = usb_request_set_configuration(&result->endpoints.control, 1);
-        if(opResult!=EOK){
-                usb_log_error("could not set default configuration, errno %d",opResult);
-                return opResult;
-        }
-         */
-        size_t received_size;
-        int opResult = usb_request_get_descriptor(&hub_info->usb_device->ctrl_pipe,
+        usb_log_debug("starting control transaction");
+        usb_endpoint_pipe_start_session(&result->endpoints.control);
+        opResult = usb_request_set_configuration(&result->endpoints.control, 1);
+        assert(opResult == EOK);
+
+        opResult = usb_request_get_descriptor(&result->endpoints.control,
                         USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_DEVICE,
                         USB_DESCTYPE_HUB,
                         0, 0, serialized_descriptor,
                         USB_HUB_MAX_DESCRIPTOR_SIZE, &received_size);
-
-        if (opResult != EOK) {
-                usb_log_error("failed when receiving hub descriptor, badcode = %d\n",
+        usb_endpoint_pipe_end_session(&result->endpoints.control);
+
+        if (opResult != EOK) {
+                usb_log_error("failed when receiving hub descriptor, badcode = %d",
                                 opResult);
                 free(serialized_descriptor);
-                return opResult;
-        }
-        usb_log_debug2("deserializing descriptor\n");
+                free(result);
+                return NULL;
+        }
+        usb_log_debug2("deserializing descriptor");
         descriptor = usb_deserialize_hub_desriptor(serialized_descriptor);
         if(descriptor==NULL){
-                usb_log_warning("could not deserialize descriptor \n");
-                return opResult;
-        }
-        usb_log_info("setting port count to %d\n",descriptor->ports_count);
-        hub_info->port_count = descriptor->ports_count;
-        hub_info->attached_devs = (usb_hc_attached_device_t*)
-            malloc((hub_info->port_count+1) * sizeof(usb_hc_attached_device_t));
+                usb_log_warning("could not deserialize descriptor ");
+                free(result);
+                return NULL;
+        }
+
+        usb_log_info("setting port count to %d",descriptor->ports_count);
+        result->port_count = descriptor->ports_count;
+        result->attached_devs = (usb_hc_attached_device_t*)
+            malloc((result->port_count+1) * sizeof(usb_hc_attached_device_t));
         int i;
-        for(i=0;i<hub_info->port_count+1;++i){
-                hub_info->attached_devs[i].handle=0;
-                hub_info->attached_devs[i].address=0;
-        }
-        usb_log_debug2("freeing data\n");
+        for(i=0;i<result->port_count+1;++i){
+                result->attached_devs[i].handle=0;
+                result->attached_devs[i].address=0;
+        }
+        usb_log_debug2("freeing data");
         free(serialized_descriptor);
         free(descriptor->devices_removable);
         free(descriptor);
-        return EOK;
-}
-/**
- * Set configuration of hub
- *
- * Check whether there is at least one configuration and sets the first one.
- * This function should be run prior to running any hub-specific action.
- * @param hub_info
+
+        //finish
+
+        usb_log_info("hub info created");
+
+        return result;
+}
+
+/**
+ * Create hub representation and add it into hub list
+ * @param dev
  * @return
  */
-static int usb_hub_set_configuration(usb_hub_info_t * hub_info){
-        //device descriptor
-        usb_standard_device_descriptor_t std_descriptor;
-        int opResult = usb_request_get_device_descriptor(
-                &hub_info->usb_device->ctrl_pipe,
-            &std_descriptor);
-        if(opResult!=EOK){
-                usb_log_error("could not get device descriptor, %d\n",opResult);
-                return opResult;
-        }
-        usb_log_info("hub has %d configurations\n",
-                        std_descriptor.configuration_count);
-        if(std_descriptor.configuration_count<1){
-                usb_log_error("THERE ARE NO CONFIGURATIONS AVAILABLE\n");
-                //shouldn`t I return?
-        }
-
-        /* Retrieve full configuration descriptor. */
-        uint8_t *descriptors = NULL;
-        size_t descriptors_size = 0;
-        opResult = usb_request_get_full_configuration_descriptor_alloc(
-            &hub_info->usb_device->ctrl_pipe, 0,
-            (void **) &descriptors, &descriptors_size);
-        if (opResult != EOK) {
-                usb_log_error("Could not get configuration descriptor: %s.\n",
-                    str_error(opResult));
-                return opResult;
-        }
-        usb_standard_configuration_descriptor_t *config_descriptor
-            = (usb_standard_configuration_descriptor_t *) descriptors;
-
-        /* Set configuration. */
-        opResult = usb_request_set_configuration(&hub_info->usb_device->ctrl_pipe,
-            config_descriptor->configuration_number);
-
-        if (opResult != EOK) {
-                usb_log_error("Failed to set hub configuration: %s.\n",
-                    str_error(opResult));
-                return opResult;
-        }
-        usb_log_debug("\tused configuration %d\n",
-                        config_descriptor->configuration_number);
-        free(descriptors);
-        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_add_device(usb_device_t * usb_dev){
-        if(!usb_dev) return EINVAL;
-        usb_hub_info_t * hub_info = usb_hub_info_create(usb_dev);
-        //create hc connection
-        usb_log_debug("Initializing USB wire abstraction.\n");
-        int opResult = usb_hc_connection_initialize_from_device(
-                        &hub_info->connection,
-                        hub_info->usb_device->ddf_dev);
+int usb_add_hub_device(ddf_dev_t *dev) {
+        usb_log_info("add_hub_device(handle=%d)", (int) dev->handle);
+
+        //dev->ops = &hub_device_ops;
+        (void) hub_device_ops;
+
+        usb_hub_info_t * hub_info = usb_create_hub_info(dev);
+        if(!hub_info){
+                return EINTR;
+        }
+
+        int opResult;
+
+        //perform final configurations
+        usb_endpoint_pipe_start_session(&hub_info->endpoints.control);
+        // process descriptors
+        opResult = usb_hub_process_configuration_descriptors(hub_info);
         if(opResult != EOK){
-                usb_log_error("could not initialize connection to device, errno %d\n",
+                usb_log_error("could not get configuration descriptors, %d",
                                 opResult);
-                free(hub_info);
-                return opResult;
-        }
-        
-        usb_endpoint_pipe_start_session(hub_info->control_pipe);
-        //set hub configuration
-        opResult = usb_hub_set_configuration(hub_info);
-        if(opResult!=EOK){
-                usb_log_error("could not set hub configuration, errno %d\n",opResult);
-                free(hub_info);
-                return opResult;
-        }
-        //get port count and create attached_devs
-        opResult = usb_hub_get_hub_specific_info(hub_info);
-        if(opResult!=EOK){
-                usb_log_error("could not set hub configuration, errno %d\n",opResult);
-                free(hub_info);
-                return opResult;
-        }
-        usb_endpoint_pipe_end_session(hub_info->control_pipe);
-
-
-        /// \TODO what is this?
+                return opResult;
+        }
+        //power ports
+        usb_device_request_setup_packet_t request;
+        int port;
+        for (port = 1; port < hub_info->port_count+1; ++port) {
+                usb_hub_set_power_port_request(&request, port);
+                opResult = usb_endpoint_pipe_control_write(&hub_info->endpoints.control,
+                                &request,sizeof(usb_device_request_setup_packet_t), NULL, 0);
+                usb_log_info("powering port %d",port);
+                if (opResult != EOK) {
+                        usb_log_warning("something went wrong when setting hub`s %dth port", port);
+                }
+        }
+        //ports powered, hub seems to be enabled
+        usb_endpoint_pipe_end_session(&hub_info->endpoints.control);
+
+        //add the hub to list
+        //is this needed now?
+        fibril_mutex_lock(&usb_hub_list_lock);
+        usb_lst_append(&usb_hub_list, hub_info);
+        fibril_mutex_unlock(&usb_hub_list_lock);
+        usb_log_debug("hub info added to list");
+
         usb_log_debug("adding to ddf");
-        ddf_fun_t *hub_fun = ddf_fun_create(hub_info->usb_device->ddf_dev,
-                        fun_exposed, "hub");
+        ddf_fun_t *hub_fun = ddf_fun_create(dev, fun_exposed, "hub");
         assert(hub_fun != NULL);
         hub_fun->ops = NULL;
@@ -254 +349 @@
         assert(rc == EOK);
 
-        //create fibril for the hub control loop
         fid_t fid = fibril_create(usb_hub_control_loop, hub_info);
         if (fid == 0) {
@@ -261 +355 @@
         }
         fibril_add_ready(fid);
+
         usb_log_debug("hub fibril created");
-        usb_log_debug("has %d ports ",hub_info->port_count);
+        //(void)hub_info;
+        //usb_hub_check_hub_changes();
+        
+        usb_log_info("hub dev added");
+        //address is lost...
+        usb_log_debug("\taddress %d, has %d ports ",
+                        //hub_info->endpoints.control.,
+                        hub_info->port_count);
+
         return EOK;
+        //return ENOTSUP;
 }
 
@@ -284 +388 @@
         int opResult = usb_hc_release_default_address(&hub->connection);
         if(opResult!=EOK){
-                usb_log_error("could not release default address, errno %d\n",opResult);
+                usb_log_error("could not release default address, errno %d",opResult);
                 return opResult;
         }
@@ -301 +405 @@
         //if this hub already uses default address, it cannot request it once more
         if(hub->is_default_address_used) return;
-        usb_log_info("some connection changed\n");
-        assert(hub->control_pipe->hc_phone);
-        int opResult = usb_hub_clear_port_feature(hub->control_pipe,
+        int opResult = usb_hub_clear_port_feature(&hub->endpoints.control,
                                 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");
+        }
+
         usb_device_request_setup_packet_t request;
-        
+        usb_log_info("some connection changed");
+        assert(hub->endpoints.control.hc_phone);
         //get default address
         opResult = usb_hc_reserve_default_address(&hub->connection, speed);
         
         if (opResult != EOK) {
-                usb_log_warning("cannot assign default address, it is probably used %d\n",
+                usb_log_warning("cannot assign default address, it is probably used %d",
                                 opResult);
                 return;
@@ -322 +426 @@
         usb_hub_set_reset_port_request(&request, port);
         opResult = usb_endpoint_pipe_control_write(
-                        hub->control_pipe,
+                        &hub->endpoints.control,
                         &request,sizeof(usb_device_request_setup_packet_t),
                         NULL, 0
                         );
         if (opResult != EOK) {
-                usb_log_error("something went wrong when reseting a port %d\n",opResult);
+                usb_log_error("something went wrong when reseting a port %d",opResult);
                 //usb_hub_release_default_address(hc);
                 usb_hub_release_default_address(hub);
@@ -341 +445 @@
  */
 static void usb_hub_finalize_add_device( usb_hub_info_t * hub,
-                uint16_t port, usb_speed_t speed) {
+                uint16_t port, bool isLowSpeed) {
 
         int opResult;
-        usb_log_info("finalizing add device\n");
-        opResult = usb_hub_clear_port_feature(hub->control_pipe,
+        usb_log_info("finalizing add device");
+        opResult = usb_hub_clear_port_feature(&hub->endpoints.control,
             port, USB_HUB_FEATURE_C_PORT_RESET);
 
         if (opResult != EOK) {
-                usb_log_error("failed to clear port reset feature\n");
+                usb_log_error("failed to clear port reset feature");
                 usb_hub_release_default_address(hub);
                 return;
@@ -364 +468 @@
                         &new_device_connection);
         usb_endpoint_pipe_probe_default_control(&new_device_pipe);
+        /// \TODO get highspeed info
+        usb_speed_t speed = isLowSpeed?USB_SPEED_LOW:USB_SPEED_FULL;
+
 
         /* Request address from host controller. */
@@ -371 +478 @@
                         );
         if (new_device_address < 0) {
-                usb_log_error("failed to get free USB address\n");
+                usb_log_error("failed to get free USB address");
                 opResult = new_device_address;
                 usb_hub_release_default_address(hub);
                 return;
         }
-        usb_log_info("setting new address %d\n",new_device_address);
+        usb_log_info("setting new address %d",new_device_address);
         //opResult = usb_drv_req_set_address(hc, USB_ADDRESS_DEFAULT,
         //    new_device_address);
@@ -383 +490 @@
         usb_endpoint_pipe_end_session(&new_device_pipe);
         if (opResult != EOK) {
-                usb_log_error("could not set address for new device %d\n",opResult);
+                usb_log_error("could not set address for new device %d",opResult);
                 usb_hub_release_default_address(hub);
                 return;
@@ -398 +505 @@
         //??
     opResult = usb_device_register_child_in_devman(new_device_address,
-            hub->connection.hc_handle, hub->usb_device->ddf_dev, &child_handle,
+            hub->connection.hc_handle, hub->device, &child_handle,
             NULL, NULL, NULL);
 
         if (opResult != EOK) {
-                usb_log_error("could not start driver for new device %d\n",opResult);
+                usb_log_error("could not start driver for new device %d",opResult);
                 return;
         }
@@ -413 +520 @@
                         &hub->attached_devs[port]);
         if (opResult != EOK) {
-                usb_log_error("could not assign address of device in hcd %d\n",opResult);
-                return;
-        }
-        usb_log_info("new device address %d, handle %zu\n",
+                usb_log_error("could not assign address of device in hcd %d",opResult);
+                return;
+        }
+        usb_log_info("new device address %d, handle %zu",
             new_device_address, child_handle);
 
@@ -430 +537 @@
     usb_hub_info_t * hub,uint16_t port) {
 
-        int opResult = usb_hub_clear_port_feature(hub->control_pipe,
+        int opResult = usb_hub_clear_port_feature(&hub->endpoints.control,
                                 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");
         }
         /** \TODO remove device from device manager - not yet implemented in
@@ -452 +559 @@
                  */
         }else{
-                usb_log_warning("this is strange, disconnected device had no address\n");
+                usb_log_warning("this is strange, disconnected device had no address");
                 //device was disconnected before it`s port was reset - return default address
                 usb_hub_release_default_address(hub);
@@ -470 +577 @@
                 uint16_t port){
         int opResult;
-        opResult = usb_hub_clear_port_feature(hub->control_pipe,
+        opResult = usb_hub_clear_port_feature(&hub->endpoints.control,
             port, USB_HUB_FEATURE_PORT_POWER);
         if(opResult!=EOK){
-                usb_log_error("cannot power off port %d;  %d\n",
+                usb_log_error("cannot power off port %d;  %d",
                                 port, opResult);
         }
@@ -486 +593 @@
 static void usb_hub_process_interrupt(usb_hub_info_t * hub, 
         uint16_t port) {
-        usb_log_debug("interrupt at port %d\n", port);
+        usb_log_debug("interrupt at port %d", port);
         //determine type of change
-        usb_endpoint_pipe_t *pipe = hub->control_pipe;
+        usb_endpoint_pipe_t *pipe = &hub->endpoints.control;
         
         int opResult;
@@ -505 +612 @@
                         );
         if (opResult != EOK) {
-                usb_log_error("could not get port status\n");
+                usb_log_error("could not get port status");
                 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");
                 return;
         }
@@ -515 +622 @@
         if (usb_port_connect_change(&status)) {
                 if (usb_port_dev_connected(&status)) {
-                        usb_log_info("some connection changed\n");
+                        usb_log_info("some connection changed");
                         usb_hub_init_add_device(hub, port, usb_port_speed(&status));
                 } else {
@@ -527 +634 @@
                         usb_hub_over_current(hub,port);
                 }else{
-                        usb_log_info("over current condition was auto-resolved on port %d\n",
+                        usb_log_info("over current condition was auto-resolved on port %d",
                                         port);
                 }
@@ -535 +642 @@
                 usb_log_info("port reset complete");
                 if (usb_port_enabled(&status)) {
-                        usb_hub_finalize_add_device(hub, port, usb_port_speed(&status));
+                        usb_hub_finalize_add_device(hub, port, usb_port_low_speed(&status));
                 } else {
-                        usb_log_warning("port reset, but port still not enabled\n");
+                        usb_log_warning("port reset, but port still not enabled");
                 }
         }
@@ -546 +653 @@
         usb_port_set_dev_connected(&status, false);
         if (status>>16) {
-                usb_log_info("there was some unsupported change on port %d: %X\n",
+                usb_log_info("there was some unsupported change on port %d: %X",
                                 port,status);
 
         }
+        /// \TODO handle other changes - is there any?
 }
 
@@ -560 +668 @@
 int usb_hub_check_hub_changes(usb_hub_info_t * hub_info){
         int opResult;
-        opResult = usb_endpoint_pipe_start_session(
-                        hub_info->status_change_pipe);
+        opResult = usb_endpoint_pipe_start_session(&hub_info->endpoints.status_change);
         if(opResult != EOK){
-                usb_log_error("could not initialize communication for hub; %d\n",
+                usb_log_error("could not initialize communication for hub; %d",
                                 opResult);
                 return opResult;
@@ -579 +686 @@
          */
         opResult = usb_endpoint_pipe_read(
-                        hub_info->status_change_pipe,
+                        &hub_info->endpoints.status_change,
                         change_bitmap, byte_length, &actual_size
                         );
@@ -585 +692 @@
         if (opResult != EOK) {
                 free(change_bitmap);
-                usb_log_warning("something went wrong while getting status of hub\n");
-                usb_endpoint_pipe_end_session(hub_info->status_change_pipe);
+                usb_log_warning("something went wrong while getting status of hub");
+                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
                 return opResult;
         }
         unsigned int port;
-        opResult = usb_endpoint_pipe_start_session(hub_info->control_pipe);
+        opResult = usb_endpoint_pipe_start_session(&hub_info->endpoints.control);
         if(opResult!=EOK){
-                usb_log_error("could not start control pipe session %d\n", opResult);
-                usb_endpoint_pipe_end_session(hub_info->status_change_pipe);
+                usb_log_error("could not start control pipe session %d", opResult);
+                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
                 return opResult;
         }
         opResult = usb_hc_connection_open(&hub_info->connection);
         if(opResult!=EOK){
-                usb_log_error("could not start host controller session %d\n",
+                usb_log_error("could not start host controller session %d",
                                 opResult);
-                usb_endpoint_pipe_end_session(hub_info->control_pipe);
-                usb_endpoint_pipe_end_session(hub_info->status_change_pipe);
+                usb_endpoint_pipe_end_session(&hub_info->endpoints.control);
+                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
                 return opResult;
         }
@@ -615 +722 @@
         }
         usb_hc_connection_close(&hub_info->connection);
-        usb_endpoint_pipe_end_session(hub_info->control_pipe);
-        usb_endpoint_pipe_end_session(hub_info->status_change_pipe);
+        usb_endpoint_pipe_end_session(&hub_info->endpoints.control);
+        usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
         free(change_bitmap);
         return EOK;

uspace/drv/usbhub/usbhub.h

@@ -45 +45 @@
 
 #include <usb/pipes.h>
-#include <usb/devdrv.h>
-
-
-/** Hub status-change endpoint description
- *
- * For more see usb hub specification in 11.15.1 of
- */
-extern usb_endpoint_description_t hub_status_change_endpoint_description;
-
-
 
 /* Hub endpoints. */
-/*typedef struct {
+typedef struct {
         usb_endpoint_pipe_t control;
         usb_endpoint_pipe_t status_change;
 } usb_hub_endpoints_t;
-*/
+
 
 
@@ -68 +58 @@
         /** Number of ports. */
         int port_count;
-
         /** attached device handles, for each port one */
         usb_hc_attached_device_t * attached_devs;
-        
+        /** General usb device info. */
+        //usb_hcd_attached_device_info_t * usb_device;
+        /** General device info*/
+        ddf_dev_t * device;
         /** connection to hcd */
+        //usb_device_connection_t connection;
         usb_hc_connection_t connection;
+        /** */
+        usb_device_connection_t device_connection;
+        /** hub endpoints */
+        usb_hub_endpoints_t endpoints;
 
-        /** default address is used indicator
-         *
-         * If default address is requested by this device, it cannot
-         * be requested by the same hub again, otherwise a deadlock will occur.
-         */
         bool is_default_address_used;
-
-        /** convenience pointer to status change pipe
-         *
-         * Status change pipe is initialized in usb_device structure. This is
-         * pointer into this structure, so that it does not have to be
-         * searched again and again for the 'right pipe'.
-         */
-        usb_endpoint_pipe_t * status_change_pipe;
-
-        /** convenience pointer to control pipe
-         *
-         * Control pipe is initialized in usb_device structure. This is
-         * pointer into this structure, so that it does not have to be
-         * searched again and again for the 'right pipe'.
-         */
-        usb_endpoint_pipe_t * control_pipe;
-
-        /** generic usb device data*/
-        usb_device_t * usb_device;
 } usb_hub_info_t;
 
@@ -107 +80 @@
  */
 int usb_hub_control_loop(void * hub_info_param);
+
+/** Callback when new hub device is detected.
+ *
+ * @param dev New device.
+ * @return Error code.
+ */
+int usb_add_hub_device(ddf_dev_t *dev);
 
 /**
@@ -117 +97 @@
 
 
-int usb_hub_add_device(usb_device_t * usb_dev);
+
+
 
 #endif

uspace/drv/usbhub/usbhub_private.h

@@ -58 +58 @@
 
 
+//************
+//
+// convenience debug printf for usb hub
+//
+//************
+#define dprintf(level, format, ...) \
+        usb_log_printf((level), format "\n", ##__VA_ARGS__)
+
+
 /**
  * Create hub structure instance
@@ -68 +77 @@
  */
 usb_hub_info_t * usb_create_hub_info(ddf_dev_t * device);
+
+/** List of hubs maanged by this driver */
+extern usb_general_list_t usb_hub_list;
+
+/** Lock for hub list*/
+extern fibril_mutex_t usb_hub_list_lock;
+
+
+/**
+ * Perform complete control read transaction
+ *
+ * Manages all three steps of transaction: setup, read and finalize
+ * @param phone
+ * @param target
+ * @param request Request packet
+ * @param rcvd_buffer Received data
+ * @param rcvd_size
+ * @param actual_size Actual size of received data
+ * @return error code
+ */
+/*
+int usb_drv_sync_control_read(
+    usb_endpoint_pipe_t *pipe,
+    usb_device_request_setup_packet_t * request,
+    void * rcvd_buffer, size_t rcvd_size, size_t * actual_size
+);*/
+
+/**
+ * Perform complete control write transaction
+ *
+ * Manages all three steps of transaction: setup, write and finalize
+ * @param phone
+ * @param target
+ * @param request Request packet to send data
+ * @param sent_buffer
+ * @param sent_size
+ * @return error code
+ */
+/*int usb_drv_sync_control_write(
+    usb_endpoint_pipe_t *pipe,
+    usb_device_request_setup_packet_t * request,
+    void * sent_buffer, size_t sent_size
+);*/
 
 /**
@@ -111 +163 @@
 
 /**
- * create uint8_t array with serialized descriptor
+ * @brief create uint8_t array with serialized descriptor
  *
  * @param descriptor
@@ -119 +171 @@
 
 /**
- * create deserialized desriptor structure out of serialized descriptor
+ * @brief create deserialized desriptor structure out of serialized descriptor
  *
  * The serialized descriptor must be proper usb hub descriptor,

uspace/drv/usbhub/utils.c

@@ -88 +88 @@
 
         if (sdescriptor[1] != USB_DESCTYPE_HUB) {
-                usb_log_warning("trying to deserialize wrong descriptor %x\n",sdescriptor[1]);
+                dprintf(1,"[usb_hub] wrong descriptor %x\n",sdescriptor[1]);
                 return NULL;
         }
@@ -103 +103 @@
                         ? 1 : 0);
         result->devices_removable = (uint8_t*) malloc(var_size);
-
+        //printf("[usb_hub] getting removable devices data \n");
         size_t i;
         for (i = 0; i < var_size; ++i) {
@@ -111 +111 @@
 }
 
+//control transactions
+/*
+int usb_drv_sync_control_read(
+    int phone, usb_target_t target,
+    usb_device_request_setup_packet_t * request,
+    void * rcvd_buffer, size_t rcvd_size, size_t * actual_size
+) {
+        usb_handle_t handle;
+        int opResult;
+        //setup
+        opResult = usb_drv_async_control_read_setup(phone, target,
+            request, sizeof (usb_device_request_setup_packet_t),
+            &handle);
+        if (opResult != EOK) {
+                return opResult;
+        }
+        opResult = usb_drv_async_wait_for(handle);
+        if (opResult != EOK) {
+                return opResult;
+        }
+        //read
+        opResult = usb_drv_async_control_read_data(phone, target,
+                        rcvd_buffer, rcvd_size, actual_size,
+                        &handle);
+        if (opResult != EOK) {
+                return opResult;
+        }
+        opResult = usb_drv_async_wait_for(handle);
+        if (opResult != EOK) {
+                return opResult;
+        }
+        //finalize
+        opResult = usb_drv_async_control_read_status(phone, target,
+                        &handle);
+        if (opResult != EOK) {
+                return opResult;
+        }
+        opResult = usb_drv_async_wait_for(handle);
+        if (opResult != EOK) {
+                return opResult;
+        }
+        return EOK;
+}
+
+int usb_drv_sync_control_write(
+    int phone, usb_target_t target,
+    usb_device_request_setup_packet_t * request,
+    void * sent_buffer, size_t sent_size
+) {
+        usb_handle_t handle;
+        int opResult;
+        //setup
+        opResult = usb_drv_async_control_write_setup(phone, target,
+            request, sizeof (usb_device_request_setup_packet_t),
+            &handle);
+        if (opResult != EOK) {
+                return opResult;
+        }
+        opResult = usb_drv_async_wait_for(handle);
+        if (opResult != EOK) {
+                return opResult;
+        }
+        //write
+        opResult = usb_drv_async_control_write_data(phone, target,
+                        sent_buffer, sent_size,
+                        &handle);
+        if (opResult != EOK) {
+                return opResult;
+        }
+        opResult = usb_drv_async_wait_for(handle);
+        if (opResult != EOK) {
+                return opResult;
+        }
+        //finalize
+        opResult = usb_drv_async_control_write_status(phone, target,
+            &handle);
+        if (opResult != EOK) {
+                return opResult;
+        }
+        opResult = usb_drv_async_wait_for(handle);
+        if (opResult != EOK) {
+                return opResult;
+        }
+        return EOK;
+}
+
+*/
+
 
 

uspace/lib/usb/include/usb/devdrv.h

@@ -79 +79 @@
          */
         const char *name;
-        /** Expected endpoints description, excluding default control endpoint.
-         *
-         * It MUST be of size expected_enpoints_count(excluding default ctrl) + 1
-         * where the last record MUST BE NULL, otherwise catastrophic things may
-         * happen.
-         */
+        /** Expected endpoints description. */
         usb_endpoint_description_t **endpoints;
         /** Driver ops. */

uspace/lib/usb/src/devdrv.c

@@ -206 +206 @@
  * @return Error code.
  */
-static int initialize_pipes(usb_device_t *dev)
+static int initialize_pipes(usb_driver_t *drv, usb_device_t *dev)
 {
         int rc;
@@ -284 +284 @@
         dev->driver_data = NULL;
 
-        rc = initialize_pipes(dev);
+        rc = initialize_pipes(driver, dev);
         if (rc != EOK) {
                 free(dev);