Changes in / [58854f2:5863a95] in mainline

Files:

• Makefile (modified) (3 diffs)
• tools/check.sh (deleted)
• uspace/app/tester/Makefile (modified) (1 diff)
• uspace/app/tester/hw/misc/virtchar1.c (deleted)
• uspace/app/tester/hw/misc/virtchar1.def (deleted)
• uspace/app/tester/tester.c (modified) (1 diff)
• uspace/app/tester/tester.h (modified) (1 diff)
• uspace/drv/rootvirt/devices.def (modified) (1 diff)
• uspace/drv/test1/Makefile (modified) (1 diff)
• uspace/drv/test1/char.c (deleted)
• uspace/drv/test1/test1.c (modified) (3 diffs)
• uspace/drv/test1/test1.h (deleted)
• uspace/drv/usbhub/Makefile (modified) (1 diff)
• uspace/drv/usbhub/main.c (modified) (2 diffs)
• uspace/drv/usbhub/usbhub.c (deleted)
• uspace/drv/usbhub/usbhub_private.h (modified) (2 diffs)
• uspace/drv/usbhub/usblist.c (deleted)
• uspace/drv/usbhub/usblist.h (deleted)
• uspace/drv/usbhub/utils.c (modified) (5 diffs)
• uspace/lib/c/generic/devmap.c (modified) (2 diffs)
• uspace/lib/c/generic/net/modules.c (modified) (1 diff)
• uspace/lib/c/include/devmap.h (modified) (1 diff)
• uspace/lib/c/include/ipc/devman.h (modified) (1 diff)
• uspace/lib/c/include/net/modules.h (modified) (2 diffs)
• uspace/lib/usb/include/usb/hcdhubd.h (modified) (1 diff)
• uspace/srv/devman/devman.c (modified) (6 diffs)
• uspace/srv/devman/main.c (modified) (5 diffs)
• uspace/srv/devmap/devmap.c (modified) (4 diffs)
• uspace/srv/hw/netif/dp8390/dp8390_module.c (modified) (2 diffs)
• uspace/srv/net/il/arp/arp.c (modified) (5 diffs)
• uspace/srv/net/il/arp/arp_module.c (modified) (1 diff)
• uspace/srv/net/il/ip/ip.c (modified) (7 diffs)
• uspace/srv/net/il/ip/ip_module.c (modified) (1 diff)
• uspace/srv/net/net/net.c (modified) (1 diff)
• uspace/srv/net/netif/lo/lo.c (modified) (1 diff)
• uspace/srv/net/nil/eth/eth.c (modified) (1 diff)
• uspace/srv/net/nil/eth/eth_module.c (modified) (1 diff)
• uspace/srv/net/nil/nildummy/nildummy_module.c (modified) (1 diff)
• uspace/srv/net/tl/icmp/icmp_module.c (modified) (1 diff)
• uspace/srv/net/tl/tcp/tcp.c (modified) (3 diffs)
• uspace/srv/net/tl/tcp/tcp_module.c (modified) (1 diff)
• uspace/srv/net/tl/udp/udp.c (modified) (2 diffs)
• uspace/srv/net/tl/udp/udp_module.c (modified) (1 diff)

Makefile

@@ -28 +28 @@
 
 CSCOPE = cscope
-CHECK = tools/check.sh
 CONFIG = tools/config.py
 AUTOTOOL = tools/autotool.py
@@ -42 +41 @@
 CONFIG_HEADER = config.h
 
-.PHONY: all precheck cscope autotool config_auto config_default config distclean clean check
+.PHONY: all precheck cscope autotool config_auto config_default config distclean clean
 
 all: $(COMMON_MAKEFILE) $(COMMON_HEADER) $(CONFIG_MAKEFILE) $(CONFIG_HEADER)
@@ -55 +54 @@
 cscope:
         find kernel boot uspace -regex '^.*\.[chsS]$$' | xargs $(CSCOPE) -b -k -u -f$(CSCOPE).out
-
-# Pre-integration build check
-check: $(CHECK)
-ifdef JOBS 
-        $(CHECK) -j $(JOBS)
-else
-        $(CHECK)
-endif
 
 $(COMMON_MAKEFILE): autotool

uspace/app/tester/Makefile

@@ -55 +55 @@
         loop/loop1.c \
         mm/malloc1.c \
-        hw/misc/virtchar1.c \
         hw/serial/serial1.c
 

uspace/app/tester/tester.c

@@ -66 +66 @@
 #include "hw/serial/serial1.def"
 #include "adt/usbaddrkeep.def"
-#include "hw/misc/virtchar1.def"
         {NULL, NULL, NULL, false}
 };

uspace/app/tester/tester.h

@@ -83 +83 @@
 extern const char *test_serial1(void);
 extern const char *test_usbaddrkeep(void);
-extern const char *test_virtchar1(void);
 
 extern test_t tests[];

uspace/drv/rootvirt/devices.def

@@ -17 +17 @@
         .match_id = "virtual&test2"
 },
-{
-        .name = "null",
-        .match_id = "virtual&test1"
-},
 #endif
 /* Virtual USB host controller. */

uspace/drv/test1/Makefile

@@ -33 +33 @@
 
 SOURCES = \
-        char.c \
         test1.c
 

uspace/drv/test1/test1.c

@@ -34 +34 @@
 #include <errno.h>
 #include <str_error.h>
-#include "test1.h"
+#include <driver.h>
+
+#define NAME "test1"
 
 static int add_device(device_t *dev);
@@ -96 +98 @@
         add_device_to_class(dev, "virtual");
 
