Changes in / [4144630:45e9cc6] in mainline

Files:

• .bzrignore (modified) (2 diffs)
• boot/arch/amd64/Makefile.inc (modified) (1 diff)
• boot/arch/mips32/include/arch.h (modified) (1 diff)
• contrib/conf/msim.conf (modified) (1 diff)
• kernel/arch/mips32/src/exception.c (modified) (1 diff)
• kernel/arch/mips32/src/smp/dorder.c (modified) (1 diff)
• kernel/generic/include/ipc/ipc.h (modified) (1 diff)
• tools/config.py (modified) (24 diffs)
• uspace/Makefile (modified) (1 diff)
• uspace/drv/uhci/Makefile (modified) (1 diff)
• uspace/drv/uhci/main.c (modified) (2 diffs)
• uspace/drv/uhci/transfers.c (added)
• uspace/drv/uhci/uhci.h (added)
• uspace/drv/uhci/uhci.ma (modified) (1 diff)
• uspace/drv/usbhub/Makefile (added)
• uspace/drv/usbhub/main.c (added)
• uspace/drv/usbhub/usbhub.h (added)
• uspace/drv/usbhub/usbhub.ma (added)
• uspace/drv/usbhub/utils.c (added)
• uspace/drv/vhc/Makefile (modified) (1 diff)
• uspace/drv/vhc/addrmgm.c (added)
• uspace/drv/vhc/conn.h (modified) (2 diffs)
• uspace/drv/vhc/connhost.c (modified) (7 diffs)
• uspace/drv/vhc/hcd.c (modified) (4 diffs)
• uspace/drv/vhc/vhc.ma (modified) (1 diff)
• uspace/lib/block/libblock.c (modified) (17 diffs)
• uspace/lib/block/libblock.h (modified) (1 diff)
• uspace/lib/drv/generic/remote_usbhc.c (modified) (3 diffs)
• uspace/lib/drv/include/usbhc_iface.h (modified) (2 diffs)
• uspace/lib/usb/Makefile (modified) (1 diff)
• uspace/lib/usb/include/usb/hcdhubd.h (modified) (2 diffs)
• uspace/lib/usb/include/usb/usbdrv.h (modified) (1 diff)
• uspace/lib/usb/src/hcdhubd.c (modified) (4 diffs)
• uspace/lib/usb/src/hcdhubd_private.h (modified) (1 diff)
• uspace/lib/usb/src/hcdrv.c (modified) (2 diffs)
• uspace/lib/usb/src/hubdrv.c (deleted)
• uspace/lib/usb/src/localdrv.c (modified) (1 diff)
• uspace/lib/usb/src/usbdrv.c (modified) (2 diffs)
• uspace/srv/bd/file_bd/file_bd.c (modified) (4 diffs)

.bzrignore

@@ -94 +94 @@
 ./uspace/dist/drv/rootia32/
 ./uspace/dist/drv/uhci/
+./uspace/dist/drv/usbhub/
 ./uspace/dist/drv/usbkbd/
 ./uspace/dist/drv/vhc/
@@ -130 +131 @@
 ./uspace/drv/rootia32/rootia32
 ./uspace/drv/uhci/uhci
+./uspace/drv/usbhub/usbhub
 ./uspace/drv/usbkbd/usbkbd
 ./uspace/drv/vhc/vhc

boot/arch/amd64/Makefile.inc

@@ -42 +42 @@
         ns8250 \
         uhci \
+        usbhub \
         usbkbd
         

boot/arch/mips32/include/arch.h

@@ -40 +40 @@
 
 #define MSIM_VIDEORAM_ADDRESS  0xb0000000
-#define MSIM_DORDER_ADDRESS    0xb0000004
+#define MSIM_DORDER_ADDRESS    0xb0000100
 
 #ifndef __ASM__

contrib/conf/msim.conf

@@ -16 +16 @@
 add dprinter printer 0x10000000
 add dkeyboard keyboard 0x10000000 2
-add dorder order 0x10000004 5
+add dorder order 0x10000100 5

kernel/arch/mips32/src/exception.c

