Changeset 79e1abd in mainline

Timestamp:

2011-03-29T12:09:15Z (13 years ago)

Author:

Matej Klonfar <maklf@…>

Branches:

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

Children:

d012590

Parents:

841e6e5 (diff), 51e5608 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

development merge - mainline changes

Files:

• HelenOS.config (modified) (2 diffs)
• kernel/arch/arm32/src/mach/integratorcp/integratorcp.c (modified) (1 diff)
• kernel/arch/mips32/include/cp0.h (modified) (2 diffs)
• kernel/arch/sparc64/src/smp/sun4v/smp.c (modified) (2 diffs)
• kernel/arch/sparc64/src/sun4v/start.S (modified) (1 diff)
• kernel/arch/sparc64/src/trap/sun4v/interrupt.c (modified) (1 diff)
• kernel/genarch/Makefile.inc (modified) (1 diff)
• kernel/genarch/src/kbrd/kbrd_pl050.c (deleted)
• kernel/genarch/src/kbrd/scanc_pl050.c (deleted)
• kernel/generic/src/console/console.c (modified) (1 diff)
• kernel/generic/src/mm/as.c (modified) (1 diff)
• uspace/app/bdsh/cmds/modules/cat/cat.c (modified) (10 diffs)
• uspace/app/bdsh/cmds/modules/cat/cat.h (modified) (1 diff)
• uspace/app/bdsh/cmds/modules/cp/cp.c (modified) (2 diffs)
• uspace/app/bdsh/cmds/modules/rm/rm.c (modified) (2 diffs)
• uspace/app/init/init.c (modified) (1 diff)
• uspace/app/klog/klog.c (modified) (3 diffs)
• uspace/drv/ohci/Makefile (modified) (1 diff)
• uspace/drv/ohci/hc.c (modified) (4 diffs)
• uspace/drv/ohci/hc.h (modified) (1 diff)
• uspace/drv/ohci/iface.h (modified) (1 diff)
• uspace/drv/ohci/main.c (modified) (3 diffs)
• uspace/drv/ohci/ohci.c (added)
• uspace/drv/ohci/ohci.h (added)
• uspace/drv/ohci/root_hub.c (modified) (2 diffs)
• uspace/drv/ohci/root_hub.h (modified) (1 diff)
• uspace/drv/pciintel/pci.c (modified) (1 diff)
• uspace/drv/uhci-hcd/Makefile (modified) (1 diff)
• uspace/drv/uhci-hcd/hc.c (modified) (3 diffs)
• uspace/drv/uhci-hcd/root_hub.c (modified) (1 diff)
• uspace/drv/uhci-hcd/transfer_list.c (modified) (6 diffs)
• uspace/drv/uhci-hcd/transfer_list.h (modified) (1 diff)
• uspace/drv/uhci-hcd/uhci.c (modified) (2 diffs)
• uspace/drv/uhci-hcd/utils/malloc32.h (modified) (5 diffs)
• uspace/drv/uhci-hcd/utils/slab.c (added)
• uspace/drv/uhci-hcd/utils/slab.h (added)
• uspace/drv/usbhub/port_status.h (modified) (4 diffs)
• uspace/drv/usbhub/usbhub.c (modified) (16 diffs)
• uspace/drv/usbmid/explore.c (modified) (7 diffs)
• uspace/drv/usbmid/main.c (modified) (4 diffs)
• uspace/drv/usbmid/usbmid.c (modified) (3 diffs)
• uspace/drv/usbmid/usbmid.h (modified) (2 diffs)
• uspace/lib/c/generic/malloc.c (modified) (1 diff)
• uspace/lib/c/include/ipc/services.h (modified) (1 diff)
• uspace/lib/fs/libfs.c (modified) (2 diffs)
• uspace/lib/usb/include/usb/host/device_keeper.h (modified) (3 diffs)
• uspace/lib/usb/src/host/device_keeper.c (modified) (4 diffs)
• uspace/srv/hid/kbd/Makefile (modified) (1 diff)
• uspace/srv/hid/kbd/ctl/pl050.c (deleted)
• uspace/srv/hid/kbd/generic/kbd.c (modified) (2 diffs)
• uspace/srv/hid/kbd/include/kbd.h (modified) (1 diff)
• uspace/srv/hid/kbd/port/ns16550.c (modified) (1 diff)
• uspace/srv/hid/kbd/port/z8530.c (modified) (1 diff)
• uspace/srv/hw/irc/apic/apic.c (modified) (4 diffs)
• uspace/srv/hw/irc/fhc/fhc.c (modified) (1 diff)
• uspace/srv/hw/irc/i8259/i8259.c (modified) (1 diff)
• uspace/srv/hw/irc/obio/obio.c (modified) (1 diff)
• uspace/srv/hw/netif/ne2000/ne2000.c (modified) (2 diffs)
• uspace/srv/net/net/net.c (modified) (2 diffs)
• uspace/srv/vfs/vfs_ops.c (modified) (6 diffs)
• version (modified) (2 diffs)

HelenOS.config

@@ -417 +417 @@
 ! [(CONFIG_HID_IN=generic|CONFIG_HID_IN=keyboard)&PLATFORM=ia64&MACHINE=i460GX] CONFIG_PC_KBD (y/n)
 
+% PC keyboard support
+! [(CONFIG_HID_IN=generic|CONFIG_HID_IN=keyboard)&PLATFORM=arm32&MACHINE=integratorcp] CONFIG_PC_KBD (y/n)
+
 % Support for msim/GXemul keyboard
 ! [CONFIG_HID_IN=generic&PLATFORM=mips32] CONFIG_MIPS_KBD (y/n)
@@ -554 +557 @@
 % Polling UHCI & OHCI (no interrupts)
 ! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_USBHC_NO_INTERRUPTS (y/n)
+
+% Run devman in kconsole (not recommended)
+! CONFIG_DEVMAN_EARLY_LAUNCH (n/y)
+

kernel/arch/arm32/src/mach/integratorcp/integratorcp.c

@@ -292 +292 @@
                 .y = 480,
                 .scan = 2560,
-                .visual = VISUAL_BGR_0_8_8_8,
+                .visual = VISUAL_RGB_8_8_8_0,
         };
         

kernel/arch/mips32/include/cp0.h