-        if (str_cmp(dev->name, "null") == 0) {
-                dev->ops = &char_device_ops;
-                add_device_to_class(dev, "virt-null");
-        } else if (dev->parent == NULL) {
+        if (dev->parent == NULL) {
                 register_child_verbose(dev, "cloning myself ;-)", "clone",
                     "virtual&test1", 10);
@@ -118 +117 @@
 }
 
+

uspace/drv/usbhub/Makefile

@@ -34 +34 @@
 SOURCES = \
         main.c \
-        utils.c \
-        usbhub.c \
-        usblist.c
+        utils.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/drv/usbhub/main.c

@@ -32 +32 @@
 
 #include <usb/usbdrv.h>
-
 #include "usbhub.h"
 #include "usbhub_private.h"
@@ -59 +58 @@
 int main(int argc, char *argv[])
 {
-        usb_dprintf_enable(NAME,1);
         usb_lst_init(&usb_hub_list);
         fid_t fid = fibril_create(usb_hub_control_loop, NULL);
         if (fid == 0) {
-                dprintf(1, "failed to start fibril for HUB devices");
-                //printf("%s: failed to start fibril for HUB devices\n", NAME);
+                printf("%s: failed to start fibril for HUB devices\n", NAME);
                 return ENOMEM;
         }

uspace/drv/usbhub/usbhub_private.h

@@ -38 +38 @@
 
 #include "usbhub.h"
-#include "usblist.h"
-
 #include <adt/list.h>
 #include <bool.h>
 #include <driver.h>
 #include <usb/usb.h>
-#include <usb/usbdrv.h>
 #include <usb/classes/hub.h>
 #include <usb/devreq.h>
-#include <usb/debug.h>
 
 //************
@@ -59 +55 @@
 //************
 //
-// convenience debug printf
-//
-//************
-#define dprintf(level, format, ...) \
-        usb_dprintf(NAME, (level), format "\n", ##__VA_ARGS__)
+// My private list implementation; I did not like the original helenos list
+//
+// This one does not depend on the structure of stored data
+//
+//************
+
+/** general list structure */
+
+
+typedef struct usb_general_list{
+        void * data;
+        struct usb_general_list * prev, * next;
+} usb_general_list_t;
+
+/** create head of usb general list */
+usb_general_list_t * usb_lst_create(void);
+
+/** initialize head of usb general list */
+void usb_lst_init(usb_general_list_t * lst);
+
+
+/** is the list empty? */
+static inline bool usb_lst_empty(usb_general_list_t * lst){
+        return lst?(lst->next==lst):true;
+}
+
+/** append data behind item */
+void usb_lst_append(usb_general_list_t * lst, void * data);
+
+/** prepend data beore item */
+void usb_lst_prepend(usb_general_list_t * lst, void * data);
+
+/** remove list item from list */
+void usb_lst_remove(usb_general_list_t * item);
+
+/** get data o specified type from list item */
+#define usb_lst_get_data(item, type)  (type *) (item->data)
+
+/** get usb_hub_info_t data from list item */
+static inline usb_hub_info_t * usb_hub_lst_get_data(usb_general_list_t * item) {
+        return usb_lst_get_data(item,usb_hub_info_t);
+}
 
 /**

uspace/drv/usbhub/utils.c

@@ -31 +31 @@
  */
 /** @file
- * @brief various utilities
+ * @brief Hub driver.
  */
 #include <driver.h>
@@ -90 +90 @@
 
         if (sdescriptor[1] != USB_DESCTYPE_HUB) {
-                dprintf(1,"[usb_hub] wrong descriptor %x\n",sdescriptor[1]);
+                printf("[usb_hub] wrong descriptor %x\n",sdescriptor[1]);
                 return NULL;
         }
@@ -102 +102 @@
         result->pwr_on_2_good_time = sdescriptor[5];
         result->current_requirement = sdescriptor[6];
-        size_t var_size = result->ports_count / 8 + ((result->ports_count % 8 > 0)
-                        ? 1 : 0);
+        size_t var_size = result->ports_count / 8 + ((result->ports_count % 8 > 0) ? 1 : 0);
         result->devices_removable = (uint8_t*) malloc(var_size);
         //printf("[usb_hub] getting removable devices data \n");
@@ -199 +198 @@
 }
 
-
-/*
- * method for testing port status bitmap
- 
+//list implementation
+
+usb_general_list_t * usb_lst_create(void) {
+        usb_general_list_t* result = usb_new(usb_general_list_t);
+        usb_lst_init(result);
+        return result;
+}
+
+void usb_lst_init(usb_general_list_t * lst) {
+        lst->prev = lst;
+        lst->next = lst;
+        lst->data = NULL;
+}
+
+void usb_lst_prepend(usb_general_list_t* item, void* data) {
+        usb_general_list_t* appended = usb_new(usb_general_list_t);
+        appended->data = data;
+        appended->next = item;
+        appended->prev = item->prev;
+        item->prev->next = appended;
+        item->prev = appended;
+}
+
+void usb_lst_append(usb_general_list_t* item, void* data) {
+        usb_general_list_t* appended = usb_new(usb_general_list_t);
+        appended->data = data;
+        appended->next = item->next;
+        appended->prev = item;
+        item->next->prev = appended;
+        item->next = appended;
+}
+
+void usb_lst_remove(usb_general_list_t* item) {
+        item->next->prev = item->prev;
+        item->prev->next = item->next;
+}
+
 static void usb_hub_test_port_status(void) {
         printf("[usb_hub] -------------port status test---------\n");
@@ -254 +286 @@
         //printf("this should be 0: %d \n",usb_port_get_bit(&status,4));
 
-}
-*/
-
+
+
+
+}
+
+//*********************************************
+//
+//  hub driver code, initialization
+//
+//*********************************************
+
+usb_hub_info_t * usb_create_hub_info(device_t * device, int hc) {
+        usb_hub_info_t* result = usb_new(usb_hub_info_t);
+        //result->device = device;
+        result->port_count = -1;
+        /// \TODO is this correct? is the device stored?
+        result->device = device;
+
+
+        //printf("[usb_hub] phone to hc = %d\n", hc);
+        if (hc < 0) {
+                return result;
+        }
+        //get some hub info
+        usb_address_t addr = usb_drv_get_my_address(hc, device);
+        printf("[usb_hub] addres of newly created hub = %d\n", addr);
+        /*if(addr<0){
+                //return result;
+                
+        }*/
+
+        result->usb_device = usb_new(usb_hcd_attached_device_info_t);
+        result->usb_device->address = addr;
+
+        // get hub descriptor
+        usb_target_t target;
+        target.address = addr;
+        target.endpoint = 0;
+        usb_device_request_setup_packet_t request;
+        //printf("[usb_hub] creating descriptor request\n");
+        usb_hub_set_descriptor_request(&request);
+
+        //printf("[usb_hub] creating serialized descriptor\n");
+        void * serialized_descriptor = malloc(USB_HUB_MAX_DESCRIPTOR_SIZE);
+        usb_hub_descriptor_t * descriptor;
+        size_t received_size;
+        int opResult;
+        //printf("[usb_hub] starting control transaction\n");
+        opResult = usb_drv_sync_control_read(
+                        hc, target, &request, serialized_descriptor,
+                        USB_HUB_MAX_DESCRIPTOR_SIZE, &received_size);
+        if (opResult != EOK) {
+                printf("[usb_hub] failed when receiving hub descriptor, badcode = %d\n",opResult);
+                ///\TODO memory leak will occur here!
+                return result;
+        }
+        //printf("[usb_hub] deserializing descriptor\n");
+        descriptor = usb_deserialize_hub_desriptor(serialized_descriptor);
+        if(descriptor==NULL){
+                printf("[usb_hub] could not deserialize descriptor \n");
+                result->port_count = 1;///\TODO this code is only for debug!!!
+                return result;
+        }
+        //printf("[usb_hub] setting port count to %d\n",descriptor->ports_count);
+        result->port_count = descriptor->ports_count;
+        result->attached_devs = (usb_hub_attached_device_t*)
+            malloc((result->port_count+1) * sizeof(usb_hub_attached_device_t));
+        int i;
+        for(i=0;i<result->port_count+1;++i){
+                result->attached_devs[i].devman_handle=0;
+                result->attached_devs[i].address=0;
+        }
+        //printf("[usb_hub] freeing data\n");
+        free(serialized_descriptor);
+        free(descriptor->devices_removable);
+        free(descriptor);
+
+        //finish
+
+        printf("[usb_hub] hub info created\n");
+
+        return result;
+}
+
+int usb_add_hub_device(device_t *dev) {
+        printf(NAME ": add_hub_device(handle=%d)\n", (int) dev->handle);
+        printf("[usb_hub] hub device\n");
+
+        /*
+         * We are some (probably deeply nested) hub.
+         * Thus, assign our own operations and explore already
+         * connected devices.
+         */
+
+        //create the hub structure
+        //get hc connection
+        /// \TODO correct params
+        int hc = usb_drv_hc_connect(dev, 0);
+
+        usb_hub_info_t * hub_info = usb_create_hub_info(dev, hc);
+        int port;
+        int opResult;
+        usb_device_request_setup_packet_t request;
+        usb_target_t target;
+        target.address = hub_info->usb_device->address;
+        target.endpoint = 0;
+
+        //get configuration descriptor
+        // this is not fully correct - there are more configurations
+        // and all should be checked
+        usb_standard_device_descriptor_t std_descriptor;
+        opResult = usb_drv_req_get_device_descriptor(hc, target.address,
+    &std_descriptor);
+        if(opResult!=EOK){
+                printf("[usb_hub] could not get device descriptor, %d\n",opResult);
+                return 1;///\TODO some proper error code needed
+        }
+        printf("[usb_hub] hub has %d configurations\n",std_descriptor.configuration_count);
+        if(std_descriptor.configuration_count<1){
+                printf("[usb_hub] THERE ARE NO CONFIGURATIONS AVAILABLE\n");
+        }
+        usb_standard_configuration_descriptor_t config_descriptor;
+        opResult = usb_drv_req_get_bare_configuration_descriptor(hc,
+        target.address, 0,
+        &config_descriptor);
+        if(opResult!=EOK){
+                printf("[usb_hub] could not get configuration descriptor, %d\n",opResult);
+                return 1;///\TODO some proper error code needed
+        }
+        //set configuration
+        request.request_type = 0;
+        request.request = USB_DEVREQ_SET_CONFIGURATION;
+        request.index=0;
+        request.length=0;
+        request.value_high=0;
+        request.value_low = config_descriptor.configuration_number;
+        opResult = usb_drv_sync_control_write(hc, target, &request, NULL, 0);
+        if (opResult != EOK) {
+                printf("[usb_hub]something went wrong when setting hub`s configuration, %d\n", opResult);
+        }
+
+
+        for (port = 1; port < hub_info->port_count+1; ++port) {
+                usb_hub_set_power_port_request(&request, port);
+                opResult = usb_drv_sync_control_write(hc, target, &request, NULL, 0);
+                printf("[usb_hub] powering port %d\n",port);
+                if (opResult != EOK) {
+                        printf("[usb_hub]something went wrong when setting hub`s %dth port\n", port);
+                }
+        }
+        //ports powered, hub seems to be enabled
+        
+
+        ipc_hangup(hc);
+
+        //add the hub to list
+        usb_lst_append(&usb_hub_list, hub_info);
+        printf("[usb_hub] hub info added to list\n");
+        //(void)hub_info;
+        usb_hub_check_hub_changes();
+
+        /// \TODO start the check loop, if not already started...
+
+        //this is just a test for port status bitmap type
+        usb_hub_test_port_status();
+
+        printf("[usb_hub] hub dev added\n");
+        printf("\taddress %d, has %d ports \n",
+                        hub_info->usb_device->address,
+                        hub_info->port_count);
+        printf("\tused configuration %d\n",config_descriptor.configuration_number);
+
+        return EOK;
+        //return ENOTSUP;
+}
+
+//*********************************************
+//
+//  hub driver code, main loop
+//
+//*********************************************
+
+/**
+ * reset the port with new device and reserve the default address
+ * @param hc
+ * @param port
+ * @param target
+ */
+static void usb_hub_init_add_device(int hc, uint16_t port, usb_target_t target) {
+        usb_device_request_setup_packet_t request;
+        int opResult;
+        printf("[usb_hub] some connection changed\n");
+        //get default address
+        opResult = usb_drv_reserve_default_address(hc);
+        if (opResult != EOK) {
+                printf("[usb_hub] cannot assign default address, it is probably used\n");
+                return;
+        }
+        //reset port
+        usb_hub_set_reset_port_request(&request, port);
+        opResult = usb_drv_sync_control_write(
+                        hc, target,
+                        &request,
+                        NULL, 0
+                        );
+        if (opResult != EOK) {
+                //continue;
+                printf("[usb_hub] something went wrong when reseting a port\n");
+        }
+}
+
+/**
+ * finalize adding new device after port reset
+ * @param hc
+ * @param port
+ * @param target
+ */
+static void usb_hub_finalize_add_device( usb_hub_info_t * hub,
+                int hc, uint16_t port, usb_target_t target) {
+
+        int opResult;
+        printf("[usb_hub] finalizing add device\n");
+        opResult = usb_hub_clear_port_feature(hc, target.address,
+            port, USB_HUB_FEATURE_C_PORT_RESET);
+        if (opResult != EOK) {
+                goto release;
+        }
+
+        /* Request address at from host controller. */
+        usb_address_t new_device_address = usb_drv_request_address(hc);
+        if (new_device_address < 0) {
+                printf("[usb_hub] failed to get free USB address\n");
+                opResult = new_device_address;
+                goto release;
+        }
+        printf("[usb_hub] setting new address\n");
+        opResult = usb_drv_req_set_address(hc, USB_ADDRESS_DEFAULT,
+            new_device_address);
+
+        if (opResult != EOK) {
+                printf("[usb_hub] could not set address for new device\n");
+                goto release;
+        }
+
+release:
+        printf("[usb_hub] releasing default address\n");
+        usb_drv_release_default_address(hc);
+        if (opResult != EOK) {
+                return;
+        }
+
+        devman_handle_t child_handle;
+        opResult = usb_drv_register_child_in_devman(hc, hub->device,
+            new_device_address, &child_handle);
+        if (opResult != EOK) {
+                printf("[usb_hub] could not start driver for new device \n");
+                return;
+        }
+        hub->attached_devs[port].devman_handle = child_handle;
+        hub->attached_devs[port].address = new_device_address;
+
+        opResult = usb_drv_bind_address(hc, new_device_address, child_handle);
+        if (opResult != EOK) {
+                printf("[usb_hub] could not assign address of device in hcd \n");
+                return;
+        }
+        printf("[usb_hub] new device address %d, handle %zu\n",
+            new_device_address, child_handle);
+        
+}
+
+/**
+ * unregister device address in hc, close the port
+ * @param hc
+ * @param port
+ * @param target
+ */
+static void usb_hub_removed_device(
+    usb_hub_info_t * hub, int hc, uint16_t port, usb_target_t target) {
+        //usb_device_request_setup_packet_t request;
+        int opResult;
+        //disable port
+        /*usb_hub_set_disable_port_request(&request, port);
+        opResult = usb_drv_sync_control_write(
+                        hc, target,
+                        &request,
+                        NULL, 0
+                        );
+        if (opResult != EOK) {
+                //continue;
+                printf("[usb_hub] something went wrong when disabling a port\n");
+        }*/
+        /// \TODO remove device
+
+        hub->attached_devs[port].devman_handle=0;
+        //close address
+        if(hub->attached_devs[port].address!=0){
+                opResult = usb_drv_release_address(hc,hub->attached_devs[port].address);
+                if(opResult != EOK) {
+                        printf("[usb_hub] could not release address of removed device: %d\n",opResult);
+                }
+                hub->attached_devs[port].address = 0;
+        }else{
+                printf("[usb_hub] this is strange, disconnected device had no address\n");
+                //device was disconnected before it`s port was reset - return default address
+                usb_drv_release_default_address(hc);
+        }
+}
+
+/**
+ * process interrupts on given hub port
+ * @param hc
+ * @param port
+ * @param target
+ */
+static void usb_hub_process_interrupt(usb_hub_info_t * hub, int hc,
+        uint16_t port, usb_address_t address) {
+        printf("[usb_hub] interrupt at port %d\n", port);
+        //determine type of change
+        usb_target_t target;
+        target.address=address;
+        target.endpoint=0;
+        usb_port_status_t status;
+        size_t rcvd_size;
+        usb_device_request_setup_packet_t request;
+        int opResult;
+        usb_hub_set_port_status_request(&request, port);
+        //endpoint 0
+
+        opResult = usb_drv_sync_control_read(
+                        hc, target,
+                        &request,
+                        &status, 4, &rcvd_size
+                        );
+        if (opResult != EOK) {
+                printf("[usb_hub] ERROR: could not get port status\n");
+                return;
+        }
+        if (rcvd_size != sizeof (usb_port_status_t)) {
+                printf("[usb_hub] ERROR: received status has incorrect size\n");
+                return;
+        }
+        //something connected/disconnected
+        if (usb_port_connect_change(&status)) {
+                opResult = usb_hub_clear_port_feature(hc, target.address,
+                    port, USB_HUB_FEATURE_C_PORT_CONNECTION);
+                // TODO: check opResult
+                if (usb_port_dev_connected(&status)) {
+                        printf("[usb_hub] some connection changed\n");
+                        usb_hub_init_add_device(hc, port, target);
+                } else {
+                        usb_hub_removed_device(hub, hc, port, target);
+                }
+        }
+        //port reset
+        if (usb_port_reset_completed(&status)) {
+                printf("[usb_hub] port reset complete\n");
+                if (usb_port_enabled(&status)) {
+                        usb_hub_finalize_add_device(hub, hc, port, target);
+                } else {
+                        printf("[usb_hub] ERROR: port reset, but port still not enabled\n");
+                }
+        }
+
+        usb_port_set_connect_change(&status, false);
+        usb_port_set_reset(&status, false);
+        usb_port_set_reset_completed(&status, false);
+        usb_port_set_dev_connected(&status, false);
+        if (status) {
+                printf("[usb_hub]there was some unsupported change on port %d\n",port);
+        }
+        /// \TODO handle other changes
+        /// \TODO debug log for various situations
+
+
+
+        /*
+        //configure device
+        usb_drv_reserve_default_address(hc);
+
+        usb_address_t new_device_address = usb_drv_request_address(hc);
+
+
+        usb_drv_release_default_address(hc);
+         * */
+}
+
+/** Check changes on all known hubs.
+ */
+void usb_hub_check_hub_changes(void) {
+        /*
+         * Iterate through all hubs.
+         */
+        usb_general_list_t * lst_item;
+        for (lst_item = usb_hub_list.next;
+                        lst_item != &usb_hub_list;
+                        lst_item = lst_item->next) {
+                usb_hub_info_t * hub_info = ((usb_hub_info_t*)lst_item->data);
+                /*
+                 * Check status change pipe of this hub.
+                 */
+
+                usb_target_t target;
+                target.address = hub_info->usb_device->address;
+                target.endpoint = 1;/// \TODO get from endpoint descriptor
+                printf("[usb_hub] checking changes for hub at addr %d\n",
+                    target.address);
+
+                size_t port_count = hub_info->port_count;
+
+                /*
+                 * Connect to respective HC.
+                 */
+                int hc = usb_drv_hc_connect(hub_info->device, 0);
+                if (hc < 0) {
+                        continue;
+                }
+
+                // FIXME: count properly
+                size_t byte_length = ((port_count+1) / 8) + 1;
+
+                void *change_bitmap = malloc(byte_length);
+                size_t actual_size;
+                usb_handle_t handle;
+
+                /*
+                 * Send the request.
+                 */
+                int opResult = usb_drv_async_interrupt_in(hc, target,
+                                change_bitmap, byte_length, &actual_size,
+                                &handle);
+
+                usb_drv_async_wait_for(handle);
+
+                if (opResult != EOK) {
+                        printf("[usb_hub] something went wrong while getting status of hub\n");
+                        continue;
+                }
+                unsigned int port;
+                for (port = 1; port < port_count+1; ++port) {
+                        bool interrupt = (((uint8_t*) change_bitmap)[port / 8] >> (port % 8)) % 2;
+                        if (interrupt) {
+                                usb_hub_process_interrupt(
+                                        hub_info, hc, port, hub_info->usb_device->address);
+                        }
+                }
+
+
+                /*
+                 * TODO: handle the changes.
+                 */
+
+                /*
+                 * WARNING: sample code, will not work out of the box.
+                 * And does not contain code for checking for errors.
+                 */
+#if 0
+                /*
+                 * Before opening the port, we must acquire the default
+                 * address.
+                 */
+                usb_drv_reserve_default_address(hc);
+
+                usb_address_t new_device_address = usb_drv_request_address(hc);
+
+                // TODO: open the port
+
+                // TODO: send request for setting address to new_device_address
+
+                /*
+                 * Once new address is set, we can release the default
+                 * address.
+                 */
+                usb_drv_release_default_address(hc);
+
+                /*
+                 * Obtain descriptors and create match ids for devman.
+                 */
+
+                // TODO: get device descriptors
+
+                // TODO: create match ids
+
+                // TODO: add child device
+
+                // child_device_register sets the device handle
+                // TODO: store it here
+                devman_handle_t new_device_handle = 0;
+
+                /*
+                 * Inform the HC that the new device has devman handle
+                 * assigned.
+                 */
+                usb_drv_bind_address(hc, new_device_address, new_device_handle);
+
+                /*
+                 * That's all.
+                 */
+#endif
+
+
+                /*
+                 * Hang-up the HC-connected phone.
+                 */
+                ipc_hangup(hc);
+        }
+}
 
 /**

uspace/lib/c/generic/devmap.c

@@ -127 +127 @@
 /** Register new device.
  *
- * The @p interface is used when forwarding connection to the driver.
- * If not 0, the first argument is the interface and the second argument
- * is the devmap handle of the device.
- * When the interface is zero (default), the first argument is directly
- * the handle (to ensure backward compatibility).
- *
- * @param fqdn Fully qualified device name.
- * @param[out] handle Handle to the created instance of device.
- * @param interface Interface when forwarding.
- *
- */
-int devmap_device_register_with_iface(const char *fqdn,
-    devmap_handle_t *handle, sysarg_t interface)
-{
-        int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
-        
-        if (phone < 0)
-                return phone;
-        
-        async_serialize_start();
-        
-        ipc_call_t answer;
-        aid_t req = async_send_2(phone, DEVMAP_DEVICE_REGISTER, interface, 0,
-            &answer);
-        
-        sysarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
-        if (retval != EOK) {
-                async_wait_for(req, NULL);
-                async_serialize_end();
-                return retval;
-        }
-        
-        async_wait_for(req, &retval);
-        
-        async_serialize_end();
-        
-        if (retval != EOK) {
-                if (handle != NULL)
-                        *handle = -1;
-                return retval;
-        }
-        
-        if (handle != NULL)
-                *handle = (devmap_handle_t) IPC_GET_ARG1(answer);
-        
-        return retval;
-}
-
-/** Register new device.
- *
+ * @param namespace Namespace name.
  * @param fqdn      Fully qualified device name.
  * @param handle    Output: Handle to the created instance of device.
@@ -183 +134 @@
 int devmap_device_register(const char *fqdn, devmap_handle_t *handle)
 {
-        return devmap_device_register_with_iface(fqdn, handle, 0);
-}
-
+        int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
+        
+        if (phone < 0)
+                return phone;
+        
+        async_serialize_start();
+        
+        ipc_call_t answer;
+        aid_t req = async_send_2(phone, DEVMAP_DEVICE_REGISTER, 0, 0,
+            &answer);
+        
+        sysarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
+                async_serialize_end();
+                return retval;
+        }
+        
+        async_wait_for(req, &retval);
+        
+        async_serialize_end();
+        
+        if (retval != EOK) {
+                if (handle != NULL)
+                        *handle = -1;
+                return retval;
+        }
+        
+        if (handle != NULL)
+                *handle = (devmap_handle_t) IPC_GET_ARG1(answer);
+        
+        return retval;
+}
 
 int devmap_device_get_handle(const char *fqdn, devmap_handle_t *handle, unsigned int flags)

uspace/lib/c/generic/net/modules.c

@@ -198 +198 @@
 }
 
+/** Receives data from the other party.
+ *
+ * The received data buffer is allocated and returned.
+ *
+ * @param[out] data     The data buffer to be filled.
+ * @param[out] length   The buffer length.
+ * @return              EOK on success.
+ * @return              EBADMEM if the data or the length parameter is NULL.
+ * @return              EINVAL if the client does not send data.
+ * @return              ENOMEM if there is not enough memory left.
+ * @return              Other error codes as defined for the
+ *                      async_data_write_finalize() function.
+ */
+int data_receive(void **data, size_t *length)
+{
+        ipc_callid_t callid;
+        int rc;
+
+        if (!data || !length)
+                return EBADMEM;
+
+        // fetch the request
+        if (!async_data_write_receive(&callid, length))
+                return EINVAL;
+
+        // allocate the buffer
+        *data = malloc(*length);
+        if (!*data)
+                return ENOMEM;
+
+        // fetch the data
+        rc = async_data_write_finalize(callid, *data, *length);
+        if (rc != EOK) {
+                free(data);
+                return rc;
+        }
+
+        return EOK;
+}
+
 /** Replies the data to the other party.
  *

uspace/lib/c/include/devmap.h

@@ -45 +45 @@
 extern int devmap_driver_register(const char *, async_client_conn_t);
 extern int devmap_device_register(const char *, devmap_handle_t *);
-extern int devmap_device_register_with_iface(const char *, devmap_handle_t *, sysarg_t);
 
 extern int devmap_device_get_handle(const char *, devmap_handle_t *, unsigned int);

uspace/lib/c/include/ipc/devman.h

@@ -123 +123 @@
         DEVMAN_CLIENT,
         DEVMAN_CONNECT_TO_DEVICE,
-        DEVMAN_CONNECT_FROM_DEVMAP,
         DEVMAN_CONNECT_TO_PARENTS_DEVICE
 } devman_interface_t;

uspace/lib/c/include/net/modules.h

@@ -49 +49 @@
 #include <sys/time.h>
 
+/** Converts the data length between different types.
+ *
+ * @param[in] type_from The source type.
+ * @param[in] type_to   The destination type.
+ * @param[in] count     The number units of the source type size.
+ */
+#define CONVERT_SIZE(type_from, type_to, count) \
+        ((sizeof(type_from) / sizeof(type_to)) * (count))
+
+/** Registers the module service at the name server.
+ *
+ * @param[in] me        The module service.
+ * @param[out] phonehash The created phone hash.
+ */
+#define REGISTER_ME(me, phonehash) \
+        ipc_connect_to_me(PHONE_NS, (me), 0, 0, (phonehash))
+
 /** Connect to the needed module function type definition.
  *
@@ -63 +80 @@
 extern int connect_to_service(services_t);
 extern int connect_to_service_timeout(services_t, suseconds_t);
+extern int data_receive(void **, size_t *);
 extern int data_reply(void *, size_t);
 extern void refresh_answer(ipc_call_t *, int *);

uspace/lib/usb/include/usb/hcdhubd.h

@@ -207 +207 @@
 int usb_hc_add_child_device(device_t *, const char *, const char *, bool);
 
-
-/**
- * @}
- */
-
 #endif

uspace/srv/devman/devman.c

@@ -62 +62 @@
 }
 