@@ -74 +74 @@
 void istate_decode(istate_t *istate)
 {
-        printf("epc=%p\tsta=%#0" PRIx32 "\t"
-            "lo =%#0" PRIx32 "\thi =%#0" PRIx32 "\n",
+        printf("epc=%p\tsta=%#010" PRIx32 "\t"
+            "lo =%#010" PRIx32 "\thi =%#010" PRIx32 "\n",
             (void *) istate->epc, istate->status,
             istate->lo, istate->hi);
         
-        printf("a0 =%#0" PRIx32 "\ta1 =%#0" PRIx32 "\t"
-            "a2 =%#0" PRIx32 "\ta3 =%#0" PRIx32 "\n",
+        printf("a0 =%#010" PRIx32 "\ta1 =%#010" PRIx32 "\t"
+            "a2 =%#010" PRIx32 "\ta3 =%#010" PRIx32 "\n",
             istate->a0, istate->a1, istate->a2, istate->a3);
         
-        printf("t0 =%#0" PRIx32 "\tt1 =%#0" PRIx32 "\t"
-            "t2 =%#0" PRIx32 "\tt3 =%#0" PRIx32 "\n",
+        printf("t0 =%#010" PRIx32 "\tt1 =%#010" PRIx32 "\t"
+            "t2 =%#010" PRIx32 "\tt3 =%#010" PRIx32 "\n",
             istate->t0, istate->t1, istate->t2, istate->t3);
         
-        printf("t4 =%#0" PRIx32 "\tt5 =%#0" PRIx32 "\t"
-            "t6 =%#0" PRIx32 "\tt7 =%#0" PRIx32 "\n",
+        printf("t4 =%#010" PRIx32 "\tt5 =%#010" PRIx32 "\t"
+            "t6 =%#010" PRIx32 "\tt7 =%#010" PRIx32 "\n",
             istate->t4, istate->t5, istate->t6, istate->t7);
         
-        printf("t8 =%#0" PRIx32 "\tt9 =%#0" PRIx32 "\t"
-            "v0 =%#0" PRIx32 "\tv1 =%#0" PRIx32 "\n",
+        printf("t8 =%#010" PRIx32 "\tt9 =%#010" PRIx32 "\t"
+            "v0 =%#010" PRIx32 "\tv1 =%#010" PRIx32 "\n",
             istate->t8, istate->t9, istate->v0, istate->v1);
         
-        printf("s0 =%#0" PRIx32 "\ts1 =%#0" PRIx32 "\t"
-            "s2 =%#0" PRIx32 "\ts3 =%#0" PRIx32 "\n",
+        printf("s0 =%#010" PRIx32 "\ts1 =%#010" PRIx32 "\t"
+            "s2 =%#010" PRIx32 "\ts3 =%#010" PRIx32 "\n",
             istate->s0, istate->s1, istate->s2, istate->s3);
         
-        printf("s4 =%#0" PRIx32 "\ts5 =%#0" PRIx32 "\t"
-            "s6 =%#0" PRIx32 "\ts7 =%#0" PRIx32 "\n",
+        printf("s4 =%#010" PRIx32 "\ts5 =%#010" PRIx32 "\t"
+            "s6 =%#010" PRIx32 "\ts7 =%#010" PRIx32 "\n",
             istate->s4, istate->s5, istate->s6, istate->s7);
         
-        printf("s8 =%#0" PRIx32 "\tat =%#0" PRIx32 "\t"
-            "kt0=%#0" PRIx32 "\tkt1=%#0" PRIx32 "\n",
+        printf("s8 =%#010" PRIx32 "\tat =%#010" PRIx32 "\t"
+            "kt0=%#010" PRIx32 "\tkt1=%#010" PRIx32 "\n",
             istate->s8, istate->at, istate->kt0, istate->kt1);
         

kernel/arch/mips32/src/smp/dorder.c

@@ -37 +37 @@
 #include <arch/smp/dorder.h>
 
-#define MSIM_DORDER_ADDRESS  0xB0000004
+#define MSIM_DORDER_ADDRESS  0xB0000100
 
 #ifdef CONFIG_SMP

kernel/generic/include/ipc/ipc.h

@@ -45 +45 @@
 /** Maximum active async calls per thread */
 #ifdef CONFIG_DEBUG
-        #define IPC_MAX_ASYNC_CALLS  4
+        #define IPC_MAX_ASYNC_CALLS  16
 #else
         #define IPC_MAX_ASYNC_CALLS  4000

tools/config.py

@@ -3 +3 @@
 # Copyright (c) 2006 Ondrej Palkovsky
 # Copyright (c) 2009 Martin Decky
+# Copyright (c) 2010 Jiri Svoboda
 # All rights reserved.
 #
@@ -40 +41 @@
 import xtui
 
-INPUT = sys.argv[1]
+RULES_FILE = sys.argv[1]
 MAKEFILE = 'Makefile.config'
 MACROS = 'config.h'
-PRECONF = 'defaults'
-
-def read_defaults(fname, defaults):
+PRESETS_DIR = 'defaults'
+
+def read_config(fname, config):
         "Read saved values from last configuration run"
         
@@ -52 +53 @@
         for line in inf:
                 res = re.match(r'^(?:#!# )?([^#]\w*)\s*=\s*(.*?)\s*$', line)
-                if (res):
-                        defaults[res.group(1)] = res.group(2)
+                if res:
+                        config[res.group(1)] = res.group(2)
         
         inf.close()
 
-def check_condition(text, defaults, ask_names):
+def check_condition(text, config, rules):
         "Check that the condition specified on input line is True (only CNF and DNF is supported)"
         
         ctype = 'cnf'
         
-        if ((')|' in text) or ('|(' in text)):
+        if (')|' in text) or ('|(' in text):
                 ctype = 'dnf'
         
-        if (ctype == 'cnf'):
+        if ctype == 'cnf':
                 conds = text.split('&')
         else:
@@ -71 +72 @@
         
         for cond in conds:
-                if (cond.startswith('(')) and (cond.endswith(')')):
+                if cond.startswith('(') and cond.endswith(')'):
                         cond = cond[1:-1]
                 
-                inside = check_inside(cond, defaults, ctype)
+                inside = check_inside(cond, config, ctype)
                 
                 if (ctype == 'cnf') and (not inside):
                         return False
                 
-                if (ctype == 'dnf') and (inside):
+                if (ctype == 'dnf') and inside:
                         return True
         
-        if (ctype == 'cnf'):
+        if ctype == 'cnf':
                 return True
         return False
 
-def check_inside(text, defaults, ctype):
+def check_inside(text, config, ctype):
         "Check for condition"
         
-        if (ctype == 'cnf'):
+        if ctype == 'cnf':
                 conds = text.split('|')
         else:
@@ -96 +97 @@
         for cond in conds:
                 res = re.match(r'^(.*?)(!?=)(.*)$', cond)
-                if (not res):
+                if not res:
                         raise RuntimeError("Invalid condition: %s" % cond)
                 
@@ -103 +104 @@
                 condval = res.group(3)
                 
-                if (not condname in defaults):
+                if not condname in config:
                         varval = ''
                 else:
-                        varval = defaults[condname]
+                        varval = config[condname]
                         if (varval == '*'):
                                 varval = 'y'
                 
-                if (ctype == 'cnf'):
+                if ctype == 'cnf':
                         if (oper == '=') and (condval == varval):
                                 return True
@@ -123 +124 @@
                                 return False
         
-        if (ctype == 'cnf'):
+        if ctype == 'cnf':
                 return False
         
         return True
 
-def parse_config(fname, ask_names):
-        "Parse configuration file"
+def parse_rules(fname, rules):
+        "Parse rules file"
         
         inf = open(fname, 'r')
@@ -138 +139 @@
         for line in inf:
                 
-                if (line.startswith('!')):
+                if line.startswith('!'):
                         # Ask a question
                         res = re.search(r'!\s*(?:\[(.*?)\])?\s*([^\s]+)\s*\((.*)\)\s*$', line)
                         
-                        if (not res):
+                        if not res:
                                 raise RuntimeError("Weird line: %s" % line)
                         
@@ -149 +150 @@
                         vartype = res.group(3)
                         
-                        ask_names.append((varname, vartype, name, choices, cond))
+                        rules.append((varname, vartype, name, choices, cond))
                         name = ''
                         choices = []
                         continue
                 
-                if (line.startswith('@')):
+                if line.startswith('@'):
                         # Add new line into the 'choices' array
                         res = re.match(r'@\s*(?:\[(.*?)\])?\s*"(.*?)"\s*(.*)$', line)
@@ -164 +165 @@
                         continue
                 
-                if (line.startswith('%')):
+                if line.startswith('%'):
                         # Name of the option
                         name = line[1:].strip()
                         continue
                 
-                if ((line.startswith('#')) or (line == '\n')):
+                if line.startswith('#') or (line == '\n'):
                         # Comment or empty line
                         continue
@@ -181 +182 @@
         "Return '*' if yes, ' ' if no"
         
-        if (default == 'y'):
+        if default == 'y':
                 return '*'
         
@@ -199 +200 @@
         cnt = 0
         for key, val in choices:
-                if ((default) and (key == default)):
+                if (default) and (key == default):
                         position = cnt
                 
@@ -207 +208 @@
         (button, value) = xtui.choice_window(screen, name, 'Choose value', options, position)
         
-        if (button == 'cancel'):
+        if button == 'cancel':
                 return None
         
         return choices[value][0]
 
-def check_choices(defaults, ask_names):
-        "Check whether all accessible variables have a default"
-        
-        for varname, vartype, name, choices, cond in ask_names:
-                if ((cond) and (not check_condition(cond, defaults, ask_names))):
+## Infer and verify configuration values.
+#
+# Augment @a config with values that can be inferred, purge invalid ones
+# and verify that all variables have a value (previously specified or inferred).
+#
+# @param config Configuration to work on
+# @param rules  Rules
+#
+# @return       True if configuration is complete and valid, False
+#               otherwise.
+#
+def infer_verify_choices(config, rules):
+        "Infer and verify configuration values."
+        
+        for rule in rules:
+                varname, vartype, name, choices, cond = rule
+
+                if cond and (not check_condition(cond, config, rules)):
                         continue
                 
-                if (not varname in defaults):
+                if not varname in config:
+                        value = None
+                else:
+                        value = config[varname]
+
+                if not rule_value_is_valid(rule, value):
+                        value = None
+
+                default = rule_get_default(rule)
+                if default != None:
+                        config[varname] = default
+
+                if not varname in config:
                         return False
         
         return True
 
-def create_output(mkname, mcname, defaults, ask_names):
+## Get default value from a rule.
+def rule_get_default(rule):
+        varname, vartype, name, choices, cond = rule
+
+        default = None
+
+        if vartype == 'choice':
+                # If there is just one option, use it
+                if len(choices) == 1:
+                        default = choices[0][0]
+        elif vartype == 'y':
+                default = '*'
+        elif vartype == 'n':
+                default = 'n'
+        elif vartype == 'y/n':
+                default = 'y'
+        elif vartype == 'n/y':
+                default = 'n'
+        else:
+                raise RuntimeError("Unknown variable type: %s" % vartype)
+
+        return default
+
+## Get option from a rule.
+#
+# @param rule   Rule for a variable
+# @param value  Current value of the variable
+#
+# @return Option (string) to ask or None which means not to ask.
+#
+def rule_get_option(rule, value):
+        varname, vartype, name, choices, cond = rule
+
+        option = None
+
+        if vartype == 'choice':
+                # If there is just one option, don't ask
+                if len(choices) != 1:
+                        if (value == None):
+                                option = "?     %s --> " % name
+                        else:
+                                option = "      %s [%s] --> " % (name, value)
+        elif vartype == 'y':
+                pass
+        elif vartype == 'n':
+                pass
+        elif vartype == 'y/n':
+                option = "  <%s> %s " % (yes_no(value), name)
+        elif vartype == 'n/y':
+                option ="  <%s> %s " % (yes_no(value), name)
+        else:
+                raise RuntimeError("Unknown variable type: %s" % vartype)
+
+        return option
+
+## Check if variable value is valid.
+#
+# @param rule   Rule for the variable
+# @param value  Value of the variable
+#
+# @return       True if valid, False if not valid.
+#
+def rule_value_is_valid(rule, value):
+        varname, vartype, name, choices, cond = rule
+        
+        if value == None:
+                return True
+
+        if vartype == 'choice':
+                if not value in [choice[0] for choice in choices]:
+                        return False
+        elif vartype == 'y':
+                if value != 'y':
+                        return False
+        elif vartype == 'n':
+                if value != 'n':
+                        return False
+        elif vartype == 'y/n':
+                if not value in ['y', 'n']:
+                        return False
+        elif vartype == 'n/y':
+                if not value in ['y', 'n']:
+                        return False
+        else:
+                raise RuntimeError("Unknown variable type: %s" % vartype)
+
+        return True
+
+def create_output(mkname, mcname, config, rules):
         "Create output configuration"
         
@@ -238 +352 @@
                 sys.stderr.write("failed\n")
         
-        if (len(version) == 3):
+        if len(version) == 3:
                 revision = version[1]
-                if (version[0] != 1):
+                if version[0] != 1:
                         revision += 'M'
                 revision += ' (%s)' % version[2]
@@ -259 +373 @@
         defs = 'CONFIG_DEFS ='
         
-        for varname, vartype, name, choices, cond in ask_names:
-                if ((cond) and (not check_condition(cond, defaults, ask_names))):
+        for varname, vartype, name, choices, cond in rules:
+                if cond and (not check_condition(cond, config, rules)):
                         continue
                 
-                if (not varname in defaults):
-                        default = ''
+                if not varname in config:
+                        value = ''
                 else:
-                        default = defaults[varname]
-                        if (default == '*'):
-                                default = 'y'
-                
-                outmk.write('# %s\n%s = %s\n\n' % (name, varname, default))
-                
-                if ((vartype == "y") or (vartype == "n") or (vartype == "y/n") or (vartype == "n/y")):
-                        if (default == "y"):
+                        value = config[varname]
+                        if (value == '*'):
+                                value = 'y'
+                
+                outmk.write('# %s\n%s = %s\n\n' % (name, varname, value))
+                
+                if vartype in ["y", "n", "y/n", "n/y"]:
+                        if value == "y":
                                 outmc.write('/* %s */\n#define %s\n\n' % (name, varname))
                                 defs += ' -D%s' % varname
                 else:
-                        outmc.write('/* %s */\n#define %s %s\n#define %s_%s\n\n' % (name, varname, default, varname, default))
-                        defs += ' -D%s=%s -D%s_%s' % (varname, default, varname, default)
-        
-        if (revision is not None):
+                        outmc.write('/* %s */\n#define %s %s\n#define %s_%s\n\n' % (name, varname, value, varname, value))
+                        defs += ' -D%s=%s -D%s_%s' % (varname, value, varname, value)
+        
+        if revision is not None:
                 outmk.write('REVISION = %s\n' % revision)
                 outmc.write('#define REVISION %s\n' % revision)
@@ -299 +413 @@
         return list
 
-def read_preconfigured(root, fname, screen, defaults):
+## Choose a profile and load configuration presets.
+#
+def load_presets(root, fname, screen, config):
         options = []
         opt2path = {}
@@ -309 +425 @@
                 canon = os.path.join(path, fname)
                 
-                if ((os.path.isdir(path)) and (os.path.exists(canon)) and (os.path.isfile(canon))):
+                if os.path.isdir(path) and os.path.exists(canon) and os.path.isfile(canon):
                         subprofile = False
                         
@@ -317 +433 @@
                                 subcanon = os.path.join(subpath, fname)
                                 
-                                if ((os.path.isdir(subpath)) and (os.path.exists(subcanon)) and (os.path.isfile(subcanon))):
+                                if os.path.isdir(subpath) and os.path.exists(subcanon) and os.path.isfile(subcanon):
                                         subprofile = True
                                         options.append("%s (%s)" % (name, subname))
@@ -323 +439 @@
                                         cnt += 1
                         
-                        if (not subprofile):
+                        if not subprofile:
                                 options.append(name)
                                 opt2path[cnt] = (canon, None)
@@ -330 +446 @@
         (button, value) = xtui.choice_window(screen, 'Load preconfigured defaults', 'Choose configuration profile', options, None)
         
-        if (button == 'cancel'):
+        if button == 'cancel':
                 return None
         
-        read_defaults(opt2path[value][0], defaults)
-        if (opt2path[value][1] != None):
-                read_defaults(opt2path[value][1], defaults)
+        read_config(opt2path[value][0], config)
+        if opt2path[value][1] != None:
+                read_config(opt2path[value][1], config)
 
 def main():
-        defaults = {}
-        ask_names = []
-        
-        # Parse configuration file
-        parse_config(INPUT, ask_names)
-        
-        # Read defaults from previous run
+        config = {}
+        rules = []
+        
+        # Parse rules file
+        parse_rules(RULES_FILE, rules)
+        
+        # Read configuration from previous run
         if os.path.exists(MAKEFILE):
-                read_defaults(MAKEFILE, defaults)
-        
-        # Default mode: only check defaults and regenerate configuration
-        if ((len(sys.argv) >= 3) and (sys.argv[2] == 'default')):
-                if (check_choices(defaults, ask_names)):
-                        create_output(MAKEFILE, MACROS, defaults, ask_names)
+                read_config(MAKEFILE, config)
+        
+        # Default mode: only check values and regenerate configuration files
+        if (len(sys.argv) >= 3) and (sys.argv[2] == 'default'):
+                if (infer_verify_choices(config, rules)):
+                        create_output(MAKEFILE, MACROS, config, rules)
                         return 0
         
-        # Check mode: only check defaults
-        if ((len(sys.argv) >= 3) and (sys.argv[2] == 'check')):
-                if (check_choices(defaults, ask_names)):
+        # Check mode: only check configuration
+        if (len(sys.argv) >= 3) and (sys.argv[2] == 'check'):
+                if infer_verify_choices(config, rules):
                         return 0
                 return 1
@@ -366 +482 @@
                 while True:
                         
-                        # Cancel out all defaults which have to be deduced
-                        for varname, vartype, name, choices, cond in ask_names:
-                                if ((vartype == 'y') and (varname in defaults) and (defaults[varname] == '*')):
-                                        defaults[varname] = None
+                        # Cancel out all values which have to be deduced
+                        for varname, vartype, name, choices, cond in rules:
+                                if (vartype == 'y') and (varname in config) and (config[varname] == '*'):
+                                        config[varname] = None
                         
                         options = []
@@ -377 +493 @@
                         options.append("  --- Load preconfigured defaults ... ")
                         
-                        for varname, vartype, name, choices, cond in ask_names:
-                                
-                                if ((cond) and (not check_condition(cond, defaults, ask_names))):
+                        for rule in rules:
+                                varname, vartype, name, choices, cond = rule
+                                
+                                if cond and (not check_condition(cond, config, rules)):
                                         continue
                                 
-                                if (varname == selname):
+                                if varname == selname:
                                         position = cnt
                                 
-                                if (not varname in defaults):
-                                        default = None
+                                if not varname in config:
+                                        value = None
                                 else:
-                                        default = defaults[varname]
-                                
-                                if (vartype == 'choice'):
-                                        # Check if the default is an acceptable value
-                                        if ((default) and (not default in [choice[0] for choice in choices])):
-                                                default = None
-                                                defaults.pop(varname)
-                                        
-                                        # If there is just one option, use it
-                                        if (len(choices) == 1):
-                                                defaults[varname] = choices[0][0]
-                                                continue
-                                        
-                                        if (default == None):
-                                                options.append("?     %s --> " % name)
-                                        else:
-                                                options.append("      %s [%s] --> " % (name, default))
-                                elif (vartype == 'y'):
-                                        defaults[varname] = '*'
-                                        continue
-                                elif (vartype == 'n'):
-                                        defaults[varname] = 'n'
-                                        continue
-                                elif (vartype == 'y/n'):
-                                        if (default == None):
-                                                default = 'y'
-                                                defaults[varname] = default
-                                        options.append("  <%s> %s " % (yes_no(default), name))
-                                elif (vartype == 'n/y'):
-                                        if (default == None):
-                                                default = 'n'
-                                                defaults[varname] = default
-                                        options.append("  <%s> %s " % (yes_no(default), name))
-                                else:
-                                        raise RuntimeError("Unknown variable type: %s" % vartype)
+                                        value = config[varname]
+                                
+                                if not rule_value_is_valid(rule, value):
+                                        value = None
+
+                                default = rule_get_default(rule)
+                                if default != None:
+                                        value = default
+                                        config[varname] = default
+
+                                option = rule_get_option(rule, value)
+                                if option != None:
+                                        options.append(option)
                                 
                                 opt2row[cnt] = (varname, vartype, name, choices)
@@ -433 +528 @@
                         (button, value) = xtui.choice_window(screen, 'HelenOS configuration', 'Choose configuration option', options, position)
                         
-                        if (button == 'cancel'):
+                        if button == 'cancel':
                                 return 'Configuration canceled'
                         
-                        if (button == 'done'):
-                                if (check_choices(defaults, ask_names)):
+                        if button == 'done':
+                                if (infer_verify_choices(config, rules)):
                                         break
                                 else:
@@ -443 +538 @@
                                         continue
                         
-                        if (value == 0):
-                                read_preconfigured(PRECONF, MAKEFILE, screen, defaults)
+                        if value == 0:
+                                load_presets(PRESETS_DIR, MAKEFILE, screen, config)
                                 position = 1
                                 continue
                         
                         position = None
-                        if (not value in opt2row):
+                        if not value in opt2row:
                                 raise RuntimeError("Error selecting value: %s" % value)
                         
                         (selname, seltype, name, choices) = opt2row[value]
                         
-                        if (not selname in defaults):
-                                        default = None
+                        if not selname in config:
+                                value = None
                         else:
-                                default = defaults[selname]
-                        
-                        if (seltype == 'choice'):
-                                defaults[selname] = subchoice(screen, name, choices, default)
-                        elif ((seltype == 'y/n') or (seltype == 'n/y')):
-                                if (defaults[selname] == 'y'):
-                                        defaults[selname] = 'n'
+                                value = config[selname]
+                        
+                        if seltype == 'choice':
+                                config[selname] = subchoice(screen, name, choices, value)
+                        elif (seltype == 'y/n') or (seltype == 'n/y'):
+                                if config[selname] == 'y':
+                                        config[selname] = 'n'
                                 else:
-                                        defaults[selname] = 'y'
+                                        config[selname] = 'y'
         finally:
                 xtui.screen_done(screen)
         
-        create_output(MAKEFILE, MACROS, defaults, ask_names)
+        create_output(MAKEFILE, MACROS, config, rules)
         return 0
 

uspace/Makefile

@@ -118 +118 @@
         DIRS += drv/ns8250
         DIRS += drv/uhci
+        DIRS += drv/usbhub
         DIRS += drv/usbkbd
 endif

uspace/drv/uhci/Makefile

@@ -33 +33 @@
 
 SOURCES = \
-        main.c
+        main.c \
+        transfers.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/drv/uhci/main.c

@@ -28 +28 @@
 #include <usb/hcdhubd.h>
 #include <errno.h>
+#include "uhci.h"
 
-static int enqueue_transfer_out(usb_hc_device_t *hc,
-    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
-    void *buffer, size_t size,
-    usb_hcd_transfer_callback_out_t callback, void *arg)
-{
-        printf("UHCI: transfer OUT [%d.%d (%s); %u]\n",
-            dev->address, endpoint->endpoint,
-            usb_str_transfer_type(endpoint->transfer_type),
-            size);
-        return ENOTSUP;
-}
-
-static int enqueue_transfer_setup(usb_hc_device_t *hc,
-    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
-    void *buffer, size_t size,
-    usb_hcd_transfer_callback_out_t callback, void *arg)
-{
-        printf("UHCI: transfer SETUP [%d.%d (%s); %u]\n",
-            dev->address, endpoint->endpoint,
-            usb_str_transfer_type(endpoint->transfer_type),
-            size);
-        return ENOTSUP;
-}
-
-static int enqueue_transfer_in(usb_hc_device_t *hc,
-    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
-    void *buffer, size_t size,
-    usb_hcd_transfer_callback_in_t callback, void *arg)
-{
-        printf("UHCI: transfer IN [%d.%d (%s); %u]\n",
-            dev->address, endpoint->endpoint,
-            usb_str_transfer_type(endpoint->transfer_type),
-            size);
-        return ENOTSUP;
-}
-
-static usb_hcd_transfer_ops_t uhci_transfer_ops = {
-        .transfer_out = enqueue_transfer_out,
-        .transfer_in = enqueue_transfer_in,
-        .transfer_setup = enqueue_transfer_setup
+static device_ops_t uhci_ops = {
+        .interfaces[USBHC_DEV_IFACE] = &uhci_iface,
 };
 
-static int uhci_add_hc(usb_hc_device_t *device)
+static int uhci_add_device(device_t *device)
 {
-        device->transfer_ops = &uhci_transfer_ops;
+        device->ops = &uhci_ops;
 
         /*
          * We need to announce the presence of our root hub.
-         * Commented out until the problem which causes the whole task to
-         * block is solved.
          */
-        //usb_hcd_add_root_hub(device);
+        usb_hcd_add_root_hub(device);
 
         return EOK;
 }
 
-usb_hc_driver_t uhci_driver = {
-        .name = "uhci",
-        .add_hc = uhci_add_hc
+static driver_ops_t uhci_driver_ops = {
+        .add_device = uhci_add_device,
+};
+
+static driver_t uhci_driver = {
+        .name = NAME,
+        .driver_ops = &uhci_driver_ops
 };
 
@@ -95 +60 @@
          * Do some global initializations.
          */
+        sleep(5);
 
-        return usb_hcd_main(&uhci_driver);
+        return driver_main(&uhci_driver);
 }

uspace/drv/uhci/uhci.ma

@@ -1 +1 @@
 10 pci/ven=8086&dev=7020
-10 usb&hc=uhci
-10 usb&hc=uhci&hub
+

uspace/drv/vhc/Makefile

@@ -39 +39 @@
 
 SOURCES = \
+        addrmgm.c \
         conndev.c \
         connhost.c \

uspace/drv/vhc/conn.h

@@ -38 +38 @@
 #include <usb/usb.h>
 #include <usb/hcdhubd.h>
+#include <usbhc_iface.h>
 #include "vhcd.h"
 #include "devices.h"
@@ -44 +45 @@
 
 usb_hcd_transfer_ops_t vhc_transfer_ops;
+usbhc_iface_t vhc_iface;
+
+void address_init(void);
+int reserve_default_address(device_t *);
+int release_default_address(device_t *);
+int request_address(device_t *, usb_address_t *);
+int release_address(device_t *, usb_address_t);
+int bind_address(device_t *, usb_address_t, devman_handle_t);
+
+int tell_address(device_t *, devman_handle_t, usb_address_t *);
 
 void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *);

uspace/drv/vhc/connhost.c

@@ -43 +43 @@
 typedef struct {
         usb_direction_t direction;
-        usb_hcd_transfer_callback_out_t out_callback;
-        usb_hcd_transfer_callback_in_t in_callback;
-        usb_hc_device_t *hc;
+        usbhc_iface_transfer_out_callback_t out_callback;
+        usbhc_iface_transfer_in_callback_t in_callback;
+        device_t *dev;
         void *arg;
 } transfer_info_t;
@@ -56 +56 @@
         switch (transfer->direction) {
                 case USB_DIRECTION_IN:
-                        transfer->in_callback(transfer->hc,
+                        transfer->in_callback(transfer->dev,
                             size, outcome,
                             transfer->arg);
                         break;
                 case USB_DIRECTION_OUT:
-                        transfer->out_callback(transfer->hc,
+                        transfer->out_callback(transfer->dev,
                             outcome,
                             transfer->arg);
@@ -73 +73 @@
 }
 
-static transfer_info_t *create_transfer_info(usb_hc_device_t *hc,
+static transfer_info_t *create_transfer_info(device_t *dev,
     usb_direction_t direction, void *arg)
 {
@@ -82 +82 @@
         transfer->out_callback = NULL;
         transfer->arg = arg;
-        transfer->hc = hc;
+        transfer->dev = dev;
 
         return transfer;
 }
 
-static int enqueue_transfer_out(usb_hc_device_t *hc,
-    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
+static int enqueue_transfer_out(device_t *dev,
+    usb_target_t target, usb_transfer_type_t transfer_type,
     void *buffer, size_t size,
-    usb_hcd_transfer_callback_out_t callback, void *arg)
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
 {
         printf(NAME ": transfer OUT [%d.%d (%s); %u]\n",
-            dev->address, endpoint->endpoint,
-            usb_str_transfer_type(endpoint->transfer_type),
+            target.address, target.endpoint,
+            usb_str_transfer_type(transfer_type),
             size);
 
         transfer_info_t *transfer
-            = create_transfer_info(hc, USB_DIRECTION_OUT, arg);
+            = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
         transfer->out_callback = callback;
-
-        usb_target_t target = {
-                .address = dev->address,
-                .endpoint = endpoint->endpoint
-        };
 
         hc_add_transaction_to_device(false, target, buffer, size,
@@ -112 +107 @@
 }
 
-static int enqueue_transfer_setup(usb_hc_device_t *hc,
-    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
+static int enqueue_transfer_setup(device_t *dev,
+    usb_target_t target, usb_transfer_type_t transfer_type,
     void *buffer, size_t size,
-    usb_hcd_transfer_callback_out_t callback, void *arg)
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
 {
         printf(NAME ": transfer SETUP [%d.%d (%s); %u]\n",
-            dev->address, endpoint->endpoint,
-            usb_str_transfer_type(endpoint->transfer_type),
+            target.address, target.endpoint,
+            usb_str_transfer_type(transfer_type),
             size);
 
         transfer_info_t *transfer
-            = create_transfer_info(hc, USB_DIRECTION_OUT, arg);
+            = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
         transfer->out_callback = callback;
-
-        usb_target_t target = {
-                .address = dev->address,
-                .endpoint = endpoint->endpoint
-        };
 
         hc_add_transaction_to_device(true, target, buffer, size,
@@ -137 +127 @@
 }
 
-static int enqueue_transfer_in(usb_hc_device_t *hc,
-    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
+static int enqueue_transfer_in(device_t *dev,
+    usb_target_t target, usb_transfer_type_t transfer_type,
     void *buffer, size_t size,
-    usb_hcd_transfer_callback_in_t callback, void *arg)
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
 {
         printf(NAME ": transfer IN [%d.%d (%s); %u]\n",
-            dev->address, endpoint->endpoint,
-            usb_str_transfer_type(endpoint->transfer_type),
+            target.address, target.endpoint,
+            usb_str_transfer_type(transfer_type),
             size);
 
         transfer_info_t *transfer
-            = create_transfer_info(hc, USB_DIRECTION_IN, arg);
+            = create_transfer_info(dev, USB_DIRECTION_IN, arg);
         transfer->in_callback = callback;
-
-        usb_target_t target = {
-                .address = dev->address,
-                .endpoint = endpoint->endpoint
-        };
 
         hc_add_transaction_from_device(target, buffer, size,
@@ -163 +148 @@
 
 
-usb_hcd_transfer_ops_t vhc_transfer_ops = {
-        .transfer_out = enqueue_transfer_out,
-        .transfer_in = enqueue_transfer_in,
-        .transfer_setup = enqueue_transfer_setup
+static int interrupt_out(device_t *dev, usb_target_t target,
+    void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        return enqueue_transfer_out(dev, target, USB_TRANSFER_INTERRUPT,
+            data, size,
+            callback, arg);
+}
+
+static int interrupt_in(device_t *dev, usb_target_t target,
+    void *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        return enqueue_transfer_in(dev, target, USB_TRANSFER_INTERRUPT,
+            data, size,
+            callback, arg);
+}
+
+static int control_write_setup(device_t *dev, usb_target_t target,
+    void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL,
+            data, size,
+            callback, arg);
+}
+
+static int control_write_data(device_t *dev, usb_target_t target,
+    void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL,
+            data, size,
+            callback, arg);
+}
+
+static int control_write_status(device_t *dev, usb_target_t target,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL,
+            NULL, 0,
+            callback, arg);
+}
+
+static int control_read_setup(device_t *dev, usb_target_t target,
+    void *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL,
+            data, size,
+            callback, arg);
+}
+
+static int control_read_data(device_t *dev, usb_target_t target,
+    void *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL,
+            data, size,
+            callback, arg);
+}
+
+static int control_read_status(device_t *dev, usb_target_t target,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL,
+            NULL, 0,
+            callback, arg);
+}
+
+
+usbhc_iface_t vhc_iface = {
+        .tell_address = tell_address,
+
+        .reserve_default_address = reserve_default_address,
+        .release_default_address = release_default_address,
+        .request_address = request_address,
+        .bind_address = bind_address,
+        .release_address = release_address,
+
+        .interrupt_out = interrupt_out,
+        .interrupt_in = interrupt_in,
+
+        .control_write_setup = control_write_setup,
+        .control_write_data = control_write_data,
+        .control_write_status = control_write_status,
+
+        .control_read_setup = control_read_setup,
+        .control_read_data = control_read_data,
+        .control_read_status = control_read_status
 };
 

uspace/drv/vhc/hcd.c

@@ -52 +52 @@
 #include "conn.h"
 
+static device_ops_t vhc_ops = {
+        .interfaces[USBHC_DEV_IFACE] = &vhc_iface,
+        .default_handler = default_connection_handler
+};
 
 static int vhc_count = 0;
-static int vhc_add_device(usb_hc_device_t *dev)
+static int vhc_add_device(device_t *dev)
 {
         /*
@@ -65 +69 @@
         vhc_count++;
 
-        dev->transfer_ops = &vhc_transfer_ops;
-        dev->generic->ops->default_handler = default_connection_handler;
+        dev->ops = &vhc_ops;
+
+        /*
+         * Initialize address management.
+         */
+        address_init();
 
         /*
@@ -79 +87 @@
 }
 
-static usb_hc_driver_t vhc_driver = {
+static driver_ops_t vhc_driver_ops = {
+        .add_device = vhc_add_device,
+};
+
+static driver_t vhc_driver = {
         .name = NAME,
-        .add_hc = &vhc_add_device
+        .driver_ops = &vhc_driver_ops
 };
 
@@ -114 +126 @@
         sleep(4);
 
-        return usb_hcd_main(&vhc_driver);
+        return driver_main(&vhc_driver);
 }
 

uspace/drv/vhc/vhc.ma

@@ -1 +1 @@
 10 usb&hc=vhc
-10 usb&hc=vhc&hub
+

uspace/lib/block/libblock.c

@@ -66 +66 @@
         fibril_mutex_t lock;
         size_t lblock_size;             /**< Logical block size. */
+        unsigned blocks_cluster;        /**< Physical blocks per block_t */
         unsigned block_count;           /**< Total number of blocks. */
         unsigned blocks_cached;         /**< Number of cached blocks. */
@@ -90 +91 @@
 static int get_block_size(int dev_phone, size_t *bsize);
 static int get_num_blocks(int dev_phone, aoff64_t *nblocks);
+static aoff64_t ba_ltop(devcon_t *devcon, aoff64_t lba);
 
 static devcon_t *devcon_search(devmap_handle_t devmap_handle)
@@ -259 +261 @@
 {
         block_t *b = hash_table_get_instance(item, block_t, hash_link);
-        return b->boff == *key;
+        return b->lba == *key;
 }
 
@@ -292 +294 @@
         cache->mode = mode;
 
-        /* No block size translation a.t.m. */
-        assert(cache->lblock_size == devcon->pblock_size);
+        /* Allow 1:1 or small-to-large block size translation */
+        if (cache->lblock_size % devcon->pblock_size != 0)
+                return ENOTSUP;
+
+        cache->blocks_cluster = cache->lblock_size / devcon->pblock_size;
 
         if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1,
@@ -329 +334 @@
                 if (b->dirty) {
                         memcpy(devcon->comm_area, b->data, b->size);
-                        rc = write_blocks(devcon, b->boff, 1);
+                        rc = write_blocks(devcon, b->pba, cache->blocks_cluster);
                         if (rc != EOK)
                                 return rc;
                 }
 
-                unsigned long key = b->boff;
+                unsigned long key = b->lba;
                 hash_table_remove(&cache->block_hash, &key, 1);
                 
@@ -375 +380 @@
  *                              block pointer on success.
  * @param devmap_handle         Device handle of the block device.
- * @param boff                  Block offset.
+ * @param ba                    Block address (logical).
  * @param flags                 If BLOCK_FLAGS_NOREAD is specified, block_get()
  *                              will not read the contents of the block from the
@@ -382 +387 @@
  * @return                      EOK on success or a negative error code.
  */
-int block_get(block_t **block, devmap_handle_t devmap_handle, aoff64_t boff, int flags)
+int block_get(block_t **block, devmap_handle_t devmap_handle, aoff64_t ba, int flags)
 {
         devcon_t *devcon;
@@ -388 +393 @@
         block_t *b;
         link_t *l;
-        unsigned long key = boff;
+        unsigned long key = ba;
         int rc;
         
@@ -465 +470 @@
                                 fibril_mutex_lock(&devcon->comm_area_lock);
                                 memcpy(devcon->comm_area, b->data, b->size);
-                                rc = write_blocks(devcon, b->boff, 1);
+                                rc = write_blocks(devcon, b->pba,
+                                    cache->blocks_cluster);
                                 fibril_mutex_unlock(&devcon->comm_area_lock);
                                 if (rc != EOK) {
@@ -495 +501 @@
                          */
                         list_remove(&b->free_link);
-                        temp_key = b->boff;
+                        temp_key = b->lba;
                         hash_table_remove(&cache->block_hash, &temp_key, 1);
                 }
@@ -502 +508 @@
                 b->devmap_handle = devmap_handle;
                 b->size = cache->lblock_size;
-                b->boff = boff;
+                b->lba = ba;
+                b->pba = ba_ltop(devcon, b->lba);
                 hash_table_insert(&cache->block_hash, &key, &b->hash_link);
 
@@ -519 +526 @@
                          */
                         fibril_mutex_lock(&devcon->comm_area_lock);
-                        rc = read_blocks(devcon, b->boff, 1);
+                        rc = read_blocks(devcon, b->pba, cache->blocks_cluster);
                         memcpy(b->data, devcon->comm_area, cache->lblock_size);
                         fibril_mutex_unlock(&devcon->comm_area_lock);
@@ -580 +587 @@
                 fibril_mutex_lock(&devcon->comm_area_lock);
                 memcpy(devcon->comm_area, block->data, block->size);
-                rc = write_blocks(devcon, block->boff, 1);
+                rc = write_blocks(devcon, block->pba, cache->blocks_cluster);
                 fibril_mutex_unlock(&devcon->comm_area_lock);
                 block->dirty = false;
@@ -614 +621 @@
                          * Take the block out of the cache and free it.
                          */
-                        unsigned long key = block->boff;
+                        unsigned long key = block->lba;
                         hash_table_remove(&cache->block_hash, &key, 1);
                         free(block);
@@ -712 +719 @@
  *
  * @param devmap_handle Device handle of the block device.
- * @param ba            Address of first block.
+ * @param ba            Address of first block (physical).
  * @param cnt           Number of blocks.
  * @param src           Buffer for storing the data.
@@ -740 +747 @@
  *
  * @param devmap_handle Device handle of the block device.
- * @param ba            Address of first block.
+ * @param ba            Address of first block (physical).
  * @param cnt           Number of blocks.
  * @param src           The data to be written.
@@ -879 +886 @@
 }
 
+/** Convert logical block address to physical block address. */
+static aoff64_t ba_ltop(devcon_t *devcon, aoff64_t lba)
+{
+        assert(devcon->cache != NULL);
+        return lba * devcon->cache->blocks_cluster;
+}
+
 /** @}
  */

uspace/lib/block/libblock.h

@@ -73 +73 @@
         /** Handle of the device where the block resides. */
         devmap_handle_t devmap_handle;
-        /** Block offset on the block device. Counted in 'size'-byte blocks. */
-        aoff64_t boff;
+        /** Logical block address */
+        aoff64_t lba;
+        /** Physical block address */
+        aoff64_t pba;
         /** Size of the block. */
         size_t size;

uspace/lib/drv/generic/remote_usbhc.c

@@ -52 +52 @@
 static void remote_usbhc_control_read_data(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_control_read_status(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_reserve_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_release_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_request_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_bind_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_release_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
 //static void remote_usbhc(device_t *, void *, ipc_callid_t, ipc_call_t *);
 
@@ -57 +62 @@
 static remote_iface_func_ptr_t remote_usbhc_iface_ops [] = {
         remote_usbhc_get_address,
+
         remote_usbhc_get_buffer,
+
+        remote_usbhc_reserve_default_address,
+        remote_usbhc_release_default_address,
+
+        remote_usbhc_request_address,
+        remote_usbhc_bind_address,
+        remote_usbhc_release_address,
+
         remote_usbhc_interrupt_out,
         remote_usbhc_interrupt_in,
+
         remote_usbhc_control_write_setup,
         remote_usbhc_control_write_data,
         remote_usbhc_control_write_status,
+
         remote_usbhc_control_read_setup,
         remote_usbhc_control_read_data,
@@ -134 +150 @@
         free(trans->buffer);
         free(trans);
+}
+
+void remote_usbhc_reserve_default_address(device_t *device, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+
+        if (!usb_iface->reserve_default_address) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        int rc = usb_iface->reserve_default_address(device);
+
+        ipc_answer_0(callid, rc);
+}
+
+void remote_usbhc_release_default_address(device_t *device, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+
+        if (!usb_iface->release_default_address) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        int rc = usb_iface->release_default_address(device);
+
+        ipc_answer_0(callid, rc);
+}
+
+void remote_usbhc_request_address(device_t *device, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+
+        if (!usb_iface->request_address) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        usb_address_t address;
+        int rc = usb_iface->request_address(device, &address);
+        if (rc != EOK) {
+                ipc_answer_0(callid, rc);
+        } else {
+                ipc_answer_1(callid, EOK, (ipcarg_t) address);
+        }
+}
+
+void remote_usbhc_bind_address(device_t *device, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+
+        if (!usb_iface->bind_address) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        usb_address_t address = (usb_address_t) IPC_GET_ARG1(*call);
+        devman_handle_t handle = (devman_handle_t) IPC_GET_ARG2(*call);
+
+        int rc = usb_iface->bind_address(device, address, handle);
+
+        ipc_answer_0(callid, rc);
+}
+
+void remote_usbhc_release_address(device_t *device, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+
+        if (!usb_iface->release_address) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        usb_address_t address = (usb_address_t) IPC_GET_ARG1(*call);
+
+        int rc = usb_iface->release_address(device, address);
+
+        ipc_answer_0(callid, rc);
 }
 

uspace/lib/drv/include/usbhc_iface.h

@@ -111 +111 @@
 
 
+        /** Reserve usage of default address.
+         * This call informs the host controller that the caller will be
+         * using default USB address. It is duty of the HC driver to ensure
+         * that only single entity will have it reserved.
+         * The address is returned via IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS.
+         * The caller can start using the address after receiving EOK
+         * answer.
+         */
+        IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS,
+
+        /** Release usage of default address.
+         * @see IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS
+         */
+        IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS,
+
+        /** Asks for address assignment by host controller.
+         * Answer:
+         * - ELIMIT - host controller run out of address
+         * - EOK - address assigned
+         * Answer arguments:
+         * - assigned address
+         *
+         * The address must be released by via IPC_M_USBHC_RELEASE_ADDRESS.
+         */
+        IPC_M_USBHC_REQUEST_ADDRESS,
+
+        /** Bind USB address with devman handle.
+         * Parameters:
+         * - USB address
+         * - devman handle
+         * Answer:
+         * - EOK - address binded
+         * - ENOENT - address is not in use
+         */
+        IPC_M_USBHC_BIND_ADDRESS,
+
+        /** Release address in use.
+         * Arguments:
+         * - address to be released
+         * Answer:
+         * - ENOENT - address not in use
+         * - EPERM - trying to release default USB address
+         */
+        IPC_M_USBHC_RELEASE_ADDRESS,
+
+
         /** Send interrupt data to device.
          * See explanation at usb_iface_funcs_t (OUT transaction).
@@ -183 +229 @@
 typedef struct {
         int (*tell_address)(device_t *, devman_handle_t, usb_address_t *);
+
+        int (*reserve_default_address)(device_t *);
+        int (*release_default_address)(device_t *);
+        int (*request_address)(device_t *, usb_address_t *);
+        int (*bind_address)(device_t *, usb_address_t, devman_handle_t);
+        int (*release_address)(device_t *, usb_address_t);
 
         usbhc_iface_transfer_out_t interrupt_out;

uspace/lib/usb/Makefile

@@ -35 +35 @@
         src/hcdhubd.c \
         src/hcdrv.c \
-        src/hubdrv.c \
         src/localdrv.c \
         src/remotedrv.c \

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

@@ -166 +166 @@
 
 int usb_hcd_main(usb_hc_driver_t *);
-int usb_hcd_add_root_hub(usb_hc_device_t *dev);
+int usb_hcd_add_root_hub(device_t *dev);
 
 /**
@@ -191 +191 @@
  */
 
+device_t *usb_hc_connect(device_t *);
 
 int usb_hc_async_interrupt_out(usb_hc_device_t *, usb_target_t,

uspace/lib/usb/include/usb/usbdrv.h

@@ -41 +41 @@
 int usb_drv_hc_connect(device_t *, unsigned int);
 
+int usb_drv_reserve_default_address(int);
+int usb_drv_release_default_address(int);
+usb_address_t usb_drv_request_address(int);
+int usb_drv_bind_address(int, usb_address_t, devman_handle_t);
+int usb_drv_release_address(int, usb_address_t);
+
 usb_address_t usb_drv_get_my_address(int, device_t *);
 

uspace/lib/usb/src/hcdhubd.c

@@ -51 +51 @@
  */
 static int add_device(device_t *dev) {
-        bool is_hc = str_cmp(dev->name, USB_HUB_DEVICE_NAME) != 0;
-        printf("%s: add_device(name=\"%s\")\n", hc_driver->name, dev->name);
-
-        if (is_hc) {
-                /*
-                 * We are the HC itself.
-                 */
-                return usb_add_hc_device(dev);
-        } else {
-                /*
-                 * We are some (maybe deeply nested) hub.
-                 * Thus, assign our own operations and explore already
-                 * connected devices.
-                 */
-                return usb_add_hub_device(dev);
-        }
+        return ENOTSUP;
 }
 
@@ -105 +90 @@
  * @return Error code.
  */
-int usb_hcd_add_root_hub(usb_hc_device_t *dev) {
+int usb_hcd_add_root_hub(device_t *dev)
+{
         char *id;
-        int rc = asprintf(&id, "usb&hc=%s&hub", dev->generic->name);
+        int rc = asprintf(&id, "usb&hub");
         if (rc <= 0) {
                 return rc;
         }
 
-        rc = usb_hc_add_child_device(dev->generic, USB_HUB_DEVICE_NAME, id, true);
+        rc = usb_hc_add_child_device(dev, USB_HUB_DEVICE_NAME, id, true);
         if (rc != EOK) {
                 free(id);
@@ -133 +119 @@
         int rc;
 
+        async_usleep(1000);
+
         device_t *child = create_device();
         match_id_t *match_id = NULL;
@@ -196 +184 @@
         printf("%s: about to add child device `%s' (%s)\n", hc_driver->name,
                         name, match_id);
+
+        /*
+         * Seems that creating fibril which postpones the action
+         * is the best solution.
+         */
+        create_fibril = true;
 
         struct child_device_info *child_info

uspace/lib/usb/src/hcdhubd_private.h

@@ -46 +46 @@
 usb_address_t usb_get_address_by_handle(devman_handle_t);
 int usb_add_hc_device(device_t *);
-int usb_add_hub_device(device_t *);
 
 /** lowest allowed usb address */

uspace/lib/usb/src/hcdrv.c

@@ -47 +47 @@
 LIST_INITIALIZE(hc_list);
 
+/* Fake driver to have the name item initialized. */
+static usb_hc_driver_t hc_driver_fake = {
+        .name = "HCD",
+};
+
 /** Our HC driver. */
-usb_hc_driver_t *hc_driver = NULL;
+usb_hc_driver_t *hc_driver = &hc_driver_fake;
 
 int usb_lowest_address = 1;
@@ -86 +91 @@
 int usb_add_hc_device(device_t *dev)
 {
+        return ENOTSUP;
         usb_hc_device_t *hc_dev = usb_hc_device_create(dev);
 

uspace/lib/usb/src/localdrv.c

@@ -39 +39 @@
 #include <errno.h>
 
+/** Find host controller when handled by current task.
+ *
+ * @param dev Device asking for connection.
+ * @return Device structure corresponding to parent host controller.
+ * @retval NULL Corresponding host controller not found.
+ */
+device_t *usb_hc_connect(device_t *dev)
+{
+        /*
+         * FIXME: this will not work when some hub on the path is
+         * not driven by the same task.
+         */
+        device_t *parent = dev;
+        while (parent->parent != NULL) {
+                parent = parent->parent;
+        }
+        
+        if (dev == parent) {
+                printf("FIXME in %s:%d encountered!\n", __FILE__, __LINE__);
+                parent = NULL;
+        }
+
+        return parent;
+}
+
 /** Information about pending transaction on HC. */
 typedef struct {

uspace/lib/usb/src/usbdrv.c

@@ -55 +55 @@
 /** Connect to host controller the device is physically attached to.
  *
- * @param handle Device handle.
+ * @param dev Device asking for connection.
  * @param flags Connection flags (blocking connection).
  * @return Phone to corresponding HC or error code.
@@ -98 +98 @@
 
         return (usb_address_t) address;
+}
+
+/** Tell HC to reserve default address.
+ *
+ * @param phone Open phone to host controller driver.
+ * @return Error code.
+ */
+int usb_drv_reserve_default_address(int phone)
+{
+        return async_req_0_0(phone, IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS);
+}
+
+/** Tell HC to release default address.
+ *
+ * @param phone Open phone to host controller driver.
+ * @return Error code.
+ */
+int usb_drv_release_default_address(int phone)
+{
+        return async_req_0_0(phone, IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS);
+}
+
+/** Ask HC for free address assignment.
+ *
+ * @param phone Open phone to host controller driver.
+ * @return Assigned USB address or negative error code.
+ */
+usb_address_t usb_drv_request_address(int phone)
+{
+        ipcarg_t address;
+        int rc = async_req_0_1(phone, IPC_M_USBHC_REQUEST_ADDRESS, &address);
+        if (rc != EOK) {
+                return rc;
+        } else {
+                return (usb_address_t) address;
+        }
+}
+
+/** Inform HC about binding address with devman handle.
+ *
+ * @param phone Open phone to host controller driver.
+ * @param address Address to be binded.
+ * @param handle Devman handle of the device.
+ * @return Error code.
+ */
+int usb_drv_bind_address(int phone, usb_address_t address,
+    devman_handle_t handle)
+{
+        int rc = async_req_2_0(phone, IPC_M_USBHC_BIND_ADDRESS,
+            address, handle);
+
+        return rc;
+}
+
+/** Inform HC about address release.
+ *
+ * @param phone Open phone to host controller driver.
+ * @param address Address to be released.
+ * @return Error code.
+ */
+int usb_drv_release_address(int phone, usb_address_t address)
+{
+        return async_req_1_0(phone, IPC_M_USBHC_RELEASE_ADDRESS, address);
 }
 

uspace/srv/bd/file_bd/file_bd.c

@@ -56 +56 @@
 #define NAME "file_bd"
 
-static const size_t block_size = 512;
+#define DEFAULT_BLOCK_SIZE 512
+
+static size_t block_size;
 static aoff64_t num_blocks;
 static FILE *img;
@@ -63 +65 @@
 static fibril_mutex_t dev_lock;
 
+static void print_usage(void);
 static int file_bd_init(const char *fname);
 static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
@@ -71 +74 @@
 {
         int rc;
+        char *image_name;
+        char *device_name;
 
         printf(NAME ": File-backed block device driver\n");
 
-        if (argc != 3) {
-                printf("Expected two arguments (image name, device name).\n");
+        block_size = DEFAULT_BLOCK_SIZE;
+
+        ++argv; --argc;
+        while (*argv != NULL && (*argv)[0] == '-') {
+                /* Option */
+                if (str_cmp(*argv, "-b") == 0) {
+                        if (argc < 2) {
+                                printf("Argument missing.\n");
+                                print_usage();
+                                return -1;
+                        }
+
+                        rc = str_size_t(argv[1], NULL, 10, true, &block_size);
+                        if (rc != EOK || block_size == 0) {
+                                printf("Invalid block size '%s'.\n", argv[1]);
+                                print_usage();
+                                return -1;
+                        }
+                        ++argv; --argc;
+                } else {
+                        printf("Invalid option '%s'.\n", *argv);
+                        print_usage();
+                        return -1;
+                }
+                ++argv; --argc;
+        }
+
+        if (argc < 2) {
+                printf("Missing arguments.\n");
+                print_usage();
                 return -1;
         }
 
-        if (file_bd_init(argv[1]) != EOK)
+        image_name = argv[0];
+        device_name = argv[1];
+
+        if (file_bd_init(image_name) != EOK)
                 return -1;
 
-        rc = devmap_device_register(argv[2], &devmap_handle);
+        rc = devmap_device_register(device_name, &devmap_handle);
         if (rc != EOK) {
                 devmap_hangup_phone(DEVMAP_DRIVER);
-                printf(NAME ": Unable to register device %s.\n",
-                        argv[2]);
+                printf(NAME ": Unable to register device '%s'.\n",
+                        device_name);
                 return rc;
         }
@@ -96 +132 @@
         /* Not reached */
         return 0;
+}
+
+static void print_usage(void)
+{
+        printf("Usage: " NAME " [-b <block_size>] <image_file> <device_name>\n");
 }