opencos-eda 0.2.28__py3-none-any.whl → 0.2.32__py3-none-any.whl

opencos/deps_helpers.py

@@ -1,4 +1,7 @@
+
+import fnmatch
 import os
+from pathlib import Path
 import sys
 import re
 import shutil
@@ -7,7 +10,8 @@ import toml, json
 from opencos import files
 from opencos import eda_config
 from opencos.util import debug, info, warning, error, ShellCommandList, \
-    yaml_safe_load, toml_load_only_root_line_numbers
+    yaml_safe_load, toml_load_only_root_line_numbers, \
+    subprocess_run_background
 
 
 class Defaults:
@@ -233,6 +237,92 @@ peakrdl_cleanup_py = os.path.join(thispath, 'peakrdl_cleanup.py')
 def deps_data_get_all_targets(data:dict) -> list:
     return [x for x in data.keys() if x not in Defaults.root_table_keys_not_targets]
 
+
+def fnmatch_or_re(pattern: str, string: str) -> bool:
+    '''Returns True if pattern/string matches in re.match or fnmatch'''
+    matches = []
+    # fnmatch check, aka: ./*test
+    matches.append(
+        bool(fnmatch.fnmatch(name=string, pat=pattern))
+    )
+    # regex check, aka: ./.*test
+    try:
+        matches.append(
+            bool(re.match(pattern=pattern, string=string))
+        )
+    except: # pylint: disable=bare-except
+        # could have been an illegal/unsupported regex, so don't match.
+        pass
+    return any(matches)
+
+
+def get_all_targets(
+        dirs: list = [os.getcwd()],
+        base_path: str = os.getcwd(),
+        filter_str: str = '',
+        filter_using_multi: str = '',
+        error_on_empty_return: bool = True
+) -> list:
+    '''Returns a list of [dir/target, ... ] using relpath from base_path
+
+    If using filter_using_multi (str), dirs (list) is not required. Example:
+        filter_using_multi='sim --tool vivado path/to/*test'
+    and filter_str is applied to all resulting targets.
+
+    If not using filter_using_multi, dirs is required, and filter_str is applied
+    To all targets from dirs.
+    '''
+
+    if filter_using_multi:
+        targets = []
+        orig_dir = os.path.abspath(os.getcwd())
+        os.chdir(base_path)
+        cmd_str = 'eda multi --quiet --print-targets ' + filter_using_multi
+        stdout, stderr, rc = subprocess_run_background(
+            work_dir='.', command_list=cmd_str.split()
+        )
+        os.chdir(orig_dir)
+        if rc != 0:
+            error(f'get_all_targets: {base_path=} {filter_using_multi=} {cmd_str=} returned:',
+                  f'{rc=}, {stdout=}')
+
+        multi_filtered_targets = stdout.split()
+        if not filter_str:
+            targets = multi_filtered_targets
+        else:
+            targets = set()
+            for target in multi_filtered_targets:
+                this_dir, leaf_target = os.path.split(target)
+                if fnmatch_or_re(pattern=filter_str,
+                                 string=leaf_target):
+                    targets.add(
+                        os.path.join(os.path.relpath(this_dir, start=base_path), leaf_target)
+                    )
+            targets = list(targets)
+        if not targets and error_on_empty_return:
+            error(f'get_all_targets: {base_path=} {filter_using_multi=} returned no targets')
+        return targets
+
+    targets = set()
+    for this_dir in dirs:
+        this_dir = os.path.join(base_path, this_dir)
+        deps_file = get_deps_markup_file(this_dir)
+        if not deps_file:
+            continue
+        data = deps_markup_safe_load(filepath=deps_file)
+
+        for leaf_target in deps_data_get_all_targets(data):
+            if not filter_str or fnmatch_or_re(pattern=filter_str,
+                                               string=leaf_target):
+                targets.add(
+                    os.path.join(os.path.relpath(this_dir, start=base_path), leaf_target)
+                )
+
+    if not targets and error_on_empty_return:
+        error(f'get_all_targets: {base_path=} {dirs=} {filter_str=} returned no targets')
+    return list(targets)
+
+
 def dep_str2list(value) -> list():
     if value is None:
         return []