-static int devmap_devices_class_compare(unsigned long key[], hash_count_t keys,
-    link_t *item)
-{
-        dev_class_info_t *class_info
-            = hash_table_get_instance(item, dev_class_info_t, devmap_link);
-        assert(class_info != NULL);
-
-        return (class_info->devmap_handle == (devmap_handle_t) key[0]);
-}
-
 static void devices_remove_callback(link_t *item)
 {
@@ -85 +75 @@
         .hash = devices_hash,
         .compare = devmap_devices_compare,
-        .remove_callback = devices_remove_callback
-};
-
-static hash_table_operations_t devmap_devices_class_ops = {
-        .hash = devices_hash,
-        .compare = devmap_devices_class_compare,
         .remove_callback = devices_remove_callback
 };
@@ -694 +678 @@
         }
         
-        devmap_device_register_with_iface(devmap_pathname,
-            &node->devmap_handle, DEVMAN_CONNECT_FROM_DEVMAP);
+        devmap_device_register(devmap_pathname, &node->devmap_handle);
         
         tree_add_devmap_device(tree, node);
@@ -1067 +1050 @@
         
         info = (dev_class_info_t *) malloc(sizeof(dev_class_info_t));
-        if (info != NULL) {
+        if (info != NULL)
                 memset(info, 0, sizeof(dev_class_info_t));
-                list_initialize(&info->dev_classes);
-                list_initialize(&info->devmap_link);
-                list_initialize(&info->link);
-        }
         
         return info;
@@ -1196 +1175 @@
         fibril_rwlock_initialize(&class_list->rwlock);
         hash_table_create(&class_list->devmap_devices, DEVICE_BUCKETS, 1,
-            &devmap_devices_class_ops);
+            &devmap_devices_ops);
 }
 
@@ -1244 +1223 @@
         hash_table_insert(&class_list->devmap_devices, &key, &cli->devmap_link);
         fibril_rwlock_write_unlock(&class_list->rwlock);
-
-        assert(find_devmap_class_device(class_list, cli->devmap_handle) != NULL);
 }
 

uspace/srv/devman/main.c

@@ -281 +281 @@
          * handle.
          */
-        devmap_device_register_with_iface(devmap_pathname,
-            &cli->devmap_handle, DEVMAN_CONNECT_FROM_DEVMAP);
+        devmap_device_register(devmap_pathname, &cli->devmap_handle);
         
         /*
@@ -487 +486 @@
 static void devman_connection_devmapper(ipc_callid_t iid, ipc_call_t *icall)
 {
-        devmap_handle_t devmap_handle = IPC_GET_ARG2(*icall);
+        devmap_handle_t devmap_handle = IPC_GET_IMETHOD(*icall);
         node_t *dev;
 
@@ -504 +503 @@
         }
         
+        printf(NAME ": devman_connection_devmapper: forward connection to "
+            "device %s to driver %s.\n", dev->pathname, dev->drv->name);
         ipc_forward_fast(iid, dev->drv->phone, DRIVER_CLIENT, dev->handle, 0,
             IPC_FF_NONE);
-        printf(NAME ": devman_connection_devmapper: forwarded connection to "
-            "device %s to driver %s.\n", dev->pathname, dev->drv->name);
 }
 
@@ -513 +512 @@
 static void devman_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
+        /*
+         * Silly hack to enable the device manager to register as a driver by
+         * the device mapper. If the ipc method is not IPC_M_CONNECT_ME_TO, this
+         * is not the forwarded connection from naming service, so it must be a
+         * connection from the devmapper which thinks this is a devmapper-style
+         * driver. So pretend this is a devmapper-style driver. (This does not
+         * work for device with handle == IPC_M_CONNECT_ME_TO, because devmapper
+         * passes device handle to the driver as an ipc method.)
+         */
+        if (IPC_GET_IMETHOD(*icall) != IPC_M_CONNECT_ME_TO)
+                devman_connection_devmapper(iid, icall);
+
+        /*
+         * ipc method is IPC_M_CONNECT_ME_TO, so this is forwarded connection
+         * from naming service by which we registered as device manager, so be
+         * device manager.
+         */
+        
         /* Select interface. */
         switch ((sysarg_t) (IPC_GET_ARG1(*icall))) {
@@ -525 +542 @@
                 devman_forward(iid, icall, false);
                 break;
-        case DEVMAN_CONNECT_FROM_DEVMAP:
-                /* Someone connected through devmap node. */
-                devman_connection_devmapper(iid, icall);
-                break;
         case DEVMAN_CONNECT_TO_PARENTS_DEVICE:
                 /* Connect client to selected device. */

uspace/srv/devmap/devmap.c

@@ -99 +99 @@
         /** Device driver handling this device */
         devmap_driver_t *driver;
-        /** Use this interface when forwarding to driver. */
-        sysarg_t forward_interface;
 } devmap_device_t;
 
