Changeset c593b21 in mainline for uspace

Timestamp:

2011-04-03T18:06:29Z (14 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

c4e0b47

Parents:

0b4e7ca (diff), 0cec844d (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:

Merge development/ changes

Location:

uspace

Files:

• app/bdsh/cmds/modules/ls/ls.c (modified) (4 diffs)
• app/bdsh/cmds/modules/ls/ls.h (deleted)
• app/init/init.c (modified) (2 diffs)
• app/tester/Makefile (modified) (1 diff)
• app/tester/devs/devman1.c (added)
• app/tester/devs/devman1.def (added)
• app/tester/tester.c (modified) (1 diff)
• app/tester/tester.h (modified) (1 diff)
• drv/isa/isa.c (modified) (13 diffs)
• drv/ns8250/ns8250.c (modified) (21 diffs)
• drv/ohci/hc.c (modified) (7 diffs)
• drv/ohci/hc.h (modified) (2 diffs)
• drv/ohci/iface.c (modified) (2 diffs)
• drv/ohci/ohci.c (modified) (4 diffs)
• drv/ohci/ohci_regs.h (modified) (2 diffs)
• drv/ohci/root_hub.c (modified) (12 diffs)
• drv/ohci/root_hub.h (modified) (2 diffs)
• drv/pciintel/pci.c (modified) (17 diffs)
• drv/root/root.c (modified) (12 diffs)
• drv/rootpc/rootpc.c (modified) (6 diffs)
• drv/rootvirt/rootvirt.c (modified) (6 diffs)
• drv/test1/test1.c (modified) (6 diffs)
• drv/test2/test2.c (modified) (10 diffs)
• drv/uhci-hcd/hc.c (modified) (5 diffs)
• drv/uhci-hcd/hc.h (modified) (2 diffs)
• drv/uhci-hcd/iface.c (modified) (2 diffs)
• drv/usbhub/port_status.h (modified) (1 diff)
• drv/usbhub/usbhub.c (modified) (6 diffs)
• drv/usbkbd/kbddev.c (modified) (9 diffs)
• drv/usbkbd/kbddev.h (modified) (1 diff)
• lib/c/Makefile (modified) (1 diff)
• lib/c/generic/adt/hash_table.c (modified) (1 diff)
• lib/c/generic/devman.c (modified) (3 diffs)
• lib/c/generic/io/log.c (added)
• lib/c/include/adt/hash_table.h (modified) (2 diffs)
• lib/c/include/devman.h (modified) (1 diff)
• lib/c/include/io/log.h (added)
• lib/c/include/ipc/devman.h (modified) (1 diff)
• lib/drv/Makefile (modified) (1 diff)
• lib/drv/generic/driver.c (modified) (1 diff)
• lib/drv/generic/log.c (added)
• lib/drv/include/ddf/log.h (added)
• lib/usb/Makefile (modified) (1 diff)
• lib/usb/include/usb/classes/hid/utled.h (added)
• lib/usb/include/usb/classes/hidparser.h (modified) (7 diffs)
• lib/usb/include/usb/host/bandwidth.h (added)
• lib/usb/include/usb/host/device_keeper.h (modified) (2 diffs)
• lib/usb/src/devdrv.c (modified) (1 diff)
• lib/usb/src/hidparser.c (modified) (27 diffs)
• lib/usb/src/host/bandwidth.c (added)
• lib/usb/src/host/device_keeper.c (modified) (2 diffs)
• lib/usb/src/request.c (modified) (1 diff)
• srv/devman/devman.c (modified) (25 diffs)
• srv/devman/devman.h (modified) (2 diffs)
• srv/devman/main.c (modified) (29 diffs)
• srv/devmap/devmap.c (modified) (1 diff)

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

@@ -38 +38 @@
 #include <dirent.h>
 #include <fcntl.h>
+#include <getopt.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <str.h>
+#include <sort.h>
 
 #include "errors.h"
@@ -46 +48 @@
 #include "util.h"
 #include "entry.h"
-#include "ls.h"
 #include "cmds.h"
 
+/* Various values that can be returned by ls_scope() */
+#define LS_BOGUS 0
+#define LS_FILE  1
+#define LS_DIR   2
+
+/** Structure to represent a directory entry.
+ *
+ * Useful to keep together important information
+ * for sorting directory entries.
+ */
+struct dir_elem_t {
+        char *name;
+        struct stat s;
+};
+
 static const char *cmdname = "ls";
 
-static void ls_scan_dir(const char *d, DIR *dirp)
-{
+static struct option const long_options[] = {
+        { "help", no_argument, 0, 'h' },
+        { "unsort", no_argument, 0, 'u' },
+        { 0, 0, 0, 0 }
+};
+
+/** Print an entry.
+ *
+ * ls_print currently does nothing more than print the entry.
+ * In the future, we will likely pass the absolute path, and
+ * some sort of ls_options structure that controls how each
+ * entry is printed and what is printed about it.
+ *
+ * Now we just print basic DOS style lists.
+ *
+ * @param de            Directory element.
+ */
+static void ls_print(struct dir_elem_t *de)
+{
+        if (de->s.is_file)
+                printf("%-40s\t%llu\n", de->name, (long long) de->s.size);
+        else if (de->s.is_directory)
+                printf("%-40s\t<dir>\n", de->name);
+        else
+                printf("%-40s\n", de->name);
+}
+
+
+/** Compare 2 directory elements.
+ *
+ * It compares 2 elements of a directory : a file is considered
+ * as bigger than a directory, and if they have the same type,
+ * they are compared alphabetically.
+ *
+ * @param a             Pointer to the structure of the first element.
+ * @param b             Pointer to the structure of the second element.
+ * @param arg           Pointer for an other and optionnal argument.
+ *
+ * @return              -1 if a < b, 1 otherwise.
+ */
+static int ls_cmp(void *a, void *b, void *arg)
+{
+        struct dir_elem_t *da = a;
+        struct dir_elem_t *db = b;
+        
+        if ((da->s.is_directory && db->s.is_file) ||
+            ((da->s.is_directory == db->s.is_directory) &&
+            str_cmp(da->name, db->name) < 0))
+                return -1;
+        else
+                return 1;
+}
+
+/** Scan a directory.
+ *
+ * Scan the content of a directory and print it.
+ *
+ * @param d             Name of the directory.
+ * @param dirp  Directory stream.
+ * @param sort  1 if the output must be sorted,
+ *                              0 otherwise.
+ */
+static void ls_scan_dir(const char *d, DIR *dirp, int sort)
+{
+        int alloc_blocks = 20;
+        int i;
+        int nbdirs = 0;
+        int rc;
+        int len;
+        char *buff;
+        struct dir_elem_t *tmp;
+        struct dir_elem_t *tosort;
         struct dirent *dp;
-        char *buff;
-
-        if (! dirp)
+        
+        if (!dirp)
                 return;
 
-        buff = (char *)malloc(PATH_MAX);
-        if (NULL == buff) {
+        buff = (char *) malloc(PATH_MAX);
+        if (!buff) {
                 cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
                 return;
         }
-
+        
+        tosort = (struct dir_elem_t *) malloc(alloc_blocks * sizeof(*tosort));
+        if (!tosort) {
+                cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
+                free(buff);
+                return;
+        }
+        
         while ((dp = readdir(dirp))) {
-                memset(buff, 0, sizeof(buff));
-                /* Don't worry if inserting a double slash, this will be fixed by
-                 * absolutize() later with subsequent calls to open() or readdir() */
-                snprintf(buff, PATH_MAX - 1, "%s/%s", d, dp->d_name);
-                ls_print(dp->d_name, buff);
-        }
-
+                if (nbdirs + 1 > alloc_blocks) {
+                        alloc_blocks += alloc_blocks;
+                        
+                        tmp = (struct dir_elem_t *) realloc(tosort,
+                            alloc_blocks * sizeof(struct dir_elem_t));
+                        if (!tmp) {
+                                cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
+                                goto out;
+                        }
+                        tosort = tmp;
+                }
+                
+                /* fill the name field */
+                tosort[nbdirs].name = (char *) malloc(str_length(dp->d_name) + 1);
+                if (!tosort[nbdirs].name) {
+                        cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
+                        goto out;
+                }
+                
+                str_cpy(tosort[nbdirs].name, str_length(dp->d_name) + 1, dp->d_name);
+                len = snprintf(buff, PATH_MAX - 1, "%s/%s", d, tosort[nbdirs].name);
+                buff[len] = '\0';
+
+                rc = stat(buff, &tosort[nbdirs++].s);
+                if (rc != 0) {
+                        printf("ls: skipping bogus node %s\n", buff);
+                        printf("rc=%d\n", rc);
+                        goto out;
+                }
+        }
+        
+        if (sort) {
+                if (!qsort(&tosort[0], nbdirs, sizeof(struct dir_elem_t),
+                    ls_cmp, NULL)) {
+                        printf("Sorting error.\n");
+                }
+        }
+        
+        for (i = 0; i < nbdirs; i++)
+                ls_print(&tosort[i]);
+        
+out:
+        for(i = 0; i < nbdirs; i++)
+                free(tosort[i].name);
+        free(tosort);
         free(buff);
-
-        return;
-}
-
-/* ls_print currently does nothing more than print the entry.
- * in the future, we will likely pass the absolute path, and
- * some sort of ls_options structure that controls how each
- * entry is printed and what is printed about it.
- *
- * Now we just print basic DOS style lists */
-
-static void ls_print(const char *name, const char *pathname)
-{
-        struct stat s;
-        int rc;
-
-        rc = stat(pathname, &s);
-        if (rc != 0) {
-                /* Odd chance it was deleted from the time readdir() found it */
-                printf("ls: skipping bogus node %s\n", pathname);
-                printf("rc=%d\n", rc);
-                return;
-        }
-        
-        if (s.is_file)
-                printf("%-40s\t%llu\n", name, (long long) s.size);
-        else if (s.is_directory)
-                printf("%-40s\t<dir>\n", name);
-        else
-                printf("%-40s\n", name);
-
-        return;
 }
 
@@ -114 +212 @@
         } else {
                 help_cmd_ls(HELP_SHORT);
-                printf("  `%s' [path], if no path is given the current "
-                                "working directory is used.\n", cmdname);
+                printf(
+                "Usage:  %s [options] [path]\n"
+                "If not path is given, the current working directory is used.\n"
+                "Options:\n"
+                "  -h, --help       A short option summary\n"
+                "  -u, --unsort     Do not sort directory entries\n",
+                cmdname);
         }
 
@@ -124 +227 @@
 {
         unsigned int argc;
-        struct stat s;
-        char *buff;
+        struct dir_elem_t de;
         DIR *dirp;
+        int c, opt_ind;
+        int sort = 1;
 
         argc = cli_count_args(argv);
-
-        buff = (char *) malloc(PATH_MAX);
-        if (NULL == buff) {
+        
+        for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
+                c = getopt_long(argc, argv, "hu", long_options, &opt_ind);
+                switch (c) {
+                case 'h':
+                        help_cmd_ls(HELP_LONG);
+                        return CMD_SUCCESS;
+                case 'u':
+                        sort = 0;
+                        break;
+                }
+        }
+        
+        argc -= optind;
+        
+        de.name = (char *) malloc(PATH_MAX);
+        if (!de.name) {
                 cli_error(CL_ENOMEM, "%s: ", cmdname);
                 return CMD_FAILURE;
         }
-        memset(buff, 0, sizeof(buff));
-
-        if (argc == 1)
-                getcwd(buff, PATH_MAX);
+        memset(de.name, 0, sizeof(PATH_MAX));
+        
+        if (argc == 0)
+                getcwd(de.name, PATH_MAX);
         else
-                str_cpy(buff, PATH_MAX, argv[1]);
-
-        if (stat(buff, &s)) {
-                cli_error(CL_ENOENT, buff);
-                free(buff);
+                str_cpy(de.name, PATH_MAX, argv[optind]);
+        
+        if (stat(de.name, &de.s)) {
+                cli_error(CL_ENOENT, de.name);
+                free(de.name);
                 return CMD_FAILURE;
         }
 
-        if (s.is_file) {
-                ls_print(buff, buff);
+        if (de.s.is_file) {
+                ls_print(&de);
         } else {
-                dirp = opendir(buff);
+                dirp = opendir(de.name);
                 if (!dirp) {
                         /* May have been deleted between scoping it and opening it */
-                        cli_error(CL_EFAIL, "Could not stat %s", buff);
-                        free(buff);
+                        cli_error(CL_EFAIL, "Could not stat %s", de.name);
+                        free(de.name);
                         return CMD_FAILURE;
                 }
-                ls_scan_dir(buff, dirp);
+                ls_scan_dir(de.name, dirp, sort);
                 closedir(dirp);
         }
 
-        free(buff);
+        free(de.name);
 
         return CMD_SUCCESS;

uspace/app/init/init.c

@@ -314 +314 @@
         getterm("term/vc6", "/app/klog", false);
 
+#ifdef CONFIG_START_DEVMAN
+
 #ifdef CONFIG_DEVMAN_EARLY_LAUNCH
         spawn("/srv/devman");
@@ -320 +322 @@
 #endif
 
+#endif
+
         return 0;
 }

uspace/app/tester/Makefile

@@ -54 +54 @@
         mm/malloc1.c \
         mm/mapping1.c \
+        devs/devman1.c \
         hw/misc/virtchar1.c \
         hw/serial/serial1.c

uspace/app/tester/tester.c

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

uspace/app/tester/tester.h

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

uspace/drv/isa/isa.c

@@ -53 +53 @@
 
 #include <ddf/driver.h>
+#include <ddf/log.h>
 #include <ops/hw_res.h>
 
@@ -134 +135 @@
         fd = open(conf_path, O_RDONLY);
         if (fd < 0) {
-                printf(NAME ": unable to open %s\n", conf_path);
+                ddf_msg(LVL_ERROR, "Unable to open %s", conf_path);
                 goto cleanup;
         }
@@ -141 +142 @@
 
         len = lseek(fd, 0, SEEK_END);
-        lseek(fd, 0, SEEK_SET); 
+        lseek(fd, 0, SEEK_SET);
         if (len == 0) {
-                printf(NAME ": fun_conf_read error: configuration file '%s' "
-                    "is empty.\n", conf_path);
+                ddf_msg(LVL_ERROR, "Configuration file '%s' is empty.",
+                    conf_path);
                 goto cleanup;
         }
@@ -150 +151 @@
         buf = malloc(len + 1);
         if (buf == NULL) {
-                printf(NAME ": fun_conf_read error: memory allocation failed.\n");
+                ddf_msg(LVL_ERROR, "Memory allocation failed.");
                 goto cleanup;
         }
 
         if (0 >= read(fd, buf, len)) {
-                printf(NAME ": fun_conf_read error: unable to read file '%s'.\n",
-                    conf_path);
+                ddf_msg(LVL_ERROR, "Unable to read file '%s'.", conf_path);
                 goto cleanup;
         }
@@ -252 +252 @@
                 fun->hw_resources.count++;
 
-                printf(NAME ": added irq 0x%x to function %s\n", irq,
+                ddf_msg(LVL_NOTE, "Added irq 0x%x to function %s", irq,
                     fun->fnode->name);
         }
@@ -270 +270 @@
                 fun->hw_resources.count++;
 
-                printf(NAME ": added io range (addr=0x%x, size=0x%x) to "
-                    "function %s\n", (unsigned int) addr, (unsigned int) len,
+                ddf_msg(LVL_NOTE, "Added io range (addr=0x%x, size=0x%x) to "
+                    "function %s", (unsigned int) addr, (unsigned int) len,
                     fun->fnode->name);
         }
@@ -331 +331 @@
         score = (int)strtol(val, &end, 10);
         if (val == end) {
-                printf(NAME " : error - could not read match score for "
-                    "function %s.\n", fun->fnode->name);
+                ddf_msg(LVL_ERROR, "Cannot read match score for function "
+                    "%s.", fun->fnode->name);
                 return;
         }
@@ -339 +339 @@
         get_match_id(&id, val);
         if (id == NULL) {
-                printf(NAME " : error - could not read match id for "
-                    "function %s.\n", fun->fnode->name);
+                ddf_msg(LVL_ERROR, "Cannot read match ID for function %s.",
+                    fun->fnode->name);
                 return;
         }
 
-        printf(NAME ": adding match id '%s' with score %d to function %s\n", id,
-            score, fun->fnode->name);
+        ddf_msg(LVL_DEBUG, "Adding match id '%s' with score %d to "
+            "function %s", id, score, fun->fnode->name);
 
         rc = ddf_fun_add_match_id(fun->fnode, id, score);
-        if (rc != EOK)
-                printf(NAME ": error adding match ID: %s\n", str_error(rc));
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "Failed adding match ID: %s",
+                    str_error(rc));
+        }
 }
 
@@ -375 +377 @@
         if (!prop_parse(fun, line, "io_range", &fun_parse_io_range) &&
             !prop_parse(fun, line, "irq", &fun_parse_irq) &&
-            !prop_parse(fun, line, "match", &fun_parse_match_id))
-        {
-            printf(NAME " error undefined device property at line '%s'\n",
-                line);
+            !prop_parse(fun, line, "match", &fun_parse_match_id)) {
+
+                ddf_msg(LVL_ERROR, "Undefined device property at line '%s'",
+                    line);
         }
 }
@@ -439 +441 @@
         fun->fnode->ops = &isa_fun_ops;
 
-        printf(NAME ": Binding function %s.\n", fun->fnode->name);
+        ddf_msg(LVL_DEBUG, "Binding function %s.", fun->fnode->name);
 
         /* XXX Handle error */
@@ -467 +469 @@
 static int isa_add_device(ddf_dev_t *dev)
 {
-        printf(NAME ": isa_add_device, device handle = %d\n",
+        ddf_msg(LVL_DEBUG, "isa_add_device, device handle = %d",
             (int) dev->handle);
 
         /* Make the bus device more visible. Does not do anything. */
-        printf(NAME ": adding a 'ctl' function\n");
+        ddf_msg(LVL_DEBUG, "Adding a 'ctl' function");
 
         ddf_fun_t *ctl = ddf_fun_create(dev, fun_exposed, "ctl");
         if (ctl == NULL) {
-                printf(NAME ": Error creating control function.\n");
+                ddf_msg(LVL_ERROR, "Failed creating control function.");
                 return EXDEV;
         }
 
         if (ddf_fun_bind(ctl) != EOK) {
-                printf(NAME ": Error binding control function.\n");
+                ddf_msg(LVL_ERROR, "Failed binding control function.");
                 return EXDEV;
         }
@@ -486 +488 @@
         /* Add functions as specified in the configuration file. */
         isa_functions_add(dev);
-        printf(NAME ": finished the enumeration of legacy functions\n");
+        ddf_msg(LVL_NOTE, "Finished enumerating legacy functions");
 
         return EOK;
@@ -493 +495 @@
 static void isa_init() 
 {
+        ddf_log_init(NAME, LVL_ERROR);
         isa_fun_ops.interfaces[HW_RES_DEV_IFACE] = &isa_fun_hw_res_ops;
 }

uspace/drv/ns8250/ns8250.c

@@ -55 +55 @@
 #include <ddf/driver.h>
 #include <ddf/interrupt.h>
+#include <ddf/log.h>
 #include <ops/char_dev.h>
 
@@ -275 +276 @@
 static bool ns8250_pio_enable(ns8250_t *ns)
 {
-        printf(NAME ": ns8250_pio_enable %s\n", ns->dev->name);
+        ddf_msg(LVL_DEBUG, "ns8250_pio_enable %s", ns->dev->name);
         
         /* Gain control over port's registers. */
         if (pio_enable((void *)(uintptr_t) ns->io_addr, REG_COUNT,
             (void **) &ns->port)) {
-                printf(NAME ": error - cannot gain the port %#" PRIx32 " for device "
-                    "%s.\n", ns->io_addr, ns->dev->name);
+                ddf_msg(LVL_ERROR, "Cannot map the port %#" PRIx32
+                    " for device %s.", ns->io_addr, ns->dev->name);
                 return false;
         }
@@ -295 +296 @@
 static bool ns8250_dev_probe(ns8250_t *ns)
 {
-        printf(NAME ": ns8250_dev_probe %s\n", ns->dev->name);
+        ddf_msg(LVL_DEBUG, "ns8250_dev_probe %s", ns->dev->name);
         
         ioport8_t *port_addr = ns->port;
@@ -313 +314 @@
         pio_write_8(port_addr + 4, olddata);
         
-        if (!res)
-                printf(NAME ": device %s is not present.\n", ns->dev->name);
+        if (!res) {
+                ddf_msg(LVL_DEBUG, "Device %s is not present.",
+                    ns->dev->name);
+        }
         
         return res;
@@ -326 +329 @@
 static int ns8250_dev_initialize(ns8250_t *ns)
 {
-        printf(NAME ": ns8250_dev_initialize %s\n", ns->dev->name);
+        ddf_msg(LVL_DEBUG, "ns8250_dev_initialize %s", ns->dev->name);
         
         int ret = EOK;
@@ -337 +340 @@
             IPC_FLAG_BLOCKING);
         if (ns->dev->parent_phone < 0) {
-                printf(NAME ": failed to connect to the parent driver of the "
-                    "device %s.\n", ns->dev->name);
+                ddf_msg(LVL_ERROR, "Failed to connect to parent driver of "
+                    "device %s.", ns->dev->name);
                 ret = ns->dev->parent_phone;
                 goto failed;
@@ -346 +349 @@
         ret = hw_res_get_resource_list(ns->dev->parent_phone, &hw_resources);
         if (ret != EOK) {
-                printf(NAME ": failed to get hw resources for the device "
-                    "%s.\n", ns->dev->name);
+                ddf_msg(LVL_ERROR, "Failed to get HW resources for device "
+                    "%s.", ns->dev->name);
                 goto failed;
         }
@@ -362 +365 @@
                         ns->irq = res->res.interrupt.irq;
                         irq = true;
-                        printf(NAME ": the %s device was asigned irq = 0x%x.\n",
+                        ddf_msg(LVL_NOTE, "Device %s was asigned irq = 0x%x.",
                             ns->dev->name, ns->irq);
                         break;
@@ -369 +372 @@
                         ns->io_addr = res->res.io_range.address;
                         if (res->res.io_range.size < REG_COUNT) {
-                                printf(NAME ": i/o range assigned to the device "
-                                    "%s is too small.\n", ns->dev->name);
+                                ddf_msg(LVL_ERROR, "I/O range assigned to "
+                                    "device %s is too small.", ns->dev->name);
                                 ret = ELIMIT;
                                 goto failed;
                         }
                         ioport = true;
-                        printf(NAME ": the %s device was asigned i/o address = "
-                            "0x%x.\n", ns->dev->name, ns->io_addr);
-                        break;
+                        ddf_msg(LVL_NOTE, "Device %s was asigned I/O address = "
+                            "0x%x.", ns->dev->name, ns->io_addr);
+                        break;
                         
                 default:
@@ -385 +388 @@
         
         if (!irq || !ioport) {
-                printf(NAME ": missing hw resource(s) for the device %s.\n",
+                ddf_msg(LVL_ERROR, "Missing HW resource(s) for device %s.",
                     ns->dev->name);
                 ret = ENOENT;
@@ -470 +473 @@
         
         if (baud_rate < 50 || MAX_BAUD_RATE % baud_rate != 0) {
-                printf(NAME ": error - somebody tried to set invalid baud rate "
-                    "%d\n", baud_rate);
+                ddf_msg(LVL_ERROR, "Invalid baud rate %d requested.",
+                    baud_rate);
                 return EINVAL;
         }
@@ -654 +657 @@
                         if (ns->client_connected) {
                                 if (!buf_push_back(&ns->input_buffer, val)) {
-                                        printf(NAME ": buffer overflow on "
-                                            "%s.\n", ns->dev->name);
+                                        ddf_msg(LVL_WARN, "Buffer overflow on "
+                                            "%s.", ns->dev->name);
                                 } else {
-                                        printf(NAME ": the character %c saved "
-                                            "to the buffer of %s.\n",
+                                        ddf_msg(LVL_DEBUG2, "Character %c saved "
+                                            "to the buffer of %s.",
                                             val, ns->dev->name);
                                 }
@@ -714 +717 @@
         int rc;
         
-        printf(NAME ": ns8250_add_device %s (handle = %d)\n",
+        ddf_msg(LVL_DEBUG, "ns8250_add_device %s (handle = %d)",
             dev->name, (int) dev->handle);
         
@@ -749 +752 @@
         /* Register interrupt handler. */
         if (ns8250_register_interrupt_handler(ns) != EOK) {
-                printf(NAME ": failed to register interrupt handler.\n");
+                ddf_msg(LVL_ERROR, "Failed to register interrupt handler.");
                 rc = EADDRNOTAVAIL;
                 goto fail;
@@ -757 +760 @@
         rc = ns8250_interrupt_enable(ns);
         if (rc != EOK) {
-                printf(NAME ": failed to enable the interrupt. Error code = "
-                    "%d.\n", rc);
+                ddf_msg(LVL_ERROR, "Failed to enable the interrupt. Error code = "
+                    "%d.", rc);
                 goto fail;
         }
@@ -764 +767 @@
         fun = ddf_fun_create(dev, fun_exposed, "a");
         if (fun == NULL) {
-                printf(NAME ": error creating function.\n");
+                ddf_msg(LVL_ERROR, "Failed creating function.");
                 goto fail;
         }
@@ -772 +775 @@
         rc = ddf_fun_bind(fun);
         if (rc != EOK) {
-                printf(NAME ": error binding function.\n");
+                ddf_msg(LVL_ERROR, "Failed binding function.");
                 goto fail;
         }
@@ -780 +783 @@
         ddf_fun_add_to_class(fun, "serial");
         
-        printf(NAME ": the %s device has been successfully initialized.\n",
+        ddf_msg(LVL_NOTE, "Device %s successfully initialized.",
             dev->name);
         
@@ -862 +865 @@
         fibril_mutex_unlock(&data->mutex);
         
-        printf(NAME ": ns8250_get_props: baud rate %d, parity 0x%x, word "
-            "length %d, stop bits %d\n", *baud_rate, *parity, *word_length,
+        ddf_msg(LVL_DEBUG, "ns8250_get_props: baud rate %d, parity 0x%x, word "
+            "length %d, stop bits %d", *baud_rate, *parity, *word_length,
             *stop_bits);
 }
@@ -879 +882 @@
     unsigned int parity, unsigned int word_length, unsigned int stop_bits)
 {
-        printf(NAME ": ns8250_set_props: baud rate %d, parity 0x%x, word "
-            "length %d, stop bits %d\n", baud_rate, parity, word_length,
+        ddf_msg(LVL_DEBUG, "ns8250_set_props: baud rate %d, parity 0x%x, word "
+            "length %d, stop bits %d", baud_rate, parity, word_length,
             stop_bits);
         
@@ -940 +943 @@
 static void ns8250_init(void)
 {
+        ddf_log_init(NAME, LVL_ERROR);
+        
         ns8250_dev_ops.open = &ns8250_open;
         ns8250_dev_ops.close = &ns8250_close;

uspace/drv/ohci/hc.c

@@ -45 +45 @@
 
 static int interrupt_emulator(hc_t *instance);
+static void hc_gain_control(hc_t *instance);
+static void hc_init_hw(hc_t *instance);
 /*----------------------------------------------------------------------------*/
 int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun)
@@ -58 +60 @@
 
         char *match_str = NULL;
-        int ret = asprintf(&match_str, "usb&mid");
+        int ret = asprintf(&match_str, "usb&class=hub");
         ret = (match_str == NULL) ? ret : EOK;
         if (ret < 0) {
@@ -77 +79 @@
         assert(instance);
         int ret = EOK;
+#define CHECK_RET_RETURN(ret, message...) \
+if (ret != EOK) { \
+        usb_log_error(message); \
+        return ret; \
+} else (void)0
 
         ret = pio_enable((void*)regs, reg_size, (void**)&instance->registers);
-        if (ret != EOK) {
-                usb_log_error("Failed to gain access to device registers.\n");
-                return ret;
-        }
+        CHECK_RET_RETURN(ret,
+            "Failed(%d) to gain access to device registers: %s.\n",
+            ret, str_error(ret));
+
         instance->ddf_instance = fun;
         usb_device_keeper_init(&instance->manager);
+        ret = bandwidth_init(&instance->bandwidth, BANDWIDTH_AVAILABLE_USB11,
+            bandwidth_count_usb11);
+        CHECK_RET_RETURN(ret, "Failed to initialize bandwidth allocator: %s.\n",
+            ret, str_error(ret));
 
         if (!interrupts) {
@@ -92 +103 @@
         }
 
+        hc_gain_control(instance);
+
         rh_init(&instance->rh, dev, instance->registers);
+
+        hc_init_hw(instance);
 
         /* TODO: implement */
@@ -117 +132 @@
                 rh_interrupt(&instance->rh);
 
+        usb_log_info("OHCI interrupt: %x.\n", status);
+
         /* TODO: Check for further interrupt causes */
         /* TODO: implement */
@@ -126 +143 @@
         usb_log_info("Started interrupt emulator.\n");
         while (1) {
-                uint32_t status = instance->registers->interrupt_status;
+                const uint32_t status = instance->registers->interrupt_status;
                 instance->registers->interrupt_status = status;
                 hc_interrupt(instance, status);
@@ -133 +150 @@
         return EOK;
 }
+/*----------------------------------------------------------------------------*/
+void hc_gain_control(hc_t *instance)
+{
+        assert(instance);
+        /* Interrupt routing enabled => smm driver is active */
+        if (instance->registers->control & C_IR) {
+                usb_log_info("Found SMM driver requesting ownership change.\n");
+                instance->registers->command_status |= CS_OCR;
+                while (instance->registers->control & C_IR) {
+                        async_usleep(1000);
+                }
+                usb_log_info("Ownership taken from SMM driver.\n");
+                return;
+        }
+
+        const unsigned hc_status =
+            (instance->registers->control >> C_HCFS_SHIFT) & C_HCFS_MASK;
+        /* Interrupt routing disabled && status != USB_RESET => BIOS active */
+        if (hc_status != C_HCFS_RESET) {
+                usb_log_info("Found BIOS driver.\n");
+                if (hc_status == C_HCFS_OPERATIONAL) {
+                        usb_log_info("HC operational(BIOS).\n");
+                        return;
+                }
+                /* HC is suspended assert resume for 20ms */
+                instance->registers->control &= (C_HCFS_RESUME << C_HCFS_SHIFT);
+                async_usleep(20000);
+                return;
+        }
+
+        /* HC is in reset (hw startup) => no other driver
+         * maintain reset for at least the time specified in USB spec (50 ms)*/
+        async_usleep(50000);
+}
+/*----------------------------------------------------------------------------*/
+void hc_init_hw(hc_t *instance)
+{
+        assert(instance);
+        const uint32_t fm_interval = instance->registers->fm_interval;
+        instance->registers->command_status = CS_HCR;
+        async_usleep(10);
+        instance->registers->fm_interval = fm_interval;
+        assert((instance->registers->command_status & CS_HCR) == 0);
+        /* hc is now in suspend state */
+        /* TODO: init HCCA block */
+        /* TODO: init queues */
+        /* TODO: enable queues */
+        /* TODO: enable interrupts */
+        /* TODO: set periodic start to 90% */
+
+        instance->registers->control &= (C_HCFS_OPERATIONAL << C_HCFS_SHIFT);
+        usb_log_info("OHCI HC up and running.\n");
+}
 /**
  * @}

uspace/drv/ohci/hc.h

@@ -42 +42 @@
 #include <usb/usb.h>
 #include <usb/host/device_keeper.h>
+#include <usb/host/bandwidth.h>
 #include <usbhc_iface.h>
 
@@ -54 +55 @@
         ddf_fun_t *ddf_instance;
         usb_device_keeper_t manager;
+        bandwidth_t bandwidth;
         fid_t interrupt_emulator;
 } hc_t;

uspace/drv/ohci/iface.c

@@ -151 +151 @@
     size_t max_packet_size, unsigned int interval)
 {
-        UNSUPPORTED("register_endpoint");
-
-        return ENOTSUP;
+        assert(fun);
+        hc_t *hc = fun_to_hc(fun);
+        assert(hc);
+        if (address == hc->rh.address)
+                return EOK;
+        const usb_speed_t speed =
+                usb_device_keeper_get_speed(&hc->manager, address);
+        const size_t size = max_packet_size;
+        usb_log_debug("Register endpoint %d:%d %s %s(%d) %zu(%zu) %u.\n",
+            address, endpoint, usb_str_transfer_type(transfer_type),
+            usb_str_speed(speed), direction, size, max_packet_size, interval);
+        return bandwidth_reserve(&hc->bandwidth, address, endpoint, direction,
+            speed, transfer_type, max_packet_size, size, interval);
 }
 /*----------------------------------------------------------------------------*/
@@ -168 +178 @@
     usb_endpoint_t endpoint, usb_direction_t direction)
 {
-        UNSUPPORTED("unregister_endpoint");
+        assert(fun);
+        hc_t *hc = fun_to_hc(fun);
+        assert(hc);
+        usb_log_debug("Unregister endpoint %d:%d %d.\n",
+            address, endpoint, direction);
+        return bandwidth_release(&hc->bandwidth, address, endpoint, direction);
 
         return ENOTSUP;

uspace/drv/ohci/ohci.c

@@ -31 +31 @@
  */
 /** @file
- * @brief UHCI driver
+ * @brief OHCI driver
  */
 #include <errno.h>
@@ -117 +117 @@
 /** Initialize hc and rh ddf structures and their respective drivers.
  *
- * @param[in] instance UHCI structure to use.
+ * @param[in] instance OHCI structure to use.
  * @param[in] device DDF instance of the device to use.
  *
  * This function does all the preparatory work for hc and rh drivers:
  *  - gets device hw resources
- *  - disables UHCI legacy support
+ *  - disables OHCI legacy support
  *  - asks for interrupt
  *  - registers interrupt handler
@@ -185 +185 @@
         ret = ddf_fun_bind(instance->hc_fun);
         CHECK_RET_DEST_FUN_RETURN(ret,
-            "Failed(%d) to bind UHCI device function: %s.\n",
+            "Failed(%d) to bind OHCI device function: %s.\n",
             ret, str_error(ret));
 #undef CHECK_RET_HC_RETURN
@@ -216 +216 @@
         ret = ddf_fun_bind(instance->rh_fun);
         CHECK_RET_FINI_RETURN(ret,
-            "Failed(%d) to register UHCI root hub.\n", ret);
+            "Failed(%d) to register OHCI root hub.\n", ret);
 
         return EOK;

uspace/drv/ohci/ohci_regs.h

@@ -39 +39 @@
 typedef struct ohci_regs
 {
-        volatile uint32_t revision;
+        const volatile uint32_t revision;
         volatile uint32_t control;
+#define C_CSBR_MASK (0x3)
+#define C_CSBR_SHIFT (0)
+#define C_PLE (1 << 2)
+#define C_IE (1 << 3)
+#define C_CLE (1 << 4)
+#define C_BLE (1 << 5)
+
+#define C_HCFS_MASK (0x3)
+#define C_HCFS_SHIFT (6)
+#define C_HCFS_RESET (0x0)
+#define C_HCFS_OPERATIONAL (0x1)
+#define C_HCFS_RESUME (0x2)
+#define C_HCFS_SUSPEND (0x3)
+
+#define C_IR (1 << 8)
+#define C_RWC (1 << 9)
+#define C_RWE (1 << 10)
+
         volatile uint32_t command_status;
+#define CS_HCR (1 << 0)
+#define CS_CLF (1 << 1)
+#define CS_BLF (1 << 2)
+#define CS_OCR (1 << 3)
+#define CS_SOC_MASK (0x3)
+#define CS_SOC_SHIFT (16)
+
         volatile uint32_t interrupt_status;
 #define IS_SO (1 << 0)
@@ -51 +76 @@
 #define IS_RHSC (1 << 6)
 #define IS_OC (1 << 30)
+
         volatile uint32_t interupt_enable;
 #define IE_SO   (1 << 0)

uspace/drv/ohci/root_hub.c

@@ -40 +40 @@
 #include "root_hub.h"
 #include "usb/classes/classes.h"
+#include "usb/devdrv.h"
 #include <usb/request.h>
 #include <usb/classes/hub.h>
@@ -61 +62 @@
                 /// \TODO these values migt be different
                 .str_serial_number = 0,
-                .usb_spec_version = 0,
+                .usb_spec_version = 0x110,
 };
 
@@ -110 +111 @@
 };
 
-/** Root hub initialization
- * @return Error code.
- */
-int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs)
-{
-        assert(instance);
-        instance->address = -1;
-        instance->registers = regs;
-        instance->device = dev;
-
-
-        usb_log_info("OHCI root hub with %d ports.\n", regs->rh_desc_a & 0xff);
-
-        //start generic usb hub driver
+static const uint32_t hub_clear_feature_valid_mask =
+        (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) +
+        (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
+
+static const uint32_t hub_clear_feature_by_writing_one_mask =
+        1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER;
+
+static const uint32_t hub_set_feature_valid_mask =
+        (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
+
         
-        /* 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;
-
-}
+static const uint32_t hub_set_feature_direct_mask =
+        (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
+
+static const uint32_t port_set_feature_valid_mask =
+        (1 << USB_HUB_FEATURE_PORT_ENABLE) +
+        (1 << USB_HUB_FEATURE_PORT_SUSPEND) +
+        (1 << USB_HUB_FEATURE_PORT_RESET) +
+        (1 << USB_HUB_FEATURE_PORT_POWER);
+
+static const uint32_t port_clear_feature_valid_mask =
+        (1 << USB_HUB_FEATURE_PORT_CONNECTION) +
+        (1 << USB_HUB_FEATURE_PORT_SUSPEND) +
+        (1 << USB_HUB_FEATURE_PORT_OVER_CURRENT) +
+        (1 << USB_HUB_FEATURE_PORT_POWER) +
+        (1 << USB_HUB_FEATURE_C_PORT_CONNECTION) +
+        (1 << USB_HUB_FEATURE_C_PORT_ENABLE) +
+        (1 << USB_HUB_FEATURE_C_PORT_SUSPEND) +
+        (1 << USB_HUB_FEATURE_C_PORT_OVER_CURRENT) +
+        (1 << USB_HUB_FEATURE_C_PORT_RESET);
+//note that USB_HUB_FEATURE_PORT_POWER bit is translated into USB_HUB_FEATURE_PORT_LOW_SPEED
+
+
+
 
 /**
  * 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.
@@ -197 +173 @@
         result[2] = instance->port_count;
         uint32_t hub_desc_reg = instance->registers->rh_desc_a;
-        result[3] = 
+        result[3] =
                         ((hub_desc_reg >> 8) %2) +
                         (((hub_desc_reg >> 9) %2) << 1) +
@@ -219 +195 @@
         (*out_size) = size;
 }
+
+
+/** initialize hub descriptors
+ *
+ * Initialized are device and full configuration descriptor. These need to
+ * be initialized only once per hub.
+ * @instance root hub instance
+ */
+static void rh_init_descriptors(rh_t *instance){
+        memcpy(&instance->descriptors.device, &ohci_rh_device_descriptor,
+                sizeof(ohci_rh_device_descriptor)
+        );
+        usb_standard_configuration_descriptor_t descriptor;
+        memcpy(&descriptor,&ohci_rh_conf_descriptor,
+                        sizeof(ohci_rh_conf_descriptor));
+        uint8_t * hub_descriptor;
+        size_t hub_desc_size;
+        usb_create_serialized_hub_descriptor(instance, &hub_descriptor,
+                        &hub_desc_size);
+
+        descriptor.total_length =
+                        sizeof(usb_standard_configuration_descriptor_t)+
+                        sizeof(usb_standard_endpoint_descriptor_t)+
+                        sizeof(usb_standard_interface_descriptor_t)+
+                        hub_desc_size;
+        
+        uint8_t * full_config_descriptor =
+                        (uint8_t*) malloc(descriptor.total_length);
+        memcpy(full_config_descriptor, &descriptor, sizeof(descriptor));
+        memcpy(full_config_descriptor + sizeof(descriptor),
+                        &ohci_rh_iface_descriptor, sizeof(ohci_rh_iface_descriptor));
+        memcpy(full_config_descriptor + sizeof(descriptor) +
+                                sizeof(ohci_rh_iface_descriptor),
+                        &ohci_rh_ep_descriptor, sizeof(ohci_rh_ep_descriptor));
+        memcpy(full_config_descriptor + sizeof(descriptor) +
+                                sizeof(ohci_rh_iface_descriptor) +
+                                sizeof(ohci_rh_ep_descriptor),
+                        hub_descriptor, hub_desc_size);
+        
+        instance->descriptors.configuration = full_config_descriptor;
+        instance->descriptors.configuration_size = descriptor.total_length;
+}
+
+/** Root hub initialization
+ * @return Error code.
+ */
+int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs)
+{
+        assert(instance);
+        instance->address = -1;
+        instance->registers = regs;
+        instance->device = dev;
+        instance->port_count = instance->registers->rh_desc_a & 0xff;
+        rh_init_descriptors(instance);
+        /// \TODO set port power mode
+
+
+        usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
+
+        //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->transport_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->transport_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;
+
+}
+
 
 
@@ -284 +366 @@
         }
 }
-
-/**
- * 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
@@ -344 +403 @@
                 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;
+                        result_descriptor = instance->descriptors.configuration;
+                        size = instance->descriptors.configuration_size;
                         break;
                 }
@@ -380 +435 @@
         }
         request->transfered_size = size;
-        memcpy(request->buffer,result_descriptor,size);
+        memcpy(request->transport_buffer,result_descriptor,size);
+        usb_log_debug("sent desctiptor: %s\n",
+                        usb_debug_str_buffer((uint8_t*)request->transport_buffer,size,size));
         if (del)
                 free(result_descriptor);
@@ -400 +457 @@
         if(request->buffer_size != 1)
                 return EINVAL;
-        request->buffer[0] = 1;
+        request->transport_buffer[0] = 1;
         request->transfered_size = 1;
         return EOK;
@@ -406 +463 @@
 
 /**
- * process feature-enabling/disabling request on hub
+ * process feature-enabling 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)
+                uint16_t feature){
+        if(! ((1<<feature) & hub_set_feature_valid_mask))
                 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
+                        & (~ hub_clear_feature_by_writing_one_mask);
+        return EOK;
+}
+
+/**
+ * process feature-disabling request on hub
+ *
+ * @param instance root hub instance
+ * @param feature feature selector
+ * @return error code
+ */
+static int process_hub_feature_clear_request(rh_t *instance,
+                uint16_t feature){
+        if(! ((1<<feature) & hub_clear_feature_valid_mask))
+                return EINVAL;
+        //is the feature cleared directly?
+        if ((1<<feature) & hub_set_feature_direct_mask){
+                instance->registers->rh_status =
+                        (instance->registers->rh_status & (~(1<<feature)))
+                        & (~ hub_clear_feature_by_writing_one_mask);
+        }else{//the feature is cleared by writing '1'
+                instance->registers->rh_status =
+                                (instance->registers->rh_status
+                                & (~ hub_clear_feature_by_writing_one_mask))
+                                | (1<<feature);
+        }
+        return EOK;
+}
+
+
+
+/**
+ * process feature-enabling request on hub
  * 
  * @param instance root hub instance
@@ -436 +516 @@
  */
 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)
+                uint16_t feature, uint16_t port){
+        if(!((1<<feature) & port_set_feature_valid_mask))
                 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)));
+                        & (~port_clear_feature_valid_mask);
         /// \TODO any error?
         return EOK;
 }
+
+/**
+ * process feature-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_clear_request(rh_t *instance,
+                uint16_t feature, uint16_t port){
+        if(!((1<<feature) & port_clear_feature_valid_mask))
+                return EINVAL;
+        if(port<1 || port>instance->port_count)
+                return EINVAL;
+        if(feature == USB_HUB_FEATURE_PORT_POWER)
+                feature = USB_HUB_FEATURE_PORT_LOW_SPEED;
+        if(feature == USB_HUB_FEATURE_PORT_SUSPEND)
+                feature = USB_HUB_FEATURE_PORT_OVER_CURRENT;
+        instance->registers->rh_port_status[port - 1] =
+                        (instance->registers->rh_port_status[port - 1] 
+                        & (~port_clear_feature_valid_mask))
+                        | (1<<feature);
+        /// \TODO any error?
+        return EOK;
+}
+
 
 /**
@@ -530 +636 @@
                         (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 == USB_DEVREQ_CLEAR_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);
+                        return process_hub_feature_clear_request(instance,
+                                        setup_request->value);
                 }
                 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);
+                        return process_port_feature_clear_request(instance,
+                                        setup_request->value,
+                                        setup_request->index);
+                }
+                usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",
+                                setup_request->request_type);
+                return EINVAL;
+        }
+        if(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);
+                }
+                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);
                 }
                 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",setup_request->request_type);

uspace/drv/ohci/root_hub.h

@@ -37 +37 @@
 
 #include <usb/usb.h>
+#include <usb/devdrv.h>
 
 #include "ohci_regs.h"
@@ -53 +54 @@
         /** hub port count */
         int port_count;
+        /** hubs descriptors */
+        usb_device_descriptors_t descriptors;
 } rh_t;
 

uspace/drv/pciintel/pci.c

@@ -48 +48 @@
 
 #include <ddf/driver.h>
+#include <ddf/log.h>
 #include <devman.h>
 #include <ipc/devman.h>
@@ -325 +326 @@
 
         if (match_id_str == NULL) {
-                printf(NAME ": out of memory creating match ID.\n");
+                ddf_msg(LVL_ERROR, "Out of memory creating match ID.");
                 return;
         }
@@ -331 +332 @@
         rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 90);
         if (rc != EOK) {
-                printf(NAME ": error adding match ID: %s\n",
+                ddf_msg(LVL_ERROR, "Failed adding match ID: %s",
                     str_error(rc));
         }
@@ -428 +429 @@
         
         if (range_addr != 0) {
-                printf(NAME ": function %s : ", fun->fnode->name);
-                printf("address = %" PRIx64, range_addr);
-                printf(", size = %x\n", (unsigned int) range_size);
+                ddf_msg(LVL_DEBUG, "Function %s : address = %" PRIx64
+                    ", size = %x", fun->fnode->name, range_addr,
+                    (unsigned int) range_size);
         }
         
@@ -455 +456 @@
         hw_res_list->count++;
         
-        printf(NAME ": function %s uses irq %x.\n", fun->fnode->name, irq);
+        ddf_msg(LVL_NOTE, "Function %s uses irq %x.", fun->fnode->name, irq);
 }
 
@@ -511 +512 @@
                         char *fun_name = pci_fun_create_name(fun);
                         if (fun_name == NULL) {
-                                printf(NAME ": out of memory.\n");
+                                ddf_msg(LVL_ERROR, "Out of memory.");
                                 return;
                         }
@@ -517 +518 @@
                         fnode = ddf_fun_create(bus->dnode, fun_inner, fun_name);
                         if (fnode == NULL) {
-                                printf(NAME ": error creating function.\n");
+                                ddf_msg(LVL_ERROR, "Failed creating function.");
                                 return;
                         }
@@ -531 +532 @@
                         fnode->driver_data = fun;
                         
-                        printf(NAME ": adding new function %s.\n",
+                        ddf_msg(LVL_DEBUG, "Adding new function %s.",
                             fnode->name);
                         
@@ -548 +549 @@
                                 child_bus = pci_conf_read_8(fun,
                                     PCI_BRIDGE_SEC_BUS_NUM);
-                                printf(NAME ": device is pci-to-pci bridge, "
-                                    "secondary bus number = %d.\n", bus_num);
+                                ddf_msg(LVL_DEBUG, "Device is pci-to-pci "
+                                    "bridge, secondary bus number = %d.",
+                                    bus_num);
                                 if (child_bus > bus_num)
                                         pci_bus_scan(bus, child_bus);
@@ -571 +573 @@
         int rc;
         
-        printf(NAME ": pci_add_device\n");
+        ddf_msg(LVL_DEBUG, "pci_add_device");
         dnode->parent_phone = -1;
         
         bus = pci_bus_new();
         if (bus == NULL) {
-                printf(NAME ": pci_add_device allocation failed.\n");
+                ddf_msg(LVL_ERROR, "pci_add_device allocation failed.");
                 rc = ENOMEM;
                 goto fail;
@@ -586 +588 @@
             IPC_FLAG_BLOCKING);
         if (dnode->parent_phone < 0) {
-                printf(NAME ": pci_add_device failed to connect to the "
-                    "parent's driver.\n");
+                ddf_msg(LVL_ERROR, "pci_add_device failed to connect to the "
+                    "parent's driver.");
                 rc = dnode->parent_phone;
                 goto fail;
@@ -596 +598 @@
         rc = hw_res_get_resource_list(dnode->parent_phone, &hw_resources);
         if (rc != EOK) {
-                printf(NAME ": pci_add_device failed to get hw resources for "
-                    "the device.\n");
+                ddf_msg(LVL_ERROR, "pci_add_device failed to get hw resources "
+                    "for the device.");
                 goto fail;
         }
         got_res = true;
         
-        printf(NAME ": conf_addr = %" PRIx64 ".\n",
+        ddf_msg(LVL_DEBUG, "conf_addr = %" PRIx64 ".",
             hw_resources.resources[0].res.io_range.address);
         
@@ -614 +616 @@
         if (pio_enable((void *)(uintptr_t)bus->conf_io_addr, 8,
             &bus->conf_addr_port)) {
-                printf(NAME ": failed to enable configuration ports.\n");
+                ddf_msg(LVL_ERROR, "Failed to enable configuration ports.");
                 rc = EADDRNOTAVAIL;
                 goto fail;
@@ -621 +623 @@
         
         /* Make the bus device more visible. It has no use yet. */
-        printf(NAME ": adding a 'ctl' function\n");
+        ddf_msg(LVL_DEBUG, "Adding a 'ctl' function");
         
         ctl = ddf_fun_create(bus->dnode, fun_exposed, "ctl");
         if (ctl == NULL) {
-                printf(NAME ": error creating control function.\n");
+                ddf_msg(LVL_ERROR, "Failed creating control function.");
                 rc = ENOMEM;
                 goto fail;
@@ -632 +634 @@
         rc = ddf_fun_bind(ctl);
         if (rc != EOK) {
-                printf(NAME ": error binding control function.\n");
+                ddf_msg(LVL_ERROR, "Failed binding control function.");
                 goto fail;
         }
         
         /* Enumerate functions. */
-        printf(NAME ": scanning the bus\n");
+        ddf_msg(LVL_DEBUG, "Scanning the bus");
         pci_bus_scan(bus, 0);
         
@@ -659 +661 @@
 static void pciintel_init(void)
 {
+        ddf_log_init(NAME, LVL_ERROR);
         pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops;
         pci_fun_ops.interfaces[PCI_DEV_IFACE] = &pci_dev_ops;
@@ -738 +741 @@
 int main(int argc, char *argv[])
 {
-        printf(NAME ": HelenOS pci bus driver (intel method 1).\n");
+        printf(NAME ": HelenOS PCI bus driver (Intel method 1).\n");
         pciintel_init();
         return ddf_driver_main(&pci_driver);

uspace/drv/root/root.c

@@ -52 +52 @@
 
 #include <ddf/driver.h>
+#include <ddf/log.h>
 #include <devman.h>
 #include <ipc/devman.h>
@@ -89 +90 @@
         int rc;
 
-        printf(NAME ": adding new function for virtual devices.\n");
-        printf(NAME ":   function node is `%s' (%d %s)\n", name,
+        ddf_msg(LVL_DEBUG, "Adding new function for virtual devices. "
+            "Function node is `%s' (%d %s)", name,
             VIRTUAL_FUN_MATCH_SCORE, VIRTUAL_FUN_MATCH_ID);
 
         fun = ddf_fun_create(dev, fun_inner, name);
         if (fun == NULL) {
-                printf(NAME ": error creating function %s\n", name);
+                ddf_msg(LVL_ERROR, "Failed creating function %s", name);
                 return ENOMEM;
         }
@@ -102 +103 @@
             VIRTUAL_FUN_MATCH_SCORE);
         if (rc != EOK) {
-                printf(NAME ": error adding match IDs to function %s\n", name);
+                ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s",
+                    name);
                 ddf_fun_destroy(fun);
                 return rc;
@@ -109 +111 @@
         rc = ddf_fun_bind(fun);
         if (rc != EOK) {
-                printf(NAME ": error binding function %s: %s\n", name,
+                ddf_msg(LVL_ERROR, "Failed binding function %s: %s", name,
                     str_error(rc));
                 ddf_fun_destroy(fun);
@@ -136 +138 @@
         platform = sysinfo_get_data("platform", &platform_size);
         if (platform == NULL) {
-                printf(NAME ": Failed to obtain platform name.\n");
+                ddf_msg(LVL_ERROR, "Failed to obtain platform name.");
                 return ENOENT;
         }
@@ -143 +145 @@
         platform = realloc(platform, platform_size + 1);
         if (platform == NULL) {
-                printf(NAME ": Memory allocation failed.\n");
+                ddf_msg(LVL_ERROR, "Memory allocation failed.");
                 return ENOMEM;
         }
@@ -151 +153 @@
         /* Construct match ID. */
         if (asprintf(&match_id, PLATFORM_FUN_MATCH_ID_FMT, platform) == -1) {
-                printf(NAME ": Memory allocation failed.\n");
+                ddf_msg(LVL_ERROR, "Memory allocation failed.");
                 return ENOMEM;
         }
 
         /* Add function. */
-        printf(NAME ": adding platform function\n");
-        printf(NAME ":   function node is `%s' (%d %s)\n", PLATFORM_FUN_NAME,
-            PLATFORM_FUN_MATCH_SCORE, match_id);
+        ddf_msg(LVL_DEBUG, "Adding platform function. Function node is `%s' "
+            " (%d %s)", PLATFORM_FUN_NAME, PLATFORM_FUN_MATCH_SCORE,
+            match_id);
 
         fun = ddf_fun_create(dev, fun_inner, name);
         if (fun == NULL) {
-                printf(NAME ": error creating function %s\n", name);
+                ddf_msg(LVL_ERROR, "Error creating function %s", name);
                 return ENOMEM;
         }
@@ -168 +170 @@
         rc = ddf_fun_add_match_id(fun, match_id, PLATFORM_FUN_MATCH_SCORE);
         if (rc != EOK) {
-                printf(NAME ": error adding match IDs to function %s\n", name);
+                ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s",
+                    name);
                 ddf_fun_destroy(fun);
                 return rc;
@@ -175 +178 @@
         rc = ddf_fun_bind(fun);
         if (rc != EOK) {
-                printf(NAME ": error binding function %s: %s\n", name,
+                ddf_msg(LVL_ERROR, "Failed binding function %s: %s", name,
                     str_error(rc));
                 ddf_fun_destroy(fun);
@@ -191 +194 @@
 static int root_add_device(ddf_dev_t *dev)
 {
-        printf(NAME ": root_add_device, device handle=%" PRIun "\n",
+        ddf_msg(LVL_DEBUG, "root_add_device, device handle=%" PRIun,
             dev->handle);
 
@@ -204 +207 @@
         int res = add_platform_fun(dev);
         if (EOK != res)
-                printf(NAME ": failed to add child device for platform.\n");
+                ddf_msg(LVL_ERROR, "Failed adding child device for platform.");
 
         return res;
@@ -212 +215 @@
 {
         printf(NAME ": HelenOS root device driver\n");
+
+        ddf_log_init(NAME, LVL_ERROR);
         return ddf_driver_main(&root_driver);
 }

uspace/drv/rootpc/rootpc.c

@@ -47 +47 @@
 
 #include <ddf/driver.h>
+#include <ddf/log.h>
 #include <devman.h>
 #include <ipc/devman.h>
@@ -119 +120 @@
     rootpc_fun_t *fun)
 {
-        printf(NAME ": adding new function '%s'.\n", name);
+        ddf_msg(LVL_DEBUG, "Adding new function '%s'.", name);
         
         ddf_fun_t *fnode = NULL;
@@ -145 +146 @@
         /* Register function. */
         if (ddf_fun_bind(fnode) != EOK) {
-                printf(NAME ": error binding function %s.\n", name);
+                ddf_msg(LVL_ERROR, "Failed binding function %s.", name);
                 goto failure;
         }
@@ -158 +159 @@
                 ddf_fun_destroy(fnode);
         
-        printf(NAME ": failed to add function '%s'.\n", name);
+        ddf_msg(LVL_ERROR, "Failed adding function '%s'.", name);
         
         return false;
@@ -176 +177 @@
 static int rootpc_add_device(ddf_dev_t *dev)
 {
-        printf(NAME ": rootpc_add_device, device handle = %d\n",
+        ddf_msg(LVL_DEBUG, "rootpc_add_device, device handle = %d",
             (int)dev->handle);
         
         /* Register functions. */
         if (!rootpc_add_functions(dev)) {
-                printf(NAME ": failed to add functions for PC platform.\n");
+                ddf_msg(LVL_ERROR, "Failed to add functions for PC platform.");
         }
         
@@ -189 +190 @@
 static void root_pc_init(void)
 {
+        ddf_log_init(NAME, LVL_ERROR);
         rootpc_fun_ops.interfaces[HW_RES_DEV_IFACE] = &fun_hw_res_ops;
 }

uspace/drv/rootvirt/rootvirt.c

@@ -40 +40 @@
 #include <str_error.h>
 #include <ddf/driver.h>
+#include <ddf/log.h>
 
 #define NAME "rootvirt"
@@ -83 +84 @@
         int rc;
 
-        printf(NAME ": registering function `%s' (match \"%s\")\n",
+        ddf_msg(LVL_DEBUG, "Registering function `%s' (match \"%s\")",
             vfun->name, vfun->match_id);
 
         fun = ddf_fun_create(vdev, fun_inner, vfun->name);
         if (fun == NULL) {
-                printf(NAME ": error creating function %s\n", vfun->name);
+                ddf_msg(LVL_ERROR, "Failed creating function %s", vfun->name);
                 return ENOMEM;
         }
@@ -94 +95 @@
         rc = ddf_fun_add_match_id(fun, vfun->match_id, 10);
         if (rc != EOK) {
-                printf(NAME ": error adding match IDs to function %s\n",
+                ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s",
                     vfun->name);
                 ddf_fun_destroy(fun);
@@ -102 +103 @@
         rc = ddf_fun_bind(fun);
         if (rc != EOK) {
-                printf(NAME ": error binding function %s: %s\n", vfun->name,
-                    str_error(rc));
+                ddf_msg(LVL_ERROR, "Failed binding function %s: %s",
+                    vfun->name, str_error(rc));
                 ddf_fun_destroy(fun);
                 return rc;
         }
 
-        printf(NAME ": registered child device `%s'\n", vfun->name);
+        ddf_msg(LVL_NOTE, "Registered child device `%s'", vfun->name);
         return EOK;
 }
@@ -124 +125 @@
         }
 
-        printf(NAME ": add_device(handle=%d)\n", (int)dev->handle);
+        ddf_msg(LVL_DEBUG, "add_device(handle=%d)", (int)dev->handle);
 
         /*
@@ -142 +143 @@
 {
         printf(NAME ": HelenOS virtual devices root driver\n");
+
+        ddf_log_init(NAME, LVL_ERROR);
         return ddf_driver_main(&rootvirt_driver);
 }

uspace/drv/test1/test1.c

@@ -35 +35 @@
 #include <str_error.h>
 #include <ddf/driver.h>
+#include <ddf/log.h>
 
 #include "test1.h"
@@ -58 +59 @@
  */
 static int register_fun_verbose(ddf_dev_t *parent, const char *message,
-    const char *name, const char *match_id, int match_score)
+    const char *name, const char *match_id, int match_score,
+    int expected_rc)
 {
-        ddf_fun_t *fun;
+        ddf_fun_t *fun = NULL;
         int rc;
 
-        printf(NAME ": registering function `%s': %s.\n", name, message);
+        ddf_msg(LVL_DEBUG, "Registering function `%s': %s.", name, message);
 
         fun = ddf_fun_create(parent, fun_inner, name);
         if (fun == NULL) {
-                printf(NAME ": error creating function %s\n", name);
-                return ENOMEM;
+                ddf_msg(LVL_ERROR, "Failed creating function %s", name);
+                rc = ENOMEM;
+                goto leave;
         }
 
-        rc = ddf_fun_add_match_id(fun, match_id, match_score);
+        rc = ddf_fun_add_match_id(fun, str_dup(match_id), match_score);
         if (rc != EOK) {
-                printf(NAME ": error adding match IDs to function %s\n", name);
-                ddf_fun_destroy(fun);
-                return rc;
+                ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s",
+                    name);
+                goto leave;
         }
 
         rc = ddf_fun_bind(fun);
         if (rc != EOK) {
-                printf(NAME ": error binding function %s: %s\n", name,
+                ddf_msg(LVL_ERROR, "Failed binding function %s: %s", name,
                     str_error(rc));
-                ddf_fun_destroy(fun);
-                return rc;
+                goto leave;
         }
 
-        printf(NAME ": registered child device `%s'\n", name);
-        return EOK;
+        ddf_msg(LVL_NOTE, "Registered child device `%s'", name);
+        rc = EOK;
+
+leave:
+        if (rc != expected_rc) {
+                fprintf(stderr,
+                    NAME ": Unexpected error registering function `%s'.\n" 
+                    NAME ":     Expected \"%s\" but got \"%s\".\n",
+                    name, str_error(expected_rc), str_error(rc));
+        }
+
+        if ((rc != EOK) && (fun != NULL)) {
+                ddf_fun_destroy(fun);
+        }
+
+        return rc;
 }
 
@@ -112 +128 @@
         int rc;
 
-        printf(NAME ": add_device(name=\"%s\", handle=%d)\n",
+        ddf_msg(LVL_DEBUG, "add_device(name=\"%s\", handle=%d)",
             dev->name, (int) dev->handle);
 
         fun_a = ddf_fun_create(dev, fun_exposed, "a");
         if (fun_a == NULL) {
-                printf(NAME ": error creating function 'a'.\n");
+                ddf_msg(LVL_ERROR, "Failed creating function 'a'.");
                 return ENOMEM;
         }
@@ -123 +139 @@
         rc = ddf_fun_bind(fun_a);
         if (rc != EOK) {
-                printf(NAME ": error binding function 'a'.\n");
+                ddf_msg(LVL_ERROR, "Failed binding function 'a'.");
                 return rc;
         }
@@ -133 +149 @@
                 ddf_fun_add_to_class(fun_a, "virt-null");
         } else if (str_cmp(dev->name, "test1") == 0) {
-                (void) register_fun_verbose(dev, "cloning myself ;-)", "clone",
-                    "virtual&test1", 10);
+                (void) register_fun_verbose(dev,
+                    "cloning myself ;-)", "clone",
+                    "virtual&test1", 10, EOK);
+                (void) register_fun_verbose(dev,
+                    "cloning myself twice ;-)", "clone",
+                    "virtual&test1", 10, EEXISTS);
         } else if (str_cmp(dev->name, "clone") == 0) {
-                (void) register_fun_verbose(dev, "run by the same task", "child",
-                    "virtual&test1&child", 10);
+                (void) register_fun_verbose(dev,
+                    "run by the same task", "child",
+                    "virtual&test1&child", 10, EOK);
         }
 
-        printf(NAME ": device `%s' accepted.\n", dev->name);
+        ddf_msg(LVL_DEBUG, "Device `%s' accepted.", dev->name);
 
         return EOK;
@@ -148 +169 @@
 {
         printf(NAME ": HelenOS test1 virtual device driver\n");
+        ddf_log_init(NAME, LVL_ERROR);
         return ddf_driver_main(&test1_driver);
 }

uspace/drv/test2/test2.c

@@ -36 +36 @@
 #include <str_error.h>
 #include <ddf/driver.h>
+#include <ddf/log.h>
 
 #define NAME "test2"
@@ -64 +65 @@
         int rc;
 
-        printf(NAME ": registering function `%s': %s.\n", name, message);
+        ddf_msg(LVL_DEBUG, "Registering function `%s': %s.", name, message);
 
         fun = ddf_fun_create(parent, fun_inner, name);
         if (fun == NULL) {
-                printf(NAME ": error creating function %s\n", name);
+                ddf_msg(LVL_ERROR, "Failed creating function %s", name);
                 return ENOMEM;
         }
@@ -74 +75 @@
         rc = ddf_fun_add_match_id(fun, match_id, match_score);
         if (rc != EOK) {
-                printf(NAME ": error adding match IDs to function %s\n", name);
+                ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s",
+                    name);
                 ddf_fun_destroy(fun);
                 return rc;
@@ -81 +83 @@
         rc = ddf_fun_bind(fun);
         if (rc != EOK) {
-                printf(NAME ": error binding function %s: %s\n", name,
+                ddf_msg(LVL_ERROR, "Failed binding function %s: %s", name,
                     str_error(rc));
                 ddf_fun_destroy(fun);
@@ -87 +89 @@
         }
 
-        printf(NAME ": registered child device `%s'\n", name);
+        ddf_msg(LVL_NOTE, "Registered child device `%s'", name);
         return EOK;
 }
@@ -111 +113 @@
         fun_a = ddf_fun_create(dev, fun_exposed, "a");
         if (fun_a == NULL) {
-                printf(NAME ": error creating function 'a'.\n");
+                ddf_msg(LVL_ERROR, "Failed creating function 'a'.");
                 return ENOMEM;
         }
@@ -117 +119 @@
         rc = ddf_fun_bind(fun_a);
         if (rc != EOK) {
-                printf(NAME ": error binding function 'a'.\n");
+                ddf_msg(LVL_ERROR, "Failed binding function 'a'.");
                 return rc;
         }
@@ -128 +130 @@
 static int test2_add_device(ddf_dev_t *dev)
 {
-        printf(NAME ": test2_add_device(name=\"%s\", handle=%d)\n",
+        ddf_msg(LVL_DEBUG, "test2_add_device(name=\"%s\", handle=%d)",
             dev->name, (int) dev->handle);
 
@@ -134 +136 @@
                 fid_t postpone = fibril_create(postponed_birth, dev);
                 if (postpone == 0) {
-                        printf(NAME ": fibril_create() error\n");
+                        ddf_msg(LVL_ERROR, "fibril_create() failed.");
                         return ENOMEM;
                 }
@@ -149 +151 @@
 {
         printf(NAME ": HelenOS test2 virtual device driver\n");
+        ddf_log_init(NAME, LVL_ERROR);
         return ddf_driver_main(&test2_driver);
 }

uspace/drv/uhci-hcd/hc.c

@@ -239 +239 @@
         usb_log_debug("Initialized device manager.\n");
 
+        ret = bandwidth_init(&instance->bandwidth, BANDWIDTH_AVAILABLE_USB11,
+            bandwidth_count_usb11);
+        assert(ret == EOK);
+
         return EOK;
 #undef CHECK_RET_DEST_CMDS_RETURN
@@ -325 +329 @@
         if (!usb_is_allowed(
             low_speed, batch->transfer_type, batch->max_packet_size)) {
-                usb_log_warning(
-                    "Invalid USB transfer specified %s SPEED %d %zu.\n",
-                    low_speed ? "LOW" : "FULL" , batch->transfer_type,
+                usb_log_error("Invalid USB transfer specified %s %d %zu.\n",
+                    usb_str_speed(batch->speed), batch->transfer_type,
                     batch->max_packet_size);
                 return ENOTSUP;
         }
-        /* TODO: check available bandwidth here */
+        /* Check available bandwidth */
+        if (batch->transfer_type == USB_TRANSFER_INTERRUPT ||
+            batch->transfer_type == USB_TRANSFER_ISOCHRONOUS) {
+                int ret =
+                    bandwidth_use(&instance->bandwidth, batch->target.address,
+                    batch->target.endpoint, batch->direction);
+                if (ret != EOK) {
+                        usb_log_warning("Failed(%d) to use reserved bw: %s.\n",
+                            ret, str_error(ret));
+                }
+        }
 
         transfer_list_t *list =
@@ -338 +351 @@
         if (batch->transfer_type == USB_TRANSFER_CONTROL) {
                 usb_device_keeper_use_control(
-                    &instance->manager, batch->target.address);
+                    &instance->manager, batch->target);
         }
         transfer_list_add_batch(list, batch);
@@ -358 +371 @@
 {
         assert(instance);
+//      status |= 1; //Uncomment to work around qemu hang
         /* TODO: Resume interrupts are not supported */
         /* Lower 2 bits are transaction error and transaction complete */
@@ -376 +390 @@
                         usb_transfer_batch_t *batch =
                             list_get_instance(item, usb_transfer_batch_t, link);
-                        if (batch->transfer_type == USB_TRANSFER_CONTROL) {
+                        switch (batch->transfer_type)
+                        {
+                        case USB_TRANSFER_CONTROL:
                                 usb_device_keeper_release_control(
-                                    &instance->manager, batch->target.address);
+                                    &instance->manager, batch->target);
+                                break;
+                        case USB_TRANSFER_INTERRUPT:
+                        case USB_TRANSFER_ISOCHRONOUS: {
+                                int ret = bandwidth_free(&instance->bandwidth,
+                                    batch->target.address,
+                                    batch->target.endpoint,
+                                    batch->direction);
+                                if (ret != EOK)
+                                        usb_log_warning("Failed(%d) to free "
+                                            "reserved bw: %s.\n", ret,
+                                            str_error(ret));
+                                }
+                        default:
+                                break;
                         }
                         batch->next_step(batch);

uspace/drv/uhci-hcd/hc.h

@@ -43 +43 @@
 #include <usbhc_iface.h>
 #include <usb/host/device_keeper.h>
+#include <usb/host/bandwidth.h>
 
 #include "batch.h"
@@ -84 +85 @@
 typedef struct hc {
         usb_device_keeper_t manager;
+        bandwidth_t bandwidth;
 
         regs_t *registers;

uspace/drv/uhci-hcd/iface.c

@@ -128 +128 @@
 }
 /*----------------------------------------------------------------------------*/
+static int register_endpoint(
+    ddf_fun_t *fun, usb_address_t address, usb_endpoint_t endpoint,
+    usb_transfer_type_t transfer_type, usb_direction_t direction,
+    size_t max_packet_size, unsigned int interval)
+{
+        hc_t *hc = fun_to_hc(fun);
+        assert(hc);
+        const usb_speed_t speed =
+            usb_device_keeper_get_speed(&hc->manager, address);
+        size_t size = max_packet_size;
+
+        usb_log_debug("Register endpoint %d:%d %s %s(%d) %zu(%zu) %u.\n",
+            address, endpoint, usb_str_transfer_type(transfer_type),
+            usb_str_speed(speed), direction, size, max_packet_size, interval);
+        return bandwidth_reserve(&hc->bandwidth, address, endpoint, direction,
+            speed, transfer_type, max_packet_size, size, interval);
+}
+/*----------------------------------------------------------------------------*/
+static int unregister_endpoint(
+    ddf_fun_t *fun, usb_address_t address,
+    usb_endpoint_t endpoint, usb_direction_t direction)
+{
+        hc_t *hc = fun_to_hc(fun);
+        assert(hc);
+        usb_log_debug("Unregister endpoint %d:%d %d.\n",
+            address, endpoint, direction);
+        return bandwidth_release(&hc->bandwidth, address, endpoint, direction);
+}
+/*----------------------------------------------------------------------------*/
 /** Interrupt out transaction interface function
  *
@@ -365 +394 @@
         .release_address = release_address,
 
+        .register_endpoint = register_endpoint,
+        .unregister_endpoint = unregister_endpoint,
+
         .interrupt_out = interrupt_out,
         .interrupt_in = interrupt_in,

uspace/drv/usbhub/port_status.h

@@ -95 +95 @@
 }
 
+/**
+ * set the device request to be a port feature clear request
+ * @param request
+ * @param port
+ * @param feature_selector
+ */
+static inline void usb_hub_set_disable_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_CLEAR_FEATURE;
+        request->value = feature_selector;
+        request->length = 0;
+}
 
 /**

uspace/drv/usbhub/usbhub.c

@@ -74 +74 @@
 
         while(errorCode == EOK){
+                async_usleep(1000 * 1000 * 10 );/// \TODO proper number once
                 errorCode = usb_hub_check_hub_changes(hub_info);
-                async_usleep(1000 * 1000 );/// \TODO proper number once
         }
         usb_log_error("something in ctrl loop went wrong, errno %d\n",errorCode);
@@ -317 +317 @@
                         //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);
+                                usb_hub_set_disable_port_feature_request(&request, port,
+                                                USB_HUB_FEATURE_PORT_CONNECTION);
                                 opResult = usb_pipe_control_read(
                                                 hub->control_pipe,
@@ -326 +326 @@
                                 if (opResult != EOK) {
                                         usb_log_warning(
-                                                        "could not set port change on port %d errno:%d\n",
+                                                        "could not clear port connection on port %d errno:%d\n",
                                                         port, opResult);
                                 }
+                                usb_log_debug("cleared port connection\n");
+                                usb_hub_set_enable_port_feature_request(&request, port,
+                                                USB_HUB_FEATURE_PORT_ENABLE);
+                                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 enabled on port %d errno:%d\n",
+                                                        port, opResult);
+                                }
+                                usb_log_debug("port set to enabled - should lead to connection change\n");
                         }
+                }
+        }
+        /// \TODO this is just a debug code
+        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("port %d is non-removable\n",port);
+                        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_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 %d\n",opResult);
+                        }
+                        if (rcvd_size != sizeof (usb_port_status_t)) {
+                                usb_log_error("received status has incorrect size\n");
+                        }
+                        //something connected/disconnected
+                        if (usb_port_connect_change(&status)) {
+                                usb_log_debug("some connection changed\n");
+                        }
+                        usb_log_debug("status: %s\n",usb_debug_str_buffer(
+                                        (uint8_t *)&status,4,4));
                 }
         }
@@ -582 +627 @@
         //something connected/disconnected
         if (usb_port_connect_change(&status)) {
+                usb_log_debug("connection change on port\n");
                 if (usb_port_dev_connected(&status)) {
                         usb_log_debug("some connection changed\n");
@@ -592 +638 @@
         if (usb_port_overcurrent_change(&status)) {
                 //check if it was not auto-resolved
+                usb_log_debug("overcurrent change on port\n");
                 if(usb_port_over_current(&status)){
                         usb_hub_over_current(hub,port);
@@ -608 +655 @@
                 }
         }
+        usb_log_debug("status %x\n ",status);
 
         usb_port_set_connect_change(&status, false);

uspace/drv/usbkbd/kbddev.c

@@ -56 +56 @@
 #include <usb/classes/hidreq.h>
 #include <usb/classes/hidreport.h>
+#include <usb/classes/hid/utled.h>
 
 #include <usb/devdrv.h>
@@ -69 +70 @@
 static const unsigned DEFAULT_ACTIVE_MODS = KM_NUM_LOCK;
 
-/** Boot protocol report size (key part). */
-static const size_t BOOTP_REPORT_SIZE = 6;
-
-/** Boot protocol total report size. */
-static const size_t BOOTP_BUFFER_SIZE = 8;
-
-/** Boot protocol output report size. */
-static const size_t BOOTP_BUFFER_OUT_SIZE = 1;
-
-/** Boot protocol error key code. */
-static const uint8_t BOOTP_ERROR_ROLLOVER = 1;
+///** Boot protocol report size (key part). */
+//static const size_t BOOTP_REPORT_SIZE = 6;
+
+///** Boot protocol total report size. */
+//static const size_t BOOTP_BUFFER_SIZE = 8;
+
+///** Boot protocol output report size. */
+//static const size_t BOOTP_BUFFER_OUT_SIZE = 1;
+
+///** Boot protocol error key code. */
+//static const uint8_t BOOTP_ERROR_ROLLOVER = 1;
+static const uint8_t ERROR_ROLLOVER = 1;
 
 /** Default idle rate for keyboards. */
@@ -263 +265 @@
 static void usb_kbd_set_led(usb_kbd_t *kbd_dev) 
 {
-        uint8_t buffer[BOOTP_BUFFER_OUT_SIZE];
-        int rc= 0;
-        
-        memset(buffer, 0, BOOTP_BUFFER_OUT_SIZE);
-        uint8_t leds = 0;
-
-        if (kbd_dev->mods & KM_NUM_LOCK) {
-                leds |= USB_HID_LED_NUM_LOCK;
-        }
-        
-        if (kbd_dev->mods & KM_CAPS_LOCK) {
-                leds |= USB_HID_LED_CAPS_LOCK;
-        }
-        
-        if (kbd_dev->mods & KM_SCROLL_LOCK) {
-                leds |= USB_HID_LED_SCROLL_LOCK;
+        unsigned i = 0;
+        
+        /* Reset the LED data. */
+        memset(kbd_dev->led_data, 0, kbd_dev->led_output_size * sizeof(int32_t));
+        
+        if ((kbd_dev->mods & KM_NUM_LOCK) && (i < kbd_dev->led_output_size)) {
+                kbd_dev->led_data[i++] = USB_HID_LED_NUM_LOCK;
+        }
+        
+        if ((kbd_dev->mods & KM_CAPS_LOCK) && (i < kbd_dev->led_output_size)) {
+                kbd_dev->led_data[i++] = USB_HID_LED_CAPS_LOCK;
+        }
+        
+        if ((kbd_dev->mods & KM_SCROLL_LOCK) 
+            && (i < kbd_dev->led_output_size)) {
+                kbd_dev->led_data[i++] = USB_HID_LED_SCROLL_LOCK;
         }
 
@@ -284 +286 @@
         
         usb_log_debug("Creating output report.\n");
-        usb_log_debug("Leds: 0x%x\n", leds);
-        if ((rc = usb_hid_boot_keyboard_output_report(
-            leds, buffer, BOOTP_BUFFER_OUT_SIZE)) != EOK) {
-                usb_log_warning("Error composing output report to the keyboard:"
-                    "%s.\n", str_error(rc));
+        
+        int rc = usb_hid_report_output_translate(kbd_dev->parser, 
+            kbd_dev->led_path, USB_HID_PATH_COMPARE_END, kbd_dev->output_buffer, 
+            kbd_dev->output_size, kbd_dev->led_data, kbd_dev->led_output_size);
+        
+        if (rc != EOK) {
+                usb_log_warning("Error translating LED output to output report"
+                    ".\n");
                 return;
         }
         
         usb_log_debug("Output report buffer: %s\n", 
-            usb_debug_str_buffer(buffer, BOOTP_BUFFER_OUT_SIZE, 0));
-        
-        assert(kbd_dev->usb_dev != NULL);
+            usb_debug_str_buffer(kbd_dev->output_buffer, kbd_dev->output_size, 
+                0));
         
         usbhid_req_set_report(&kbd_dev->usb_dev->ctrl_pipe, 
             kbd_dev->usb_dev->interface_no, USB_HID_REPORT_TYPE_OUTPUT, 
-            buffer, BOOTP_BUFFER_OUT_SIZE);
+            kbd_dev->output_buffer, kbd_dev->output_size);
 }
 
@@ -450 +454 @@
          * First of all, check if the kbd have reported phantom state.
          *
-         *  this must be changed as we don't know which keys are modifiers
-         *       and which are regular keys.
+         * As there is no way to distinguish keys from modifiers, we do not have
+         * a way to check that 'all keys report Error Rollover'. We thus check
+         * if there is at least one such error and in such case we ignore the
+         * whole input report.
          */
         i = 0;
-        // all fields should report Error Rollover
-        while (i < count &&
-            key_codes[i] == BOOTP_ERROR_ROLLOVER) {
+        while (i < count && key_codes[i] != ERROR_ROLLOVER) {
                 ++i;
         }
-        if (i == count) {
+        if (i != count) {
                 usb_log_debug("Phantom state occured.\n");
                 // phantom state, do nothing
@@ -586 +590 @@
  */
 static void usb_kbd_process_data(usb_kbd_t *kbd_dev,
-                                    uint8_t *buffer, size_t actual_size)
+                                 uint8_t *buffer, size_t actual_size)
 {
         assert(kbd_dev->initialized == USB_KBD_STATUS_INITIALIZED);
@@ -760 +764 @@
         usb_log_debug("Size of the input report: %zu\n", kbd_dev->key_count);
         
-        kbd_dev->keys = (uint8_t *)calloc(
-            kbd_dev->key_count, sizeof(uint8_t));
+        kbd_dev->keys = (uint8_t *)calloc(kbd_dev->key_count, sizeof(uint8_t));
         
         if (kbd_dev->keys == NULL) {
@@ -768 +771 @@
         }
         
+        /*
+         * Output report
+         */
+        kbd_dev->output_size = 0;
+        kbd_dev->output_buffer = usb_hid_report_output(kbd_dev->parser, 
+            &kbd_dev->output_size);
+        if (kbd_dev->output_buffer == NULL) {
+                usb_log_warning("Error creating output report buffer.\n");
+                free(kbd_dev->keys);
+                return ENOMEM;  /* TODO: other error code */
+        }
+        
+        usb_log_debug("Output buffer size: %zu\n", kbd_dev->output_size);
+        
+        kbd_dev->led_path = usb_hid_report_path();
+        usb_hid_report_path_append_item(
+            kbd_dev->led_path, USB_HIDUT_PAGE_LED, 0);
+        
+        kbd_dev->led_output_size = usb_hid_report_output_size(kbd_dev->parser, 
+            kbd_dev->led_path, USB_HID_PATH_COMPARE_END);
+        
+        usb_log_debug("Output report size (in items): %zu\n", 
+            kbd_dev->led_output_size);
+        
+        kbd_dev->led_data = (int32_t *)calloc(
+            kbd_dev->led_output_size, sizeof(int32_t));
+        
+        if (kbd_dev->led_data == NULL) {
+                usb_log_warning("Error creating buffer for LED output report."
+                    "\n");
+                free(kbd_dev->keys);
+                usb_hid_report_output_free(kbd_dev->output_buffer);
+                return ENOMEM;
+        }
+        
+        /*
+         * Modifiers and locks
+         */     
         kbd_dev->modifiers = 0;
         kbd_dev->mods = DEFAULT_ACTIVE_MODS;
         kbd_dev->lock_keys = 0;
         
+        /*
+         * Autorepeat
+         */     
         kbd_dev->repeat.key_new = 0;
         kbd_dev->repeat.key_repeated = 0;
@@ -879 +923 @@
         }
         
+        // free the output buffer
+        usb_hid_report_output_free((*kbd_dev)->output_buffer);
+        
         /* TODO: what about the USB device structure?? */
 

uspace/drv/usbkbd/kbddev.h

@@ -94 +94 @@
         /** Report descriptor size. */
         size_t report_desc_size;
+        
+        uint8_t *output_buffer;
+        
+        size_t output_size;
+        
+        size_t led_output_size;
+        
+        usb_hid_report_path_t *led_path;
+        
+        int32_t *led_data;
 
         /** HID Report parser. */

uspace/lib/c/Makefile

@@ -77 +77 @@
         generic/io/io.c \
         generic/io/printf.c \
+        generic/io/log.c \
         generic/io/klog.c \
         generic/io/snprintf.c \

uspace/lib/c/generic/adt/hash_table.c

@@ -54 +54 @@
  *
  */
-int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
+bool hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
     hash_table_operations_t *op)
 {

uspace/lib/c/generic/devman.c

@@ -147 +147 @@
                 ret = devman_send_match_id(phone, match_id);
                 if (ret != EOK) {
-                        printf("Driver failed to send match id, error %d\n",
-                            ret);
                         return ret;
                 }
@@ -195 +193 @@
         }
         
-        devman_send_match_ids(phone, match_ids);
-        
-        async_wait_for(req, &retval);
-        
-        async_serialize_end();
-        
+        int match_ids_rc = devman_send_match_ids(phone, match_ids);
+        
+        async_wait_for(req, &retval);
+        
+        async_serialize_end();
+        
+        /* Prefer the answer to DEVMAN_ADD_FUNCTION in case of errors. */
+        if ((match_ids_rc != EOK) && (retval == EOK)) {
+                retval = match_ids_rc;
+        }
+
         if (retval == EOK)
                 fun_handle = (int) IPC_GET_ARG1(answer);
@@ -326 +329 @@
 }
 
+int devman_device_get_handle_by_class(const char *classname,
+    const char *devname, devman_handle_t *handle, unsigned int flags)
+{
+        int phone = devman_get_phone(DEVMAN_CLIENT, flags);
+
+        if (phone < 0)
+                return phone;
+
+        async_serialize_start();
+
+        ipc_call_t answer;
+        aid_t req = async_send_1(phone, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
+            flags, &answer);
+
+        sysarg_t retval = async_data_write_start(phone, classname,
+            str_size(classname));
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
+                async_serialize_end();
+                return retval;
+        }
+        retval = async_data_write_start(phone, devname,
+            str_size(devname));
+        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 = (devman_handle_t) -1;
+                return retval;
+        }
+
+        if (handle != NULL)
+                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
+
+        return retval;
+}
+
 
 /** @}

uspace/lib/c/include/adt/hash_table.h

@@ -38 +38 @@
 #include <adt/list.h>
 #include <unistd.h>
+#include <bool.h>
 
 typedef unsigned long hash_count_t;
@@ -83 +84 @@
     list_get_instance((item), type, member)
 
-extern int hash_table_create(hash_table_t *, hash_count_t, hash_count_t,
+extern bool hash_table_create(hash_table_t *, hash_count_t, hash_count_t,
     hash_table_operations_t *);
 extern void hash_table_insert(hash_table_t *, unsigned long [], link_t *);

uspace/lib/c/include/devman.h

@@ -53 +53 @@
 extern int devman_device_get_handle(const char *, devman_handle_t *,
     unsigned int);
+extern int devman_device_get_handle_by_class(const char *, const char *,
+    devman_handle_t *, unsigned int);
 
 extern int devman_add_device_to_class(devman_handle_t, const char *);

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

@@ -148 +148 @@
 
 typedef enum {
-        DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD
+        DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD,
+        DEVMAN_DEVICE_GET_HANDLE_BY_CLASS
 } client_to_devman_t;
 

uspace/lib/drv/Makefile

@@ -36 +36 @@
         generic/dev_iface.c \
         generic/remote_char_dev.c \
+        generic/log.c \
         generic/remote_hw_res.c \
         generic/remote_usb.c \

uspace/lib/drv/generic/driver.c

@@ -273 +273 @@
         
         res = driver->driver_ops->add_device(dev);
-        if (res == EOK) {
-                printf("%s: new device with handle=%" PRIun " was added.\n",
-                    driver->name, dev_handle);
-        } else {
-                printf("%s: failed to add a new device with handle = %" PRIun ".\n",
-                    driver->name, dev_handle);
+        if (res != EOK)
                 delete_device(dev);
-        }
         
         async_answer_0(iid, res);

uspace/lib/usb/Makefile

@@ -53 +53 @@
         src/hidreport.c \
         src/host/device_keeper.c \
-        src/host/batch.c
+        src/host/batch.c \
+        src/host/bandwidth.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/lib/usb/include/usb/classes/hidparser.h

@@ -31 +31 @@
  */
 /** @file
- * @brief USB HID parser.
+ * USB HID report descriptor and report data parser
  */
 #ifndef LIBUSB_HIDPARSER_H_
@@ -74 +74 @@
 #define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY    4
 
+/** */
 typedef struct {
+        /** */
         int32_t usage_page;
+        /** */  
         int32_t usage;
-
+        /** */
         link_t link;
 } usb_hid_report_usage_path_t;
 
+/** */
 typedef struct {
+        /** */  
         int depth;      
+        
+        /** */  
         link_t link;
 } usb_hid_report_path_t;
@@ -90 +97 @@
  */
 typedef struct {
+        /** */  
         int32_t id;
+        /** */  
         int32_t usage_minimum;
+        /** */  
         int32_t usage_maximum;
+        /** */  
         int32_t logical_minimum;
+        /** */  
         int32_t logical_maximum;
+        /** */  
         int32_t size;
+        /** */  
         int32_t count;
+        /** */  
         size_t offset;
+        /** */  
         int32_t delimiter;
-
+        /** */  
         int32_t unit_exponent;
+        /** */  
         int32_t unit;
 
-        /*
-         * some not yet used fields
-         */
+        /** */
         int32_t string_index;
+        /** */  
         int32_t string_minimum;
+        /** */  
         int32_t string_maximum;
+        /** */  
         int32_t designator_index;
+        /** */  
         int32_t designator_minimum;
+        /** */  
         int32_t designator_maximum;
+        /** */  
         int32_t physical_minimum;
+        /** */  
         int32_t physical_maximum;
 
+        /** */  
         uint8_t item_flags;
 
+        /** */  
         usb_hid_report_path_t *usage_path;
+        /** */  
         link_t link;
 } usb_hid_report_item_t;
@@ -124 +149 @@
 /** HID report parser structure. */
 typedef struct {        
+        /** */  
         link_t input;
+        /** */  
         link_t output;
+        /** */  
         link_t feature;
 } usb_hid_report_parser_t;      
@@ -154 +182 @@
 } usb_hid_modifiers_t;
 
-typedef enum {
-        USB_HID_LED_NUM_LOCK = 0x1,
-        USB_HID_LED_CAPS_LOCK = 0x2,
-        USB_HID_LED_SCROLL_LOCK = 0x4,
-        USB_HID_LED_COMPOSE = 0x8,
-        USB_HID_LED_KANA = 0x10,
-        USB_HID_LED_COUNT = 5
-} usb_hid_led_t;
+//typedef enum {
+//      USB_HID_LED_NUM_LOCK = 0x1,
+//      USB_HID_LED_CAPS_LOCK = 0x2,
+//      USB_HID_LED_SCROLL_LOCK = 0x4,
+//      USB_HID_LED_COMPOSE = 0x8,
+//      USB_HID_LED_KANA = 0x10,
+//      USB_HID_LED_COUNT = 5
+//} usb_hid_led_t;
 
 static const usb_hid_modifiers_t 
@@ -190 +218 @@
 
 /*
- * modifiers definitions
- */
-
+ * Descriptor parser functions
+ */
+/** */
+int usb_hid_parser_init(usb_hid_report_parser_t *parser);
+
+/** */
+int usb_hid_parse_report_descriptor(usb_hid_report_parser_t *parser, 
+    const uint8_t *data, size_t size);
+
+/** */
+void usb_hid_free_report_parser(usb_hid_report_parser_t *parser);
+
+/** */
+void usb_hid_descriptor_print(usb_hid_report_parser_t *parser);
+
+/*
+ * Boot protocol functions
+ */
+/** */
 int usb_hid_boot_keyboard_input_report(const uint8_t *data, size_t size,
         const usb_hid_report_in_callbacks_t *callbacks, void *arg);
 
+/** */
 int usb_hid_boot_keyboard_output_report(uint8_t leds, uint8_t *data, size_t size);
 
-int usb_hid_parser_init(usb_hid_report_parser_t *parser);
-int usb_hid_parse_report_descriptor(usb_hid_report_parser_t *parser, 
-    const uint8_t *data, size_t size);
-
+
+/*
+ * Input report parser functions
+ */
+/** */
 int usb_hid_parse_report(const usb_hid_report_parser_t *parser,  
     const uint8_t *data, size_t size,
@@ -207 +253 @@
     const usb_hid_report_in_callbacks_t *callbacks, void *arg);
 
-int usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
+/** */
+size_t usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
         usb_hid_report_path_t *path, int flags);
 
 
-void usb_hid_free_report_parser(usb_hid_report_parser_t *parser);
-
-void usb_hid_descriptor_print(usb_hid_report_parser_t *parser);
-
-/* usage path functions */
+
+/* 
+ * usage path functions 
+ */
+/** */
 usb_hid_report_path_t *usb_hid_report_path(void);
+
+/** */
 void usb_hid_report_path_free(usb_hid_report_path_t *path);
+
+/** */
 int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, int32_t usage_page, int32_t usage);
+
+/** */
 void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path);
+
+/** */
 void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path);
+
+/** */
 void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data);
+
+/** */
 int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, usb_hid_report_path_t *path, int flags);
-int     usb_hid_report_path_clone(usb_hid_report_path_t *new_usage_path, usb_hid_report_path_t *usage_path);
-
-
-// output
-//      - funkce co vrati cesty poli v output reportu
-//      - funkce co pro danou cestu nastavi data
-//      - finalize
-
+
+/** */
+usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path);
+
+
+/*
+ * Output report parser functions
+ */
+/** Allocates output report buffer*/
+uint8_t *usb_hid_report_output(usb_hid_report_parser_t *parser, size_t *size);
+
+/** Frees output report buffer*/
+void usb_hid_report_output_free(uint8_t *output);
+
+/** Returns size of output for given usage path */
+size_t usb_hid_report_output_size(usb_hid_report_parser_t *parser,
+                                  usb_hid_report_path_t *path, int flags);
+
+/** Updates the output report buffer by translated given data */
+int usb_hid_report_output_translate(usb_hid_report_parser_t *parser,
+                                    usb_hid_report_path_t *path, int flags,
+                                    uint8_t *buffer, size_t size,
+                                    int32_t *data, size_t data_size);
 #endif
 /**

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

@@ -51 +51 @@
         usb_speed_t speed;
         bool occupied;
-        bool control_used;
+        uint16_t control_used;
         uint16_t toggle_status[2];
         devman_handle_t handle;
@@ -99 +99 @@
 
 void usb_device_keeper_use_control(usb_device_keeper_t *instance,
-    usb_address_t address);
+    usb_target_t target);
 
 void usb_device_keeper_release_control(usb_device_keeper_t *instance,
-    usb_address_t address);
+    usb_target_t target);
 
 #endif

uspace/lib/usb/src/devdrv.c

@@ -262 +262 @@
             &dev->descriptors.configuration_size);
         if (rc != EOK) {
-                usb_log_error("Failed retrieving configuration descriptor: %s.\n",
+                usb_log_error("Failed retrieving configuration descriptor: %s. %s\n",
                     dev->ddf_dev->name, str_error(rc));
                 return rc;

uspace/lib/usb/src/hidparser.c

@@ -31 +31 @@
  */
 /** @file
- * @brief HID parser implementation.
+ * HID report descriptor and report data parser implementation.
  */
 #include <usb/classes/hidparser.h>
@@ -40 +40 @@
 #include <usb/debug.h>
 
+/** */
 #define USB_HID_NEW_REPORT_ITEM 1
+
+/** */
 #define USB_HID_NO_ACTION               2
+
+/** */
 #define USB_HID_UNKNOWN_TAG             -99
 
-#define BAD_HACK_USAGE_PAGE             0x07
-
+/*
+ * Private descriptor parser functions
+ */
 int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size,
                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
@@ -58 +64 @@
 int usb_hid_report_reset_local_items();
 void usb_hid_free_report_list(link_t *head);
+
+/*
+ * Data translation private functions
+ */
 int32_t usb_hid_report_tag_data_int32(const uint8_t *data, size_t size);
 inline size_t usb_hid_count_item_offset(usb_hid_report_item_t * report_item, size_t offset);
 int usb_hid_translate_data(usb_hid_report_item_t *item, const uint8_t *data, size_t j);
+int32_t usb_hid_translate_data_reverse(usb_hid_report_item_t *item, int32_t value);
 int usb_pow(int a, int b);
 
-
+// TODO: tohle ma bejt asi jinde
 int usb_pow(int a, int b)
 {
@@ -80 +91 @@
 
 /**
- *
+ * Initialize the report descriptor parser structure
+ *
+ * @param parser Report descriptor parser structure
+ * @return Error code
  */
 int usb_hid_parser_init(usb_hid_report_parser_t *parser)
 {
-   if(parser == NULL) {
-        return EINVAL;
-   }
-
-    list_initialize(&(parser->input));
+        if(parser == NULL) {
+                return EINVAL;
+        }
+
+        list_initialize(&(parser->input));
     list_initialize(&(parser->output));
     list_initialize(&(parser->feature));
@@ -164 +178 @@
                                         // store current usage path
                                         report_item->usage_path = usage_path;
-
-                                        // new current usage path 
-                                        tmp_usage_path = usb_hid_report_path();
                                         
-                                        // copy old path to the new one
-                                        usb_hid_report_path_clone(tmp_usage_path, usage_path);
+                                        // clone path to the new one
+                                        tmp_usage_path = usb_hid_report_path_clone(usage_path);
 
                                         // swap
@@ -304 +315 @@
 
 /**
+ * Parse one tag of the report descriptor
  *
  * @param Tag to parse
@@ -391 +403 @@
  * @return Error code
  */
-
 int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size,
                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
@@ -520 +531 @@
  * Prints content of given list of report items.
  *
- * @param List of report items
+ * @param List of report items (usb_hid_report_item_t)
  * @return void
  */
@@ -552 +563 @@
                         path = path->next;
                 }
-                
-                
-//              usb_log_debug("\tUSAGE: %X\n", report_item->usage);
-//              usb_log_debug("\tUSAGE PAGE: %X\n", report_item->usage_page);
+                                
                 usb_log_debug("\tLOGMIN: %X\n", report_item->logical_minimum);
                 usb_log_debug("\tLOGMAX: %X\n", report_item->logical_maximum);          
@@ -570 +578 @@
 }
 /**
- * Prints content of given descriptor in human readable format.
- *
- * @param Parsed descriptor to print
+ * Prints content of given report descriptor in human readable format.
+ *
+ * @param parser Parsed descriptor to print
  * @return void
  */
@@ -595 +603 @@
  * Releases whole linked list of report items
  *
- * 
+ * @param head Head of list of report descriptor items (usb_hid_report_item_t)
+ * @return void
  */
 void usb_hid_free_report_list(link_t *head)
@@ -627 +636 @@
 }
 
-/** Free the HID report parser structure 
+/** Frees the HID report descriptor parser structure 
  *
  * @param parser Opaque HID report parser structure
- * @return Error code
+ * @return void
  */
 void usb_hid_free_report_parser(usb_hid_report_parser_t *parser)
@@ -660 +669 @@
     const usb_hid_report_in_callbacks_t *callbacks, void *arg)
 {
-        /*
-         *
-         * only key codes (usage page 0x07) will be processed
-         * other usages will be ignored 
-         */
         link_t *list_item;
         usb_hid_report_item_t *item;
@@ -676 +680 @@
                 return EINVAL;
         }
-
-        
-        // get the size of result keycodes array
+        
+        /* get the size of result array */
         key_count = usb_hid_report_input_length(parser, path, flags);
 
@@ -685 +688 @@
         }
 
-        // read data            
+        /* read data */
         list_item = parser->input.next;    
         while(list_item != &(parser->input)) {
@@ -719 +722 @@
 }
 
-
+/**
+ * Translate data from the report as specified in report descriptor
+ *
+ * @param item Report descriptor item with definition of translation
+ * @param data Data to translate
+ * @param j Index of processed field in report descriptor item
+ * @return Translated data
+ */
 int usb_hid_translate_data(usb_hid_report_item_t *item, const uint8_t *data, size_t j)
 {
@@ -796 +806 @@
 }
 
-int usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
+/**
+ *
+ *
+ * @param parser
+ * @param path
+ * @param flags
+ * @return
+ */
+size_t usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
         usb_hid_report_path_t *path, int flags)
 {       
-        int ret = 0;
+        size_t ret = 0;
         link_t *item;
         usb_hid_report_item_t *report_item;
 
         if(parser == NULL) {
-                return EINVAL;
-        }
-        
-        item = (&parser->input)->next;
+                return 0;
+        }
+        
+        item = parser->input.next;
         while(&parser->input != item) {
                 report_item = list_get_instance(item, usb_hid_report_item_t, link);
@@ -824 +842 @@
 /**
  * 
+ * @param usage_path
+ * @param usage_page
+ * @param usage
+ * @return
  */
 int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, 
@@ -845 +867 @@
 /**
  *
+ * @param usage_path
+ * @return
  */
 void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path)
@@ -860 +884 @@
 /**
  *
+ * @param usage_path
+ * @return
  */
 void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path)
@@ -873 +899 @@
 /**
  *
+ * @param usage_path
+ * @param tag
+ * @param data
+ * @return
  */
 void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data)
@@ -894 +924 @@
 
 /**
- *
+ * 
+ *
+ * @param report_path
+ * @param path
+ * @param flags
+ * @return
  */
 int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, 
@@ -949 +984 @@
                         break;
 
-                /* given path must be the end of the report one*/
+                /* compare with only the end of path*/
                 case USB_HID_PATH_COMPARE_END:
                                 report_link = report_path->link.prev;
@@ -992 +1027 @@
 /**
  *
+ * @return
  */
 usb_hid_report_path_t *usb_hid_report_path(void)
@@ -1009 +1045 @@
 /**
  *
+ * @param path
+ * @return void
  */
 void usb_hid_report_path_free(usb_hid_report_path_t *path)
@@ -1019 +1057 @@
 
 /**
- *
- */
-int     usb_hid_report_path_clone(usb_hid_report_path_t *new_usage_path, usb_hid_report_path_t *usage_path)
+ * Clone content of given usage path to the new one
+ *
+ * @param usage_path
+ * @return
+ */
+usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path)
 {
         usb_hid_report_usage_path_t *path_item;
         link_t *path_link;
-
+        usb_hid_report_path_t *new_usage_path = usb_hid_report_path ();
+
+        if(new_usage_path == NULL){
+                return NULL;
+        }
         
         if(list_empty(&usage_path->link)){
-                return EOK;
+                return new_usage_path;
         }
 
@@ -1039 +1084 @@
         }
 
+        return new_usage_path;
+}
+
+
+/*** OUTPUT API **/
+
+/** Allocates output report buffer
+ *
+ * @param parser
+ * @param size
+ * @return
+ */
+uint8_t *usb_hid_report_output(usb_hid_report_parser_t *parser, size_t *size)
+{
+        if(parser == NULL) {
+                *size = 0;
+                return NULL;
+        }
+        
+        // read the last output report item
+        usb_hid_report_item_t *last;
+        link_t *link;
+
+        link = parser->output.prev;
+        if(link != &parser->output) {
+                last = list_get_instance(link, usb_hid_report_item_t, link);
+                *size = (last->offset + (last->size * last->count)) / 8;
+
+                uint8_t *buffer = malloc(sizeof(uint8_t) * (*size));
+                memset(buffer, 0, sizeof(uint8_t) * (*size));
+                usb_log_debug("output buffer: %s\n", usb_debug_str_buffer(buffer, *size, 0));
+
+                return buffer;
+        }
+        else {
+                *size = 0;              
+                return NULL;
+        }
+}
+
+
+/** Frees output report buffer
+ *
+ * @param output Output report buffer
+ * @return
+ */
+void usb_hid_report_output_free(uint8_t *output)
+
+{
+        if(output != NULL) {
+                free (output);
+        }
+}
+
+/** Returns size of output for given usage path 
+ *
+ * @param parser
+ * @param path
+ * @param flags
+ * @return
+ */
+size_t usb_hid_report_output_size(usb_hid_report_parser_t *parser,
+                                  usb_hid_report_path_t *path, int flags)
+{
+        size_t ret = 0;
+        link_t *item;
+        usb_hid_report_item_t *report_item;
+
+        if(parser == NULL) {
+                return 0;
+        }
+        
+        item = parser->output.next;
+        while(&parser->output != item) {
+                report_item = list_get_instance(item, usb_hid_report_item_t, link);
+                if(!USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags) &&
+                   (usb_hid_report_compare_usage_path(report_item->usage_path, path, flags) == EOK)) {
+                        ret += report_item->count;
+                }
+
+                item = item->next;
+        } 
+
+        return ret;
+        
+}
+
+/** Updates the output report buffer by translated given data 
+ *
+ * @param parser
+ * @param path
+ * @param flags
+ * @param buffer
+ * @param size
+ * @param data
+ * @param data_size
+ * @return
+ */
+int usb_hid_report_output_translate(usb_hid_report_parser_t *parser,
+                                    usb_hid_report_path_t *path, int flags,
+                                    uint8_t *buffer, size_t size,
+                                    int32_t *data, size_t data_size)
+{
+        usb_hid_report_item_t *report_item;
+        link_t *item;   
+        size_t idx=0;
+        int i=0;
+        int32_t value=0;
+        int offset;
+        int length;
+        int32_t tmp_value;
+        
+        if(parser == NULL) {
+                return EINVAL;
+        }
+
+        usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));
+        usb_log_debug("OUTPUT DATA[0]: %d, DATA[1]: %d, DATA[2]: %d\n", data[0], data[1], data[2]);
+
+        item = parser->output.next;     
+        while(item != &parser->output) {
+                report_item = list_get_instance(item, usb_hid_report_item_t, link);
+
+                for(i=0; i<report_item->count; i++) {
+
+                        if(idx >= data_size) {
+                                break;
+                        }
+
+                        if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) ||
+                                ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) {
+                                        
+//                              // variable item
+                                value = usb_hid_translate_data_reverse(report_item, data[idx++]);
+                                offset = report_item->offset + (i * report_item->size);
+                                length = report_item->size;
+                        }
+                        else {
+                                //bitmap
+                                value += usb_hid_translate_data_reverse(report_item, data[idx++]);
+                                offset = report_item->offset;
+                                length = report_item->size * report_item->count;
+                        }
+
+                        if((offset/8) == ((offset+length-1)/8)) {
+                                // je to v jednom bytu
+                                if(((size_t)(offset/8) >= size) || ((size_t)(offset+length-1)/8) >= size) {
+                                        break; // TODO ErrorCode
+                                }
+
+                                size_t shift = offset%8;
+
+                                value = value << shift;                                                 
+                                value = value & (((1 << length)-1) << shift);
+                                
+                                uint8_t mask = 0;
+                                mask = 0xff - (((1 << length) - 1) << shift);
+                                buffer[offset/8] = (buffer[offset/8] & mask) | value;
+                        }
+                        else {
+                                // je to ve dvou!! FIXME: melo by to umet delsi jak 2
+
+                                // konec prvniho -- dolni x bitu
+                                tmp_value = value;
+                                tmp_value = tmp_value & ((1 << (8-(offset%8)))-1);                              
+                                tmp_value = tmp_value << (offset%8);
+
+                                uint8_t mask = 0;
+                                mask = ~(((1 << (8-(offset%8)))-1) << (offset%8));
+                                buffer[offset/8] = (buffer[offset/8] & mask) | tmp_value;
+
+                                // a ted druhej -- hornich length-x bitu
+                                value = value >> (8 - (offset % 8));
+                                value = value & ((1 << (length - (8 - (offset % 8)))) - 1);
+                                
+                                mask = ((1 << (length - (8 - (offset % 8)))) - 1);
+                                buffer[(offset+length-1)/8] = (buffer[(offset+length-1)/8] & mask) | value;
+                        }
+
+                }
+
+                item = item->next;
+        }
+
+        usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));
+
         return EOK;
 }
 