@@ -70 +70 @@
   { \
       uint32_t retval; \
-      asm("mfc0 %0, $" #reg : "=r"(retval)); \
+      asm volatile ("mfc0 %0, $" #reg : "=r"(retval)); \
       return retval; \
   }
@@ -76 +76 @@
 #define GEN_WRITE_CP0(nm,reg) static inline void cp0_ ##nm##_write(uint32_t val) \
  { \
-    asm("mtc0 %0, $" #reg : : "r"(val) ); \
+    asm volatile ("mtc0 %0, $" #reg : : "r"(val) ); \
  }
 

kernel/arch/sparc64/src/smp/sun4v/smp.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2006 Jakub Jermar
- * Copyright (c) 2009 Pavel Rimsky 
+ * Copyright (c) 2009 Pavel Rimsky
  * All rights reserved.
  *
@@ -439 +439 @@
         if (waitq_sleep_timeout(&ap_completion_wq, 10000000, SYNCH_FLAGS_NONE) ==
             ESYNCH_TIMEOUT)
-                printf("%s: waiting for processor (cpuid = %" PRIu32 ") timed out\n",
+                printf("%s: waiting for processor (cpuid = %" PRIu64 ") timed out\n",
                     __func__, cpuid);
         

kernel/arch/sparc64/src/sun4v/start.S

@@ -296 +296 @@
          * Create the first stack frame.
          */
-        save %sp, -(STACK_WINDWO_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE), %sp
+        save %sp, -(STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE), %sp
         flushw
         add %g0, -STACK_BIAS, %fp

kernel/arch/sparc64/src/trap/sun4v/interrupt.c

@@ -111 +111 @@
                         ((void (*)(void)) data1)();
                 } else {
-                        printf("Spurious interrupt on %d, data = %" PRIx64 ".\n",
+                        printf("Spurious interrupt on %" PRIu64 ", data = %" PRIx64 ".\n",
                             CPU->arch.id, data1);
                 }

kernel/genarch/Makefile.inc

@@ -122 +122 @@
 endif
 
-ifeq ($(CONFIG_PL050),y)
-        GENARCH_SOURCES += \
-                genarch/src/kbrd/kbrd_pl050.c \
-                genarch/src/kbrd/scanc_pl050.c
-endif
-
 ifeq ($(CONFIG_MAC_KBD),y)
         GENARCH_SOURCES += \

kernel/generic/src/console/console.c

@@ -53 +53 @@
 #include <str.h>
 
+/*
+ * devman produces a lot of output and by giving so many pages
+ * we to allow /app/klog to catch-up.
+ */
+#ifdef CONFIG_DEVMAN_EARLY_LAUNCH
+#define KLOG_PAGES    64
+#else
 #define KLOG_PAGES    4
+#endif
+
 #define KLOG_LENGTH   (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t))
 #define KLOG_LATENCY  8

kernel/generic/src/mm/as.c

@@ -1949 +1949 @@
 sysarg_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)
 {
-        if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address,
+        if (as_area_create(AS, flags, size, address,
             AS_AREA_ATTR_NONE, &anon_backend, NULL))
                 return (sysarg_t) address;

uspace/app/bdsh/cmds/modules/cat/cat.c

@@ -1 +1 @@
 /* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * Copyright (c) 2011, Martin Sucha
  * All rights reserved.
  *
@@ -35 +36 @@
 #include <str.h>
 #include <fcntl.h>
+#include <io/console.h>
+#include <io/color.h>
+#include <io/style.h>
+#include <io/keycode.h>
+#include <errno.h>
+#include <vfs/vfs.h>
+#include <assert.h>
 
 #include "config.h"
@@ -48 +56 @@
 
 static const char *cat_oops = "That option is not yet supported\n";
+static const char *hexchars = "0123456789abcdef";
+
+static bool paging_enabled = false;
+static size_t chars_remaining = 0;
+static size_t lines_remaining = 0;
+static sysarg_t console_cols = 0;
+static sysarg_t console_rows = 0;
+static bool should_quit = false;
 
 static struct option const long_options[] = {
@@ -56 +72 @@
         { "buffer", required_argument, 0, 'b' },
         { "more", no_argument, 0, 'm' },
+        { "hex", no_argument, 0, 'x' },
         { 0, 0, 0, 0 }
 };
@@ -75 +92 @@
                 "  -b, --buffer ##  Set the read buffer size to ##\n"
                 "  -m, --more       Pause after each screen full\n"
+                "  -x, --hex        Print bytes as hex values\n"
                 "Currently, %s is under development, some options don't work.\n",
                 cmdname, cmdname);
@@ -82 +100 @@
 }
 
-static unsigned int cat_file(const char *fname, size_t blen)
+static void waitprompt()
+{
+        console_set_pos(fphone(stdout), 0, console_rows-1);
+        console_set_color(fphone(stdout), COLOR_BLUE, COLOR_WHITE, 0);
+        printf("ENTER/SPACE/PAGE DOWN - next page, "
+               "ESC/Q - quit, C - continue unpaged");
+        fflush(stdout);
+        console_set_style(fphone(stdout), STYLE_NORMAL);
+}
+
+static void waitkey()
+{
+        console_event_t ev;
+        
+        while (true) {
+                if (!console_get_event(fphone(stdin), &ev)) {
+                        return;
+                }
+                if (ev.type == KEY_PRESS) {
+                        if (ev.key == KC_ESCAPE || ev.key == KC_Q) {
+                                should_quit = true;
+                                return;
+                        }
+                        if (ev.key == KC_C) {
+                                paging_enabled = false;
+                                return;
+                        }
+                        if (ev.key == KC_ENTER || ev.key == KC_SPACE ||
+                            ev.key == KC_PAGE_DOWN) {
+                                return;
+                        }
+                }
+        }
+        assert(false);
+}
+
+static void newpage()
+{
+        console_clear(fphone(stdout));
+        chars_remaining = console_cols;
+        lines_remaining = console_rows-1;
+}
+
+static void paged_char(wchar_t c)
+{
+        putchar(c);
+        if (paging_enabled) {
+                chars_remaining--;
+                if (c == '\n' || chars_remaining == 0) {
+                        chars_remaining = console_cols;
+                        lines_remaining--;
+                }
+                if (lines_remaining == 0) {
+                        fflush(stdout);
+                        waitprompt();
+                        waitkey();
+                        newpage();
+                }
+        }
+}
+
+static unsigned int cat_file(const char *fname, size_t blen, bool hex)
 {
         int fd, bytes = 0, count = 0, reads = 0;
         off64_t total = 0;
         char *buff = NULL;
+        int i;
+        size_t offset = 0;
 
         fd = open(fname, O_RDONLY);
@@ -109 +190 @@
                         count += bytes;
                         buff[bytes] = '\0';
-                        printf("%s", buff);
+                        offset = 0;
+                        for (i = 0; i < bytes && !should_quit; i++) {
+                                if (hex) {
+                                        paged_char(hexchars[((uint8_t)buff[i])/16]);
+                                        paged_char(hexchars[((uint8_t)buff[i])%16]);
+                                }
+                                else {
+                                        wchar_t c = str_decode(buff, &offset, bytes);
+                                        if (c == 0) {
+                                                // reached end of string
+                                                break;
+                                        }
+                                        paged_char(c);
+                                }
+                                
+                        }
                         reads++;
                 }
-        } while (bytes > 0);
+        } while (bytes > 0 && !should_quit);
 
         close(fd);
@@ -131 +227 @@
         unsigned int argc, i, ret = 0, buffer = 0;
         int c, opt_ind;
+        bool hex = false;
+        bool more = false;
+        sysarg_t rows, cols;
+        int rc;
+        
+        // reset global state
+        // TODO: move to structure?
+        paging_enabled = false;
+        chars_remaining = 0;
+        lines_remaining = 0;
+        console_cols = 0;
+        console_rows = 0;
+        should_quit = false;
 
         argc = cli_count_args(argv);
 
         for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
-                c = getopt_long(argc, argv, "hvmH:t:b:", long_options, &opt_ind);
+                c = getopt_long(argc, argv, "xhvmH:t:b:", long_options, &opt_ind);
                 switch (c) {
                 case 'h':
@@ -153 +262 @@
                         break;
                 case 'm':
-                        printf("%s", cat_oops);
-                        return CMD_FAILURE;
+                        more = true;
+                        break;
+                case 'x':
+                        hex = true;
+                        break;
                 }
         }
@@ -168 +280 @@
         if (buffer <= 0)
                 buffer = CAT_DEFAULT_BUFLEN;
-
-        for (i = optind; argv[i] != NULL; i++)
-                ret += cat_file(argv[i], buffer);
+        
+        if (more) {
+                rc = console_get_size(fphone(stdout), &cols, &rows);
+                if (rc != EOK) {
+                        printf("%s - cannot get console size\n", cmdname);
+                        return CMD_FAILURE;
+                }
+                console_cols = cols;
+                console_rows = rows;
+                paging_enabled = true;
+                newpage();
+        }
+
+        for (i = optind; argv[i] != NULL && !should_quit; i++)
+                ret += cat_file(argv[i], buffer, hex);
 
         if (ret)

uspace/app/bdsh/cmds/modules/cat/cat.h

@@ -4 +4 @@
 /* Prototypes for the cat command, excluding entry points */
 
-static unsigned int cat_file(const char *, size_t);
+static unsigned int cat_file(const char *, size_t, bool);
 
 #endif /* CAT_H */

uspace/app/bdsh/cmds/modules/cp/cp.c

@@ -108 +108 @@
         for (;;) {
                 ssize_t res;
+                size_t written = 0;
 
                 bytes = read(fd1, buff, blen);
@@ -120 +121 @@
                          * returned less data than requested.
                          */
-                        bytes = write(fd2, buff, res);
+                        bytes = write(fd2, buff + written, res);
                         if (bytes < 0)
                                 goto err;
+                        written += bytes;
                         res -= bytes;
                 } while (res > 0);

uspace/app/bdsh/cmds/modules/rm/rm.c

@@ -101 +101 @@
 }
 
+static unsigned int rm_recursive_not_empty_dirs(const char *path)
+{
+        DIR *dirp;
+        struct dirent *dp;
+        char buff[PATH_MAX];
+        unsigned int scope;
+        unsigned int ret = 0;
+
+        dirp = opendir(path);
+        if (!dirp) {
+                /* May have been deleted between scoping it and opening it */
+                cli_error(CL_EFAIL, "Could not open %s", path);
+                return ret;
+        }
+
+        memset(buff, 0, sizeof(buff));
+        while ((dp = readdir(dirp))) {
+                snprintf(buff, PATH_MAX - 1, "%s/%s", path, dp->d_name);
+                scope = rm_scope(buff);
+                switch (scope) {
+                case RM_BOGUS:
+                        break;
+                case RM_FILE:
+                        ret += rm_single(buff);
+                        break;
+                case RM_DIR:
+                        ret += rm_recursive(buff);
+                        break;
+                }
+        }
+        
+        return ret;
+}
+
 static unsigned int rm_recursive(const char *path)
 {
         int rc;
+        unsigned int ret = 0;
 
         /* First see if it will just go away */
@@ -111 +146 @@
 
         /* Its not empty, recursively scan it */
-        cli_error(CL_ENOTSUP,
-                "Can not remove %s, directory not empty", path);
-        return 1;
+        ret = rm_recursive_not_empty_dirs(path);
+
+        /* Delete directory */
+        rc = rmdir(path);
+        if (rc == 0)
+                return ret;
+
+        cli_error(CL_ENOTSUP, "Can not remove %s", path);
+
+        return ret + 1;
 }
 

uspace/app/init/init.c

@@ -313 +313 @@
         getterm("term/vc5", "/app/bdsh", false);
         getterm("term/vc6", "/app/klog", false);
+
+#ifdef CONFIG_DEVMAN_EARLY_LAUNCH
+        spawn("/srv/devman");
+#else
         getterm("term/vc7", "/srv/devman", false);
-        
+#endif
+
         return 0;
 }

uspace/app/klog/klog.c

@@ -44 +44 @@
 #include <io/klog.h>
 #include <sysinfo.h>
+#include <fibril_synch.h>
 
 #define NAME       "klog"
@@ -54 +55 @@
 static FILE *log;
 
+/* Serialize the output a bit. This will not avoid messed-up log completely
+   but chances for are pretty high (experimentally confirmed). */
+static FIBRIL_MUTEX_INITIALIZE(log_mutex);
+
 static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
 {
+        fibril_mutex_lock(&log_mutex);
+        
         size_t klog_start = (size_t) IPC_GET_ARG1(*call);
         size_t klog_len = (size_t) IPC_GET_ARG2(*call);
@@ -74 +81 @@
                 fsync(fileno(log));
         }
+        
+        fibril_mutex_unlock(&log_mutex);
 }
 

uspace/drv/ohci/Makefile

@@ -37 +37 @@
         main.c \
         hc.c \
+        ohci.c \
         root_hub.c \
         pci.c

uspace/drv/ohci/hc.c

@@ -39 +39 @@
 #include <usb/debug.h>
 #include <usb/usb.h>
-#include <usb/hub.h>
 #include <usb/ddfiface.h>
 #include <usb/usbdevice.h>
@@ -45 +44 @@
 #include "hc.h"
 
-static int dummy_reset(int foo, void *arg);
 static int interrupt_emulator(hc_t *instance);
+/*----------------------------------------------------------------------------*/
+int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun)
+{
+        assert(instance);
+        assert(hub_fun);
+
+        usb_address_t hub_address =
+            device_keeper_get_free_address(&instance->manager, USB_SPEED_FULL);
+        instance->rh.address = hub_address;
+        usb_device_keeper_bind(
+            &instance->manager, hub_address, hub_fun->handle);
+
+        char *match_str = NULL;
+        int ret = asprintf(&match_str, "usb&mid");
+        ret = (match_str == NULL) ? ret : EOK;
+        if (ret < 0) {
+                usb_log_error("Failed to create root hub match-id string.\n");
+                return ret;
+        }
+
+        ret = ddf_fun_add_match_id(hub_fun, match_str, 100);
+        if (ret != EOK) {
+                usb_log_error("Failed add create root hub match-id.\n");
+        }
+        return ret;
+}
 /*----------------------------------------------------------------------------*/
 int hc_init(hc_t *instance, ddf_fun_t *fun, ddf_dev_t *dev,
@@ -68 +92 @@
         }
 
+        rh_init(&instance->rh, dev, instance->registers);
 
-        rh_init(&instance->rh, dev, instance->registers);
         /* TODO: implement */
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-int hc_register_hub(hc_t *instance)
-{
-        async_usleep(1000000);
-#define CHECK_RET_RETURN(ret, msg...) \
-        if (ret != EOK) { \
-                usb_log_error(msg); \
-                return ret; \
-        } else (void)0
-        assert(instance);
-        assert(instance->ddf_instance);
-        assert(instance->ddf_instance->handle);
-        ddf_dev_t *dev = instance->rh.device;
-        int ret = EOK;
-
-        usb_hc_connection_t conn;
-        ret =
-            usb_hc_connection_initialize(&conn, instance->ddf_instance->handle);
-        CHECK_RET_RETURN(ret, "Failed to initialize hc connection.\n");
-
-        ret = usb_hc_connection_open(&conn);
-        CHECK_RET_RETURN(ret, "Failed to open hc connection.\n");
-
-        usb_address_t address;
-        devman_handle_t handle;
-        ret = usb_hc_new_device_wrapper(dev, &conn, USB_SPEED_FULL, dummy_reset,
-            0, instance, &address, &handle, NULL, NULL, NULL);
-        if (ret != EOK) {
-                usb_log_error("Failed to add rh device.\n");
-                instance->rh.address = -1;
-                return ret;
-        }
-
-        ret = usb_hc_connection_close(&conn);
-        CHECK_RET_RETURN(ret, "Failed to close hc connection.\n");
         return EOK;
 }
@@ -134 +121 @@
 }
 /*----------------------------------------------------------------------------*/
-static int dummy_reset(int foo, void *arg)
-{
-        hc_t *hc = (hc_t*)arg;
-        assert(hc);
-        hc->rh.address = 0;
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static int interrupt_emulator(hc_t *instance)
+int interrupt_emulator(hc_t *instance)
 {
         assert(instance);

uspace/drv/ohci/hc.h

@@ -57 +57 @@
 } hc_t;
 
+int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun);
+
 int hc_init(hc_t *instance, ddf_fun_t *fun, ddf_dev_t *dev,
      uintptr_t regs, size_t reg_size, bool interrupts);