@@ -519 +517 @@
         }
         
-        /* Set the interface, if any. */
-        device->forward_interface = IPC_GET_ARG1(*icall);
-
         /* Get fqdn */
         char *fqdn;
@@ -571 +566 @@
         /* Get unique device handle */
         device->handle = devmap_create_handle();
-
+        
         devmap_namespace_addref(namespace, device);
         device->driver = driver;
@@ -622 +617 @@
         }
         
-        if (dev->forward_interface == 0) {
-                ipc_forward_fast(callid, dev->driver->phone,
-                    dev->handle, 0, 0,
-                    IPC_FF_NONE);
-        } else {
-                ipc_forward_fast(callid, dev->driver->phone,
-                    dev->forward_interface, dev->handle, 0,
-                    IPC_FF_NONE);
-        }
+        ipc_forward_fast(callid, dev->driver->phone, dev->handle,
+            IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
         
         fibril_mutex_unlock(&devices_list_mutex);

uspace/srv/hw/netif/dp8390/dp8390_module.c

@@ -197 +197 @@
                 return rc;
         address->value = (char *) (&((dpeth_t *) device->specific)->de_address);
-        address->length = sizeof(ether_addr_t);
+        address->length = CONVERT_SIZE(ether_addr_t, char, 1);
         return EOK;
 }