+/**
+ *
+ * @param item
+ * @param value
+ * @return
+ */
+int32_t usb_hid_translate_data_reverse(usb_hid_report_item_t *item, int value)
+{
+        int ret=0;
+        int resolution;
+
+        if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags)) {
+                ret = item->logical_minimum;
+        }
+
+        if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0)) {
+
+                // variable item
+                if((item->physical_minimum == 0) && (item->physical_maximum == 0)) {
+                        item->physical_minimum = item->logical_minimum;
+                        item->physical_maximum = item->logical_maximum;
+                }
+
+                if(item->physical_maximum == item->physical_minimum){
+                    resolution = 1;
+                }
+                else {
+                    resolution = (item->logical_maximum - item->logical_minimum) /
+                        ((item->physical_maximum - item->physical_minimum) *
+                        (usb_pow(10,(item->unit_exponent))));
+                }
+
+                ret = ((value - item->physical_minimum) * resolution) + item->logical_minimum;
+        }
+        else {
+                // bitmapa
+                if(value == 0) {
+                        ret = 0;
+                }
+                else {
+                        size_t bitmap_idx = (value - item->usage_minimum);
+                        ret = 1 << bitmap_idx;
+                }
+        }
+
+
+        return ret;
+}
+
 
 /**

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

@@ -54 +54 @@
         for (; i < USB_ADDRESS_COUNT; ++i) {
                 instance->devices[i].occupied = false;
-                instance->devices[i].control_used = false;
+                instance->devices[i].control_used = 0;
                 instance->devices[i].handle = 0;
                 instance->devices[i].toggle_status[0] = 0;
@@ -311 +311 @@
 /*----------------------------------------------------------------------------*/
 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) {
+    usb_target_t target)
+{
+        assert(instance);
+        const uint16_t ep = 1 << target.endpoint;
+        fibril_mutex_lock(&instance->guard);
+        while (instance->devices[target.address].control_used & ep) {
                 fibril_condvar_wait(&instance->change, &instance->guard);
         }
-        instance->devices[address].control_used = true;
+        instance->devices[target.address].control_used |= ep;
         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;
+    usb_target_t target)
+{
+        assert(instance);
+        const uint16_t ep = 1 << target.endpoint;
+        fibril_mutex_lock(&instance->guard);
+        assert((instance->devices[target.address].control_used & ep) != 0);
+        instance->devices[target.address].control_used &= ~ep;
         fibril_mutex_unlock(&instance->guard);
         fibril_condvar_signal(&instance->change);

uspace/lib/usb/src/request.c

@@ -529 +529 @@
                 return rc;
         }