-
-int hc_register_hub(hc_t *instance);
 
 int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch);

uspace/drv/ohci/iface.h

@@ -33 +33 @@
  * Common OHCI definitions.
  */
-#ifndef DRV_OHCI_OHCI_H
-#define DRV_OHCI_OHCI_H
+#ifndef DRV_OHCI_IFACE_H
+#define DRV_OHCI_IFACE_H
 
 #include <usbhc_iface.h>
-
-#define NAME "ohci"
 
 extern usbhc_iface_t hc_iface;

uspace/drv/ohci/main.c

@@ -34 +34 @@
  */
 #include <ddf/driver.h>
-#include <ddf/interrupt.h>
-#include <device/hw_res.h>
 #include <errno.h>
 #include <str_error.h>
 
-#include <usb_iface.h>
-#include <usb/ddfiface.h>
 #include <usb/debug.h>
 
-#include "pci.h"
-#include "iface.h"
-#include "hc.h"
+#include "ohci.h"
+
+#define NAME "ohci"
 
 static int ohci_add_device(ddf_dev_t *device);
-static int get_hc_handle(ddf_fun_t *fun, devman_handle_t *handle)
-{
-        assert(handle);
-  assert(fun != NULL);
-
-  *handle = fun->handle;
-  return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static int get_address(
-    ddf_fun_t *fun, devman_handle_t handle, usb_address_t *address)
-{
-        assert(fun);
-        usb_device_keeper_t *manager = &fun_to_hc(fun)->manager;
-  usb_address_t addr = usb_device_keeper_find(manager, handle);
-  if (addr < 0) {
-    return addr;
-  }
-
-  if (address != NULL) {
-    *address = addr;
-  }
-
-  return EOK;
-}
-/*----------------------------------------------------------------------------*/
-/** IRQ handling callback, identifies device
- *
- * @param[in] dev DDF instance of the device to use.
- * @param[in] iid (Unused).
- * @param[in] call Pointer to the call that represents interrupt.
- */
-static void irq_handler(ddf_dev_t *dev, ipc_callid_t iid, ipc_call_t *call)
-{
-        assert(dev);
-        hc_t *hc = (hc_t*)dev->driver_data;
-        assert(hc);
-        hc_interrupt(hc, 0);
-}
 /*----------------------------------------------------------------------------*/
 static driver_ops_t ohci_driver_ops = {
@@ -97 +54 @@
 };
 /*----------------------------------------------------------------------------*/
-static usb_iface_t hc_usb_iface = {
-        .get_address = get_address,
-        .get_hc_handle = get_hc_handle,
-};
-/*----------------------------------------------------------------------------*/
-static ddf_dev_ops_t hc_ops = {
-        .interfaces[USB_DEV_IFACE] = &hc_usb_iface,
-        .interfaces[USBHC_DEV_IFACE] = &hc_iface,
-};
-/*----------------------------------------------------------------------------*/
 /** Initializes a new ddf driver instance of OHCI hcd.
  *
@@ -112 +59 @@
  * @return Error code.
  */
-static int ohci_add_device(ddf_dev_t *device)
+int ohci_add_device(ddf_dev_t *device)
 {
+        usb_log_debug("ohci_add_device() called\n");
         assert(device);
-#define CHECK_RET_RETURN(ret, message...) \
-if (ret != EOK) { \
-        usb_log_error(message); \
-        return ret; \
-}
-
-        uintptr_t mem_reg_base = 0;
-        size_t mem_reg_size = 0;
-        int irq = 0;
-
-        int ret =
-            pci_get_my_registers(device, &mem_reg_base, &mem_reg_size, &irq);
-        CHECK_RET_RETURN(ret,
-            "Failed(%d) to get memory addresses:.\n", ret, device->handle);
-        usb_log_info("Memory mapped regs at 0x%X (size %zu), IRQ %d.\n",
-            mem_reg_base, mem_reg_size, irq);
-
-        ret = pci_disable_legacy(device);
-        CHECK_RET_RETURN(ret,
-            "Failed(%d) disable legacy USB: %s.\n", ret, str_error(ret));
-
-        hc_t *hcd = malloc(sizeof(hc_t));
-        if (hcd == NULL) {
+        ohci_t *ohci = malloc(sizeof(ohci_t));
+        if (ohci == NULL) {
                 usb_log_error("Failed to allocate OHCI driver.\n");
                 return ENOMEM;
         }
 
-        ddf_fun_t *hc_fun = ddf_fun_create(device, fun_exposed, "ohci-hc");
-        if (hc_fun == NULL) {
-                usb_log_error("Failed to create OHCI function.\n");
-                free(hcd);
-                return ENOMEM;
-        }
-
-
-        bool interrupts = false;
-#ifdef CONFIG_USBHC_NO_INTERRUPTS
-        usb_log_warning("Interrupts disabled in OS config, " \
-            "falling back to polling.\n");
-#else
-        ret = pci_enable_interrupts(device);
+        int ret = ohci_init(ohci, device);
         if (ret != EOK) {
-                usb_log_warning("Failed to enable interrupts: %s.\n",
+                usb_log_error("Failed to initialize OHCI driver: %s.\n",
                     str_error(ret));
-                usb_log_info("HW interrupts not available, " \
-                    "falling back to polling.\n");
-        } else {
-                usb_log_debug("Hw interrupts enabled.\n");
-                interrupts = true;
-        }
-#endif
-
-        ret = hc_init(hcd, hc_fun, device, mem_reg_base, mem_reg_size, interrupts);
-        if (ret != EOK) {
-                usb_log_error("Failed to initialize OHCI driver.\n");
-                free(hcd);
                 return ret;
         }
+        device->driver_data = ohci;
 
-        ret = register_interrupt_handler(device, irq, irq_handler, NULL);
-
-        hc_fun->ops = &hc_ops;
-        ret = ddf_fun_bind(hc_fun);
-        if (ret != EOK) {
-                usb_log_error("Failed to bind OHCI function.\n");
-                ddf_fun_destroy(hc_fun);
-                free(hcd);
-                return ret;
-        }
-        hc_fun->driver_data = hcd;
-
-        fid_t later = fibril_create((int(*)(void*))hc_register_hub, hcd);
-        fibril_add_ready(later);
-
-        usb_log_info("Controlling new OHCI device `%s' (handle %llu).\n",
-            device->name, device->handle);
+        usb_log_info("Controlling new OHCI device `%s'.\n", device->name);
 
         return EOK;
-#undef CHECK_RET_RETURN
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/ohci/root_hub.c

@@ -39 +39 @@
 
 #include "root_hub.h"
+#include "usb/classes/classes.h"
+#include <usb/request.h>
+#include <usb/classes/hub.h>
+
+/**
+ *      standart device descriptor for ohci root hub
+ */
+static const usb_standard_device_descriptor_t ohci_rh_device_descriptor =
+{
+                .configuration_count = 1,
+                .descriptor_type = USB_DESCTYPE_DEVICE,
+                .device_class = USB_CLASS_HUB,
+                .device_protocol = 0,
+                .device_subclass = 0,
+                .device_version = 0,
+                .length = sizeof(usb_standard_device_descriptor_t),
+                /// \TODO this value is guessed
+                .max_packet_size = 8,
+                .vendor_id = 0x16db,
+                .product_id = 0x0001,
+                /// \TODO these values migt be different
+                .str_serial_number = 0,
+                .usb_spec_version = 0,
+};
+
+/**
+ * standart configuration descriptor with filled common values
+ * for ohci root hubs
+ */
+static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor =
+{
+        /// \TODO some values are default or guessed
+        .attributes = 1<<7,
+        .configuration_number = 1,
+        .descriptor_type = USB_DESCTYPE_CONFIGURATION,
+        .interface_count = 1,
+        .length = sizeof(usb_standard_configuration_descriptor_t),
+        .max_power = 100,
+        .str_configuration = 0,
+};
+
+/**
+ * standart ohci root hub interface descriptor
+ */
+static const usb_standard_interface_descriptor_t ohci_rh_iface_descriptor =
+{
+        .alternate_setting = 0,
+        .descriptor_type = USB_DESCTYPE_INTERFACE,
+        .endpoint_count = 1,
+        .interface_class = USB_CLASS_HUB,
+        /// \TODO is this correct?
+        .interface_number = 1,
+        .interface_protocol = 0,
+        .interface_subclass = 0,
+        .length = sizeof(usb_standard_interface_descriptor_t),
+        .str_interface = 0,
+};
+
+/**
+ * standart ohci root hub endpoint descriptor
+ */
+static const usb_standard_endpoint_descriptor_t ohci_rh_ep_descriptor =
+{
+        .attributes = USB_TRANSFER_INTERRUPT,
+        .descriptor_type = USB_DESCTYPE_ENDPOINT,
+        .endpoint_address = 1 + (1<<7),
+        .length = sizeof(usb_standard_endpoint_descriptor_t),
+        .max_packet_size = 8,
+        .poll_interval = 255,
+};
 
 /** Root hub initialization
@@ -50 +120 @@
         instance->device = dev;
 
+
         usb_log_info("OHCI root hub with %d ports.\n", regs->rh_desc_a & 0xff);
 
+        //start generic usb hub driver
+        
         /* TODO: implement */
         return EOK;
 }
 /*----------------------------------------------------------------------------*/
+
+/**
+ * create answer to port status_request
+ *
+ * Copy content of corresponding port status register to answer buffer.
+ *
+ * @param instance root hub instance
+ * @param port port number, counted from 1
+ * @param request structure containing both request and response information
+ * @return error code
+ */
+static int process_get_port_status_request(rh_t *instance, uint16_t port,
+                usb_transfer_batch_t * request){
+        if(port<1 || port>instance->port_count)
+                return EINVAL;
+        uint32_t * uint32_buffer = (uint32_t*)request->buffer;
+        request->transfered_size = 4;
+        uint32_buffer[0] = instance->registers->rh_port_status[port -1];
+        return EOK;
+}
+
+/**
+ * create answer to port status_request
+ *
+ * Copy content of hub status register to answer buffer.
+ *
+ * @param instance root hub instance
+ * @param request structure containing both request and response information
+ * @return error code
+ */
+static int process_get_hub_status_request(rh_t *instance,
+                usb_transfer_batch_t * request){
+        uint32_t * uint32_buffer = (uint32_t*)request->buffer;
+        //bits, 0,1,16,17
+        request->transfered_size = 4;
+        uint32_t mask = 1 & (1<<1) & (1<<16) & (1<<17);
+        uint32_buffer[0] = mask & instance->registers->rh_status;
+        return EOK;
+
+}
+
+/**
+ * Create hub descriptor used in hub-driver <-> hub communication
+ * 
+ * This means creating byt array from data in root hub registers. For more
+ * info see usb hub specification.
+ *
+ * @param instance root hub instance
+ * @param@out out_result pointer to resultant serialized descriptor
+ * @param@out out_size size of serialized descriptor
+ */
+static void usb_create_serialized_hub_descriptor(rh_t *instance,
+                uint8_t ** out_result,
+                size_t * out_size) {
+        //base size
+        size_t size = 7;
+        //variable size according to port count
+        size_t var_size = instance->port_count / 8 +
+                        ((instance->port_count % 8 > 0) ? 1 : 0);
+        size += 2 * var_size;
+        uint8_t * result = (uint8_t*) malloc(size);
+        bzero(result,size);
+        //size
+        result[0] = size;
+        //descriptor type
+        result[1] = USB_DESCTYPE_HUB;
+        result[2] = instance->port_count;
+        uint32_t hub_desc_reg = instance->registers->rh_desc_a;
+        result[3] = 
+                        ((hub_desc_reg >> 8) %2) +
+                        (((hub_desc_reg >> 9) %2) << 1) +
+                        (((hub_desc_reg >> 10) %2) << 2) +
+                        (((hub_desc_reg >> 11) %2) << 3) +
+                        (((hub_desc_reg >> 12) %2) << 4);
+        result[4] = 0;
+        result[5] = /*descriptor->pwr_on_2_good_time*/ 50;
+        result[6] = 50;
+
+        int port;
+        for (port = 1; port <= instance->port_count; ++port) {
+                result[7 + port/8] +=
+                                ((instance->registers->rh_desc_b >> port)%2) << (port%8);
+        }
+        size_t i;
+        for (i = 0; i < var_size; ++i) {
+                result[7 + var_size + i] = 255;
+        }
+        (*out_result) = result;
+        (*out_size) = size;
+}
+
+
+/**
+ * create answer to status request
+ *
+ * This might be either hub status or port status request. If neither,
+ * ENOTSUP is returned.
+ * @param instance root hub instance
+ * @param request structure containing both request and response information
+ * @return error code
+ */
+static int process_get_status_request(rh_t *instance,
+                usb_transfer_batch_t * request)
+{
+        size_t buffer_size = request->buffer_size;
+        usb_device_request_setup_packet_t * request_packet =
+                        (usb_device_request_setup_packet_t*)
+                        request->setup_buffer;
+
+        usb_hub_bm_request_type_t request_type = request_packet->request_type;
+        if(buffer_size<4/*request_packet->length*/){///\TODO
+                usb_log_warning("requested more data than buffer size\n");
+                return EINVAL;
+        }
+
+        if(request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS)
+                return process_get_hub_status_request(instance, request);
+        if(request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS)
+                return process_get_port_status_request(instance, request_packet->index,
+                                request);
+        return ENOTSUP;
+}
+
+/**
+ * create answer to status interrupt consisting of change bitmap
+ *
+ * Result contains bitmap where bit 0 indicates change on hub and
+ * bit i indicates change on i`th port (i>0). For more info see
+ * Hub and Port status bitmap specification in USB specification.
+ * @param instance root hub instance
+ * @param@out buffer pointer to created interrupt mas
+ * @param@out buffer_size size of created interrupt mask
+ */
+static void create_interrupt_mask(rh_t *instance, void ** buffer,
+                size_t * buffer_size){
+        int bit_count = instance->port_count + 1;
+        (*buffer_size) = (bit_count / 8) + (bit_count%8==0)?0:1;
+        (*buffer) = malloc(*buffer_size);
+        uint8_t * bitmap = (uint8_t*)(*buffer);
+        uint32_t mask = (1<<16) + (1<<17);
+        bzero(bitmap,(*buffer_size));
+        if(instance->registers->rh_status & mask){
+                bitmap[0] = 1;
+        }
+        int port;
+        mask = 0;
+        int i;
+        for(i=16;i<=20;++i)
+                mask += 1<<i;
+        for(port = 1; port<=instance->port_count;++port){
+                if(mask & instance->registers->rh_port_status[port-1]){
+                        bitmap[(port+1)/8] += 1<<(port%8);
+                }
+        }
+}
+
+/**
+ * create standart configuration descriptor for the root hub instance
+ * @param instance root hub instance
+ * @return newly allocated descriptor
+ */
+static usb_standard_configuration_descriptor_t *
+usb_ohci_rh_create_standart_configuration_descriptor(rh_t *instance){
+        usb_standard_configuration_descriptor_t * descriptor =
+                        malloc(sizeof(usb_standard_configuration_descriptor_t));
+        memcpy(descriptor, &ohci_rh_conf_descriptor,
+                sizeof(usb_standard_configuration_descriptor_t));
+        /// \TODO should this include device descriptor?
+        const size_t hub_descriptor_size = 7 +
+                        2* (instance->port_count / 8 +
+                        ((instance->port_count % 8 > 0) ? 1 : 0));
+        descriptor->total_length =
+                        sizeof(usb_standard_configuration_descriptor_t)+
+                        sizeof(usb_standard_endpoint_descriptor_t)+
+                        sizeof(usb_standard_interface_descriptor_t)+
+                        hub_descriptor_size;
+        return descriptor;
+}
+
+/**
+ * create answer to a descriptor request
+ *
+ * This might be a request for standard (configuration, device, endpoint or
+ * interface) or device specific (hub) descriptor.
+ * @param instance root hub instance
+ * @param request structure containing both request and response information
+ * @return error code
+ */
+static int process_get_descriptor_request(rh_t *instance,
+                usb_transfer_batch_t *request){
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        size_t size;
+        const void * result_descriptor = NULL;
+        const uint16_t setup_request_value = setup_request->value_high;
+                        //(setup_request->value_low << 8);
+        bool del = false;
+        switch (setup_request_value)
+        {
+                case USB_DESCTYPE_HUB: {
+                        uint8_t * descriptor;
+                        usb_create_serialized_hub_descriptor(
+                                instance, &descriptor, &size);
+                        result_descriptor = descriptor;
+                        if(result_descriptor) del = true;
+                        break;
+                }
+                case USB_DESCTYPE_DEVICE: {
+                        usb_log_debug("USB_DESCTYPE_DEVICE\n");
+                        result_descriptor = &ohci_rh_device_descriptor;
+                        size = sizeof(ohci_rh_device_descriptor);
+                        break;
+                }
+                case USB_DESCTYPE_CONFIGURATION: {
+                        usb_log_debug("USB_DESCTYPE_CONFIGURATION\n");
+                        usb_standard_configuration_descriptor_t * descriptor =
+                                        usb_ohci_rh_create_standart_configuration_descriptor(
+                                                instance);
+                        result_descriptor = descriptor;
+                        size = sizeof(usb_standard_configuration_descriptor_t);
+                        del = true;
+                        break;
+                }
+                case USB_DESCTYPE_INTERFACE: {
+                        usb_log_debug("USB_DESCTYPE_INTERFACE\n");
+                        result_descriptor = &ohci_rh_iface_descriptor;
+                        size = sizeof(ohci_rh_iface_descriptor);
+                        break;
+                }
+                case USB_DESCTYPE_ENDPOINT: {
+                        usb_log_debug("USB_DESCTYPE_ENDPOINT\n");
+                        result_descriptor = &ohci_rh_ep_descriptor;
+                        size = sizeof(ohci_rh_ep_descriptor);
+                        break;
+                }
+                default: {
+                        usb_log_debug("USB_DESCTYPE_EINVAL %d \n",setup_request->value);
+                        usb_log_debug("\ttype %d\n\trequest %d\n\tvalue %d\n\tindex %d\n\tlen %d\n ",
+                                        setup_request->request_type,
+                                        setup_request->request,
+                                        setup_request_value,
+                                        setup_request->index,
+                                        setup_request->length
+                                        );
+                        return EINVAL;
+                }
+        }
+        if(request->buffer_size < size){
+                size = request->buffer_size;
+        }
+        request->transfered_size = size;
+        memcpy(request->buffer,result_descriptor,size);
+        if (del)
+                free(result_descriptor);
+        return EOK;
+}
+
+/**
+ * answer to get configuration request
+ *
+ * Root hub works independently on the configuration.
+ * @param instance root hub instance
+ * @param request structure containing both request and response information
+ * @return error code
+ */
+static int process_get_configuration_request(rh_t *instance, 
+                usb_transfer_batch_t *request){
+        //set and get configuration requests do not have any meaning, only dummy
+        //values are returned
+        if(request->buffer_size != 1)
+                return EINVAL;
+        request->buffer[0] = 1;
+        request->transfered_size = 1;
+        return EOK;
+}
+
+/**
+ * process feature-enabling/disabling request on hub
+ * 
+ * @param instance root hub instance
+ * @param feature feature selector
+ * @param enable enable or disable specified feature
+ * @return error code
+ */
+static int process_hub_feature_set_request(rh_t *instance,
+                uint16_t feature, bool enable){
+        if(feature > USB_HUB_FEATURE_C_HUB_OVER_CURRENT)
+                return EINVAL;
+        instance->registers->rh_status =
+                        enable ?
+                        (instance->registers->rh_status | (1<<feature))
+                        :
+                        (instance->registers->rh_status & (~(1<<feature)));
+        /// \TODO any error?
+        return EOK;
+}
+
+/**
+ * process feature-enabling/disabling request on hub
+ * 
+ * @param instance root hub instance
+ * @param feature feature selector
+ * @param port port number, counted from 1
+ * @param enable enable or disable the specified feature
+ * @return error code
+ */
+static int process_port_feature_set_request(rh_t *instance,
+                uint16_t feature, uint16_t port, bool enable){
+        if(feature > USB_HUB_FEATURE_C_PORT_RESET)
+                return EINVAL;
+        if(port<1 || port>instance->port_count)
+                return EINVAL;
+        instance->registers->rh_port_status[port - 1] =
+                        enable ?
+                        (instance->registers->rh_port_status[port - 1] | (1<<feature))
+                        :
+                        (instance->registers->rh_port_status[port - 1] & (~(1<<feature)));
+        /// \TODO any error?
+        return EOK;
+}
+
+/**
+ * register address to this device
+ * 
+ * @param instance root hub instance
+ * @param address new address
+ * @return error code
+ */
+static int process_address_set_request(rh_t *instance,
+                uint16_t address){
+        instance->address = address;
+        return EOK;
+}
+
+/**
+ * process one of requests that requere output data
+ *
+ * Request can be one of USB_DEVREQ_GET_STATUS, USB_DEVREQ_GET_DESCRIPTOR or
+ * USB_DEVREQ_GET_CONFIGURATION.
+ * @param instance root hub instance
+ * @param request structure containing both request and response information
+ * @return error code
+ */
+static int process_request_with_output(rh_t *instance,
+                usb_transfer_batch_t *request){
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        if(setup_request->request == USB_DEVREQ_GET_STATUS){
+                usb_log_debug("USB_DEVREQ_GET_STATUS\n");
+                return process_get_status_request(instance, request);
+        }
+        if(setup_request->request == USB_DEVREQ_GET_DESCRIPTOR){
+                usb_log_debug("USB_DEVREQ_GET_DESCRIPTOR\n");
+                return process_get_descriptor_request(instance, request);
+        }
+        if(setup_request->request == USB_DEVREQ_GET_CONFIGURATION){
+                usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n");
+                return process_get_configuration_request(instance, request);
+        }
+        return ENOTSUP;
+}
+
+/**
+ * process one of requests that carry input data
+ *
+ * Request can be one of USB_DEVREQ_SET_DESCRIPTOR or
+ * USB_DEVREQ_SET_CONFIGURATION.
+ * @param instance root hub instance
+ * @param request structure containing both request and response information
+ * @return error code
+ */
+static int process_request_with_input(rh_t *instance,
+                usb_transfer_batch_t *request){
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        request->transfered_size = 0;
+        if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR){
+                return ENOTSUP;
+        }
+        if(setup_request->request == USB_DEVREQ_SET_CONFIGURATION){
+                //set and get configuration requests do not have any meaning,
+                //only dummy values are returned
+                return EOK;
+        }
+        return ENOTSUP;
+}
+
+/**
+ * process one of requests that do not request nor carry additional data
+ *
+ * Request can be one of USB_DEVREQ_CLEAR_FEATURE, USB_DEVREQ_SET_FEATURE or
+ * USB_DEVREQ_SET_ADDRESS.
+ * @param instance root hub instance
+ * @param request structure containing both request and response information
+ * @return error code
+ */
+static int process_request_without_data(rh_t *instance,
+                usb_transfer_batch_t *request){
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        request->transfered_size = 0;
+        if(setup_request->request == USB_DEVREQ_CLEAR_FEATURE
+                                || setup_request->request == USB_DEVREQ_SET_FEATURE){
+                if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE){
+                        usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
+                        return process_hub_feature_set_request(instance, setup_request->value,
+                                        setup_request->request == USB_DEVREQ_SET_FEATURE);
+                }
+                if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){
+                        usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
+                        return process_port_feature_set_request(instance, setup_request->value,
+                                        setup_request->index,
+                                        setup_request->request == USB_DEVREQ_SET_FEATURE);
+                }
+                usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",setup_request->request_type);
+                return EINVAL;
+        }
+        if(setup_request->request == USB_DEVREQ_SET_ADDRESS){
+                usb_log_debug("USB_DEVREQ_SET_ADDRESS\n");
+                return process_address_set_request(instance, setup_request->value);
+        }
+        usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n",setup_request->request_type);
+        return ENOTSUP;
+}
+
+/**
+ * process hub control request
+ *
+ * If needed, writes answer into the request structure.
+ * Request can be one of
+ * USB_DEVREQ_GET_STATUS,
+ * USB_DEVREQ_GET_DESCRIPTOR,
+ * USB_DEVREQ_GET_CONFIGURATION,
+ * USB_DEVREQ_CLEAR_FEATURE,
+ * USB_DEVREQ_SET_FEATURE,
+ * USB_DEVREQ_SET_ADDRESS,
+ * USB_DEVREQ_SET_DESCRIPTOR or
+ * USB_DEVREQ_SET_CONFIGURATION.
+ *
+ * @param instance root hub instance
+ * @param request structure containing both request and response information
+ * @return error code
+ */
+static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request){
+        int opResult;
+        if (request->setup_buffer) {
+                if(sizeof(usb_device_request_setup_packet_t)>request->setup_size){
+                        usb_log_error("setup packet too small\n");
+                        return EINVAL;
+                }
+                usb_log_info("CTRL packet: %s.\n",
+                        usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));
+                usb_device_request_setup_packet_t * setup_request =
+                                (usb_device_request_setup_packet_t*)request->setup_buffer;
+                if(
+                        setup_request->request == USB_DEVREQ_GET_STATUS
+                        || setup_request->request == USB_DEVREQ_GET_DESCRIPTOR
+                        || setup_request->request == USB_DEVREQ_GET_CONFIGURATION
+                ){
+                        usb_log_debug("processing request with output\n");
+                        opResult = process_request_with_output(instance,request);
+                }else if(
+                        setup_request->request == USB_DEVREQ_CLEAR_FEATURE
+                        || setup_request->request == USB_DEVREQ_SET_FEATURE
+                        || setup_request->request == USB_DEVREQ_SET_ADDRESS
+                ){
+                        usb_log_debug("processing request without additional data\n");
+                        opResult = process_request_without_data(instance,request);
+                }else if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR
+                                || setup_request->request == USB_DEVREQ_SET_CONFIGURATION
+                ){
+                        usb_log_debug("processing request with input\n");
+                        opResult = process_request_with_input(instance,request);
+                }else{
+                        usb_log_warning("received unsuported request: %d\n",
+                                        setup_request->request
+                                        );
+                        opResult = ENOTSUP;
+                }
+        }else{
+                usb_log_error("root hub received empty transaction?");
+                opResult = EINVAL;
+        }
+        return opResult;
+}
+
+/**
+ * process root hub request
+ *
+ * @param instance root hub instance
+ * @param request structure containing both request and response information
+ * @return error code
+ */
 int rh_request(rh_t *instance, usb_transfer_batch_t *request)
 {
         assert(instance);
         assert(request);
-        /* TODO: implement */
-        if (request->setup_buffer) {
-                usb_log_info("Root hub got SETUP packet: %s.\n",
-                    usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));
-        }
-        usb_log_error("Root hub request processing not implemented.\n");
-        usb_transfer_batch_finish(request, ENOTSUP);
+        int opResult;
+        if(request->transfer_type == USB_TRANSFER_CONTROL){
+                usb_log_info("Root hub got CONTROL packet\n");
+                opResult = process_ctrl_request(instance,request);
+        }else if(request->transfer_type == USB_TRANSFER_INTERRUPT){
+                usb_log_info("Root hub got INTERRUPT packet\n");
+                void * buffer;
+                create_interrupt_mask(instance, &buffer,
+                        &(request->transfered_size));
+                memcpy(request->transport_buffer,buffer, request->transfered_size);
+                opResult = EOK;
+        }else{
+                opResult = EINVAL;
+        }
+        usb_transfer_batch_finish(request, opResult);
         return EOK;
 }
 /*----------------------------------------------------------------------------*/