@@ -1060,9 +1150,9 @@ def parse_deps_peakrdl(line : str, target_path : str, target_node : str, enable
 
 
     shell_commands = [
-        [ 'peakrdl', 'regblock', '-o', 'peakrdl/'] + args_list,
+        [ 'peakrdl', 'regblock', '-o', str(Path('peakrdl/'))] + args_list,
         # Edit file to apply some verilator waivers, etc, from peakrdl_cleanup.py:
-        [ 'python3', peakrdl_cleanup_py, f'peakrdl/{top}.sv', f'peakrdl/{top}.sv' ],
+        [ 'python3', peakrdl_cleanup_py, str(Path(f'peakrdl/{top}.sv')), str(Path(f'peakrdl/{top}.sv')) ],
     ]
 
     ret_dict = {

opencos/deps_schema.py

@@ -120,8 +120,12 @@ my_target_name:
 
 '''
 
-from schema import Schema, And, Or, Use, Optional, SchemaError
-import sys, os
+import os
+import sys
+
+from schema import Schema, Or, Optional, SchemaError
+
+from opencos.deps_helpers import deps_markup_safe_load, get_deps_markup_file
 
 # Because we deal with YAML, where a Table Key with dangling/empty value is allowed
 # and we have things like SystemVerilog defines where there's a Table key with no Value,
@@ -302,19 +306,18 @@ def check(data: dict, schema_obj=FILE):
         return True, None
     except SchemaError as e:
         return False, str(e)
-    except Exception as e:
+    except Exception as e: # pylint: disable=broad-exception-caught
         return False, str(e)
 
 
 def check_files(files, schema_obj=FILE) -> bool:
     '''Returns True if files lint cleanly in the FILE schema.'''
-    from opencos.deps_helpers import deps_markup_safe_load, get_deps_markup_file
 
-    if type(files) is str:
+    if isinstance(files, str):
         files = [files]
 
-    passes_list = list()
-    error_files = list()
+    passes_list = []
+    error_files = []
     for filepath in files:
         deps_filepath = filepath
         if os.path.isdir(filepath):
@@ -328,7 +331,7 @@ def check_files(files, schema_obj=FILE) -> bool:
             print(f'{deps_filepath}: [PASS]')
         if not passes:
             print(f'ERROR: {deps_filepath}:')
-            print(f'-- retdata --')
+            print('-- retdata --')
             print(retdata)
             print(f'    previous error on: {deps_filepath}\n')
             error_files.append(deps_filepath)
@@ -339,18 +342,25 @@ def check_files(files, schema_obj=FILE) -> bool:
         print(f'ERROR: files with problems (see above): {error_files}')
     return ret
 
-def main(filepaths=[]):
-    if not filepaths:
-        assert len(sys.argv) >= 2, f'Need 1 or more args - DEPS file to check'
-        filepaths = sys.argv[1:]
+def main( # pylint: disable=dangerous-default-value
+        filepaths: list = []
+) -> None:
+    '''Returns None, will exit on completion, checks all DEPS schema in list filepaths
+
+    If filepaths is empty, uses sys.argv[1:]'''
+
+    fpaths = filepaths
+    if not fpaths:
+        assert len(sys.argv) >= 2, 'Need 1 or more args - DEPS file to check'
+        fpaths = sys.argv[1:]
+
+    assert fpaths and isinstance(fpaths, list), \
+        f'Need 1 or more files to check: {fpaths=}'
 
-    for filepath in filepaths:
+    for filepath in fpaths:
         assert os.path.exists(filepath), f'{filepath=} does not exist'
-    ret = check_files(filepaths)
+    ret = check_files(fpaths)
     sys.exit(int(not ret))
 
 if __name__ == '__main__':
-    '''Runs sys.argv[1:] filenames against check_files, for linting DEPS.'''
-    assert len(sys.argv) >= 2, f'Need 1 or more args - DEPS file to check'
-    filepaths = sys.argv[1:]
-    main(filepaths)
+    main()

opencos/eda.py

@@ -168,6 +168,7 @@ def auto_tool_setup(warnings:bool=True, config=None, quiet=False, tool=None) ->
         if tool and tool != name:
             continue # if called with tool=(some_name), then only load that tool.
 
+        util.debug(f"Checking for ability to run tool: {name}")
         exe = value.get('exe', str())
         if type(exe) is list:
             exe_list = exe
@@ -183,12 +184,14 @@ def auto_tool_setup(warnings:bool=True, config=None, quiet=False, tool=None) ->
             spec = importlib.util.find_spec(pkg)
             if not spec:
                 has_all_py = False
+                util.debug(f"... No, missing pkg {spec}")
 
         has_all_env = True
         requires_env_list = value.get('requires_env', list())
         for env in requires_env_list:
             if not os.environ.get(env, ''):
                 has_all_env = False
+                util.debug(f"... No, missing env {env}")
 
         has_all_exe = True
         for exe in exe_list:
@@ -196,6 +199,7 @@ def auto_tool_setup(warnings:bool=True, config=None, quiet=False, tool=None) ->
             p = shutil.which(exe)
             if not p:
                 has_all_exe = False
+                util.debug(f"... No, missing exe {exe}")
 
         if has_all_exe:
             requires_cmd_list = value.get('requires_cmd', list())
@@ -209,6 +213,7 @@ def auto_tool_setup(warnings:bool=True, config=None, quiet=False, tool=None) ->
                         has_all_exe = False
                 except:
                     has_all_exe = False
+                    util.debug(f"... No, exception running {cmd_list}")
 
 
         if all([has_all_py, has_all_env, has_all_exe]):
@@ -358,7 +363,7 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
     util.debug(f'{command=}')
     util.debug(f'{sco.config=}')
     util.debug(f'{type(sco)=}')
-    if not parsed.tool:
+    if not parsed.tool and command not in config.get('command_determines_tool', []):
         use_tool = which_tool(command, config)
         util.info(f"--tool not specified, using default for {command=}: {use_tool}")
 

opencos/eda_base.py

@@ -119,11 +119,9 @@ class Tool:
             self.defines = {}
         self.args.update({
             'tool':   self._TOOL, # Set for all derived classes.
-            'xilinx': False,
         })
         self.args_help.update({
             'tool': 'Tool to use for this command, such as: verilator',
-            'xilinx': 'Set to use XPMs, and other global Xilinx specific cells/libraries',
         })
         # update self._EXE if config says to:
         self.set_exe(config)
@@ -224,22 +222,30 @@ class Command:
         return which_tool(command, config=self.config)
 
     def create_work_dir(self):
+        util.debug(f"create_work_dir: {self.args['eda-dir']=} {self.args['work-dir']=}")
         if (not os.path.exists(self.args['eda-dir'])): # use os.path.isfile / isdir also
             os.mkdir(self.args['eda-dir'])
+            util.info(f"create_work_dir: created {self.args['eda-dir']}")
         if self.args['design'] == "":
             if ('top' in self.args) and (self.args['top'] != ""):
                 self.args['design'] = self.args['top']
+                util.debug(f"create_work_dir: set {self.args['design']=} from {self.args['top']=}, since it was empty")
             else:
                 self.args['design'] = "design" # generic, i.e. to create work dir "design_upload"
+                util.debug(f"create_work_dir: set {self.args['design']=} to 'design', since it was empty and we have no top")
         if self.target == "":
             self.target = self.args['design']
+            util.debug(f"create_work_dir: set {self.target=} from design name, since it was empty")
         if self.args['work-dir'] == '':
             if self.args['sub-work-dir'] == '':
                 if self.args['job-name'] != '':
                     self.args['sub-work-dir'] = self.args['job-name']
+                    util.debug(f"create_work_dir: set {self.args['sub-work-dir']=} from {self.args['job-name']=}, since it was empty")
                 else:
                     self.args['sub-work-dir'] = f'{self.target}.{self.command_name}'
+                    util.debug(f"create_work_dir: set {self.args['sub-work-dir']=} from {self.target=} and {self.command_name=}, since it was empty and we have no job-name")
             self.args['work-dir'] = os.path.join(self.args['eda-dir'], self.args['sub-work-dir'])
+            util.debug(f"create_work_dir: set {self.args['work-dir']=}")
         keep_file = os.path.join(self.args['work-dir'], "eda.keep")
         if (os.path.exists(self.args['work-dir'])):
             if os.path.exists(keep_file) and not self.args['force']:
@@ -247,9 +253,11 @@ class Command:
             util.info(f"Removing previous '{self.args['work-dir']}'")
             shutil.rmtree(self.args['work-dir'])
         os.mkdir(self.args['work-dir'])
+        util.debug(f'create_work_dir: created {self.args["work-dir"]}')
         if (self.args['keep']):
             open(keep_file, 'w').close()
-        util.info(f'Creating work-dir: {self.args["work-dir"]=}')
+            util.debug(f'create_work_dir: created {keep_file}')
+        util.info(f'create_work_dir: created {self.args["work-dir"]}')
         return self.args['work-dir']
 
     def exec(self, work_dir, command_list, background=False, stop_on_error=True,
@@ -390,6 +398,12 @@ class Command:
             else:
                 assert False, f'{key=} {value=} how do we do argparse for this type of value?'
 
+        # TODO(drew): it might be nice to support positional args here as a list
+        # self.target_args (files/targets/patterns), something like:
+        #    parser.add_argument(
+        #        'targets', nargs='+', help='positional arg for targets/files/pattern'
+        #    )
+
         return parser
 
 
@@ -682,8 +696,12 @@ class CommandDesign(Command):
             util.info(f'run_dep_shell_commands {iter=}: {d=}')
             clist = util.ShellCommandList(d['exec_list'])
             # NOTE(drew): shell=True subprocess call, can disable with self.config
-            self.exec(self.args['work-dir'], clist, tee_fpath=clist.tee_fpath,
-                      shell=self.config.get('deps_subprocess_shell', False))
+            #  However, in Windows, we seem to have to run these with shell=False
+            if sys.platform.startswith('win'):
+                self.exec(self.args['work-dir'], clist, shell=False)
+            else:
+                self.exec(self.args['work-dir'], clist, tee_fpath=clist.tee_fpath,
+                          shell=self.config.get('deps_subprocess_shell', False))
 
     def update_file_lists_for_work_dir(self):
         if len(self.dep_work_dir_add_srcs) == 0:
@@ -718,7 +736,10 @@ class CommandDesign(Command):
                 self.error(f'Non-source file (reqs?) {relfname=} does not exist from {caller_info}')
             elif not os.path.exists(destfile):
                 util.debug(f'updating non-source file to work-dir: Linked {fname=} to {destfile=}, from {caller_info}')
-                os.symlink(src=fname, dst=destfile)
+                if sys.platform == "win32":
+                    shutil.copyfile(fname, destfile) # On Windows, fall back to copying
+                else:
+                    os.symlink(src=fname, dst=destfile)
 
     def get_top_name(self, name):
         return os.path.splitext(os.path.basename(name))[0]
@@ -731,7 +752,7 @@ class CommandDesign(Command):
         to unprocessed-plusargs.
         '''
 
-        # Since this may be coming from a raw CLI/bash argparser, we may have
+        # Since this may be coming from a raw CLI/bash/powershell argparser, we may have
         # args that come from shlex.quote(token), such as:
         #   token = '\'+define+OC_ROOT="/foo/bar/opencos"\''
         # So we strip all outer ' or " on the plusarg:
@@ -836,10 +857,8 @@ class CommandDesign(Command):
         util.debug("Entered resolve_target(%s)" % (target))
         # self.target is a name we grab for the job (i.e. for naming work dir etc).  we don't want the path prefix.
         # TODO: too messy -- there's also a self.target, args['job-name'], args['work-dir'], args['design'], args['top'], args['sub-work-dir'] ...
-        self.target = target
-        m = re.match(r'.*\/([\w\-]+)$', self.target)
-        if m: self.target = m.group(1)
 
+        self.target = os.path.basename(target)
 
         if target in self.targets_dict:
             # If we're encountered this target before, stop. We're not traversing again.

opencos/eda_config.py

@@ -29,6 +29,7 @@ class Defaults:
         'tools',
         'auto_tools_order',
         'file_extensions',
+        'command_determines_tool',
     ])
     supported_config_auto_tools_order_keys = set([
         'exe', 'handlers', 'requires_env', 'requires_py', 'requires_cmd',

opencos/eda_config_defaults.yml

@@ -46,6 +46,9 @@ file_extensions:
     - .vhd
     - .vhdl
 
+command_determines_tool:
+  # eda commands that will self-determine the tool to use.
+  - waves
 
 
 tools:
@@ -92,8 +95,8 @@ tools:
       --autoflush
       -j 2
       -sv
-    # Note that we do NOT use --coverage or --coverage-line, until verilator 5920 is resolved.
     compile-coverage-args: |
+      --coverage-line
       --coverage-toggle
       --coverage-underscore
       --coverage-user

opencos/eda_extract_deps_keys.py

@@ -1,9 +1,20 @@
 #!/usr/bin/env python3
-import yaml, toml, json
-import sys, os
+
+'''
+Helper pymodule used by eda_deps_bash_completion.bash, extracts valid
+targets from DEPS files
+'''
+
+import sys
+import os
+import json
+
+import yaml
+import toml
+
 from opencos.deps_helpers import get_deps_markup_file
 
-def get_markup_table_keys(partial_path='./'):
+def get_markup_table_keys(partial_path='./') -> list:
     '''Returns a list of root level keys for DEPS.[yml|yaml|toml|json]
 
     Does not include DEFAULTS.
@@ -26,15 +37,15 @@ def get_markup_table_keys(partial_path='./'):
     _, file_ext = os.path.splitext(filepath)
     try:
         if file_ext in ['', '.yml', 'yaml']:
-            with open(filepath, 'r') as f:
+            with open(filepath, 'r', encoding='utf-8') as f:
                 data = yaml.safe_load(f)
         elif file_ext == '.toml':
             data = toml.load(filepath)
         elif file_ext == '.json':
-            with open(filepath) as f:
+            with open(filepath, 'r', encoding='utf-8') as f:
                 data = json.load(f)
-    except:
-        pass
+    except Exception: # pylint: disable=broad-exception-caught
+        return []
 
     if not isinstance(data, dict):
         # We found a DEPS file, but it wasn't a table/dict so we can't return root keys
@@ -48,11 +59,17 @@ def get_markup_table_keys(partial_path='./'):
         if not partial_path.endswith('/'):
             prepend += '/'
 
-    # Return the list of keys w/ prepended path information, and don't include 'DEFAULTS'
-    return [prepend + x for x in list(data.keys()) if x.startswith(partial_target) and x != 'DEFAULTS']
+    # Return the list of keys w/ prepended path information, and don't include
+    # uppercase strings like 'DEFAULTS' or 'METADATA'
+    return [
+        prepend + x for x in list(data.keys()) if x.startswith(partial_target) and not x.isupper()
+    ]
+
 
+def main() -> None:
+    '''Returns None, prints DEPS keys space separated, uses sys.argv for a single
+    partial path arg (DEPS file to examine)'''
 
-def main():
     if len(sys.argv) > 1:
         partial_path = sys.argv[1]
     else:

opencos/files.py

@@ -33,14 +33,12 @@ def get_source_file(target:str) -> (bool, str, str):
         # target exists as a file, return True w/ original target:
         return True, target, ''
 
-    if any(target.startswith(x) for x in ALL_FORCED_PREFIXES):
-        parts = target.split('@')
-        ext = parts[0]
-        fpath = '@'.join(parts[1:]) # if target str had mulitple @'s
-        if os.path.exists(fpath):
-            # target exists as ext@fpath, return True b/c fpath exists,
-            # along with the fpath and forced ext to use:
-            return True, fpath, FORCE_PREFIX_DICT.get(ext + '@', '')
+    if '@' in target:
+        for p in ALL_FORCED_PREFIXES:
+            if p in target:
+                fpath = ''.join(target.split(p)) # essentially just removing the "sv@" or whatever it is
+                if os.path.exists(fpath):
+                    return True, fpath, FORCE_PREFIX_DICT.get(p)
 
     # target or fpath didn't exist, return False with the original target:
     return False, target, ''

opencos/names.py

@@ -31,6 +31,7 @@ table = {
         3: "U50",
         4: "U55N",
         5: "U50C",
+        6: "PYNQ-Z2",
     },
 
     'OC_LIBRARY': {

opencos/oc_cli.py

@@ -657,7 +657,7 @@ class BlockLED(Block):
         count = data & 0xff
         self.dump_reg(0, 0x0004, "Prescale", [ [9,0,"CYCLES"] ])
         for i in range(count):
-            self.dump_reg(0, 0x0008+i, "LedControl%d" % i, [ [18,16,"BLINKS"], [13,8,"BRIGHT"], [1,0,"MODE"] ])
+            self.dump_reg(0, 0x0008+(i*4), "LedControl%d" % i, [ [18,16,"BLINKS"], [13,8,"BRIGHT"], [1,0,"MODE"] ])
 
     def command_set(self, parts=[], help_line=False):
         if help_line: return "Set the state of the led: [on|off|blink|heartbeat] [brightness=0-63]";
@@ -700,6 +700,143 @@ class BlockLED(Block):
                 for i in range(self.numled): self.csr_write32(0, 8 + (  i*4), ((blinks<<16) | (bright<<8) | command) )
             else:                            self.csr_write32(0, 8 + (led*4), ((blinks<<16) | (bright<<8) | command) )
 
+class BlockRGB(Block):
+    def __init__(self, channel, blockid):
+        Block.__init__(self, channel, blockid, "RGB")
+
+    def connect(self):
+        Block.connect(self)
+        data = self.csr_read32(0, 0)
+        self.csrid = ((data >> 16) & 0xffff)
+        self.numrgb = ((data) & 0xff)
+        util.debug(f"Connect: {self} CsrId={self.csrid} NumRgb={self.numrgb}")
+
+    def rgb_status(self, rgb):
+        data = self.csr_read32(0, 8 + (rgb*4))
+        red = ((data >> 24) & 0x3f)
+        green = ((data >>16) & 0x3f)
+        blue = ((data >> 8) & 0x3f)
+        if (data & 0x1) == 1: return (f"on ({red:3d} {green:3d} {blue:3d})")
+        elif (data & 0x2) == 2: return (f"blink ({red:3d} {green:3d} {blue:3d})")
+        elif (data & 0x3) == 3: return (f"heartbeat ({red:3d} {green:3d} {blue:3d})")
+        return "off"
+
+    def command_show(self, parts=[], help_line=False):
+        if help_line: return "Shows high level status of the block in human readable form";
+        for i in range(self.numrgb):
+            util.info(f"RGB {i:3}: {self.rgb_status(i):20}")
+
+    def command_dump(self, parts=[], help_line=False):
+        if help_line: return "Dumps detailed config/status info of the block in human readable form";
+        self.info(f"Dumping {self}:")
+        data = self.dump_reg(0, 0x0000, "OcID", [ [31,16,"ID"], [7,0,"RGB_COUNT"] ])
+        count = data & 0xff
+        self.dump_reg(0, 0x0004, "Prescale", [ [9,0,"CYCLES"] ])
+        for i in range(count):
+            self.dump_reg(0, 0x0008+(i*4), "RgbControl%d" % i, [ [24,24,"RED"], [16,16,"GREEN"], [8,8,"BLUE"], [0,0,"MODE"] ])
+
+    def command_set(self, parts=[], help_line=False):
+        if help_line: return "Set the state of the rgb: [on|off|blink|heartbeat] [red=0-63] [green=0-63] [blue=0-63]";
+        rgb = -1
+        red = 0x3f
+        green = 0x3f
+        blue = 0x3f
+        command = -1 # report status
+        prescale = -1
+        while (len(parts)):
+            cmd = parts.pop(0)
+            if (eval_regex(r'^(\d+)$', cmd)):
+                rgb = eval_number(m.group(1))
+            elif (eval_regex(r'^status$', cmd)):
+                command = -1
+            elif (eval_regex(r'^off$', cmd)):
+                command = 0
+            elif (eval_regex(r'^on$', cmd)):
+                command = 1
+            elif (eval_regex(r'^blink$', cmd)):
+                command = 2
+            elif (eval_regex(r'^(?:heart)?beat$', cmd)):
+                command = 3
+            elif (eval_regex(r'^prescale=(.+)', cmd)):
+                prescale = eval_number(m.group(1), check_uint_bits=10, check_int_min=5)
+            elif (eval_regex(r'^red=(.+)', cmd)):
+                red = eval_number(m.group(1), check_uint_bits=6)
+            elif (eval_regex(r'^green=(.+)', cmd)):
+                green = eval_number(m.group(1), check_uint_bits=6)
+            elif (eval_regex(r'^blue=(.+)', cmd)):
+                blue = eval_number(m.group(1), check_uint_bits=6)
+            else:
+                util.error(f"RGB didn't understand arg(s): {parts}", do_exit=False)
+                raise HandledError
+        if prescale != -1:
+            self.csr_write32(0, 4, prescale)
+        if command == -1: # we reporting status
+            if rgb == -1: # on all RGBs
+                for i in range(self.numrgb): print("RGB %3d : %s" % (  i, self.rgb_status(  i)))
+            else:                            print("RGB %3d : %s" % (rgb, self.rgb_status(rgb)))
+        else:
+            if rgb == -1: # on all RGBs
+                for i in range(self.numrgb): self.csr_write32(0, 8 + (  i*4), ((blue<<24) | (green<<16) | (red<<8) | command) )
+            else:                            self.csr_write32(0, 8 + (rgb*4), ((blue<<24) | (green<<16) | (red<<8) | command) )
+
+class BlockToggle(Block):
+    def __init__(self, channel, blockid):
+        Block.__init__(self, channel, blockid, "Toggle")
+
+    def connect(self):
+        Block.connect(self)
+        data = self.csr_read32(0, 0)
+        self.csrid = ((data >> 16) & 0xffff)
+        self.numtoggle = ((data) & 0xff)
+        util.debug(f"Connect: {self} CsrId={self.csrid} NumToggle={self.numtoggle}")
+
+    def toggle_status(self, toggle):
+        data = self.csr_read32(0, 4 + (toggle*4))
+        if (data & 0x80000000): return "on"
+        return "off"
+
+    def command_show(self, parts=[], help_line=False):
+        if help_line: return "Shows high level status of the block in human readable form";
+        for i in range(self.numtoggle):
+            util.info(f"Toggle {i:3}: {self.toggle_status(i):20}")
+
+    def command_dump(self, parts=[], help_line=False):
+        if help_line: return "Dumps detailed config/status info of the block in human readable form";
+        self.info(f"Dumping {self}:")
+        data = self.dump_reg(0, 0x0000, "OcID", [ [31,16,"ID"], [7,0,"TOGGLE_COUNT"] ])
+        count = data & 0xff
+        for i in range(count):
+            self.dump_reg(0, 0x0004+(i*4), "ToggleStatus%d" % i, [ [31,31,"STATE"], [30,30,"EVENT"], [15,0,"COUNT"] ])
+
+class BlockButton(Block):
+    def __init__(self, channel, blockid):
+        Block.__init__(self, channel, blockid, "Button")
+
+    def connect(self):
+        Block.connect(self)
+        data = self.csr_read32(0, 0)
+        self.csrid = ((data >> 16) & 0xffff)
+        self.numbutton = ((data) & 0xff)
+        util.debug(f"Connect: {self} CsrId={self.csrid} NumButton={self.numbutton}")
+
+    def button_status(self, button):
+        data = self.csr_read32(0, 4 + (button*4))
+        if (data & 0x80000000): return "on"
+        return "off"
+
+    def command_show(self, parts=[], help_line=False):
+        if help_line: return "Shows high level status of the block in human readable form";
+        for i in range(self.numbutton):
+            util.info(f"Button {i:3}: {self.button_status(i):20}")
+
+    def command_dump(self, parts=[], help_line=False):
+        if help_line: return "Dumps detailed config/status info of the block in human readable form";
+        self.info(f"Dumping {self}:")
+        data = self.dump_reg(0, 0x0000, "OcID", [ [31,16,"ID"], [7,0,"BUTTON_COUNT"] ])
+        count = data & 0xff
+        for i in range(count):
+            self.dump_reg(0, 0x0004+(i*4), "ButtonStatus%d" % i, [ [31,31,"STATE"], [30,30,"EVENT"], [15,0,"COUNT"] ])
+
 class BlockIIC(Block):
     def __init__(self, channel, blockid):
         Block.__init__(self, channel, blockid, "IIC")
@@ -1498,6 +1635,11 @@ block_table[ 8] = { 'name' : 'Fan'        , 'csrid' :  8, 'handler' : Block
 block_table[ 9] = { 'name' : 'HBM'        , 'csrid' :  9, 'handler' : Block           }
 block_table[10] = { 'name' : 'CMAC'       , 'csrid' : 10, 'handler' : Block           }
 block_table[11] = { 'name' : 'PCIe'       , 'csrid' : 11, 'handler' : Block           }
+block_table[12] = { 'name' : 'Eth1G'      , 'csrid' : 12, 'handler' : Block           }
+block_table[13] = { 'name' : 'Eth10G'     , 'csrid' : 13, 'handler' : Block           }
+block_table[14] = { 'name' : 'RGB'        , 'csrid' : 14, 'handler' : BlockRGB        }
+block_table[15] = { 'name' : 'Toggle'     , 'csrid' : 15, 'handler' : BlockToggle     }
+block_table[16] = { 'name' : 'Button'     , 'csrid' : 16, 'handler' : BlockButton     }
 
 # **************************************************************
 # *** Channels

opencos/peakrdl_cleanup.py

@@ -2,7 +2,6 @@
 
 import sys
 import os
-import subprocess
 
 def run(file_in, file_out):
     with open(file_in) as f: