Changes in / [45e9cc6:4144630] in mainline


Ignore:
Files:
1 added
8 deleted
30 edited

Legend:

Unmodified
Added
Removed

  • .bzrignore

    r45e9cc6 r4144630  
    9494./uspace/dist/drv/rootia32/
    9595./uspace/dist/drv/uhci/
    96 ./uspace/dist/drv/usbhub/
    9796./uspace/dist/drv/usbkbd/
    9897./uspace/dist/drv/vhc/
    … …  
    131130./uspace/drv/rootia32/rootia32
    132131./uspace/drv/uhci/uhci
    133 ./uspace/drv/usbhub/usbhub
    134132./uspace/drv/usbkbd/usbkbd
    135133./uspace/drv/vhc/vhc

  • boot/arch/amd64/Makefile.inc

    r45e9cc6 r4144630  
    4242        ns8250 \
    4343        uhci \
    44         usbhub \
    4544        usbkbd
    4645       

  • boot/arch/mips32/include/arch.h

    r45e9cc6 r4144630  
    4040
    4141#define MSIM_VIDEORAM_ADDRESS  0xb0000000
    42 #define MSIM_DORDER_ADDRESS    0xb0000100
     42#define MSIM_DORDER_ADDRESS    0xb0000004
    4343
    4444#ifndef __ASM__

  • contrib/conf/msim.conf

    r45e9cc6 r4144630  
    1616add dprinter printer 0x10000000
    1717add dkeyboard keyboard 0x10000000 2
    18 add dorder order 0x10000100 5
     18add dorder order 0x10000004 5

  • kernel/arch/mips32/src/exception.c

    r45e9cc6 r4144630  
    7474void istate_decode(istate_t *istate)
    7575{
    76         printf("epc=%p\tsta=%#010" PRIx32 "\t"
    77             "lo =%#010" PRIx32 "\thi =%#010" PRIx32 "\n",
     76        printf("epc=%p\tsta=%#0" PRIx32 "\t"
     77            "lo =%#0" PRIx32 "\thi =%#0" PRIx32 "\n",
    7878            (void *) istate->epc, istate->status,
    7979            istate->lo, istate->hi);
    8080       
    81         printf("a0 =%#010" PRIx32 "\ta1 =%#010" PRIx32 "\t"
    82             "a2 =%#010" PRIx32 "\ta3 =%#010" PRIx32 "\n",
     81        printf("a0 =%#0" PRIx32 "\ta1 =%#0" PRIx32 "\t"
     82            "a2 =%#0" PRIx32 "\ta3 =%#0" PRIx32 "\n",
    8383            istate->a0, istate->a1, istate->a2, istate->a3);
    8484       
    85         printf("t0 =%#010" PRIx32 "\tt1 =%#010" PRIx32 "\t"
    86             "t2 =%#010" PRIx32 "\tt3 =%#010" PRIx32 "\n",
     85        printf("t0 =%#0" PRIx32 "\tt1 =%#0" PRIx32 "\t"
     86            "t2 =%#0" PRIx32 "\tt3 =%#0" PRIx32 "\n",
    8787            istate->t0, istate->t1, istate->t2, istate->t3);
    8888       
    89         printf("t4 =%#010" PRIx32 "\tt5 =%#010" PRIx32 "\t"
    90             "t6 =%#010" PRIx32 "\tt7 =%#010" PRIx32 "\n",
     89        printf("t4 =%#0" PRIx32 "\tt5 =%#0" PRIx32 "\t"
     90            "t6 =%#0" PRIx32 "\tt7 =%#0" PRIx32 "\n",
    9191            istate->t4, istate->t5, istate->t6, istate->t7);
    9292       
    93         printf("t8 =%#010" PRIx32 "\tt9 =%#010" PRIx32 "\t"
    94             "v0 =%#010" PRIx32 "\tv1 =%#010" PRIx32 "\n",
     93        printf("t8 =%#0" PRIx32 "\tt9 =%#0" PRIx32 "\t"
     94            "v0 =%#0" PRIx32 "\tv1 =%#0" PRIx32 "\n",
    9595            istate->t8, istate->t9, istate->v0, istate->v1);
    9696       
    97         printf("s0 =%#010" PRIx32 "\ts1 =%#010" PRIx32 "\t"
    98             "s2 =%#010" PRIx32 "\ts3 =%#010" PRIx32 "\n",
     97        printf("s0 =%#0" PRIx32 "\ts1 =%#0" PRIx32 "\t"
     98            "s2 =%#0" PRIx32 "\ts3 =%#0" PRIx32 "\n",
    9999            istate->s0, istate->s1, istate->s2, istate->s3);
    100100       
    101         printf("s4 =%#010" PRIx32 "\ts5 =%#010" PRIx32 "\t"
    102             "s6 =%#010" PRIx32 "\ts7 =%#010" PRIx32 "\n",
     101        printf("s4 =%#0" PRIx32 "\ts5 =%#0" PRIx32 "\t"
     102            "s6 =%#0" PRIx32 "\ts7 =%#0" PRIx32 "\n",
    103103            istate->s4, istate->s5, istate->s6, istate->s7);
    104104       
    105         printf("s8 =%#010" PRIx32 "\tat =%#010" PRIx32 "\t"
    106             "kt0=%#010" PRIx32 "\tkt1=%#010" PRIx32 "\n",
     105        printf("s8 =%#0" PRIx32 "\tat =%#0" PRIx32 "\t"
     106            "kt0=%#0" PRIx32 "\tkt1=%#0" PRIx32 "\n",
    107107            istate->s8, istate->at, istate->kt0, istate->kt1);
    108108       

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

    r45e9cc6 r4144630  
    3737#include <arch/smp/dorder.h>
    3838
    39 #define MSIM_DORDER_ADDRESS  0xB0000100
     39#define MSIM_DORDER_ADDRESS  0xB0000004
    4040
    4141#ifdef CONFIG_SMP

  • kernel/generic/include/ipc/ipc.h

    r45e9cc6 r4144630  
    4545/** Maximum active async calls per thread */
    4646#ifdef CONFIG_DEBUG
    47         #define IPC_MAX_ASYNC_CALLS  16
     47        #define IPC_MAX_ASYNC_CALLS  4
    4848#else
    4949        #define IPC_MAX_ASYNC_CALLS  4000

  • tools/config.py

    r45e9cc6 r4144630  
    33# Copyright (c) 2006 Ondrej Palkovsky
    44# Copyright (c) 2009 Martin Decky
    5 # Copyright (c) 2010 Jiri Svoboda
    65# All rights reserved.
    76#
    … …  
    4140import xtui
    4241
    43 RULES_FILE = sys.argv[1]
     42INPUT = sys.argv[1]
    4443MAKEFILE = 'Makefile.config'
    4544MACROS = 'config.h'
    46 PRESETS_DIR = 'defaults'
    47 
    48 def read_config(fname, config):
     45PRECONF = 'defaults'
     46
     47def read_defaults(fname, defaults):
    4948        "Read saved values from last configuration run"
    5049       
    … …  
    5352        for line in inf:
    5453                res = re.match(r'^(?:#!# )?([^#]\w*)\s*=\s*(.*?)\s*$', line)
    55                 if res:
    56                         config[res.group(1)] = res.group(2)
     54                if (res):
     55                        defaults[res.group(1)] = res.group(2)
    5756       
    5857        inf.close()
    5958
    60 def check_condition(text, config, rules):
     59def check_condition(text, defaults, ask_names):
    6160        "Check that the condition specified on input line is True (only CNF and DNF is supported)"
    6261       
    6362        ctype = 'cnf'
    6463       
    65         if (')|' in text) or ('|(' in text):
     64        if ((')|' in text) or ('|(' in text)):
    6665                ctype = 'dnf'
    6766       
    68         if ctype == 'cnf':
     67        if (ctype == 'cnf'):
    6968                conds = text.split('&')
    7069        else:
    … …  
    7271       
    7372        for cond in conds:
    74                 if cond.startswith('(') and cond.endswith(')'):
     73                if (cond.startswith('(')) and (cond.endswith(')')):
    7574                        cond = cond[1:-1]
    7675               
    77                 inside = check_inside(cond, config, ctype)
     76                inside = check_inside(cond, defaults, ctype)
    7877               
    7978                if (ctype == 'cnf') and (not inside):
    8079                        return False
    8180               
    82                 if (ctype == 'dnf') and inside:
     81                if (ctype == 'dnf') and (inside):
    8382                        return True
    8483       
    85         if ctype == 'cnf':
     84        if (ctype == 'cnf'):
    8685                return True
    8786        return False
    8887
    89 def check_inside(text, config, ctype):
     88def check_inside(text, defaults, ctype):
    9089        "Check for condition"
    9190       
    92         if ctype == 'cnf':
     91        if (ctype == 'cnf'):
    9392                conds = text.split('|')
    9493        else:
    … …  
    9796        for cond in conds:
    9897                res = re.match(r'^(.*?)(!?=)(.*)$', cond)
    99                 if not res:
     98                if (not res):
    10099                        raise RuntimeError("Invalid condition: %s" % cond)
    101100               
    … …  
    104103                condval = res.group(3)
    105104               
    106                 if not condname in config:
     105                if (not condname in defaults):
    107106                        varval = ''
    108107                else:
    109                         varval = config[condname]
     108                        varval = defaults[condname]
    110109                        if (varval == '*'):
    111110                                varval = 'y'
    112111               
    113                 if ctype == 'cnf':
     112                if (ctype == 'cnf'):
    114113                        if (oper == '=') and (condval == varval):
    115114                                return True
    … …  
    124123                                return False
    125124       
    126         if ctype == 'cnf':
     125        if (ctype == 'cnf'):
    127126                return False
    128127       
    129128        return True
    130129
    131 def parse_rules(fname, rules):
    132         "Parse rules file"
     130def parse_config(fname, ask_names):
     131        "Parse configuration file"
    133132       
    134133        inf = open(fname, 'r')
    … …  
    139138        for line in inf:
    140139               
    141                 if line.startswith('!'):
     140                if (line.startswith('!')):
    142141                        # Ask a question
    143142                        res = re.search(r'!\s*(?:\[(.*?)\])?\s*([^\s]+)\s*\((.*)\)\s*$', line)
    144143                       
    145                         if not res:
     144                        if (not res):
    146145                                raise RuntimeError("Weird line: %s" % line)
    147146                       
    … …  
    150149                        vartype = res.group(3)
    151150                       
    152                         rules.append((varname, vartype, name, choices, cond))
     151                        ask_names.append((varname, vartype, name, choices, cond))
    153152                        name = ''
    154153                        choices = []
    155154                        continue
    156155               
    157                 if line.startswith('@'):
     156                if (line.startswith('@')):
    158157                        # Add new line into the 'choices' array
    159158                        res = re.match(r'@\s*(?:\[(.*?)\])?\s*"(.*?)"\s*(.*)$', line)
    … …  
    165164                        continue
    166165               
    167                 if line.startswith('%'):
     166                if (line.startswith('%')):
    168167                        # Name of the option
    169168                        name = line[1:].strip()
    170169                        continue
    171170               
    172                 if line.startswith('#') or (line == '\n'):
     171                if ((line.startswith('#')) or (line == '\n')):
    173172                        # Comment or empty line
    174173                        continue
    … …  
    182181        "Return '*' if yes, ' ' if no"
    183182       
    184         if default == 'y':
     183        if (default == 'y'):
    185184                return '*'
    186185       
    … …  
    200199        cnt = 0
    201200        for key, val in choices:
    202                 if (default) and (key == default):
     201                if ((default) and (key == default)):
    203202                        position = cnt
    204203               
    … …  
    208207        (button, value) = xtui.choice_window(screen, name, 'Choose value', options, position)
    209208       
    210         if button == 'cancel':
     209        if (button == 'cancel'):
    211210                return None
    212211       
    213212        return choices[value][0]
    214213
    215 ## Infer and verify configuration values.
    216 #
    217 # Augment @a config with values that can be inferred, purge invalid ones
    218 # and verify that all variables have a value (previously specified or inferred).
    219 #
    220 # @param config Configuration to work on
    221 # @param rules  Rules
    222 #
    223 # @return       True if configuration is complete and valid, False
    224 #               otherwise.
    225 #
    226 def infer_verify_choices(config, rules):
    227         "Infer and verify configuration values."
    228        
    229         for rule in rules:
    230                 varname, vartype, name, choices, cond = rule
    231 
    232                 if cond and (not check_condition(cond, config, rules)):
    233                         continue
    234                
    235                 if not varname in config:
    236                         value = None
    237                 else:
    238                         value = config[varname]
    239 
    240                 if not rule_value_is_valid(rule, value):
    241                         value = None
    242 
    243                 default = rule_get_default(rule)
    244                 if default != None:
    245                         config[varname] = default
    246 
    247                 if not varname in config:
     214def check_choices(defaults, ask_names):
     215        "Check whether all accessible variables have a default"
     216       
     217        for varname, vartype, name, choices, cond in ask_names:
     218                if ((cond) and (not check_condition(cond, defaults, ask_names))):
     219                        continue
     220               
     221                if (not varname in defaults):
    248222                        return False
    249223       
    250224        return True
    251225
    252 ## Get default value from a rule.
    253 def rule_get_default(rule):
    254         varname, vartype, name, choices, cond = rule
    255 
    256         default = None
    257 
    258         if vartype == 'choice':
    259                 # If there is just one option, use it
    260                 if len(choices) == 1:
    261                         default = choices[0][0]
    262         elif vartype == 'y':
    263                 default = '*'
    264         elif vartype == 'n':
    265                 default = 'n'
    266         elif vartype == 'y/n':
    267                 default = 'y'
    268         elif vartype == 'n/y':
    269                 default = 'n'
    270         else:
    271                 raise RuntimeError("Unknown variable type: %s" % vartype)
    272 
    273         return default
    274 
    275 ## Get option from a rule.
    276 #
    277 # @param rule   Rule for a variable
    278 # @param value  Current value of the variable
    279 #
    280 # @return Option (string) to ask or None which means not to ask.
    281 #
    282 def rule_get_option(rule, value):
    283         varname, vartype, name, choices, cond = rule
    284 
    285         option = None
    286 
    287         if vartype == 'choice':
    288                 # If there is just one option, don't ask
    289                 if len(choices) != 1:
    290                         if (value == None):
    291                                 option = "?     %s --> " % name
    292                         else:
    293                                 option = "      %s [%s] --> " % (name, value)
    294         elif vartype == 'y':
    295                 pass
    296         elif vartype == 'n':
    297                 pass
    298         elif vartype == 'y/n':
    299                 option = "  <%s> %s " % (yes_no(value), name)
    300         elif vartype == 'n/y':
    301                 option ="  <%s> %s " % (yes_no(value), name)
    302         else:
    303                 raise RuntimeError("Unknown variable type: %s" % vartype)
    304 
    305         return option
    306 
    307 ## Check if variable value is valid.
    308 #
    309 # @param rule   Rule for the variable
    310 # @param value  Value of the variable
    311 #
    312 # @return       True if valid, False if not valid.
    313 #
    314 def rule_value_is_valid(rule, value):
    315         varname, vartype, name, choices, cond = rule
    316        
    317         if value == None:
    318                 return True
    319 
    320         if vartype == 'choice':
    321                 if not value in [choice[0] for choice in choices]:
    322                         return False
    323         elif vartype == 'y':
    324                 if value != 'y':
    325                         return False
    326         elif vartype == 'n':
    327                 if value != 'n':
    328                         return False
    329         elif vartype == 'y/n':
    330                 if not value in ['y', 'n']:
    331                         return False
    332         elif vartype == 'n/y':
    333                 if not value in ['y', 'n']:
    334                         return False
    335         else:
    336                 raise RuntimeError("Unknown variable type: %s" % vartype)
    337 
    338         return True
    339 
    340 def create_output(mkname, mcname, config, rules):
     226def create_output(mkname, mcname, defaults, ask_names):
    341227        "Create output configuration"
    342228       
    … …  
    352238                sys.stderr.write("failed\n")
    353239       
    354         if len(version) == 3:
     240        if (len(version) == 3):
    355241                revision = version[1]
    356                 if version[0] != 1:
     242                if (version[0] != 1):
    357243                        revision += 'M'
    358244                revision += ' (%s)' % version[2]
    … …  
    373259        defs = 'CONFIG_DEFS ='
    374260       
    375         for varname, vartype, name, choices, cond in rules:
    376                 if cond and (not check_condition(cond, config, rules)):
    377                         continue
    378                
    379                 if not varname in config:
    380                         value = ''
     261        for varname, vartype, name, choices, cond in ask_names:
     262                if ((cond) and (not check_condition(cond, defaults, ask_names))):
     263                        continue
     264               
     265                if (not varname in defaults):
     266                        default = ''
    381267                else:
    382                         value = config[varname]
    383                         if (value == '*'):
    384                                 value = 'y'
    385                
    386                 outmk.write('# %s\n%s = %s\n\n' % (name, varname, value))
    387                
    388                 if vartype in ["y", "n", "y/n", "n/y"]:
    389                         if value == "y":
     268                        default = defaults[varname]
     269                        if (default == '*'):
     270                                default = 'y'
     271               
     272                outmk.write('# %s\n%s = %s\n\n' % (name, varname, default))
     273               
     274                if ((vartype == "y") or (vartype == "n") or (vartype == "y/n") or (vartype == "n/y")):
     275                        if (default == "y"):
    390276                                outmc.write('/* %s */\n#define %s\n\n' % (name, varname))
    391277                                defs += ' -D%s' % varname
    392278                else:
    393                         outmc.write('/* %s */\n#define %s %s\n#define %s_%s\n\n' % (name, varname, value, varname, value))
    394                         defs += ' -D%s=%s -D%s_%s' % (varname, value, varname, value)
    395        
    396         if revision is not None:
     279                        outmc.write('/* %s */\n#define %s %s\n#define %s_%s\n\n' % (name, varname, default, varname, default))
     280                        defs += ' -D%s=%s -D%s_%s' % (varname, default, varname, default)
     281       
     282        if (revision is not None):
    397283                outmk.write('REVISION = %s\n' % revision)
    398284                outmc.write('#define REVISION %s\n' % revision)
    … …  
    413299        return list
    414300
    415 ## Choose a profile and load configuration presets.
    416 #
    417 def load_presets(root, fname, screen, config):
     301def read_preconfigured(root, fname, screen, defaults):
    418302        options = []
    419303        opt2path = {}
    … …  
    425309                canon = os.path.join(path, fname)
    426310               
    427                 if os.path.isdir(path) and os.path.exists(canon) and os.path.isfile(canon):
     311                if ((os.path.isdir(path)) and (os.path.exists(canon)) and (os.path.isfile(canon))):
    428312                        subprofile = False
    429313                       
    … …  
    433317                                subcanon = os.path.join(subpath, fname)
    434318                               
    435                                 if os.path.isdir(subpath) and os.path.exists(subcanon) and os.path.isfile(subcanon):
     319                                if ((os.path.isdir(subpath)) and (os.path.exists(subcanon)) and (os.path.isfile(subcanon))):
    436320                                        subprofile = True
    437321                                        options.append("%s (%s)" % (name, subname))
    … …  
    439323                                        cnt += 1
    440324                       
    441                         if not subprofile:
     325                        if (not subprofile):
    442326                                options.append(name)
    443327                                opt2path[cnt] = (canon, None)
    … …  
    446330        (button, value) = xtui.choice_window(screen, 'Load preconfigured defaults', 'Choose configuration profile', options, None)
    447331       
    448         if button == 'cancel':
     332        if (button == 'cancel'):
    449333                return None
    450334       
    451         read_config(opt2path[value][0], config)
    452         if opt2path[value][1] != None:
    453                 read_config(opt2path[value][1], config)
     335        read_defaults(opt2path[value][0], defaults)
     336        if (opt2path[value][1] != None):
     337                read_defaults(opt2path[value][1], defaults)
    454338
    455339def main():
    456         config = {}
    457         rules = []
    458        
    459         # Parse rules file
    460         parse_rules(RULES_FILE, rules)
    461        
    462         # Read configuration from previous run
     340        defaults = {}
     341        ask_names = []
     342       
     343        # Parse configuration file
     344        parse_config(INPUT, ask_names)
     345       
     346        # Read defaults from previous run
    463347        if os.path.exists(MAKEFILE):
    464                 read_config(MAKEFILE, config)
    465        
    466         # Default mode: only check values and regenerate configuration files
    467         if (len(sys.argv) >= 3) and (sys.argv[2] == 'default'):
    468                 if (infer_verify_choices(config, rules)):
    469                         create_output(MAKEFILE, MACROS, config, rules)
     348                read_defaults(MAKEFILE, defaults)
     349       
     350        # Default mode: only check defaults and regenerate configuration
     351        if ((len(sys.argv) >= 3) and (sys.argv[2] == 'default')):
     352                if (check_choices(defaults, ask_names)):
     353                        create_output(MAKEFILE, MACROS, defaults, ask_names)
    470354                        return 0
    471355       
    472         # Check mode: only check configuration
    473         if (len(sys.argv) >= 3) and (sys.argv[2] == 'check'):
    474                 if infer_verify_choices(config, rules):
     356        # Check mode: only check defaults
     357        if ((len(sys.argv) >= 3) and (sys.argv[2] == 'check')):
     358                if (check_choices(defaults, ask_names)):
    475359                        return 0
    476360                return 1
    … …  
    482366                while True:
    483367                       
    484                         # Cancel out all values which have to be deduced
    485                         for varname, vartype, name, choices, cond in rules:
    486                                 if (vartype == 'y') and (varname in config) and (config[varname] == '*'):
    487                                         config[varname] = None
     368                        # Cancel out all defaults which have to be deduced
     369                        for varname, vartype, name, choices, cond in ask_names:
     370                                if ((vartype == 'y') and (varname in defaults) and (defaults[varname] == '*')):
     371                                        defaults[varname] = None
    488372                       
    489373                        options = []
    … …  
    493377                        options.append("  --- Load preconfigured defaults ... ")
    494378                       
    495                         for rule in rules:
    496                                 varname, vartype, name, choices, cond = rule
    497                                
    498                                 if cond and (not check_condition(cond, config, rules)):
     379                        for varname, vartype, name, choices, cond in ask_names:
     380                               
     381                                if ((cond) and (not check_condition(cond, defaults, ask_names))):
    499382                                        continue
    500383                               
    501                                 if varname == selname:
     384                                if (varname == selname):
    502385                                        position = cnt
    503386                               
    504                                 if not varname in config:
    505                                         value = None
     387                                if (not varname in defaults):
     388                                        default = None
    506389                                else:
    507                                         value = config[varname]
    508                                
    509                                 if not rule_value_is_valid(rule, value):
    510                                         value = None
    511 
    512                                 default = rule_get_default(rule)
    513                                 if default != None:
    514                                         value = default
    515                                         config[varname] = default
    516 
    517                                 option = rule_get_option(rule, value)
    518                                 if option != None:
    519                                         options.append(option)
     390                                        default = defaults[varname]
     391                               
     392                                if (vartype == 'choice'):
     393                                        # Check if the default is an acceptable value
     394                                        if ((default) and (not default in [choice[0] for choice in choices])):
     395                                                default = None
     396                                                defaults.pop(varname)
     397                                       
     398                                        # If there is just one option, use it
     399                                        if (len(choices) == 1):
     400                                                defaults[varname] = choices[0][0]
     401                                                continue
     402                                       
     403                                        if (default == None):
     404                                                options.append("?     %s --> " % name)
     405                                        else:
     406                                                options.append("      %s [%s] --> " % (name, default))
     407                                elif (vartype == 'y'):
     408                                        defaults[varname] = '*'
     409                                        continue
     410                                elif (vartype == 'n'):
     411                                        defaults[varname] = 'n'
     412                                        continue
     413                                elif (vartype == 'y/n'):
     414                                        if (default == None):
     415                                                default = 'y'
     416                                                defaults[varname] = default
     417                                        options.append("  <%s> %s " % (yes_no(default), name))
     418                                elif (vartype == 'n/y'):
     419                                        if (default == None):
     420                                                default = 'n'
     421                                                defaults[varname] = default
     422                                        options.append("  <%s> %s " % (yes_no(default), name))
     423                                else:
     424                                        raise RuntimeError("Unknown variable type: %s" % vartype)
    520425                               
    521426                                opt2row[cnt] = (varname, vartype, name, choices)
    … …  
    528433                        (button, value) = xtui.choice_window(screen, 'HelenOS configuration', 'Choose configuration option', options, position)
    529434                       
    530                         if button == 'cancel':
     435                        if (button == 'cancel'):
    531436                                return 'Configuration canceled'
    532437                       
    533                         if button == 'done':
    534                                 if (infer_verify_choices(config, rules)):
     438                        if (button == 'done'):
     439                                if (check_choices(defaults, ask_names)):
    535440                                        break
    536441                                else:
    … …  
    538443                                        continue
    539444                       
    540                         if value == 0:
    541                                 load_presets(PRESETS_DIR, MAKEFILE, screen, config)
     445                        if (value == 0):
     446                                read_preconfigured(PRECONF, MAKEFILE, screen, defaults)
    542447                                position = 1
    543448                                continue
    544449                       
    545450                        position = None
    546                         if not value in opt2row:
     451                        if (not value in opt2row):
    547452                                raise RuntimeError("Error selecting value: %s" % value)
    548453                       
    549454                        (selname, seltype, name, choices) = opt2row[value]
    550455                       
    551                         if not selname in config:
    552                                 value = None
     456                        if (not selname in defaults):
     457                                        default = None
    553458                        else:
    554                                 value = config[selname]
    555                        
    556                         if seltype == 'choice':
    557                                 config[selname] = subchoice(screen, name, choices, value)
    558                         elif (seltype == 'y/n') or (seltype == 'n/y'):
    559                                 if config[selname] == 'y':
    560                                         config[selname] = 'n'
     459                                default = defaults[selname]
     460                       
     461                        if (seltype == 'choice'):
     462                                defaults[selname] = subchoice(screen, name, choices, default)
     463                        elif ((seltype == 'y/n') or (seltype == 'n/y')):
     464                                if (defaults[selname] == 'y'):
     465                                        defaults[selname] = 'n'
    561466                                else:
    562                                         config[selname] = 'y'
     467                                        defaults[selname] = 'y'
    563468        finally:
    564469                xtui.screen_done(screen)
    565470       
    566         create_output(MAKEFILE, MACROS, config, rules)
     471        create_output(MAKEFILE, MACROS, defaults, ask_names)
    567472        return 0
    568473

  • uspace/Makefile

    r45e9cc6 r4144630  
    118118        DIRS += drv/ns8250
    119119        DIRS += drv/uhci
    120         DIRS += drv/usbhub
    121120        DIRS += drv/usbkbd
    122121endif

  • uspace/drv/uhci/Makefile

    r45e9cc6 r4144630  
    3333
    3434SOURCES = \
    35         main.c \
    36         transfers.c
     35        main.c
    3736
    3837include $(USPACE_PREFIX)/Makefile.common

  • uspace/drv/uhci/main.c

    r45e9cc6 r4144630  
    2828#include <usb/hcdhubd.h>
    2929#include <errno.h>
    30 #include "uhci.h"
    3130
    32 static device_ops_t uhci_ops = {
    33         .interfaces[USBHC_DEV_IFACE] = &uhci_iface,
     31static int enqueue_transfer_out(usb_hc_device_t *hc,
     32    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
     33    void *buffer, size_t size,
     34    usb_hcd_transfer_callback_out_t callback, void *arg)
     35{
     36        printf("UHCI: transfer OUT [%d.%d (%s); %u]\n",
     37            dev->address, endpoint->endpoint,
     38            usb_str_transfer_type(endpoint->transfer_type),
     39            size);
     40        return ENOTSUP;
     41}
     42
     43static int enqueue_transfer_setup(usb_hc_device_t *hc,
     44    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
     45    void *buffer, size_t size,
     46    usb_hcd_transfer_callback_out_t callback, void *arg)
     47{
     48        printf("UHCI: transfer SETUP [%d.%d (%s); %u]\n",
     49            dev->address, endpoint->endpoint,
     50            usb_str_transfer_type(endpoint->transfer_type),
     51            size);
     52        return ENOTSUP;
     53}
     54
     55static int enqueue_transfer_in(usb_hc_device_t *hc,
     56    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
     57    void *buffer, size_t size,
     58    usb_hcd_transfer_callback_in_t callback, void *arg)
     59{
     60        printf("UHCI: transfer IN [%d.%d (%s); %u]\n",
     61            dev->address, endpoint->endpoint,
     62            usb_str_transfer_type(endpoint->transfer_type),
     63            size);
     64        return ENOTSUP;
     65}
     66
     67static usb_hcd_transfer_ops_t uhci_transfer_ops = {
     68        .transfer_out = enqueue_transfer_out,
     69        .transfer_in = enqueue_transfer_in,
     70        .transfer_setup = enqueue_transfer_setup
    3471};
    3572
    36 static int uhci_add_device(device_t *device)
     73static int uhci_add_hc(usb_hc_device_t *device)
    3774{
    38         device->ops = &uhci_ops;
     75        device->transfer_ops = &uhci_transfer_ops;
    3976
    4077        /*
    4178         * We need to announce the presence of our root hub.
     79         * Commented out until the problem which causes the whole task to
     80         * block is solved.
    4281         */
    43         usb_hcd_add_root_hub(device);
     82        //usb_hcd_add_root_hub(device);
    4483
    4584        return EOK;
    4685}
    4786
    48 static driver_ops_t uhci_driver_ops = {
    49         .add_device = uhci_add_device,
    50 };
    51 
    52 static driver_t uhci_driver = {
    53         .name = NAME,
    54         .driver_ops = &uhci_driver_ops
     87usb_hc_driver_t uhci_driver = {
     88        .name = "uhci",
     89        .add_hc = uhci_add_hc
    5590};
    5691
    … …  
    6095         * Do some global initializations.
    6196         */
    62         sleep(5);
    6397
    64         return driver_main(&uhci_driver);
     98        return usb_hcd_main(&uhci_driver);
    6599}

  • uspace/drv/uhci/uhci.ma

    r45e9cc6 r4144630  
    1110 pci/ven=8086&dev=7020
    2 
     210 usb&hc=uhci
     310 usb&hc=uhci&hub

  • uspace/drv/vhc/Makefile

    r45e9cc6 r4144630  
    3939
    4040SOURCES = \
    41         addrmgm.c \
    4241        conndev.c \
    4342        connhost.c \

  • uspace/drv/vhc/conn.h

    r45e9cc6 r4144630  
    3838#include <usb/usb.h>
    3939#include <usb/hcdhubd.h>
    40 #include <usbhc_iface.h>
    4140#include "vhcd.h"
    4241#include "devices.h"
    … …  
    4544
    4645usb_hcd_transfer_ops_t vhc_transfer_ops;
    47 usbhc_iface_t vhc_iface;
    48 
    49 void address_init(void);
    50 int reserve_default_address(device_t *);
    51 int release_default_address(device_t *);
    52 int request_address(device_t *, usb_address_t *);
    53 int release_address(device_t *, usb_address_t);
    54 int bind_address(device_t *, usb_address_t, devman_handle_t);
    55 
    56 int tell_address(device_t *, devman_handle_t, usb_address_t *);
    5746
    5847void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *);

  • uspace/drv/vhc/connhost.c

    r45e9cc6 r4144630  
    4343typedef struct {
    4444        usb_direction_t direction;
    45         usbhc_iface_transfer_out_callback_t out_callback;
    46         usbhc_iface_transfer_in_callback_t in_callback;
    47         device_t *dev;
     45        usb_hcd_transfer_callback_out_t out_callback;
     46        usb_hcd_transfer_callback_in_t in_callback;
     47        usb_hc_device_t *hc;
    4848        void *arg;
    4949} transfer_info_t;
    … …  
    5656        switch (transfer->direction) {
    5757                case USB_DIRECTION_IN:
    58                         transfer->in_callback(transfer->dev,
     58                        transfer->in_callback(transfer->hc,
    5959                            size, outcome,
    6060                            transfer->arg);
    6161                        break;
    6262                case USB_DIRECTION_OUT:
    63                         transfer->out_callback(transfer->dev,
     63                        transfer->out_callback(transfer->hc,
    6464                            outcome,
    6565                            transfer->arg);
    … …  
    7373}
    7474
    75 static transfer_info_t *create_transfer_info(device_t *dev,
     75static transfer_info_t *create_transfer_info(usb_hc_device_t *hc,
    7676    usb_direction_t direction, void *arg)
    7777{
    … …  
    8282        transfer->out_callback = NULL;
    8383        transfer->arg = arg;
    84         transfer->dev = dev;
     84        transfer->hc = hc;
    8585
    8686        return transfer;
    8787}
    8888
    89 static int enqueue_transfer_out(device_t *dev,
    90     usb_target_t target, usb_transfer_type_t transfer_type,
     89static int enqueue_transfer_out(usb_hc_device_t *hc,
     90    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
    9191    void *buffer, size_t size,
    92     usbhc_iface_transfer_out_callback_t callback, void *arg)
     92    usb_hcd_transfer_callback_out_t callback, void *arg)
    9393{
    9494        printf(NAME ": transfer OUT [%d.%d (%s); %u]\n",
    95             target.address, target.endpoint,
    96             usb_str_transfer_type(transfer_type),
     95            dev->address, endpoint->endpoint,
     96            usb_str_transfer_type(endpoint->transfer_type),
    9797            size);
    9898
    9999        transfer_info_t *transfer
    100             = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
     100            = create_transfer_info(hc, USB_DIRECTION_OUT, arg);
    101101        transfer->out_callback = callback;
     102
     103        usb_target_t target = {
     104                .address = dev->address,
     105                .endpoint = endpoint->endpoint
     106        };
    102107
    103108        hc_add_transaction_to_device(false, target, buffer, size,
    … …  
    107112}
    108113
    109 static int enqueue_transfer_setup(device_t *dev,
    110     usb_target_t target, usb_transfer_type_t transfer_type,
     114static int enqueue_transfer_setup(usb_hc_device_t *hc,
     115    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
    111116    void *buffer, size_t size,
    112     usbhc_iface_transfer_out_callback_t callback, void *arg)
     117    usb_hcd_transfer_callback_out_t callback, void *arg)
    113118{
    114119        printf(NAME ": transfer SETUP [%d.%d (%s); %u]\n",
    115             target.address, target.endpoint,
    116             usb_str_transfer_type(transfer_type),
     120            dev->address, endpoint->endpoint,
     121            usb_str_transfer_type(endpoint->transfer_type),
    117122            size);
    118123
    119124        transfer_info_t *transfer
    120             = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
     125            = create_transfer_info(hc, USB_DIRECTION_OUT, arg);
    121126        transfer->out_callback = callback;
     127
     128        usb_target_t target = {
     129                .address = dev->address,
     130                .endpoint = endpoint->endpoint
     131        };
    122132
    123133        hc_add_transaction_to_device(true, target, buffer, size,
    … …  
    127137}
    128138
    129 static int enqueue_transfer_in(device_t *dev,
    130     usb_target_t target, usb_transfer_type_t transfer_type,
     139static int enqueue_transfer_in(usb_hc_device_t *hc,
     140    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
    131141    void *buffer, size_t size,
    132     usbhc_iface_transfer_in_callback_t callback, void *arg)
     142    usb_hcd_transfer_callback_in_t callback, void *arg)
    133143{
    134144        printf(NAME ": transfer IN [%d.%d (%s); %u]\n",
    135             target.address, target.endpoint,
    136             usb_str_transfer_type(transfer_type),
     145            dev->address, endpoint->endpoint,
     146            usb_str_transfer_type(endpoint->transfer_type),
    137147            size);
    138148
    139149        transfer_info_t *transfer
    140             = create_transfer_info(dev, USB_DIRECTION_IN, arg);
     150            = create_transfer_info(hc, USB_DIRECTION_IN, arg);
    141151        transfer->in_callback = callback;
     152
     153        usb_target_t target = {
     154                .address = dev->address,
     155                .endpoint = endpoint->endpoint
     156        };
    142157
    143158        hc_add_transaction_from_device(target, buffer, size,
    … …  
    148163
    149164
    150 static int interrupt_out(device_t *dev, usb_target_t target,
    151     void *data, size_t size,
    152     usbhc_iface_transfer_out_callback_t callback, void *arg)
    153 {
    154         return enqueue_transfer_out(dev, target, USB_TRANSFER_INTERRUPT,
    155             data, size,
    156             callback, arg);
    157 }
    158 
    159 static int interrupt_in(device_t *dev, usb_target_t target,
    160     void *data, size_t size,
    161     usbhc_iface_transfer_in_callback_t callback, void *arg)
    162 {
    163         return enqueue_transfer_in(dev, target, USB_TRANSFER_INTERRUPT,
    164             data, size,
    165             callback, arg);
    166 }
    167 
    168 static int control_write_setup(device_t *dev, usb_target_t target,
    169     void *data, size_t size,
    170     usbhc_iface_transfer_out_callback_t callback, void *arg)
    171 {
    172         return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL,
    173             data, size,
    174             callback, arg);
    175 }
    176 
    177 static int control_write_data(device_t *dev, usb_target_t target,
    178     void *data, size_t size,
    179     usbhc_iface_transfer_out_callback_t callback, void *arg)
    180 {
    181         return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL,
    182             data, size,
    183             callback, arg);
    184 }
    185 
    186 static int control_write_status(device_t *dev, usb_target_t target,
    187     usbhc_iface_transfer_in_callback_t callback, void *arg)
    188 {
    189         return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL,
    190             NULL, 0,
    191             callback, arg);
    192 }
    193 
    194 static int control_read_setup(device_t *dev, usb_target_t target,
    195     void *data, size_t size,
    196     usbhc_iface_transfer_out_callback_t callback, void *arg)
    197 {
    198         return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL,
    199             data, size,
    200             callback, arg);
    201 }
    202 
    203 static int control_read_data(device_t *dev, usb_target_t target,
    204     void *data, size_t size,
    205     usbhc_iface_transfer_in_callback_t callback, void *arg)
    206 {
    207         return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL,
    208             data, size,
    209             callback, arg);
    210 }
    211 
    212 static int control_read_status(device_t *dev, usb_target_t target,
    213     usbhc_iface_transfer_out_callback_t callback, void *arg)
    214 {
    215         return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL,
    216             NULL, 0,
    217             callback, arg);
    218 }
    219 
    220 
    221 usbhc_iface_t vhc_iface = {
    222         .tell_address = tell_address,
    223 
    224         .reserve_default_address = reserve_default_address,
    225         .release_default_address = release_default_address,
    226         .request_address = request_address,
    227         .bind_address = bind_address,
    228         .release_address = release_address,
    229 
    230         .interrupt_out = interrupt_out,
    231         .interrupt_in = interrupt_in,
    232 
    233         .control_write_setup = control_write_setup,
    234         .control_write_data = control_write_data,
    235         .control_write_status = control_write_status,
    236 
    237         .control_read_setup = control_read_setup,
    238         .control_read_data = control_read_data,
    239         .control_read_status = control_read_status
     165usb_hcd_transfer_ops_t vhc_transfer_ops = {
     166        .transfer_out = enqueue_transfer_out,
     167        .transfer_in = enqueue_transfer_in,
     168        .transfer_setup = enqueue_transfer_setup
    240169};
    241170

  • uspace/drv/vhc/hcd.c

    r45e9cc6 r4144630  
    5252#include "conn.h"
    5353
    54 static device_ops_t vhc_ops = {
    55         .interfaces[USBHC_DEV_IFACE] = &vhc_iface,
    56         .default_handler = default_connection_handler
    57 };
    5854
    5955static int vhc_count = 0;
    60 static int vhc_add_device(device_t *dev)
     56static int vhc_add_device(usb_hc_device_t *dev)
    6157{
    6258        /*
    … …  
    6965        vhc_count++;
    7066
    71         dev->ops = &vhc_ops;
    72 
    73         /*
    74          * Initialize address management.
    75          */
    76         address_init();
     67        dev->transfer_ops = &vhc_transfer_ops;
     68        dev->generic->ops->default_handler = default_connection_handler;
    7769
    7870        /*
    … …  
    8779}
    8880
    89 static driver_ops_t vhc_driver_ops = {
    90         .add_device = vhc_add_device,
    91 };
    92 
    93 static driver_t vhc_driver = {
     81static usb_hc_driver_t vhc_driver = {
    9482        .name = NAME,
    95         .driver_ops = &vhc_driver_ops
     83        .add_hc = &vhc_add_device
    9684};
    9785
    … …  
    126114        sleep(4);
    127115
    128         return driver_main(&vhc_driver);
     116        return usb_hcd_main(&vhc_driver);
    129117}
    130118

  • uspace/drv/vhc/vhc.ma

    r45e9cc6 r4144630  
    1110 usb&hc=vhc
    2 
     210 usb&hc=vhc&hub

  • uspace/lib/block/libblock.c

    r45e9cc6 r4144630  
    6666        fibril_mutex_t lock;
    6767        size_t lblock_size;             /**< Logical block size. */
    68         unsigned blocks_cluster;        /**< Physical blocks per block_t */
    6968        unsigned block_count;           /**< Total number of blocks. */
    7069        unsigned blocks_cached;         /**< Number of cached blocks. */
    … …  
    9190static int get_block_size(int dev_phone, size_t *bsize);
    9291static int get_num_blocks(int dev_phone, aoff64_t *nblocks);
    93 static aoff64_t ba_ltop(devcon_t *devcon, aoff64_t lba);
    9492
    9593static devcon_t *devcon_search(devmap_handle_t devmap_handle)
    … …  
    261259{
    262260        block_t *b = hash_table_get_instance(item, block_t, hash_link);
    263         return b->lba == *key;
     261        return b->boff == *key;
    264262}
    265263
    … …  
    294292        cache->mode = mode;
    295293
    296         /* Allow 1:1 or small-to-large block size translation */
    297         if (cache->lblock_size % devcon->pblock_size != 0)
    298                 return ENOTSUP;
    299 
    300         cache->blocks_cluster = cache->lblock_size / devcon->pblock_size;
     294        /* No block size translation a.t.m. */
     295        assert(cache->lblock_size == devcon->pblock_size);
    301296
    302297        if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1,
    … …  
    334329                if (b->dirty) {
    335330                        memcpy(devcon->comm_area, b->data, b->size);
    336                         rc = write_blocks(devcon, b->pba, cache->blocks_cluster);
     331                        rc = write_blocks(devcon, b->boff, 1);
    337332                        if (rc != EOK)
    338333                                return rc;
    339334                }
    340335
    341                 unsigned long key = b->lba;
     336                unsigned long key = b->boff;
    342337                hash_table_remove(&cache->block_hash, &key, 1);
    343338               
    … …  
    380375 *                              block pointer on success.
    381376 * @param devmap_handle         Device handle of the block device.
    382  * @param ba                    Block address (logical).
     377 * @param boff                  Block offset.
    383378 * @param flags                 If BLOCK_FLAGS_NOREAD is specified, block_get()
    384379 *                              will not read the contents of the block from the
    … …  
    387382 * @return                      EOK on success or a negative error code.
    388383 */
    389 int block_get(block_t **block, devmap_handle_t devmap_handle, aoff64_t ba, int flags)
     384int block_get(block_t **block, devmap_handle_t devmap_handle, aoff64_t boff, int flags)
    390385{
    391386        devcon_t *devcon;
    … …  
    393388        block_t *b;
    394389        link_t *l;
    395         unsigned long key = ba;
     390        unsigned long key = boff;
    396391        int rc;
    397392       
    … …  
    470465                                fibril_mutex_lock(&devcon->comm_area_lock);
    471466                                memcpy(devcon->comm_area, b->data, b->size);
    472                                 rc = write_blocks(devcon, b->pba,
    473                                     cache->blocks_cluster);
     467                                rc = write_blocks(devcon, b->boff, 1);
    474468                                fibril_mutex_unlock(&devcon->comm_area_lock);
    475469                                if (rc != EOK) {
    … …  
    501495                         */
    502496                        list_remove(&b->free_link);
    503                         temp_key = b->lba;
     497                        temp_key = b->boff;
    504498                        hash_table_remove(&cache->block_hash, &temp_key, 1);
    505499                }
    … …  
    508502                b->devmap_handle = devmap_handle;
    509503                b->size = cache->lblock_size;
    510                 b->lba = ba;
    511                 b->pba = ba_ltop(devcon, b->lba);
     504                b->boff = boff;
    512505                hash_table_insert(&cache->block_hash, &key, &b->hash_link);
    513506
    … …  
    526519                         */
    527520                        fibril_mutex_lock(&devcon->comm_area_lock);
    528                         rc = read_blocks(devcon, b->pba, cache->blocks_cluster);
     521                        rc = read_blocks(devcon, b->boff, 1);
    529522                        memcpy(b->data, devcon->comm_area, cache->lblock_size);
    530523                        fibril_mutex_unlock(&devcon->comm_area_lock);
    … …  
    587580                fibril_mutex_lock(&devcon->comm_area_lock);
    588581                memcpy(devcon->comm_area, block->data, block->size);
    589                 rc = write_blocks(devcon, block->pba, cache->blocks_cluster);
     582                rc = write_blocks(devcon, block->boff, 1);
    590583                fibril_mutex_unlock(&devcon->comm_area_lock);
    591584                block->dirty = false;
    … …  
    621614                         * Take the block out of the cache and free it.
    622615                         */
    623                         unsigned long key = block->lba;
     616                        unsigned long key = block->boff;
    624617                        hash_table_remove(&cache->block_hash, &key, 1);
    625618                        free(block);
    … …  
    719712 *
    720713 * @param devmap_handle Device handle of the block device.
    721  * @param ba            Address of first block (physical).
     714 * @param ba            Address of first block.
    722715 * @param cnt           Number of blocks.
    723716 * @param src           Buffer for storing the data.
    … …  
    747740 *
    748741 * @param devmap_handle Device handle of the block device.
    749  * @param ba            Address of first block (physical).
     742 * @param ba            Address of first block.
    750743 * @param cnt           Number of blocks.
    751744 * @param src           The data to be written.
    … …  
    886879}
    887880
    888 /** Convert logical block address to physical block address. */
    889 static aoff64_t ba_ltop(devcon_t *devcon, aoff64_t lba)
    890 {
    891         assert(devcon->cache != NULL);
    892         return lba * devcon->cache->blocks_cluster;
    893 }
    894 
    895881/** @}
    896882 */

  • uspace/lib/block/libblock.h

    r45e9cc6 r4144630  
    7373        /** Handle of the device where the block resides. */
    7474        devmap_handle_t devmap_handle;
    75         /** Logical block address */
    76         aoff64_t lba;
    77         /** Physical block address */
    78         aoff64_t pba;
     75        /** Block offset on the block device. Counted in 'size'-byte blocks. */
     76        aoff64_t boff;
    7977        /** Size of the block. */
    8078        size_t size;

  • uspace/lib/drv/generic/remote_usbhc.c

    r45e9cc6 r4144630  
    5252static void remote_usbhc_control_read_data(device_t *, void *, ipc_callid_t, ipc_call_t *);
    5353static void remote_usbhc_control_read_status(device_t *, void *, ipc_callid_t, ipc_call_t *);
    54 static void remote_usbhc_reserve_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
    55 static void remote_usbhc_release_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
    56 static void remote_usbhc_request_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
    57 static void remote_usbhc_bind_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
    58 static void remote_usbhc_release_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
    5954//static void remote_usbhc(device_t *, void *, ipc_callid_t, ipc_call_t *);
    6055
    … …  
    6257static remote_iface_func_ptr_t remote_usbhc_iface_ops [] = {
    6358        remote_usbhc_get_address,
    64 
    6559        remote_usbhc_get_buffer,
    66 
    67         remote_usbhc_reserve_default_address,
    68         remote_usbhc_release_default_address,
    69 
    70         remote_usbhc_request_address,
    71         remote_usbhc_bind_address,
    72         remote_usbhc_release_address,
    73 
    7460        remote_usbhc_interrupt_out,
    7561        remote_usbhc_interrupt_in,
    76 
    7762        remote_usbhc_control_write_setup,
    7863        remote_usbhc_control_write_data,
    7964        remote_usbhc_control_write_status,
    80 
    8165        remote_usbhc_control_read_setup,
    8266        remote_usbhc_control_read_data,
    … …  
    150134        free(trans->buffer);
    151135        free(trans);
    152 }
    153 
    154 void remote_usbhc_reserve_default_address(device_t *device, void *iface,
    155     ipc_callid_t callid, ipc_call_t *call)
    156 {
    157         usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    158 
    159         if (!usb_iface->reserve_default_address) {
    160                 ipc_answer_0(callid, ENOTSUP);
    161                 return;
    162         }
    163 
    164         int rc = usb_iface->reserve_default_address(device);
    165 
    166         ipc_answer_0(callid, rc);
    167 }
    168 
    169 void remote_usbhc_release_default_address(device_t *device, void *iface,
    170     ipc_callid_t callid, ipc_call_t *call)
    171 {
    172         usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    173 
    174         if (!usb_iface->release_default_address) {
    175                 ipc_answer_0(callid, ENOTSUP);
    176                 return;
    177         }
    178 
    179         int rc = usb_iface->release_default_address(device);
    180 
    181         ipc_answer_0(callid, rc);
    182 }
    183 
    184 void remote_usbhc_request_address(device_t *device, void *iface,
    185     ipc_callid_t callid, ipc_call_t *call)
    186 {
    187         usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    188 
    189         if (!usb_iface->request_address) {
    190                 ipc_answer_0(callid, ENOTSUP);
    191                 return;
    192         }
    193 
    194         usb_address_t address;
    195         int rc = usb_iface->request_address(device, &address);
    196         if (rc != EOK) {
    197                 ipc_answer_0(callid, rc);
    198         } else {
    199                 ipc_answer_1(callid, EOK, (ipcarg_t) address);
    200         }
    201 }
    202 
    203 void remote_usbhc_bind_address(device_t *device, void *iface,
    204     ipc_callid_t callid, ipc_call_t *call)
    205 {
    206         usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    207 
    208         if (!usb_iface->bind_address) {
    209                 ipc_answer_0(callid, ENOTSUP);
    210                 return;
    211         }
    212 
    213         usb_address_t address = (usb_address_t) IPC_GET_ARG1(*call);
    214         devman_handle_t handle = (devman_handle_t) IPC_GET_ARG2(*call);
    215 
    216         int rc = usb_iface->bind_address(device, address, handle);
    217 
    218         ipc_answer_0(callid, rc);
    219 }
    220 
    221 void remote_usbhc_release_address(device_t *device, void *iface,
    222     ipc_callid_t callid, ipc_call_t *call)
    223 {
    224         usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    225 
    226         if (!usb_iface->release_address) {
    227                 ipc_answer_0(callid, ENOTSUP);
    228                 return;
    229         }
    230 
    231         usb_address_t address = (usb_address_t) IPC_GET_ARG1(*call);
    232 
    233         int rc = usb_iface->release_address(device, address);
    234 
    235         ipc_answer_0(callid, rc);
    236136}
    237137

  • uspace/lib/drv/include/usbhc_iface.h

    r45e9cc6 r4144630  
    111111
    112112
    113         /** Reserve usage of default address.
    114          * This call informs the host controller that the caller will be
    115          * using default USB address. It is duty of the HC driver to ensure
    116          * that only single entity will have it reserved.
    117          * The address is returned via IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS.
    118          * The caller can start using the address after receiving EOK
    119          * answer.
    120          */
    121         IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS,
    122 
    123         /** Release usage of default address.
    124          * @see IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS
    125          */
    126         IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS,
    127 
    128         /** Asks for address assignment by host controller.
    129          * Answer:
    130          * - ELIMIT - host controller run out of address
    131          * - EOK - address assigned
    132          * Answer arguments:
    133          * - assigned address
    134          *
    135          * The address must be released by via IPC_M_USBHC_RELEASE_ADDRESS.
    136          */
    137         IPC_M_USBHC_REQUEST_ADDRESS,
    138 
    139         /** Bind USB address with devman handle.
    140          * Parameters:
    141          * - USB address
    142          * - devman handle
    143          * Answer:
    144          * - EOK - address binded
    145          * - ENOENT - address is not in use
    146          */
    147         IPC_M_USBHC_BIND_ADDRESS,
    148 
    149         /** Release address in use.
    150          * Arguments:
    151          * - address to be released
    152          * Answer:
    153          * - ENOENT - address not in use
    154          * - EPERM - trying to release default USB address
    155          */
    156         IPC_M_USBHC_RELEASE_ADDRESS,
    157 
    158 
    159113        /** Send interrupt data to device.
    160114         * See explanation at usb_iface_funcs_t (OUT transaction).
    … …  
    229183typedef struct {
    230184        int (*tell_address)(device_t *, devman_handle_t, usb_address_t *);
    231 
    232         int (*reserve_default_address)(device_t *);
    233         int (*release_default_address)(device_t *);
    234         int (*request_address)(device_t *, usb_address_t *);
    235         int (*bind_address)(device_t *, usb_address_t, devman_handle_t);
    236         int (*release_address)(device_t *, usb_address_t);
    237185
    238186        usbhc_iface_transfer_out_t interrupt_out;

  • uspace/lib/usb/Makefile

    r45e9cc6 r4144630  
    3535        src/hcdhubd.c \
    3636        src/hcdrv.c \
     37        src/hubdrv.c \
    3738        src/localdrv.c \
    3839        src/remotedrv.c \

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

    r45e9cc6 r4144630  
    166166
    167167int usb_hcd_main(usb_hc_driver_t *);
    168 int usb_hcd_add_root_hub(device_t *dev);
     168int usb_hcd_add_root_hub(usb_hc_device_t *dev);
    169169
    170170/**
    … …  
    191191 */
    192192
    193 device_t *usb_hc_connect(device_t *);
    194193
    195194int usb_hc_async_interrupt_out(usb_hc_device_t *, usb_target_t,

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

    r45e9cc6 r4144630  
    4141int usb_drv_hc_connect(device_t *, unsigned int);
    4242
    43 int usb_drv_reserve_default_address(int);
    44 int usb_drv_release_default_address(int);
    45 usb_address_t usb_drv_request_address(int);
    46 int usb_drv_bind_address(int, usb_address_t, devman_handle_t);
    47 int usb_drv_release_address(int, usb_address_t);
    48 
    4943usb_address_t usb_drv_get_my_address(int, device_t *);
    5044

  • uspace/lib/usb/src/hcdhubd.c

    r45e9cc6 r4144630  
    5151 */
    5252static int add_device(device_t *dev) {
    53         return ENOTSUP;
     53        bool is_hc = str_cmp(dev->name, USB_HUB_DEVICE_NAME) != 0;
     54        printf("%s: add_device(name=\"%s\")\n", hc_driver->name, dev->name);
     55
     56        if (is_hc) {
     57                /*
     58                 * We are the HC itself.
     59                 */
     60                return usb_add_hc_device(dev);
     61        } else {
     62                /*
     63                 * We are some (maybe deeply nested) hub.
     64                 * Thus, assign our own operations and explore already
     65                 * connected devices.
     66                 */
     67                return usb_add_hub_device(dev);
     68        }
    5469}
    5570
    … …  
    90105 * @return Error code.
    91106 */
    92 int usb_hcd_add_root_hub(device_t *dev)
    93 {
     107int usb_hcd_add_root_hub(usb_hc_device_t *dev) {
    94108        char *id;
    95         int rc = asprintf(&id, "usb&hub");
     109        int rc = asprintf(&id, "usb&hc=%s&hub", dev->generic->name);
    96110        if (rc <= 0) {
    97111                return rc;
    98112        }
    99113
    100         rc = usb_hc_add_child_device(dev, USB_HUB_DEVICE_NAME, id, true);
     114        rc = usb_hc_add_child_device(dev->generic, USB_HUB_DEVICE_NAME, id, true);
    101115        if (rc != EOK) {
    102116                free(id);
    … …  
    119133        int rc;
    120134
    121         async_usleep(1000);
    122 
    123135        device_t *child = create_device();
    124136        match_id_t *match_id = NULL;
    … …  
    184196        printf("%s: about to add child device `%s' (%s)\n", hc_driver->name,
    185197                        name, match_id);
    186 
    187         /*
    188          * Seems that creating fibril which postpones the action
    189          * is the best solution.
    190          */
    191         create_fibril = true;
    192198
    193199        struct child_device_info *child_info

  • uspace/lib/usb/src/hcdhubd_private.h

    r45e9cc6 r4144630  
    4646usb_address_t usb_get_address_by_handle(devman_handle_t);
    4747int usb_add_hc_device(device_t *);
     48int usb_add_hub_device(device_t *);
    4849
    4950/** lowest allowed usb address */

  • uspace/lib/usb/src/hcdrv.c

    r45e9cc6 r4144630  
    4747LIST_INITIALIZE(hc_list);
    4848
    49 /* Fake driver to have the name item initialized. */
    50 static usb_hc_driver_t hc_driver_fake = {
    51         .name = "HCD",
    52 };
    53 
    5449/** Our HC driver. */
    55 usb_hc_driver_t *hc_driver = &hc_driver_fake;
     50usb_hc_driver_t *hc_driver = NULL;
    5651
    5752int usb_lowest_address = 1;
    … …  
    9186int usb_add_hc_device(device_t *dev)
    9287{
    93         return ENOTSUP;
    9488        usb_hc_device_t *hc_dev = usb_hc_device_create(dev);
    9589

  • uspace/lib/usb/src/localdrv.c

    r45e9cc6 r4144630  
    3939#include <errno.h>
    4040
    41 /** Find host controller when handled by current task.
    42  *
    43  * @param dev Device asking for connection.
    44  * @return Device structure corresponding to parent host controller.
    45  * @retval NULL Corresponding host controller not found.
    46  */
    47 device_t *usb_hc_connect(device_t *dev)
    48 {
    49         /*
    50          * FIXME: this will not work when some hub on the path is
    51          * not driven by the same task.
    52          */
    53         device_t *parent = dev;
    54         while (parent->parent != NULL) {
    55                 parent = parent->parent;
    56         }
    57        
    58         if (dev == parent) {
    59                 printf("FIXME in %s:%d encountered!\n", __FILE__, __LINE__);
    60                 parent = NULL;
    61         }
    62 
    63         return parent;
    64 }
    65 
    6641/** Information about pending transaction on HC. */
    6742typedef struct {

  • uspace/lib/usb/src/usbdrv.c

    r45e9cc6 r4144630  
    5555/** Connect to host controller the device is physically attached to.
    5656 *
    57  * @param dev Device asking for connection.
     57 * @param handle Device handle.
    5858 * @param flags Connection flags (blocking connection).
    5959 * @return Phone to corresponding HC or error code.
    … …  
    9898
    9999        return (usb_address_t) address;
    100 }
    101 
    102 /** Tell HC to reserve default address.
    103  *
    104  * @param phone Open phone to host controller driver.
    105  * @return Error code.
    106  */
    107 int usb_drv_reserve_default_address(int phone)
    108 {
    109         return async_req_0_0(phone, IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS);
    110 }
    111 
    112 /** Tell HC to release default address.
    113  *
    114  * @param phone Open phone to host controller driver.
    115  * @return Error code.
    116  */
    117 int usb_drv_release_default_address(int phone)
    118 {
    119         return async_req_0_0(phone, IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS);
    120 }
    121 
    122 /** Ask HC for free address assignment.
    123  *
    124  * @param phone Open phone to host controller driver.
    125  * @return Assigned USB address or negative error code.
    126  */
    127 usb_address_t usb_drv_request_address(int phone)
    128 {
    129         ipcarg_t address;
    130         int rc = async_req_0_1(phone, IPC_M_USBHC_REQUEST_ADDRESS, &address);
    131         if (rc != EOK) {
    132                 return rc;
    133         } else {
    134                 return (usb_address_t) address;
    135         }
    136 }
    137 
    138 /** Inform HC about binding address with devman handle.
    139  *
    140  * @param phone Open phone to host controller driver.
    141  * @param address Address to be binded.
    142  * @param handle Devman handle of the device.
    143  * @return Error code.
    144  */
    145 int usb_drv_bind_address(int phone, usb_address_t address,
    146     devman_handle_t handle)
    147 {
    148         int rc = async_req_2_0(phone, IPC_M_USBHC_BIND_ADDRESS,
    149             address, handle);
    150 
    151         return rc;
    152 }
    153 
    154 /** Inform HC about address release.
    155  *
    156  * @param phone Open phone to host controller driver.
    157  * @param address Address to be released.
    158  * @return Error code.
    159  */
    160 int usb_drv_release_address(int phone, usb_address_t address)
    161 {
    162         return async_req_1_0(phone, IPC_M_USBHC_RELEASE_ADDRESS, address);
    163100}
    164101

  • uspace/srv/bd/file_bd/file_bd.c

    r45e9cc6 r4144630  
    5656#define NAME "file_bd"
    5757
    58 #define DEFAULT_BLOCK_SIZE 512
    59 
    60 static size_t block_size;
     58static const size_t block_size = 512;
    6159static aoff64_t num_blocks;
    6260static FILE *img;
    … …  
    6563static fibril_mutex_t dev_lock;
    6664
    67 static void print_usage(void);
    6865static int file_bd_init(const char *fname);
    6966static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
    … …  
    7471{
    7572        int rc;
    76         char *image_name;
    77         char *device_name;
    7873
    7974        printf(NAME ": File-backed block device driver\n");
    8075
    81         block_size = DEFAULT_BLOCK_SIZE;
    82 
    83         ++argv; --argc;
    84         while (*argv != NULL && (*argv)[0] == '-') {
    85                 /* Option */
    86                 if (str_cmp(*argv, "-b") == 0) {
    87                         if (argc < 2) {
    88                                 printf("Argument missing.\n");
    89                                 print_usage();
    90                                 return -1;
    91                         }
    92 
    93                         rc = str_size_t(argv[1], NULL, 10, true, &block_size);
    94                         if (rc != EOK || block_size == 0) {
    95                                 printf("Invalid block size '%s'.\n", argv[1]);
    96                                 print_usage();
    97                                 return -1;
    98                         }
    99                         ++argv; --argc;
    100                 } else {
    101                         printf("Invalid option '%s'.\n", *argv);
    102                         print_usage();
    103                         return -1;
    104                 }
    105                 ++argv; --argc;
    106         }
    107 
    108         if (argc < 2) {
    109                 printf("Missing arguments.\n");
    110                 print_usage();
     76        if (argc != 3) {
     77                printf("Expected two arguments (image name, device name).\n");
    11178                return -1;
    11279        }
    11380
    114         image_name = argv[0];
    115         device_name = argv[1];
    116 
    117         if (file_bd_init(image_name) != EOK)
     81        if (file_bd_init(argv[1]) != EOK)
    11882                return -1;
    11983
    120         rc = devmap_device_register(device_name, &devmap_handle);
     84        rc = devmap_device_register(argv[2], &devmap_handle);
    12185        if (rc != EOK) {
    12286                devmap_hangup_phone(DEVMAP_DRIVER);
    123                 printf(NAME ": Unable to register device '%s'.\n",
    124                         device_name);
     87                printf(NAME ": Unable to register device %s.\n",
     88                        argv[2]);
    12589                return rc;
    12690        }
    … …  
    13296        /* Not reached */
    13397        return 0;
    134 }
    135 
    136 static void print_usage(void)
    137 {
    138         printf("Usage: " NAME " [-b <block_size>] <image_file> <device_name>\n");
    13998}
    14099
Note: See TracChangeset for help on using the changeset viewer.