+
+
 void rh_interrupt(rh_t *instance)
 {
-        usb_log_error("Root hub interrupt not implemented.\n");
-        /* TODO: implement */
+        usb_log_info("Whoa whoa wait, I`m not supposed to receive any interrupts, am I?\n");
+        /* TODO: implement? */
 }
 /**

uspace/drv/ohci/root_hub.h

@@ -41 +41 @@
 #include "batch.h"
 
+/**
+ * ohci root hub representation
+ */
 typedef struct rh {
+        /** pointer to ohci driver registers */
         ohci_regs_t *registers;
+        /** usb address of the root hub */
         usb_address_t address;
+        /** ddf device information */
         ddf_dev_t *device;
+        /** hub port count */
+        int port_count;
 } rh_t;
 

uspace/drv/pciintel/pci.c

@@ -95 +95 @@
         sysarg_t i8259;
 
-        int irc_phone = -1;
-        int irc_service = -1;
-
-        if ((sysinfo_get_value("apic", &apic) == EOK) && (apic)) {
-                irc_service = SERVICE_APIC;
-        } else if ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259)) {
-                irc_service = SERVICE_I8259;
-        }
-
-        if (irc_service == -1) {
-                return false;
-        }
-
-        irc_phone = service_connect_blocking(irc_service, 0, 0);
+        int irc_phone = ENOTSUP;
+
+        if (((sysinfo_get_value("apic", &apic) == EOK) && (apic))
+            || ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259))) {
+                irc_phone = service_connect_blocking(SERVICE_IRC, 0, 0);
+        }
+
         if (irc_phone < 0) {
                 return false;

uspace/drv/uhci-hcd/Makefile

@@ -40 +40 @@
         root_hub.c \
         hw_struct/transfer_descriptor.c \
+        utils/slab.c \
         pci.c \
         batch.c

uspace/drv/uhci-hcd/hc.c

@@ -223 +223 @@
         ret = instance ? EOK : ENOMEM;
         CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to get frame list page.\n");
-        usb_log_debug("Initialized frame list.\n");
+        usb_log_debug("Initialized frame list at %p.\n", instance->frame_list);
 
         /* Set all frames to point to the first queue head */
@@ -336 +336 @@
             instance->transfers[batch->speed][batch->transfer_type];
         assert(list);
+        if (batch->transfer_type == USB_TRANSFER_CONTROL) {
+                usb_device_keeper_use_control(
+                    &instance->manager, batch->target.address);
+        }
         transfer_list_add_batch(list, batch);
 
@@ -357 +361 @@
         /* Lower 2 bits are transaction error and transaction complete */
         if (status & 0x3) {
-                transfer_list_remove_finished(&instance->transfers_interrupt);
-                transfer_list_remove_finished(&instance->transfers_control_slow);
-                transfer_list_remove_finished(&instance->transfers_control_full);
-                transfer_list_remove_finished(&instance->transfers_bulk_full);
+                LIST_INITIALIZE(done);
+                transfer_list_remove_finished(
+                    &instance->transfers_interrupt, &done);
+                transfer_list_remove_finished(
+                    &instance->transfers_control_slow, &done);
+                transfer_list_remove_finished(
+                    &instance->transfers_control_full, &done);
+                transfer_list_remove_finished(
+                    &instance->transfers_bulk_full, &done);
+
+                while (!list_empty(&done)) {
+                        link_t *item = done.next;
+                        list_remove(item);
+                        usb_transfer_batch_t *batch =
+                            list_get_instance(item, usb_transfer_batch_t, link);
+                        if (batch->transfer_type == USB_TRANSFER_CONTROL) {
+                                usb_device_keeper_release_control(
+                                    &instance->manager, batch->target.address);
+                        }
+                        batch->next_step(batch);
+                }
         }
         /* bits 4 and 5 indicate hc error */

uspace/drv/uhci-hcd/root_hub.c

@@ -48 +48 @@
  * @return Error code.
  */
-int rh_init(
-    rh_t *instance, ddf_fun_t *fun, uintptr_t reg_addr, size_t reg_size)
+int rh_init(rh_t *instance, ddf_fun_t *fun, uintptr_t reg_addr, size_t reg_size)
 {
         assert(fun);

uspace/drv/uhci-hcd/transfer_list.c

@@ -58 +58 @@
         }
         instance->queue_head_pa = addr_to_phys(instance->queue_head);
+        usb_log_debug2("Transfer list %s setup with QH: %p(%p).\n",
+            name, instance->queue_head, instance->queue_head_pa);
 
         qh_init(instance->queue_head);
@@ -118 +120 @@
         qh_set_next_qh(last_qh, pa);
 
+        asm volatile ("": : :"memory");
+
         /* Add to the driver list */
         list_append(&batch->link, &instance->batch_list);
@@ -137 +141 @@
  * this transfer list leading to the deadlock if its done inline.
  */
-void transfer_list_remove_finished(transfer_list_t *instance)
-{
-        assert(instance);
-
-        LIST_INITIALIZE(done);
+void transfer_list_remove_finished(transfer_list_t *instance, link_t *done)
+{
+        assert(instance);
+        assert(done);
 
         fibril_mutex_lock(&instance->guard);
@@ -153 +156 @@
                         /* Save for post-processing */
                         transfer_list_remove_batch(instance, batch);
-                        list_append(current, &done);
+                        list_append(current, done);
                 }
                 current = next;
@@ -159 +162 @@
         fibril_mutex_unlock(&instance->guard);
 
-        while (!list_empty(&done)) {
-                link_t *item = done.next;
-                list_remove(item);
-                usb_transfer_batch_t *batch =
-                    list_get_instance(item, usb_transfer_batch_t, link);
-                batch->next_step(batch);
-        }
 }
 /*----------------------------------------------------------------------------*/
@@ -222 +218 @@
                 qpos = "NOT FIRST";
         }