@@ -310 +310 @@
         async_set_interrupt_received(irq_handler);
 
-        return ipc_connect_to_me(PHONE_NS, SERVICE_DP8390, 0, 0, &phonehash);
+        return REGISTER_ME(SERVICE_DP8390, &phonehash);
 }
 

uspace/srv/net/il/arp/arp.c

@@ -483 +483 @@
         des_proto = des_hw + header->hardware_length;
         trans = arp_addr_find(&proto->addresses, (char *) src_proto,
-            header->protocol_length);
+            CONVERT_SIZE(uint8_t, char, header->protocol_length));
         /* Exists? */
         if (trans && trans->hw_addr) {
-                if (trans->hw_addr->length != header->hardware_length)
+                if (trans->hw_addr->length != CONVERT_SIZE(uint8_t, char,
+                    header->hardware_length)) {
                         return EINVAL;
+                }
                 memcpy(trans->hw_addr->value, src_hw, trans->hw_addr->length);
         }
         /* Is my protocol address? */
-        if (proto->addr->length != header->protocol_length)
+        if (proto->addr->length != CONVERT_SIZE(uint8_t, char,
+            header->protocol_length)) {
                 return EINVAL;
+        }
         if (!str_lcmp(proto->addr->value, (char *) des_proto,
             proto->addr->length)) {
@@ -503 +507 @@
                         fibril_condvar_initialize(&trans->cv);
                         rc = arp_addr_add(&proto->addresses, (char *) src_proto,
-                            header->protocol_length, trans);
+                            CONVERT_SIZE(uint8_t, char, header->protocol_length),
+                            trans);
                         if (rc != EOK) {
                                 /* The generic char map has already freed trans! */
@@ -511 +516 @@
                 if (!trans->hw_addr) {
                         trans->hw_addr = measured_string_create_bulk(
-                            (char *) src_hw, header->hardware_length);
+                            (char *) src_hw, CONVERT_SIZE(uint8_t, char,
+                            header->hardware_length));
                         if (!trans->hw_addr)
                                 return ENOMEM;
@@ -600 +606 @@
 
         /* ARP packet content size = header + (address + translation) * 2 */
-        length = 8 + 2 * (proto->addr->length + device->addr->length);
+        length = 8 + 2 * (CONVERT_SIZE(char, uint8_t, proto->addr->length) +
+            CONVERT_SIZE(char, uint8_t, device->addr->length));
         if (length > device->packet_dimension.content)
                 return ELIMIT;
@@ -633 +640 @@
 
         rc = packet_set_addr(packet, (uint8_t *) device->addr->value,
-            (uint8_t *) device->broadcast_addr->value, device->addr->length);
+            (uint8_t *) device->broadcast_addr->value,
+            CONVERT_SIZE(char, uint8_t, device->addr->length));
         if (rc != EOK) {
                 pq_release_remote(arp_globals.net_phone, packet_get_id(packet));

uspace/srv/net/il/arp/arp_module.c

@@ -79 +79 @@
                 goto out;
         
-        rc = ipc_connect_to_me(PHONE_NS, SERVICE_ARP, 0, 0, &phonehash);
+        rc = REGISTER_ME(SERVICE_ARP, &phonehash);
         if (rc != EOK)
                 goto out;

uspace/srv/net/il/ip/ip.c

@@ -442 +442 @@
                 if (route) {
                         address.value = (char *) &route->address.s_addr;
-                        address.length = sizeof(in_addr_t);
+                        address.length = CONVERT_SIZE(in_addr_t, char, 1);
                         
                         rc = arp_device_req(ip_netif->arp->phone,
@@ -639 +639 @@
         if (destination) {
                 rc = packet_set_addr(packet, NULL, (uint8_t *) destination->value,
-                    destination->length);
+                    CONVERT_SIZE(char, uint8_t, destination->length));
         } else {
                 rc = packet_set_addr(packet, NULL, NULL, 0);
@@ -687 +687 @@
                                 rc = packet_set_addr(next, NULL,
                                     (uint8_t *) destination->value,
-                                    destination->length);
+                                    CONVERT_SIZE(char, uint8_t,
+                                    destination->length));
                                 if (rc != EOK) {
                                         free(last_header);
@@ -717 +718 @@
                         rc = packet_set_addr(next, NULL,
                             (uint8_t *) destination->value,
-                            destination->length);
+                            CONVERT_SIZE(char, uint8_t, destination->length));
                         if (rc != EOK) {
                                 free(last_header);
@@ -1005 +1006 @@
                 destination.value = route->gateway.s_addr ?
                     (char *) &route->gateway.s_addr : (char *) &dest.s_addr;
-                destination.length = sizeof(dest.s_addr);
+                destination.length = CONVERT_SIZE(dest.s_addr, char, 1);
 
                 rc = arp_translate_req(netif->arp->phone, netif->device_id,
@@ -1757 +1758 @@
                         // clear the ARP mapping if any
                         address.value = (char *) &header->destination_address;
-                        address.length = sizeof(header->destination_address);
+                        address.length = CONVERT_SIZE(uint8_t, char,
+                            sizeof(header->destination_address));
                         arp_clear_address_req(netif->arp->phone,
                             netif->device_id, SERVICE_IP, &address);
@@ -1949 +1951 @@
 
         case NET_IP_GET_ROUTE:
-                rc = async_data_write_accept((void **) &addr, false, 0, 0, 0,
-                    &addrlen);
+                rc = data_receive((void **) &addr, &addrlen);
                 if (rc != EOK)
                         return rc;

uspace/srv/net/il/ip/ip_module.c

@@ -80 +80 @@
                 goto out;
         
-        rc = ipc_connect_to_me(PHONE_NS, SERVICE_IP, 0, 0, &phonehash);
+        rc = REGISTER_ME(SERVICE_IP, &phonehash);
         if (rc != EOK)
                 goto out;

uspace/srv/net/net/net.c

@@ -335 +335 @@
                 goto out;
         
-        rc = ipc_connect_to_me(PHONE_NS, SERVICE_NETWORKING, 0, 0, &phonehash);
+        rc = REGISTER_ME(SERVICE_NETWORKING, &phonehash);
         if (rc != EOK)
                 goto out;

uspace/srv/net/netif/lo/lo.c

@@ -166 +166 @@
         sysarg_t phonehash;
 
-        return ipc_connect_to_me(PHONE_NS, SERVICE_LO, 0, 0, &phonehash);
+        return REGISTER_ME(SERVICE_LO, &phonehash);
 }
 

uspace/srv/net/nil/eth/eth.c

@@ -201 +201 @@
 
         eth_globals.broadcast_addr =
-            measured_string_create_bulk("\xFF\xFF\xFF\xFF\xFF\xFF", ETH_ADDR);
+            measured_string_create_bulk("\xFF\xFF\xFF\xFF\xFF\xFF",
+            CONVERT_SIZE(uint8_t, char, ETH_ADDR));
         if (!eth_globals.broadcast_addr) {
                 rc = ENOMEM;

uspace/srv/net/nil/eth/eth_module.c

@@ -66 +66 @@
                 goto out;
 
-        rc = ipc_connect_to_me(PHONE_NS, SERVICE_ETHERNET, 0, 0, &phonehash);
+        rc = REGISTER_ME(SERVICE_ETHERNET, &phonehash);
         if (rc != EOK)
                 goto out;

uspace/srv/net/nil/nildummy/nildummy_module.c

@@ -67 +67 @@
                 goto out;
         
-        rc = ipc_connect_to_me(PHONE_NS, SERVICE_NILDUMMY, 0, 0, &phonehash);
+        rc = REGISTER_ME(SERVICE_NILDUMMY, &phonehash);
         if (rc != EOK)
                 goto out;

uspace/srv/net/tl/icmp/icmp_module.c

@@ -74 +74 @@
                 goto out;
 
-        rc = ipc_connect_to_me(PHONE_NS, SERVICE_ICMP, 0, 0, &phonehash);
+        rc = REGISTER_ME(SERVICE_ICMP, &phonehash);
         if (rc != EOK)
                 goto out;

uspace/srv/net/tl/tcp/tcp.c

@@ -1365 +1365 @@
 
                 case NET_SOCKET_BIND:
-                        res = async_data_write_accept((void **) &addr, false,
-                            0, 0, 0, &addrlen);
+                        res = data_receive((void **) &addr, &addrlen);
                         if (res != EOK)
                                 break;
@@ -1403 +1402 @@
 
                 case NET_SOCKET_CONNECT:
-                        res = async_data_write_accept((void **) &addr, false,
-                            0, 0, 0, &addrlen);
+                        res = data_receive((void **) &addr, &addrlen);
                         if (res != EOK)
                                 break;
@@ -1455 +1453 @@
 
                 case NET_SOCKET_SENDTO:
-                        res = async_data_write_accept((void **) &addr, false,
-                            0, 0, 0, &addrlen);
+                        res = data_receive((void **) &addr, &addrlen);
                         if (res != EOK)
                                 break;

uspace/srv/net/tl/tcp/tcp_module.c

@@ -75 +75 @@
                 goto out;
 
-        rc = ipc_connect_to_me(PHONE_NS, SERVICE_TCP, 0, 0, &phonehash);
+        rc = REGISTER_ME(SERVICE_TCP, &phonehash);
         if (rc != EOK)
                 goto out;

uspace/srv/net/tl/udp/udp.c

@@ -771 +771 @@
 
                 case NET_SOCKET_BIND:
-                        res = async_data_write_accept((void **) &addr, false,
-                            0, 0, 0, &addrlen);
+                        res = data_receive((void **) &addr, &addrlen);
                         if (res != EOK)
                                 break;
@@ -785 +784 @@
 
                 case NET_SOCKET_SENDTO:
-                        res = async_data_write_accept((void **) &addr, false,
-                            0, 0, 0, &addrlen);
+                        res = data_receive((void **) &addr, &addrlen);
                         if (res != EOK)
                                 break;

uspace/srv/net/tl/udp/udp_module.c

@@ -75 +75 @@
                 goto out;
         
-        rc = ipc_connect_to_me(PHONE_NS, SERVICE_UDP, 0, 0, &phonehash);
+        rc = REGISTER_ME(SERVICE_UDP, &phonehash);
         if (rc != EOK)
                 goto out;