-
         if (bare_config.descriptor_type != USB_DESCTYPE_CONFIGURATION) {
                 return ENOENT;

uspace/srv/devman/devman.c

@@ -34 +34 @@
 #include <fcntl.h>
 #include <sys/stat.h>
+#include <io/log.h>
 #include <ipc/driver.h>
 #include <ipc/devman.h>
@@ -146 +147 @@
         fibril_mutex_unlock(&drivers_list->drivers_mutex);
 
-        printf(NAME": the '%s' driver was added to the list of available "
-            "drivers.\n", drv->name);
-
-        printf(NAME ": match ids:");
-        link_t *cur;
-        for (cur = drv->match_ids.ids.next; cur != &drv->match_ids.ids; cur = cur->next) {
-                match_id_t *match_id = list_get_instance(cur, match_id_t, link);
-                printf(" %d:%s", match_id->score, match_id->id);
-        }
-        printf("\n");
+        log_msg(LVL_NOTE, "Driver `%s' was added to the list of available "
+            "drivers.", drv->name);
 }
 
@@ -245 +238 @@
 bool read_match_ids(const char *conf_path, match_id_list_t *ids)
 {
-        printf(NAME ": read_match_ids conf_path = %s.\n", conf_path);
+        log_msg(LVL_DEBUG, "read_match_ids(conf_path=\"%s\")", conf_path);
         
         bool suc = false;
@@ -255 +248 @@
         fd = open(conf_path, O_RDONLY);
         if (fd < 0) {
-                printf(NAME ": unable to open %s\n", conf_path);
+                log_msg(LVL_ERROR, "Unable to open `%s' for reading: %s.",
+                    conf_path, str_error(fd));
                 goto cleanup;
         }
@@ -263 +257 @@
         lseek(fd, 0, SEEK_SET);
         if (len == 0) {
-                printf(NAME ": configuration file '%s' is empty.\n", conf_path);
+                log_msg(LVL_ERROR, "Configuration file '%s' is empty.",
+                    conf_path);
                 goto cleanup;
         }
@@ -269 +264 @@
         buf = malloc(len + 1);
         if (buf == NULL) {
-                printf(NAME ": memory allocation failed when parsing file "
-                    "'%s'.\n", conf_path);
+                log_msg(LVL_ERROR, "Memory allocation failed when parsing file "
+                    "'%s'.", conf_path);
                 goto cleanup;
         }
@@ -276 +271 @@
         ssize_t read_bytes = safe_read(fd, buf, len);
         if (read_bytes <= 0) {
-                printf(NAME ": unable to read file '%s'.\n", conf_path);
+                log_msg(LVL_ERROR, "Unable to read file '%s'.", conf_path);
                 goto cleanup;
         }
@@ -314 +309 @@
 bool get_driver_info(const char *base_path, const char *name, driver_t *drv)
 {
-        printf(NAME ": get_driver_info base_path = %s, name = %s.\n",
+        log_msg(LVL_DEBUG, "get_driver_info(base_path=\"%s\", name=\"%s\")",
             base_path, name);
         
@@ -346 +341 @@
         struct stat s;
         if (stat(drv->binary_path, &s) == ENOENT) { /* FIXME!! */
-                printf(NAME ": driver not found at path %s.", drv->binary_path);
+                log_msg(LVL_ERROR, "Driver not found at path `%s'.",
+                    drv->binary_path);
                 goto cleanup;
         }
@@ -373 +369 @@
 int lookup_available_drivers(driver_list_t *drivers_list, const char *dir_path)
 {
-        printf(NAME ": lookup_available_drivers, dir = %s \n", dir_path);
+        log_msg(LVL_DEBUG, "lookup_available_drivers(dir=\"%s\")", dir_path);
         
         int drv_cnt = 0;
@@ -407 +403 @@
         dev_node_t *dev;
         
-        printf(NAME ": create_root_nodes\n");
+        log_msg(LVL_DEBUG, "create_root_nodes()");
         
         fibril_rwlock_write_lock(&tree->rwlock);
@@ -492 +488 @@
 void attach_driver(dev_node_t *dev, driver_t *drv)
 {
-        printf(NAME ": attach_driver %s to device %s\n",
-            drv->name, dev->pfun->pathname);
+        log_msg(LVL_DEBUG, "attach_driver(dev=\"%s\",drv=\"%s\")",
+            dev->pfun->pathname, drv->name);
         
         fibril_mutex_lock(&drv->driver_mutex);
@@ -515 +511 @@
         assert(fibril_mutex_is_locked(&drv->driver_mutex));
         
-        printf(NAME ": start_driver '%s'\n", drv->name);
+        log_msg(LVL_DEBUG, "start_driver(drv=\"%s\")", drv->name);
         
         rc = task_spawnl(NULL, drv->binary_path, drv->binary_path, NULL);
         if (rc != EOK) {
-                printf(NAME ": error spawning %s (%s)\n",
-                    drv->name, str_error(rc));
+                log_msg(LVL_ERROR, "Spawning driver `%s' (%s) failed: %s.",
+                    drv->name, drv->binary_path, str_error(rc));
                 return false;
         }
@@ -582 +578 @@
         int phone;
 
-        printf(NAME ": pass_devices_to_driver(`%s')\n", driver->name);
+        log_msg(LVL_DEBUG, "pass_devices_to_driver(driver=\"%s\")",
+            driver->name);
 
         fibril_mutex_lock(&driver->driver_mutex);
@@ -649 +646 @@
          * immediately and possibly started here as well.
          */
-        printf(NAME ": driver %s goes into running state.\n", driver->name);
+        log_msg(LVL_DEBUG, "Driver `%s' enters running state.", driver->name);
         driver->state = DRIVER_RUNNING;
 
@@ -666 +663 @@
 void initialize_running_driver(driver_t *driver, dev_tree_t *tree)
 {
-        printf(NAME ": initialize_running_driver (`%s')\n", driver->name);
+        log_msg(LVL_DEBUG, "initialize_running_driver(driver=\"%s\")",
+            driver->name);
         
         /*
@@ -756 +754 @@
          * access any structures that would affect driver_t.
          */
-        printf(NAME ": add_device (driver `%s', device `%s')\n", drv->name,
-            dev->pfun->name);
+        log_msg(LVL_DEBUG, "add_device(drv=\"%s\", dev=\"%s\")",
+            drv->name, dev->pfun->name);
         
         sysarg_t rc;
@@ -818 +816 @@
         driver_t *drv = find_best_match_driver(drivers_list, dev);
         if (drv == NULL) {
-                printf(NAME ": no driver found for device '%s'.\n",
+                log_msg(LVL_ERROR, "No driver found for device `%s'.",
                     dev->pfun->pathname);
                 return false;
@@ -856 +854 @@
 bool init_device_tree(dev_tree_t *tree, driver_list_t *drivers_list)
 {
-        printf(NAME ": init_device_tree.\n");
+        log_msg(LVL_DEBUG, "init_device_tree()");
         
         tree->current_handle = 0;
@@ -1035 +1033 @@
         fun->pathname = (char *) malloc(pathsize);
         if (fun->pathname == NULL) {
-                printf(NAME ": failed to allocate device path.\n");
+                log_msg(LVL_ERROR, "Failed to allocate device path.");
                 return false;
         }
@@ -1066 +1064 @@
         assert(fibril_rwlock_is_write_locked(&tree->rwlock));
         
+        log_msg(LVL_DEBUG, "insert_dev_node(dev=%p, pfun=%p [\"%s\"])",
+            dev, pfun, pfun->pathname);
+
         /* Add the node to the handle-to-node map. */
         dev->handle = ++tree->current_handle;
@@ -1072 +1073 @@
 
         /* Add the node to the list of its parent's children. */
-        printf("insert_dev_node: dev=%p, dev->pfun := %p\n", dev, pfun);
         dev->pfun = pfun;
         pfun->child = dev;
@@ -1173 +1173 @@
 }
 
+/** Find function with a specified name belonging to given device.
+ *
+ * Device tree rwlock should be held at least for reading.
+ *
+ * @param dev Device the function belongs to.
+ * @param name Function name (not path).
+ * @return Function node.
+ * @retval NULL No function with given name.
+ */
+fun_node_t *find_fun_node_in_device(dev_node_t *dev, const char *name)
+{
+        assert(dev != NULL);
+        assert(name != NULL);
+
+        fun_node_t *fun;
+        link_t *link;
+
+        for (link = dev->functions.next;
+            link != &dev->functions;
+            link = link->next) {
+                fun = list_get_instance(link, fun_node_t, dev_functions);
+
+                if (str_cmp(name, fun->name) == 0)
+                        return fun;
+        }
+
+        return NULL;
+}
+
+/** Find function node by its class name and index. */
+fun_node_t *find_fun_node_by_class(class_list_t *class_list,
+    const char *class_name, const char *dev_name)
+{
+        assert(class_list != NULL);
+        assert(class_name != NULL);
+        assert(dev_name != NULL);
+
+        fibril_rwlock_read_lock(&class_list->rwlock);
+
+        dev_class_t *cl = find_dev_class_no_lock(class_list, class_name);
+        if (cl == NULL) {
+                fibril_rwlock_read_unlock(&class_list->rwlock);
+                return NULL;
+        }
+
+        dev_class_info_t *dev = find_dev_in_class(cl, dev_name);
+        if (dev == NULL) {
+                fibril_rwlock_read_unlock(&class_list->rwlock);
+                return NULL;
+        }
+
+        fun_node_t *fun = dev->fun;
+
+        fibril_rwlock_read_unlock(&class_list->rwlock);
+
+        return fun;
+}
+
+
 /** Find child function node with a specified name.
  *
@@ -1183 +1242 @@
 fun_node_t *find_node_child(fun_node_t *pfun, const char *name)
 {
-        fun_node_t *fun;
-        link_t *link;
-        
-        link = pfun->child->functions.next;
-        
-        while (link != &pfun->child->functions) {
-                fun = list_get_instance(link, fun_node_t, dev_functions);
-                
-                if (str_cmp(name, fun->name) == 0)
-                        return fun;
-                
-                link = link->next;
-        }
-        
-        return NULL;
+        return find_fun_node_in_device(pfun->child, name);
 }
 
@@ -1359 +1404 @@
 }
 
+dev_class_info_t *find_dev_in_class(dev_class_t *dev_class, const char *dev_name)
+{
+        assert(dev_class != NULL);
+        assert(dev_name != NULL);
+
+        link_t *link;
+        for (link = dev_class->devices.next;
+            link != &dev_class->devices;
+            link = link->next) {
+                dev_class_info_t *dev = list_get_instance(link,
+                    dev_class_info_t, link);
+
+                if (str_cmp(dev->dev_name, dev_name) == 0) {
+                        return dev;
+                }
+        }
+
+        return NULL;
+}
+
 void init_class_list(class_list_t *class_list)
 {

uspace/srv/devman/devman.h

@@ -338 +338 @@
 extern fun_node_t *find_fun_node(dev_tree_t *tree, devman_handle_t handle);
 extern fun_node_t *find_fun_node_by_path(dev_tree_t *, char *);
+extern fun_node_t *find_fun_node_in_device(dev_node_t *, const char *);
+extern fun_node_t *find_fun_node_by_class(class_list_t *, const char *, const char *);
 
 /* Device tree */
@@ -359 +361 @@
 extern dev_class_t *get_dev_class(class_list_t *, char *);
 extern dev_class_t *find_dev_class_no_lock(class_list_t *, const char *);
+extern dev_class_info_t *find_dev_in_class(dev_class_t *, const char *);
 extern void add_dev_class_no_lock(class_list_t *, dev_class_t *);
 

uspace/srv/devman/main.c

@@ -43 +43 @@
 #include <stdio.h>
 #include <errno.h>
+#include <str_error.h>
 #include <bool.h>
 #include <fibril_synch.h>
@@ -51 +52 @@
 #include <sys/stat.h>
 #include <ctype.h>
+#include <io/log.h>
 #include <ipc/devman.h>
 #include <ipc/driver.h>
@@ -71 +73 @@
         driver_t *driver = NULL;
 
-        printf(NAME ": devman_driver_register \n");
+        log_msg(LVL_DEBUG, "devman_driver_register");
         
         iid = async_get_call(&icall);
@@ -88 +90 @@
         }
 
-        printf(NAME ": the %s driver is trying to register by the service.\n",
+        log_msg(LVL_DEBUG, "The `%s' driver is trying to register.",
             drv_name);
         
@@ -95 +97 @@
         
         if (driver == NULL) {
-                printf(NAME ": no driver named %s was found.\n", drv_name);
+                log_msg(LVL_ERROR, "No driver named `%s' was found.", drv_name);
                 free(drv_name);
                 drv_name = NULL;
@@ -106 +108 @@
         
         /* Create connection to the driver. */
-        printf(NAME ":  creating connection to the %s driver.\n", driver->name);
+        log_msg(LVL_DEBUG, "Creating connection to the `%s' driver.",
+            driver->name);
         ipc_call_t call;
         ipc_callid_t callid = async_get_call(&call);
@@ -118 +121 @@
         set_driver_phone(driver, IPC_GET_ARG5(call));
         
-        printf(NAME ": the %s driver was successfully registered as running.\n",
+        log_msg(LVL_NOTE, 
+            "The `%s' driver was successfully registered as running.",
             driver->name);
         
@@ -142 +146 @@
         callid = async_get_call(&call);
         if (DEVMAN_ADD_MATCH_ID != IPC_GET_IMETHOD(call)) {
-                printf(NAME ": ERROR: devman_receive_match_id - invalid "
-                    "protocol.\n");
+                log_msg(LVL_ERROR, 
+                    "Invalid protocol when trying to receive match id.");
                 async_answer_0(callid, EINVAL); 
                 delete_match_id(match_id);
@@ -150 +154 @@
         
         if (match_id == NULL) {
-                printf(NAME ": ERROR: devman_receive_match_id - failed to "
-                    "allocate match id.\n");
+                log_msg(LVL_ERROR, "Failed to allocate match id.");
                 async_answer_0(callid, ENOMEM);
                 return ENOMEM;
@@ -165 +168 @@
         if (rc != EOK) {
                 delete_match_id(match_id);
-                printf(NAME ": devman_receive_match_id - failed to receive "
-                    "match id string.\n");
+                log_msg(LVL_ERROR, "Failed to receive match id string: %s.",
+                    str_error(rc));
                 return rc;
         }
@@ -172 +175 @@
         list_append(&match_id->link, &match_ids->ids);
         
-        printf(NAME ": received match id '%s', score = %d \n",
+        log_msg(LVL_DEBUG, "Received match id `%s', score %d.",
             match_id->id, match_id->score);
         return rc;
@@ -228 +231 @@
         if (ftype != fun_inner && ftype != fun_exposed) {
                 /* Unknown function type */
-                printf(NAME ": Error, unknown function type provided by driver!\n");
+                log_msg(LVL_ERROR, 
+                    "Unknown function type %d provided by driver.",
+                    (int) ftype);
 
                 fibril_rwlock_write_unlock(&tree->rwlock);
@@ -243 +248 @@
         }
         
+        /* Check that function with same name is not there already. */
+        if (find_fun_node_in_device(pdev, fun_name) != NULL) {
+                fibril_rwlock_write_unlock(&tree->rwlock);
+                async_answer_0(callid, EEXISTS);
+                printf(NAME ": Warning, driver tried to register `%s' twice.\n",
+                    fun_name);
+                free(fun_name);
+                return;
+        }
+
         fun_node_t *fun = create_fun_node();
         if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) {
@@ -265 +280 @@
         fibril_rwlock_write_unlock(&tree->rwlock);
         
-        printf(NAME ": devman_add_function %s\n", fun->pathname);
+        log_msg(LVL_DEBUG, "devman_add_function(fun=\"%s\")", fun->pathname);
         
         devman_receive_match_ids(match_count, &fun->match_ids);
@@ -347 +362 @@
         devmap_register_class_dev(class_info);
         
-        printf(NAME ": function'%s' added to class '%s', class name '%s' was "
-            "asigned to it\n", fun->pathname, class_name, class_info->dev_name);
+        log_msg(LVL_NOTE, "Function `%s' added to class `%s' as `%s'.",
+            fun->pathname, class_name, class_info->dev_name);
 
         async_answer_0(callid, EOK);
@@ -363 +378 @@
         
         initialize_running_driver(driver, &device_tree);
-        printf(NAME ": the %s driver was successfully initialized. \n",
+        log_msg(LVL_DEBUG, "The `%s` driver was successfully initialized.",
             driver->name);
         return 0;
@@ -385 +400 @@
         fid_t fid = fibril_create(init_running_drv, driver);
         if (fid == 0) {
-                printf(NAME ": Error creating fibril for the initialization of "
-                    "the newly registered running driver.\n");
+                log_msg(LVL_ERROR, "Failed to create initialization fibril " \
+                    "for driver `%s'.", driver->name);
                 return;
         }
@@ -438 +453 @@
 }
 
+/** Find handle for the device instance identified by device class name. */
+static void devman_function_get_handle_by_class(ipc_callid_t iid,
+    ipc_call_t *icall)
+{
+        char *classname;
+        char *devname;
+
+        int rc = async_data_write_accept((void **) &classname, true, 0, 0, 0, 0);
+        if (rc != EOK) {
+                async_answer_0(iid, rc);
+                return;
+        }
+        rc = async_data_write_accept((void **) &devname, true, 0, 0, 0, 0);
+        if (rc != EOK) {
+                free(classname);
+                async_answer_0(iid, rc);
+                return;
+        }
+
+
+        fun_node_t *fun = find_fun_node_by_class(&class_list,
+            classname, devname);
+
+        free(classname);
+        free(devname);
+
+        if (fun == NULL) {
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+
+        async_answer_1(iid, EOK, fun->handle);
+}
+
 
 /** Function for handling connections from a client to the device manager. */
@@ -457 +506 @@
                         devman_function_get_handle(callid, &call);
                         break;
+                case DEVMAN_DEVICE_GET_HANDLE_BY_CLASS:
+                        devman_function_get_handle_by_class(callid, &call);
+                        break;
                 default:
                         async_answer_0(callid, ENOENT);
@@ -484 +536 @@
          */
         if (dev == NULL) {
-                printf(NAME ": devman_forward error - no device or function with "
-                    "handle %" PRIun " was found.\n", handle);
+                log_msg(LVL_ERROR, "IPC forwarding failed - no device or "
+                    "function with handle %" PRIun " was found.", handle);
                 async_answer_0(iid, ENOENT);
                 return;
@@ -491 +543 @@
 
         if (fun == NULL && !drv_to_parent) {
-                printf(NAME ": devman_forward error - cannot connect to "
-                    "handle %" PRIun ", refers to a device.\n", handle);
+                log_msg(LVL_ERROR, NAME ": devman_forward error - cannot "
+                    "connect to handle %" PRIun ", refers to a device.",
+                    handle);
                 async_answer_0(iid, ENOENT);
                 return;
@@ -513 +566 @@
         
         if (driver == NULL) {
-                printf(NAME ": devman_forward error - the device %" PRIun \
-                    " (%s) is not in usable state.\n",
+                log_msg(LVL_ERROR, "IPC forwarding refused - " \
+                    "the device %" PRIun "(%s) is not in usable state.",
                     handle, dev->pfun->pathname);
                 async_answer_0(iid, ENOENT);
@@ -527 +580 @@
         
         if (driver->phone <= 0) {
-                printf(NAME ": devman_forward: cound not forward to driver %s ",
-                    driver->name);
-                printf("the driver's phone is %" PRIun ").\n", driver->phone);
+                log_msg(LVL_ERROR, 
+                    "Could not forward to driver `%s' (phone is %d).",
+                    driver->name, (int) driver->phone);
                 async_answer_0(iid, EINVAL);
                 return;
@@ -535 +588 @@
 
         if (fun != NULL) {
-                printf(NAME ": devman_forward: forward connection to function %s to "
-                    "driver %s.\n", fun->pathname, driver->name);
+                log_msg(LVL_DEBUG, 
+                    "Forwarding request for `%s' function to driver `%s'.",
+                    fun->pathname, driver->name);
         } else {
-                printf(NAME ": devman_forward: forward connection to device %s to "
-                    "driver %s.\n", dev->pfun->pathname, driver->name);
+                log_msg(LVL_DEBUG, 
+                    "Forwarding request for `%s' device to driver `%s'.",
+                    dev->pfun->pathname, driver->name);
         }
 
@@ -571 +626 @@
         async_forward_fast(iid, dev->drv->phone, DRIVER_CLIENT, fun->handle, 0,
             IPC_FF_NONE);
-        printf(NAME ": devman_connection_devmapper: forwarded connection to "
-            "device %s to driver %s.\n", fun->pathname, dev->drv->name);
+        log_msg(LVL_DEBUG, 
+            "Forwarding devmapper request for `%s' function to driver `%s'.",
+            fun->pathname, dev->drv->name);
 }
 
@@ -607 +663 @@
 static bool devman_init(void)
 {
-        printf(NAME ": devman_init - looking for available drivers.\n");
+        log_msg(LVL_DEBUG, "devman_init - looking for available drivers.");
         
         /* Initialize list of available drivers. */
@@ -613 +669 @@
         if (lookup_available_drivers(&drivers_list,
             DRIVER_DEFAULT_STORE) == 0) {
-                printf(NAME " no drivers found.");
+                log_msg(LVL_FATAL, "No drivers found.");
                 return false;
         }
 
-        printf(NAME ": devman_init  - list of drivers has been initialized.\n");
+        log_msg(LVL_DEBUG, "devman_init - list of drivers has been initialized.");
 
         /* Create root device node. */
         if (!init_device_tree(&device_tree, &drivers_list)) {
-                printf(NAME " failed to initialize device tree.");
+                log_msg(LVL_FATAL, "Failed to initialize device tree.");
                 return false;
         }
@@ -642 +698 @@
         printf(NAME ": HelenOS Device Manager\n");
 
+        if (log_init(NAME, LVL_ERROR) != EOK) {
+                printf(NAME ": Error initializing logging subsystem.\n");
+                return -1;
+        }
+
         if (!devman_init()) {
-                printf(NAME ": Error while initializing service\n");
+                log_msg(LVL_ERROR, "Error while initializing service.");
                 return -1;
         }
@@ -651 +712 @@
 
         /* Register device manager at naming service. */
-        if (service_register(SERVICE_DEVMAN) != EOK)
+        if (service_register(SERVICE_DEVMAN) != EOK) {
+                log_msg(LVL_ERROR, "Failed registering as a service.");
                 return -1;
-
-        printf(NAME ": Accepting connections\n");
+        }
+
+        printf(NAME ": Accepting connections.\n");
         async_manager();
 

uspace/srv/devmap/devmap.c

@@ -551 +551 @@
         if (devmap_device_find_name(namespace->name, device->name) != NULL) {
                 printf("%s: Device '%s/%s' already registered\n", NAME,
-                    device->namespace->name, device->name);
+                    namespace->name, device->name);
                 devmap_namespace_destroy(namespace);
                 fibril_mutex_unlock(&devices_list_mutex);