+        asm volatile ("": : :"memory");
         /* Remove from the batch list */
         list_remove(&batch->link);

uspace/drv/uhci-hcd/transfer_list.h

@@ -67 +67 @@
 void transfer_list_add_batch(transfer_list_t *instance, usb_transfer_batch_t *batch);
 
-void transfer_list_remove_finished(transfer_list_t *instance);
+void transfer_list_remove_finished(transfer_list_t *instance, link_t *done);
 
 void transfer_list_abort_all(transfer_list_t *instance);

uspace/drv/uhci-hcd/uhci.c

@@ -44 +44 @@
 #include "pci.h"
 
-
 /** IRQ handling callback, identifies device
  *
@@ -108 +107 @@
 /*----------------------------------------------------------------------------*/
 static ddf_dev_ops_t hc_ops = {
-        .interfaces[USB_DEV_IFACE] = &usb_iface,
+//      .interfaces[USB_DEV_IFACE] = &usb_iface,
         .interfaces[USBHC_DEV_IFACE] = &hc_iface, /* see iface.h/c */
 };

uspace/drv/uhci-hcd/utils/malloc32.h

@@ -40 +40 @@
 #include <as.h>
 
+#include "slab.h"
+
 #define UHCI_STRCUTURES_ALIGNMENT 16
 #define UHCI_REQUIRED_PAGE_SIZE 4096
+
 
 /** Get physical address translation
@@ -54 +57 @@
 
         uintptr_t result;
-        int ret = as_get_physical_mapping(addr, &result);
+        const int ret = as_get_physical_mapping(addr, &result);
+        assert(ret == EOK);
 
         if (ret != EOK)
@@ -66 +70 @@
  * @return Address of the alligned and big enough memory place, NULL on failure.
  */
-static inline void * malloc32(size_t size)
-        { return memalign(UHCI_STRCUTURES_ALIGNMENT, size); }
+static inline void * malloc32(size_t size) {
+        if (size <= SLAB_ELEMENT_SIZE)
+                return slab_malloc_g();
+        assert(false);
+        return memalign(UHCI_STRCUTURES_ALIGNMENT, size);
+}
 /*----------------------------------------------------------------------------*/
 /** Physical mallocator simulator
@@ -73 +81 @@
  * @param[in] addr Address of the place allocated by malloc32
  */
-static inline void free32(void *addr)
-        { if (addr) free(addr); }
+static inline void free32(void *addr) {
+        if (!addr)
+                return;
+        if (slab_in_range_g(addr))
+                return slab_free_g(addr);
+        free(addr);
+}
 /*----------------------------------------------------------------------------*/
 /** Create 4KB page mapping
@@ -82 +95 @@
 static inline void * get_page(void)
 {
-        void * free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
-        assert(free_address);
+        void *free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
+        assert(free_address); /* TODO: remove this assert */
         if (free_address == 0)
                 return NULL;
-        void* ret =
-          as_area_create(free_address, UHCI_REQUIRED_PAGE_SIZE,
+        void *ret = as_area_create(free_address, UHCI_REQUIRED_PAGE_SIZE,
                   AS_AREA_READ | AS_AREA_WRITE);
         if (ret != free_address)

uspace/drv/usbhub/port_status.h

@@ -30 +30 @@
  */
 
-#ifndef PORT_STATUS_H
-#define PORT_STATUS_H
+#ifndef HUB_PORT_STATUS_H
+#define HUB_PORT_STATUS_H
 
 #include <bool.h>
@@ -79 +79 @@
 
 /**
+ * set the device request to be a port feature enable request
+ * @param request
+ * @param port
+ * @param feature_selector
+ */
+static inline void usb_hub_set_enable_port_feature_request(
+usb_device_request_setup_packet_t * request, uint16_t port,
+                uint16_t feature_selector
+){
+        request->index = port;
+        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
+        request->request = USB_HUB_REQUEST_SET_FEATURE;
+        request->value = feature_selector;
+        request->length = 0;
+}
+
+
+/**
  * set the device request to be a port enable request
  * @param request
@@ -191 +209 @@
         request->length = 0;
 }
+
 
 /** get i`th bit of port status */
@@ -335 +354 @@
 
 
-#endif  /* PORT_STATUS_H */
+#endif  /* HUB_PORT_STATUS_H */
 
 /**

uspace/drv/usbhub/usbhub.c

@@ -53 +53 @@
 #include "usb/classes/classes.h"
 
+
+static void usb_hub_init_add_device(usb_hub_info_t * hub, uint16_t port,
+                usb_speed_t speed);
+
+static int usb_hub_trigger_connecting_non_removable_devices(
+                usb_hub_info_t * hub, usb_hub_descriptor_t * descriptor);
+
+/**
+ * control loop running in hub`s fibril
+ *
+ * Hub`s fibril periodically asks for changes on hub and if needded calls
+ * change handling routine.
+ * @warning currently hub driver asks for changes once a second
+ * @param hub_info_param hub representation pointer
+ * @return zero
+ */
 int usb_hub_control_loop(void * hub_info_param){
         usb_hub_info_t * hub_info = (usb_hub_info_t*)hub_info_param;
@@ -91 +107 @@
 
 /**
- * Load hub-specific information into hub_info structure.
+ * Load hub-specific information into hub_info structure and process if needed
  *
  * Particularly read port count and initialize structure holding port
- * information.
+ * information. If there are non-removable devices, start initializing them.
  * 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
+ * @param hub_info hub representation
  * @return error code
  */
-static int usb_hub_get_hub_specific_info(usb_hub_info_t * hub_info){
+static int usb_hub_process_hub_specific_info(usb_hub_info_t * hub_info){
         // get hub descriptor
         usb_log_debug("creating serialized descriptor\n");
@@ -107 +123 @@
 
         /* this was one fix of some bug, should not be needed anymore
+         * these lines allow to reset hub once more, it can be used as
+         * brute-force initialization for non-removable devices
         int opResult = usb_request_set_configuration(&result->endpoints.control, 1);
         if(opResult!=EOK){
@@ -141 +159 @@
                 hub_info->attached_devs[i].address=0;
         }
+        //handle non-removable devices
+        usb_hub_trigger_connecting_non_removable_devices(hub_info, descriptor);
         usb_log_debug2("freeing data\n");
         free(serialized_descriptor);
@@ -152 +172 @@
  * 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
- * @return
+ * @param hub_info hub representation
+ * @return error code
  */
 static int usb_hub_set_configuration(usb_hub_info_t * hub_info){
@@ -162 +182 @@
             std_descriptor->configuration_count);
         if(std_descriptor->configuration_count<1){
-                usb_log_error("THERE ARE NO CONFIGURATIONS AVAILABLE\n");
-                //shouldn`t I return?
-                //definitely
+                usb_log_error("there are no configurations available\n");
                 return EINVAL;
         }
@@ -220 +238 @@
         }
         //get port count and create attached_devs
-        opResult = usb_hub_get_hub_specific_info(hub_info);
+        opResult = usb_hub_process_hub_specific_info(hub_info);
         if(opResult!=EOK){
                 usb_log_error("could not set hub configuration, errno %d\n",opResult);
@@ -258 +276 @@
 //*********************************************
 //
-//  hub driver code, main loop
+//  hub driver code, main loop and port handling
 //
 //*********************************************
+
+/**
+ * triggers actions to connect non0removable devices
+ *
+ * This will trigger operations leading to activated non-removable device.
+ * Control pipe of the hub must be open fo communication.
+ * @param hub hub representation
+ * @param descriptor usb hub descriptor
+ * @return error code
+ */
+static int usb_hub_trigger_connecting_non_removable_devices(usb_hub_info_t * hub,
+                usb_hub_descriptor_t * descriptor)
+{
+        usb_log_info("attaching non-removable devices(if any)\n");
+        usb_device_request_setup_packet_t request;
+        int opResult;
+        size_t rcvd_size;
+        usb_port_status_t status;
+        uint8_t * non_removable_dev_bitmap = descriptor->devices_removable;
+        int port;
+        for(port=1;port<=descriptor->ports_count;++port){
+                bool is_non_removable =
+                                ((non_removable_dev_bitmap[port/8]) >> (port%8)) %2;
+                if(is_non_removable){
+                        usb_log_debug("non-removable device on port %d\n",port);
+                        usb_hub_set_port_status_request(&request, port);
+                        opResult = usb_pipe_control_read(
+                                        hub->control_pipe,
+                                        &request, sizeof(usb_device_request_setup_packet_t),
+                                        &status, 4, &rcvd_size
+                                        );
+                        if (opResult != EOK) {
+                                usb_log_error("could not get port status of port %d errno:%d\n",
+                                                port, opResult);
+                                return opResult;
+                        }
+                        //set the status change bit, so it will be noticed in driver loop
+                        if(usb_port_dev_connected(&status)){
+                                usb_hub_set_enable_port_feature_request(&request, port,
+                                                USB_HUB_FEATURE_C_PORT_CONNECTION);
+                                opResult = usb_pipe_control_read(
+                                                hub->control_pipe,
+                                                &request, sizeof(usb_device_request_setup_packet_t),
+                                                &status, 4, &rcvd_size
+                                                );
+                                if (opResult != EOK) {
+                                        usb_log_warning(
+                                                        "could not set port change on port %d errno:%d\n",
+                                                        port, opResult);
+                                }
+                        }
+                }
+        }
+        return EOK;
+}
+
 
 /**
@@ -282 +356 @@
 /**
  * Reset the port with new device and reserve the default address.
- * @param hc
- * @param port
- * @param target
+ * @param hub hub representation
+ * @param port port number, starting from 1
+ * @param speed transfer speed of attached device, one of low, full or high
  */
 static void usb_hub_init_add_device(usb_hub_info_t * hub, uint16_t port,
@@ -317 +391 @@
         if (opResult != EOK) {
                 usb_log_error("something went wrong when reseting a port %d\n",opResult);
-                //usb_hub_release_default_address(hc);
                 usb_hub_release_default_address(hub);
         }
@@ -325 +398 @@
 /**
  * Finalize adding new device after port reset
- * @param hc
- * @param port
- * @param target
+ *
+ * Set device`s address and start it`s driver.
+ * @param hub hub representation
+ * @param port port number, starting from 1
+ * @param speed transfer speed of attached device, one of low, full or high
  */
 static void usb_hub_finalize_add_device( usb_hub_info_t * hub,
@@ -377 +452 @@
         }
 
-
         //opResult = usb_hub_release_default_address(hc);
         opResult = usb_hub_release_default_address(hub);
@@ -412 +486 @@
 
 /**
- * Unregister device address in hc
- * @param hc
- * @param port
- * @param target
+ * routine called when a device on port has been removed
+ *
+ * If the device on port had default address, it releases default address.
+ * Otherwise does not do anything, because DDF does not allow to remove device
+ * from it`s device tree.
+ * @param hub hub representation
+ * @param port port number, starting from 1
  */
 static void usb_hub_removed_device(
@@ -454 +531 @@
  * Turn off the power on the port.
  *
- * @param hub
- * @param port
+ * @param hub hub representation
+ * @param port port number, starting from 1
  */
 static void usb_hub_over_current( usb_hub_info_t * hub,
@@ -470 +547 @@
 /**
  * Process interrupts on given hub port
- * @param hc
- * @param port
- * @param target
+ *
+ * Accepts connection, over current and port reset change.
+ * @param hub hub representation
+ * @param port port number, starting from 1
  */
 static void usb_hub_process_interrupt(usb_hub_info_t * hub, 
@@ -543 +621 @@
 
 /**
- * Check changes on particular hub
- * @param hub_info_param pointer to usb_hub_info_t structure
- * @return error code if there is problem when initializing communication with
- * hub, EOK otherwise
+ * check changes on hub
+ *
+ * Handles changes on each port with a status change.
+ * @param hub_info hub representation
+ * @return error code
  */
 int usb_hub_check_hub_changes(usb_hub_info_t * hub_info){

uspace/drv/usbmid/explore.c

@@ -40 +40 @@
 #include <usb/request.h>
 #include <usb/dp.h>
+#include <usb/ddfiface.h>
 #include "usbmid.h"
+
+/** Operations of the device itself. */
+static ddf_dev_ops_t mid_device_ops = {
+        .interfaces[USB_DEV_IFACE] = &usb_iface_hub_impl
+};
 
 /** Find starting indexes of all interface descriptors in a configuration.
@@ -105 +111 @@
  * @return Whether to accept this device from devman.
  */
-bool usbmid_explore_device(usbmid_device_t *dev)
+bool usbmid_explore_device(usb_device_t *dev)
 {
-        usb_standard_device_descriptor_t device_descriptor;
-        int rc = usb_request_get_device_descriptor(&dev->ctrl_pipe,
-            &device_descriptor);
-        if (rc != EOK) {
-                usb_log_error("Getting device descriptor failed: %s.\n",
-                    str_error(rc));
-                return false;
-        }
-
-        if (device_descriptor.device_class != USB_CLASS_USE_INTERFACE) {
+        int rc;
+
+        int dev_class = dev->descriptors.device.device_class;
+        if (dev_class != USB_CLASS_USE_INTERFACE) {
                 usb_log_warning(
                     "Device class: %d (%s), but expected class 0.\n",
-                    device_descriptor.device_class,
-                    usb_str_class(device_descriptor.device_class));
+                    dev_class, usb_str_class(dev_class));
                 usb_log_error("Not multi interface device, refusing.\n");
                 return false;
         }
 
-        size_t config_descriptor_size;
-        uint8_t *config_descriptor_raw = NULL;
-        rc = usb_request_get_full_configuration_descriptor_alloc(
-            &dev->ctrl_pipe, 0,
-            (void **) &config_descriptor_raw, &config_descriptor_size);
-        if (rc != EOK) {
-                usb_log_error("Failed getting full config descriptor: %s.\n",
-                    str_error(rc));
-                return false;
-        }
-
-        usb_standard_configuration_descriptor_t *config_descriptor
-            = (usb_standard_configuration_descriptor_t *) config_descriptor_raw;
+        /* Short cuts to save on typing ;-). */
+        uint8_t *config_descriptor_raw = dev->descriptors.configuration;
+        size_t config_descriptor_size = dev->descriptors.configuration_size;
+        usb_standard_configuration_descriptor_t *config_descriptor =
+            (usb_standard_configuration_descriptor_t *) config_descriptor_raw;
 
         size_t *interface_descriptors
@@ -154 +145 @@
         if (interface_descriptors_count == (size_t) -1) {
                 usb_log_error("Problem parsing configuration descriptor.\n");
-                free(config_descriptor_raw);
                 free(interface_descriptors);
                 return false;
@@ -165 +155 @@
                 usb_log_error("Failed to set device configuration: %s.\n",
                     str_error(rc));
-                free(config_descriptor_raw);
                 free(interface_descriptors);
                 return false;
@@ -172 +161 @@
 
         /* Create control function */
-        ddf_fun_t *ctl_fun = ddf_fun_create(dev->dev, fun_exposed, "ctl");
+        ddf_fun_t *ctl_fun = ddf_fun_create(dev->ddf_dev, fun_exposed, "ctl");
         if (ctl_fun == NULL) {
                 usb_log_error("Failed to create control function.\n");
-                free(config_descriptor_raw);
-                free(interface_descriptors);
-                return false;
-        }
+                free(interface_descriptors);
+                return false;
+        }
+
+        ctl_fun->ops = &mid_device_ops;
+
         rc = ddf_fun_bind(ctl_fun);
         if (rc != EOK) {
                 usb_log_error("Failed to bind control function: %s.\n",
                     str_error(rc));
-                free(config_descriptor_raw);
                 free(interface_descriptors);
                 return false;
@@ -199 +189 @@
                     (int) interface->interface_number,
                     usb_str_class(interface->interface_class));
-                rc = usbmid_spawn_interface_child(dev, &device_descriptor,
+                rc = usbmid_spawn_interface_child(dev, &dev->descriptors.device,
                     interface);
                 if (rc != EOK) {
@@ -207 +197 @@
         }
 
-        free(config_descriptor_raw);
-
         return true;
 }

uspace/drv/usbmid/main.c

@@ -49 +49 @@
  * @return Error code.
  */
-static int usbmid_add_device(ddf_dev_t *gen_dev)
+static int usbmid_add_device(usb_device_t *dev)
 {
-        usbmid_device_t *dev = usbmid_device_create(gen_dev);
-        if (dev == NULL) {
-                return ENOMEM;
-        }
-
-        usb_log_info("Taking care of new MID: addr %d (HC %zu)\n",
-            dev->wire.address, dev->wire.hc_handle);
+        usb_log_info("Taking care of new MID `%s'.\n", dev->ddf_dev->name);
 
         int rc;
@@ -65 +59 @@
                 usb_log_error("Failed to start session on control pipe: %s.\n",
                     str_error(rc));
-                goto error_leave;
+                return rc;
         }
 
@@ -77 +71 @@
 
         if (!accept) {
-                rc = ENOTSUP;
-                goto error_leave;
+                return ENOTSUP;
         }
 
-        gen_dev->driver_data = dev;
-
         return EOK;
-
-
-error_leave:
-        free(dev);
-        return rc;
 }
 
 /** USB MID driver ops. */
-static driver_ops_t mid_driver_ops = {
+static usb_driver_ops_t mid_driver_ops = {
         .add_device = usbmid_add_device,
 };
 
 /** USB MID driver. */
-static driver_t mid_driver = {
+static usb_driver_t mid_driver = {
         .name = NAME,
-        .driver_ops = &mid_driver_ops
+        .ops = &mid_driver_ops,
+        .endpoints = NULL
 };
 
@@ -107 +94 @@
 
         usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME);
-        return ddf_driver_main(&mid_driver);
+
+        return usb_driver_main(&mid_driver);
 }
 

uspace/drv/usbmid/usbmid.c

@@ -79 +79 @@
 };
 
-/** Operations of the device itself. */
-static ddf_dev_ops_t mid_device_ops = {
-        .interfaces[USB_DEV_IFACE] = &usb_iface_hub_impl
-};
-
-/** Create new USB multi interface device.
- *
- * @param dev Backing generic DDF device.
- * @return New USB MID device.
- * @retval NULL Error occured.
- */
-usbmid_device_t *usbmid_device_create(ddf_dev_t *dev)
-{
-        usbmid_device_t *mid = malloc(sizeof(usbmid_device_t));
-        if (mid == NULL) {
-                usb_log_error("Out of memory (wanted %zu bytes).\n",
-                    sizeof(usbmid_device_t));
-                return NULL;
-        }
-
-        int rc;
-        rc = usb_device_connection_initialize_from_device(&mid->wire, dev);
-        if (rc != EOK) {
-                usb_log_error("Failed to initialize `USB wire': %s.\n",
-                    str_error(rc));
-                free(mid);
-                return NULL;
-        }
-
-        rc = usb_pipe_initialize_default_control(&mid->ctrl_pipe,
-            &mid->wire);
-        if (rc != EOK) {
-                usb_log_error("Failed to initialize control pipe: %s.\n",
-                    str_error(rc));
-                free(mid);
-                return NULL;
-        }
-        rc = usb_pipe_probe_default_control(&mid->ctrl_pipe);
-        if (rc != EOK) {
-                usb_log_error("Probing default control pipe failed: %s.\n",
-                    str_error(rc));
-                free(mid);
-                return NULL;
-        }
-
-        mid->dev = dev;
-        (void) &mid_device_ops;
-
-        return mid;
-}
-
 /** Create new interface for USB MID device.
  *
@@ -160 +109 @@
  * @return Error code.
  */
-int usbmid_spawn_interface_child(usbmid_device_t *parent,
+int usbmid_spawn_interface_child(usb_device_t *parent,
     const usb_standard_device_descriptor_t *device_descriptor,
     const usb_standard_interface_descriptor_t *interface_descriptor)
@@ -182 +131 @@
 
         /* Create the device. */
-        child = ddf_fun_create(parent->dev, fun_inner, child_name);
+        child = ddf_fun_create(parent->ddf_dev, fun_inner, child_name);
         if (child == NULL) {
                 rc = ENOMEM;

uspace/drv/usbmid/usbmid.h

@@ -41 +41 @@
 #include <usb/pipes.h>
 #include <usb/debug.h>
+#include <usb/devdrv.h>
 
 #define NAME "usbmid"
-
-/** USB MID device container. */
-typedef struct {
-        /** Device container. */
-        ddf_dev_t *dev;
-
-        /** Representation of USB wire. */
-        usb_device_connection_t wire;
-        /** Default control pipe. */
-        usb_pipe_t ctrl_pipe;
-} usbmid_device_t;
-
 
 /** Container for single interface in a MID device. */
@@ -65 +54 @@
 } usbmid_interface_t;
 
-usbmid_device_t *usbmid_device_create(ddf_dev_t *);
 usbmid_interface_t *usbmid_interface_create(ddf_fun_t *, int);
-bool usbmid_explore_device(usbmid_device_t *);
-int usbmid_spawn_interface_child(usbmid_device_t *,
+bool usbmid_explore_device(usb_device_t *);
+int usbmid_spawn_interface_child(usb_device_t *,
     const usb_standard_device_descriptor_t *,
     const usb_standard_interface_descriptor_t *);

uspace/lib/c/generic/malloc.c

@@ -240 +240 @@
         size_t asize = ALIGN_UP(size, PAGE_SIZE);
         
-        astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ);
+        astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE);
         if (astart == (void *) -1)
                 return false;

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

@@ -47 +47 @@
         SERVICE_DEVMAP,
         SERVICE_DEVMAN,
-        SERVICE_FHC,
-        SERVICE_OBIO,
-        SERVICE_APIC,
-        SERVICE_I8259,
+        SERVICE_IRC,
         SERVICE_CLIPBOARD,
         SERVICE_NETWORKING,

uspace/lib/fs/libfs.c

@@ -391 +391 @@
                                                 if (lflag & L_CREATE)
                                                         (void) ops->destroy(fn);
+                                                else
+                                                        (void) ops->node_put(fn);
                                                 async_answer_0(rid, rc);
                                         } else {
@@ -473 +475 @@
                                         if (lflag & L_CREATE)
                                                 (void) ops->destroy(fn);
+                                        else
+                                                (void) ops->node_put(fn);
                                         async_answer_0(rid, rc);
                                 } else {

uspace/lib/usb/include/usb/host/device_keeper.h

@@ -51 +51 @@
         usb_speed_t speed;
         bool occupied;
+        bool control_used;
         uint16_t toggle_status[2];
         devman_handle_t handle;
@@ -61 +62 @@
         struct usb_device_info devices[USB_ADDRESS_COUNT];
         fibril_mutex_t guard;
-        fibril_condvar_t default_address_occupied;
+        fibril_condvar_t change;
         usb_address_t last_address;
 } usb_device_keeper_t;
@@ -97 +98 @@
     usb_address_t address);
 
+void usb_device_keeper_use_control(usb_device_keeper_t *instance,
+    usb_address_t address);
+
+void usb_device_keeper_release_control(usb_device_keeper_t *instance,
+    usb_address_t address);
+
 #endif
 /**

uspace/lib/usb/src/host/device_keeper.c

@@ -49 +49 @@
         assert(instance);
         fibril_mutex_initialize(&instance->guard);
-        fibril_condvar_initialize(&instance->default_address_occupied);
+        fibril_condvar_initialize(&instance->change);
         instance->last_address = 0;
         unsigned i = 0;
         for (; i < USB_ADDRESS_COUNT; ++i) {
                 instance->devices[i].occupied = false;
+                instance->devices[i].control_used = false;
                 instance->devices[i].handle = 0;
                 instance->devices[i].toggle_status[0] = 0;
@@ -71 +72 @@
         fibril_mutex_lock(&instance->guard);
         while (instance->devices[USB_ADDRESS_DEFAULT].occupied) {
-                fibril_condvar_wait(&instance->default_address_occupied,
-                    &instance->guard);
+                fibril_condvar_wait(&instance->change, &instance->guard);
         }
         instance->devices[USB_ADDRESS_DEFAULT].occupied = true;
@@ -90 +90 @@
         instance->devices[USB_ADDRESS_DEFAULT].occupied = false;
         fibril_mutex_unlock(&instance->guard);
-        fibril_condvar_signal(&instance->default_address_occupied);
+        fibril_condvar_signal(&instance->change);
 }
 /*----------------------------------------------------------------------------*/
@@ -309 +309 @@
         return instance->devices[address].speed;
 }
-
+/*----------------------------------------------------------------------------*/
+void usb_device_keeper_use_control(usb_device_keeper_t *instance,
+    usb_address_t address)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        while (instance->devices[address].control_used) {
+                fibril_condvar_wait(&instance->change, &instance->guard);
+        }
+        instance->devices[address].control_used = true;
+        fibril_mutex_unlock(&instance->guard);
+}
+/*----------------------------------------------------------------------------*/
+void usb_device_keeper_release_control(usb_device_keeper_t *instance,
+    usb_address_t address)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        instance->devices[address].control_used = false;
+        fibril_mutex_unlock(&instance->guard);
+        fibril_condvar_signal(&instance->change);
+}
 /**
  * @}

uspace/srv/hid/kbd/Makefile

@@ -78 +78 @@
                 SOURCES += \
                         port/pl050.c \
-                        ctl/pl050.c
+                        ctl/pc.c
         endif
 endif

uspace/srv/hid/kbd/generic/kbd.c

@@ -67 +67 @@
 static unsigned lock_keys;
 
-int cir_service = 0;
-int cir_phone = -1;
+bool irc_service = false;
+int irc_phone = -1;
 
 #define NUM_LAYOUTS 3
@@ -216 +216 @@
         sysarg_t obio;
         
-        if ((sysinfo_get_value("kbd.cir.fhc", &fhc) == EOK) && (fhc))
-                cir_service = SERVICE_FHC;
-        else if ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio))
-                cir_service = SERVICE_OBIO;
-        
-        if (cir_service) {
-                while (cir_phone < 0)
-                        cir_phone = service_connect_blocking(cir_service, 0, 0);
+        if (((sysinfo_get_value("kbd.cir.fhc", &fhc) == EOK) && (fhc))
+            || ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio)))
+                irc_service = true;
+        
+        if (irc_service) {
+                while (irc_phone < 0)
+                        irc_phone = service_connect_blocking(SERVICE_IRC, 0, 0);
         }
         

uspace/srv/hid/kbd/include/kbd.h

@@ -38 +38 @@
 #define KBD_KBD_H_
 
-extern int cir_service;
-extern int cir_phone;
+#include <bool.h>
+
+extern bool irc_service;
+extern int irc_phone;
 
 extern void kbd_push_scancode(int);

uspace/srv/hid/kbd/port/ns16550.c

@@ -120 +120 @@
         kbd_push_scancode(scan_code);
         
-        if (cir_service)
-                async_msg_1(cir_phone, IRC_CLEAR_INTERRUPT,
+        if (irc_service)
+                async_msg_1(irc_phone, IRC_CLEAR_INTERRUPT,
                     IPC_GET_IMETHOD(*call));
 }

uspace/srv/hid/kbd/port/z8530.c

@@ -108 +108 @@
         kbd_push_scancode(scan_code);
         
-        if (cir_service)
-                async_msg_1(cir_phone, IRC_CLEAR_INTERRUPT,
+        if (irc_service)
+                async_msg_1(irc_phone, IRC_CLEAR_INTERRUPT,
                     IPC_GET_IMETHOD(*call));
 }

uspace/srv/hw/irc/apic/apic.c

@@ -54 +54 @@
 #define NAME  "apic"
 
-static bool apic_found = false;
-
 static int apic_enable_irq(sysarg_t irq)
 {
@@ -81 +79 @@
                 callid = async_get_call(&call);
                 
-                sysarg_t method = IPC_GET_IMETHOD(call);
-                if (method == IPC_M_PHONE_HUNGUP) {
-                        return;
-                }
-
-                if (!apic_found) {
-                        async_answer_0(callid, ENOTSUP);
-                        break;
-                }
-
-                switch (method) {
+                switch (IPC_GET_IMETHOD(call)) {
                 case IRC_ENABLE_INTERRUPT:
                         async_answer_0(callid, apic_enable_irq(IPC_GET_ARG1(call)));
@@ -109 +97 @@
  *
  */
-static void apic_init(void)
+static bool apic_init(void)
 {
         sysarg_t apic;
         
-        apic_found = sysinfo_get_value("apic", &apic) && apic;
-        if (!apic_found) {
-                printf(NAME ": Warning: no APIC found\n");
+        if ((sysinfo_get_value("apic", &apic) != EOK) || (!apic)) {
+                printf(NAME ": No APIC found\n");
+                return false;
         }
         
         async_set_client_connection(apic_connection);
-        service_register(SERVICE_APIC);
+        service_register(SERVICE_IRC);
+        
+        return true;
 }
 
@@ -126 +116 @@
         printf(NAME ": HelenOS APIC driver\n");
         
-        apic_init();
-
+        if (!apic_init())
+                return -1;
+        
         printf(NAME ": Accepting connections\n");
         async_manager();

uspace/srv/hw/irc/fhc/fhc.c

@@ -136 +136 @@
         
         async_set_client_connection(fhc_connection);
-        service_register(SERVICE_FHC);
+        service_register(SERVICE_IRC);
         
         return true;

uspace/srv/hw/irc/i8259/i8259.c

@@ -149 +149 @@
         
         async_set_client_connection(i8259_connection);
-        service_register(SERVICE_I8259);
+        service_register(SERVICE_IRC);
         
         return true;

uspace/srv/hw/irc/obio/obio.c

@@ -137 +137 @@
         
         async_set_client_connection(obio_connection);
-        service_register(SERVICE_OBIO);
+        service_register(SERVICE_IRC);
         
         return true;

uspace/srv/hw/netif/ne2000/ne2000.c

@@ -75 +75 @@
 #define IRQ_GET_TSR(call)  ((int) IPC_GET_ARG3(call))
 
-static int irc_service = 0;
+static bool irc_service = false;
 static int irc_phone = -1;
 
@@ -383 +383 @@
         sysarg_t i8259;
         
-        if ((sysinfo_get_value("apic", &apic) == EOK) && (apic))
-                irc_service = SERVICE_APIC;
-        else if ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259))
-                irc_service = SERVICE_I8259;
+        if (((sysinfo_get_value("apic", &apic) == EOK) && (apic))
+            || ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259)))
+                irc_service = true;
         
         if (irc_service) {
                 while (irc_phone < 0)
-                        irc_phone = service_connect_blocking(irc_service, 0, 0);
+                        irc_phone = service_connect_blocking(SERVICE_IRC, 0, 0);
         }
         

uspace/srv/net/net/net.c

@@ -289 +289 @@
         if (rc != EOK)
                 return rc;
+        
         rc = add_module(NULL, &net_globals.modules, (uint8_t *) NE2000_NAME,
             (uint8_t *) NE2000_FILENAME, SERVICE_NE2000, 0, connect_to_service);
         if (rc != EOK)
                 return rc;
+        
         rc = add_module(NULL, &net_globals.modules, (uint8_t *) ETHERNET_NAME,
             (uint8_t *) ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service);
         if (rc != EOK)
                 return rc;
+        
         rc = add_module(NULL, &net_globals.modules, (uint8_t *) NILDUMMY_NAME,
             (uint8_t *) NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0, connect_to_service);
@@ -590 +593 @@
                 rc = start_device(netif);
                 if (rc != EOK) {
-                        printf("%s: Error starting interface %s (%s)\n", NAME,
+                        printf("%s: Ignoring failed interface %s (%s)\n", NAME,
                             netif->name, str_error(rc));
                         measured_strings_destroy(&netif->configuration);
                         netifs_exclude_index(&net_globals.netifs, index);
-                        
-                        return rc;
+                        continue;
                 }
                 

uspace/srv/vfs/vfs_ops.c

@@ -1234 +1234 @@
         if (!parentc) {
                 fibril_rwlock_write_unlock(&namespace_rwlock);
+                vfs_node_put(old_node);
                 async_answer_0(rid, rc);
                 free(old);
@@ -1251 +1252 @@
         if (rc != EOK) {
                 fibril_rwlock_write_unlock(&namespace_rwlock);
+                vfs_node_put(old_node);
                 async_answer_0(rid, rc);
                 free(old);
@@ -1261 +1263 @@
             (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
                 fibril_rwlock_write_unlock(&namespace_rwlock);
+                vfs_node_put(old_node);
                 async_answer_0(rid, EXDEV);     /* different file systems */
                 free(old);
@@ -1279 +1282 @@
                 if (!new_node) {
                         fibril_rwlock_write_unlock(&namespace_rwlock);
+                        vfs_node_put(old_node);
                         async_answer_0(rid, ENOMEM);
                         free(old);
@@ -1290 +1294 @@
         default:
                 fibril_rwlock_write_unlock(&namespace_rwlock);
+                vfs_node_put(old_node);
                 async_answer_0(rid, ENOTEMPTY);
                 free(old);
@@ -1300 +1305 @@
         if (rc != EOK) {
                 fibril_rwlock_write_unlock(&namespace_rwlock);
+                vfs_node_put(old_node);
                 if (new_node)
                         vfs_node_put(new_node);

version

@@ -37 +37 @@
 VERSION = 0
 PATCHLEVEL = 4
-SUBLEVEL = 2
+SUBLEVEL = 3
 
 ifdef EXTRAVERSION
@@ -45 +45 @@
 endif
 
-NAME = Skewer
+NAME = Sashimi