opencos-eda 0.3.10__py3-none-any.whl → 0.3.12__py3-none-any.whl

opencos/tools/vivado.py

@@ -10,19 +10,14 @@ upload, flist, open, proj.
 import os
 import re
 import shlex
-import shutil
-import sys
 
-from datetime import datetime
 from pathlib import Path
 
 from opencos import util, eda_base
-from opencos.eda_base import Tool
-
-from opencos.commands import CommandSim, CommandSynth, CommandProj, CommandBuild, \
+from opencos.commands import sim, CommandSim, CommandSynth, CommandProj, CommandBuild, \
     CommandFList, CommandUpload, CommandOpen
-
-from opencos.commands import sim
+from opencos.eda_base import Tool
+from opencos.files import safe_shutil_which
 
 
 class ToolVivado(Tool):
@@ -52,7 +47,7 @@ class ToolVivado(Tool):
         if self._VERSION:
             return self._VERSION
 
-        path = shutil.which(self._EXE)
+        path = safe_shutil_which(self._EXE)
         if not path:
             self.error("Vivado not in path, need to install or add to $PATH",
                        f"(looked for '{self._EXE}')")
@@ -61,10 +56,14 @@ class ToolVivado(Tool):
             self.vivado_base_path, _ = os.path.split(path)
 
         xilinx_vivado = os.environ.get('XILINX_VIVADO')
-        if not xilinx_vivado or \
+
+        # Since get_versions() doesn't have a quiet mode, and it's called as part
+        # of opencos.eda.init_config(..), let's only show an information message
+        # if XILINX_VIVADO env is set and it doesn't match the Path/bin/vivado[.bat|.exe]
+        if xilinx_vivado and \
            os.path.abspath(os.path.join(xilinx_vivado, 'bin')) != \
                os.path.abspath(os.path.dirname(self.vivado_exe)):
-            util.info("environment for XILINX_VIVADO is not set or doesn't match the vivado path:",
+            util.info("environment for XILINX_VIVADO is set, and doesn't match the vivado path:",
                       f"XILINX_VIVADO={xilinx_vivado} EXE PATH={self.vivado_exe}")
 
         # Get version based on install path name. Calling vivado -verison is too slow.
@@ -74,7 +73,7 @@ class ToolVivado(Tool):
             version = m.group(1) + '.' + m.group(2)
             self._VERSION = version
         else:
-            self.error("Vivado path doesn't specificy version, expecting (dddd.d)")
+            util.warning("Vivado path doesn't specificy version, expecting (dddd.d)")
 
         if version:
             numbers_list = version.split('.')
@@ -82,7 +81,7 @@ class ToolVivado(Tool):
             self.vivado_release = int(numbers_list[1])
             self.vivado_version = float(numbers_list[0] + '.' + numbers_list[1])
         else:
-            self.error(f"Vivado version not found, vivado path = {self.vivado_exe}")
+            util.warning(f"Vivado version not found, vivado path = {self.vivado_exe}")
         return self._VERSION
 
 
@@ -120,7 +119,10 @@ class ToolVivado(Tool):
 
 
 class CommandSimVivado(CommandSim, ToolVivado):
-    '''CommandSimVivado is a command handler for: eda sim --tool=vivado, uses xvlog, xelab, xsim'''
+    '''CommandSimVivado is a command handler for: eda sim --tool=vivado, uses xvlog, xelab, xsim
+
+    Note that we attempt to run a generated .tcl script within vivado, that will perform the
+    3-step compile/elaborate/simulate steps'''
 
     def __init__(self, config: dict):
         CommandSim.__init__(self, config)
@@ -141,9 +143,19 @@ class CommandSimVivado(CommandSim, ToolVivado):
         })
 
         self.sim_libraries = self.tool_config.get('sim-libraries', [])
-        self.xvlog_commands = []
-        self.xelab_commands = []
-        self.xsim_commands = []
+
+        self.vivado_tcl = {
+            'xvlog': [],
+            'xelab': [],
+            'xsim': [],
+            'exe_list': [],
+            'check_logs': [],
+        }
+
+        # Note this is the syntax to have your Vivado tcl print to
+        # stdout, which we do for xvlog, xelab always, and even for xsim if in
+        # --gui or not GUI
+        self.tcl_exec_pipe = ['>@stdout', '2>@stderr']
 
 
     def set_tool_defines(self):
@@ -153,72 +165,144 @@ class CommandSimVivado(CommandSim, ToolVivado):
 
     def prepare_compile(self):
         self.set_tool_defines()
-        self.xvlog_commands = self.get_compile_command_lists()
-        self.xelab_commands = self.get_elaborate_command_lists()
-        self.xsim_commands = self.get_simulate_command_lists()
-        self.write_sh_scripts_to_work_dir(
-            compile_lists=self.xvlog_commands,
-            elaborate_lists=self.xelab_commands,
-            simulate_lists=self.xsim_commands
+
+        # Don't use the return values, these will set values in self.vivado_tcl:
+        self.get_compile_command_lists()
+        self.get_elaborate_command_lists()
+        self.get_simulate_command_lists()
+
+        # We will always run a generated .tcl scirpt from vivado as:
+        # one command line call for:
+        #    vivado -mode batch -source all_vivado.tcl
+        # So we have to create all_vivado.tcl based on our commands that we saved
+        # in self.vivado_tcl:
+        tclfname = os.path.abspath(
+            os.path.join(self.args['work-dir'], 'all_vivado.tcl')
         )
+        with open(tclfname, 'w', encoding='utf-8' ) as ftcl:
+            for line in self.vivado_tcl['xvlog']:
+                if self.args['stop-before-compile']:
+                    ftcl.write('# ')
+                ftcl.write(line)
+                ftcl.write('\n\n')
+            for line in self.vivado_tcl['xelab']:
+                if any(self.args[x] for x in ('stop-before-compile', 'stop-after-compile')):
+                    ftcl.write('# ')
+                ftcl.write(line)
+                ftcl.write('\n\n')
+            for line in self.vivado_tcl['xsim']:
+                if any(self.args[x] for x in ('stop-before-compile', 'stop-after-compile',
+                                              'stop-after-elaborate')):
+                    ftcl.write('# ')
+                ftcl.write(line)
+                ftcl.write('\n\n')
+
+        # We will alwyas run this in -mode batch, the xsim call in
+        # all_vivado.tcl will have -gui in it:
+        self.vivado_tcl['exe_list'] = [
+            self.vivado_exe, '-mode', 'batch', '-source', 'all_vivado.tcl'
+        ]
 
-    def compile(self):
+        # Since we run this in a single vivado call, we don't get the automatic
+        # log checking from sim.run_commands_check_logs(..), so we need to remember
+        # which logs to check:
         if self.args['stop-before-compile']:
-            return
-        self.run_commands_check_logs(
-            self.xvlog_commands, check_logs=True, log_filename='xvlog.log'
+            self.vivado_tcl['check_logs'] = []
+        elif self.args['stop-after-compile']:
+            self.vivado_tcl['check_logs'] = ['vivado.log', 'xvlog.log']
+        elif self.args['stop-after-elaborate']:
+            self.vivado_tcl['check_logs'] = ['vivado.log', 'xvlog.log', 'xelab.log']
+        else:
+            self.vivado_tcl['check_logs'] = ['vivado.log', 'xvlog.log', 'xelab.log', 'xsim.log']
+
+        self.write_sh_scripts_to_work_dir(
+            compile_lists=[],
+            elaborate_lists=[],
+            simulate_lists=[self.vivado_tcl['exe_list']],
+            compile_line_breaks=False
         )
 
+
+    def compile(self):
+        # handled in simulate()
+        return
+
     def elaborate(self):
-        if self.args['stop-before-compile'] or self.args['stop-after-compile']:
-            return
-        # In this flow, we need to run compile + elaborate separately (unlike ModelsimASE)
-        self.run_commands_check_logs(
-            self.xelab_commands, check_logs=True, log_filename='xelab.log',
-            must_strings=['Built simulation snapshot snapshot']
-        )
+        # handled in simulate()
+        return
 
     def simulate(self):
-        if self.args['stop-before-compile'] or self.args['stop-after-compile'] or \
-           self.args['stop-after-elaborate']:
-            return
+        # even though we run one command line call (vivado -mode batch -sourc TCLFILE)
+        # it still saves xvlog.log, xelab.log, xsim.log, and a (useless) vivado.log.
+        # we'll have to manually check the logs for errors if this was run in --gui:
         self.run_commands_check_logs(
-            self.xsim_commands, check_logs=True, log_filename='xsim.log'
+            [self.vivado_tcl['exe_list']], check_logs=False, log_filename='vivado.log'
         )
 
+        for log_fname in self.vivado_tcl['check_logs']:
+            filename = os.path.join(self.args['work-dir'], log_fname)
+            self.check_logs_for_errors(filename=filename)
+
+
     def get_compile_command_lists(self, **kwargs) -> list:
+        '''Override from sim.CommandSim - which expects a return type list.
+
+        Since we run all in Vivado tcl, we always return an empty list,
+        and instead save in self.vivado_tcl['xvlog'].
+        '''
         self.set_tool_defines()
-        ret = [] # list of (list of ['xvlog', arg0, arg1, ..])
 
         if self.args['add-glbl-v']:
             self._add_glbl_v()
 
         # compile verilog
         if self.files_v:
-            ret.append(
-                self.get_xvlog_commands(files_list=self.files_v, typ='v')
-            )
+            self.add_xvlog_commands(files_list=self.files_v, typ='v')
 
         # compile systemverilog
         if self.files_sv:
-            ret.append(
-                self.get_xvlog_commands(files_list=self.files_sv, typ='sv')
-            )
+            self.add_xvlog_commands(files_list=self.files_sv, typ='sv')
+
+        return []
+
+    def process_parameters_get_list(self, arg_prefix: str = '-G') -> list:
+        '''Override from sim.CommandSim
+
+        custom handler for parameters, instead of the one in sim.py
+        all will be passed as -generic_top "k=v", avoids all unknown shell or bash
+        behavior in windows.
+        '''
+
+        # ignore arg_prefix (use -generic_top):
+        ret = []
+        for k,v in self.parameters.items():
+            if not isinstance(v, (int, str)):
+                util.warning(
+                    f'parameter {k} has value: {v}, parameters must be int/string types'
+                )
+            if isinstance(v, int):
+                ret.extend(['-generic_top', f'"{k}={v}"'])
+            else:
+                v = f'{v}'.strip('\n') # stringify
+                # Because we're writing to a .tcl file, \" will become ", and \\\" will become \"
+                # we want \" in the final file.
+                v = v.replace('"', '\\\"')
+                ret.extend(['-generic_top', f'"{k}={v}"'])
+        return ret
 
-        return ret # list of lists
 
     def get_elaborate_command_lists(self, **kwargs) -> list:
-        # elab into snapshot
-        command_list = [
-            os.path.join(self.vivado_base_path, 'xelab'),
-            self.args['top']
-        ]
-        if sys.platform == "win32":
-            command_list[0] += ".bat"
-        command_list += self.tool_config.get('elab-args',
-                                             '-s snapshot -timescale 1ns/1ps --stats').split()
+        '''Override from sim.CommandSim - which expects a return type list.
+
+        Since we run all in Vivado tcl, we always return an empty list,
+        and instead save in self.vivado_tcl['xelab'].
+        '''
+
+        command_list = ['exec', 'xelab', self.args['top']]
+
+        command_list += self.tool_config.get(
+            'elab-args', '-s snapshot -timescale 1ns/1ps --stats').split()
 
-        # parameters
         command_list.extend(
             self.process_parameters_get_list(arg_prefix='-generic_top ')
         )
@@ -241,11 +325,33 @@ class CommandSimVivado(CommandSim, ToolVivado):
                 command_list += ['-L', x]
             command_list += ['glbl']
         command_list += self.args['elab-args']
-        return [command_list]
+
+        # For Windows compatibility, we have some issues with command/Powershell passing args
+        # so as a workaround we'll create a .tcl script xelab_vivado.tcl:
+        #   exec {command_list} >@stdout 2>@stderr
+        # with the caveat that it needs POSIX style paths in the vivado tclsh,
+        # and we'll return the list to run it:
+        # and we'll save this to self.vivado_tcl['xelab']
+        command_list += self.tcl_exec_pipe
+        tclfname = os.path.abspath(
+            os.path.join(self.args['work-dir'], 'xelab_vivado.tcl')
+        )
+        line = ' '.join(command_list).replace('\n', ' ')
+        self.vivado_tcl['xelab'].append(line)
+        with open(tclfname, 'w', encoding='utf-8' ) as ftcl:
+            ftcl.write(line)
+        # return list that will go unused
+        return [ ]
+
 
     def get_simulate_command_lists(self, **kwargs) -> list:
-        # create TCL
-        tcl_name = os.path.abspath(os.path.join(self.args['work-dir'], self.args['tcl-file']))
+        '''Override from sim.CommandSim - which expects a return type list.
+
+        Since we run all in Vivado tcl, we always return an empty list,
+        and instead save in self.vivado_tcl['xsim'].
+        '''
+        # create TCL for in-simulation
+        sim_tcl_name = os.path.abspath(os.path.join(self.args['work-dir'], self.args['tcl-file']))
 
         if self.args['waves']:
             util.artifacts.add_extension(
@@ -253,8 +359,7 @@ class CommandSimVivado(CommandSim, ToolVivado):
                 typ='waveform', description='Vivado XSim Waveform WDB (Wave DataBase) file'
             )
 
-
-        with open( tcl_name, 'w', encoding='utf-8' ) as fo:
+        with open( sim_tcl_name, 'w', encoding='utf-8' ) as fo:
             if self.args['waves']:
                 if self.args['waves-start']:
                     print(f"run {self.args['waves-start']} ns", file=fo)
@@ -268,7 +373,10 @@ class CommandSimVivado(CommandSim, ToolVivado):
         assert isinstance(self.args["sim-plusargs"], list), \
             f'{self.target=} {type(self.args["sim-plusargs"])=} but must be list'
 
-        # xsim uses: --testplusarg foo=bar
+        # xsim uses: --testplusarg name=value
+        # Note - this was problematic in Windows Powershell for --testplusarg "name=value"
+        # --testplusarg "name" would work, but the only way for xsim to parse it was to
+        # run it in vivado's tclsh.
         xsim_plusargs_list = []
         for x in self.args['sim-plusargs']:
             xsim_plusargs_list.append('--testplusarg')
@@ -278,61 +386,104 @@ class CommandSimVivado(CommandSim, ToolVivado):
             xsim_plusargs_list.append(f'\"{x}\"')
 
         # execute snapshot
-        command_list = [ os.path.join(self.vivado_base_path, 'xsim') ]
-        if sys.platform == "win32":
-            command_list[0] += ".bat"
+        command_list = ['exec', 'xsim']
         command_list += self.tool_config.get('simulate-args', 'snapshot --stats').split()
         if self.args['gui'] and not self.args['test-mode']:
             command_list += ['-gui']
         command_list += [
-            '--tclbatch', tcl_name.replace('\\','\\\\'),  # needed for windows paths
+            '--tclbatch', Path(sim_tcl_name).as_posix(), # running in tclsh needs POSIX
             "--sv_seed", sv_seed
         ]
         command_list += xsim_plusargs_list
         command_list += self.args['sim-args']
-        return [command_list] # single command
+
+        # For Windows compatibility we have some issues with command/Powershell passing args
+        # so as a workaround we'll create a .tcl script xsim_vivado.tcl:
+        #   exec {command_list} >@stdout 2>@stderr
+        # with the caveat that it needs POSIX style paths in the vivado tclsh,
+        # and we'll save this to self.vivado_tcl['xsim']
+        command_list += self.tcl_exec_pipe
+
+        tclfname = os.path.abspath(
+            os.path.join(self.args['work-dir'], 'xsim_vivado.tcl')
+        )
+        line = ' '.join(command_list).replace('\n', ' ')
+        self.vivado_tcl['xsim'].append(line)
+        with open(tclfname, 'w', encoding='utf-8' ) as ftcl:
+            ftcl.write(line)
+
+        # Need to return list, will go unused.
+        return []
 
     def get_post_simulate_command_lists(self, **kwargs) -> list:
         return []
 
-    def get_xvlog_commands(self, files_list: list, typ: str = 'sv') -> list:
-        '''Returns list. Vivado still treats .v files like Verilog-2001, so we split
-
-        xvlog into .v and .sv sections'''
-        command_list = []
-
-        if files_list:
-            command_list = [ os.path.join(self.vivado_base_path, 'xvlog') ]
-            if sys.platform == "win32":
-                command_list[0] += ".bat"
-            if typ == 'sv':
-                command_list.append('-sv')
-                if self.args['uvm']:
-                    command_list.extend(['-L', 'uvm'])
-            command_list += self.tool_config.get('compile-args', '').split()
-            if util.args['verbose']:
-                command_list += ['-v', '2']
-            for value in self.incdirs:
-                command_list.append('-i')
-                command_list.append(value)
-            for key, value in self.defines.items():
-                command_list.append('-d')
-                if value is None:
-                    command_list.append(key)
-                elif sys.platform == "win32":
-                    command_list.append(f"\"{key}={value}\"") # only thing that seems to work
-                elif "\'" in value:
-                    command_list.append(f"\"{key}={value}\"")
-                else:
-                    command_list.append(f"{key}={value}")
-            command_list += self.args['compile-args']
-            command_list += files_list
-        return command_list
+
+    def add_xvlog_commands( # pylint: disable=too-many-branches
+            self, files_list: list, typ: str = 'sv'
+    ) -> None:
+        '''Returns None, because we'll save the results in self.vivado_tcl['xvlog'].
+
+        Vivado still treats .v files like Verilog-2001, so we split xvlog into .v and .sv sections,
+        as two entries in self.vivado_tcl['xvlog'] if self.args['all-sv'] is False.
+        '''
+
+
+        if not files_list:
+            return
+
+        # For Windows compatibility we have some issues with command/Powershell passing args
+        # so as a workaround we'll create a .tcl script xvlog_sv_vivado.tcl:
+        #   exec {command_list} >@stdout 2>@stderr
+        # with the caveat that it needs POSIX style paths in the vivado tclsh,
+        # and we'll save this to self.vivado_tcl['xvlog']
+        command_list = ['exec', 'xvlog']
+        if typ == 'sv':
+            command_list.append('-sv')
+            if self.args['uvm']:
+                command_list.extend(['-L', 'uvm'])
+        command_list += self.tool_config.get('compile-args', '').split()
+        if util.args['verbose']:
+            command_list += ['-v', '2']
+        for value in self.incdirs:
+            command_list.append('-i')
+            command_list.append(Path(value).as_posix())
+        for key, value in self.defines.items():
+            command_list.append('-d')
+            if value is not None:
+                # Because we're writing to a .tcl file, \" will become ", and \\\" will become \"
+                # we want \" in the final file. Parameters need to act the same way as defines:
+                value = f'{value}'.replace('"', '\\\"')
+
+            if value is None:
+                command_list.append(key)
+            else:
+                command_list.append(f"\"{key}={value}\"")
+
+        command_list += self.args['compile-args']
+
+        # Convert these to POSIX (even though we might be in Windows) b/c that's what Vivado
+        # tclsh needs
+        command_list += [Path(fpath).as_posix() for fpath in files_list]
+        command_list += self.tcl_exec_pipe
+
+        tclfname = os.path.abspath(
+            os.path.join(self.args['work-dir'], f'xvlog_{typ}_vivado.tcl')
+        )
+
+        # Make a one-liner from command line, save in self.vivado_tcl['xvlog']:
+        line = ' '.join(command_list).replace('\n', ' ')
+        self.vivado_tcl['xvlog'].append(line)
+        with open(tclfname, 'w', encoding='utf-8' ) as ftcl:
+            ftcl.write(line)
+            ftcl.write('\n')
 
 
     def _add_glbl_v(self):
         '''Adds glbl.v from Vivado's install path to self.files_v'''
-        glbl_v = self.vivado_base_path.replace('bin', 'data/verilog/src/glbl.v')
+        glbl_v = self.vivado_base_path.replace(
+            'bin', os.path.join('data', 'verilog', 'src', 'glbl.v')
+        )
         if any(x.endswith('glbl.v') for x in self.files_v):
             util.warning(f'--add-glbl-v: Not adding {glbl_v=} b/c glbl.v already in',
                          f'{self.files_v=}')
@@ -349,6 +500,8 @@ class CommandSimVivado(CommandSim, ToolVivado):
         sim.log or compile.log
         '''
         _, leafname = os.path.split(name)
+        if leafname == 'vivado.log':
+            description = 'Vivado XSim log from stdout/stderr'
         if leafname == 'xsim.log':
             description = 'Vivado XSim simulation step (3/3) log from stdout/stderr'
         elif leafname == 'xelab.log':
@@ -429,7 +582,7 @@ class CommandSynthVivado(CommandSynth, ToolVivado):
         parameters = ' '.join(
             sim.parameters_dict_get_command_list(params=self.parameters, arg_prefix='-generic ')
         )
-        incdirs = ' '.join([f'-include_dirs {x}' for x in self.incdirs])
+        incdirs = ' '.join([f'-include_dirs {Path(x).as_posix()}' for x in self.incdirs])
         flatten = ""
         if self.args['flatten-all']:
             flatten = "-flatten_hierarchy full"
@@ -437,12 +590,14 @@ class CommandSynthVivado(CommandSynth, ToolVivado):
             flatten = "-flatten_hierarchy none"
 
         tcl_lines = []
+        # Note - if we're in Windows, the vivado tcl that processes these lines expects POSIX
+        # paths, not command/Powershell paths. so we will use Path(str).as_posix()
         for f in self.files_v:
-            tcl_lines.append(f"read_verilog {f}")
+            tcl_lines.append(f"read_verilog {Path(f).as_posix()}")
         for f in self.files_sv:
-            tcl_lines.append(f"read_verilog -sv {f}")
+            tcl_lines.append(f"read_verilog -sv {Path(f).as_posix()}")
         for f in self.files_vhd:
-            tcl_lines.append(f"add_file {f}")
+            tcl_lines.append(f"add_file {Path(f).as_posix()}")
 
         part = self.args['part']
         top = self.args['top']
@@ -465,11 +620,11 @@ class CommandSynthVivado(CommandSynth, ToolVivado):
         for _file in self.files_sdc:
             # NOTE - sdc files cannot (yet) be attached to other modules.
             tcl_lines += [
-                f"add_files -fileset constraints_1 {_file} {v}",
+                f"add_files -fileset constraints_1 {Path(_file).as_posix()} {v}",
             ]
         if xdc_file:
             tcl_lines += [
-                f"add_files -fileset constraints_1 {xdc_file} {v}",
+                f"add_files -fileset constraints_1 {Path(xdc_file).as_posix()} {v}",
             ]
         tcl_lines += [
             "# FIRST PASS -- auto_detect_xpm",
@@ -513,14 +668,14 @@ class CommandSynthVivado(CommandSynth, ToolVivado):
 
         if default_xdc:
             tcl_lines += [
-                f"puts \"(Used default XDC: {xdc_file})\"",
+                f"puts \"(Used default XDC: {Path(xdc_file).as_posix()})\"",
                 f"puts \"DEF CLOCK NS  : [format %.3f {self.args['clock-ns']}]\"",
                 f"puts \"DEF IDELAY NS : [format %.3f {self.args['idelay-ns']}]\"",
                 f"puts \"DEF ODELAY NS : [format %.3f {self.args['odelay-ns']}]\"",
             ]
         else:
             tcl_lines += [
-                f"puts \"(Used provided XDC: {xdc_file})\"",
+                f"puts \"(Used provided XDC: {Path(xdc_file).as_posix()})\"",
             ]
         tcl_lines += [
             "puts \"\"",
@@ -592,13 +747,13 @@ class CommandProjVivado(CommandProj, ToolVivado):
         tcl_file = os.path.abspath(os.path.join(self.args['work-dir'], self.args['tcl-file']))
         v = self.get_vivado_tcl_verbose_arg()
 
-        incdirs = " ".join(self.incdirs)
+        incdirs = " ".join([Path(x).as_posix() for x in self.incdirs])
         defines = ""
         for key, value in self.defines.items():
             defines += (f"{key} " if value is None else f"{key}={value} ")
 
         tcl_lines = [
-            f"create_project {self.args['top']}_proj {self.args['work-dir']} {v}"
+            f"create_project {self.args['top']}_proj {Path(self.args['work-dir']).as_posix()} {v}"
         ]
 
         if self.args['oc-vivado-tcl'] and oc_root:
@@ -630,7 +785,7 @@ class CommandProjVivado(CommandProj, ToolVivado):
             else:
                 fileset = "sources_1"
             tcl_lines += [
-                f"add_files -norecurse {f} -fileset [get_filesets {fileset}]"
+                f"add_files -norecurse {Path(f).as_posix()} -fileset [get_filesets {fileset}]"
             ]
 
         tcl_lines += [
@@ -776,16 +931,16 @@ class CommandFListVivado(CommandFList, ToolVivado):
 class CommandUploadVivado(CommandUpload, ToolVivado):
     '''CommandUploadVivado is a command handler for: eda upload --tool=vivado'''
 
+    SUPPORTED_BIT_EXT = ['.bit']
+
     def __init__(self, config: dict):
         CommandUpload.__init__(self, config)
         ToolVivado.__init__(self, config=self.config)
         # add args specific to this tool
         self.args.update({
             'gui': False,
-            'bitfile': "",
             'list-usbs': False,
             'list-devices': False,
-            'list-bitfiles': False,
             'usb': -1,
             'device': -1,
             'host': "localhost",
@@ -795,82 +950,51 @@ class CommandUploadVivado(CommandUpload, ToolVivado):
             'log-file': "eda_upload.log",
             'test-mode': False,
         })
-        # TODO(drew): Add self.args_help.update({...})
 
-    # TODO(drew): This method needs to be refactored (with tests somehow) to clean
-    # up pylint waivers
+        # TODO(drew): Complete self.args_help.update({...})
+        self.args_help.update({
+            'bitfile': 'BIT file to upload (auto-detected if not specified)',
+            'list-bitfiles': 'List available BIT files',
+        })
+
+
     def do_it(self): # pylint: disable=too-many-locals,too-many-branches,too-many-statements
+        '''
+        Note this is called directly by opencos.commands.CommandUpload, based
+         on which bitfile(s) were found, or if --tool=vivado was set
+
+        We do not need to handle --list-bitfiles, was handled by CommandUpload.
+        '''
+
         # add defines for this job
         self.set_tool_defines()
         self.write_eda_config_and_args()
 
         bitfile = None
-        targets = []
         if self.args['bitfile']:
             if os.path.isfile(self.args['bitfile']):
                 bitfile = self.args['bitfile']
-            else:
-                # Not a file, treat as search pattern
-                targets = [self.args['bitfile']]
-
-        # TODO(drew): It might be nice to use positional args (supported by
-        # eda_base.Command) here, and in multi.py, so we don't accidentally
-        # grab errant --arg style strings as potential filenames or target patterns
-        for f in self.unparsed_args:
-            # self.unparsed_args are leftovers from Command.process_tokens(..)
-            if os.path.isfile(f):
-                if bitfile is None:
-                    bitfile = f
-                else:
-                    util.error("Too many bitfiles provided")
-                    if not self.args['test-mode']:
-                        sys.exit(0)
-            else:
-                # Not a file, treat as search pattern
-                targets.append(f)
-
-        # Auto-discover bitfile logic (for when we have no bitfile, and we
-        # weren't called just to listdevice/listusb)
-        if self.args['list-bitfiles'] or \
-           (not bitfile and not self.args['list-devices'] and not self.args['list-usbs']):
-            bitfiles: list[Path] = []
 
-            util.debug(f"Looking for bitfiles in {os.path.abspath('.')=}")
-            for root, _, files in os.walk("."):
-                for f in files:
-                    if f.endswith(".bit"):
-                        fullpath = os.path.abspath(Path(root) / f)
-                        if fullpath not in bitfiles:
-                            bitfiles.append(fullpath)
-
-            matched: list[Path] = []
-            for cand in bitfiles:
-                util.debug(f"Looking for {cand=} in {targets=}")
-                passing = all(re.search(t, str(cand)) for t in targets)
-                if passing:
-                    matched.append(cand)
-                    mod_time_string = datetime.fromtimestamp(
-                        os.path.getmtime(cand)).strftime('%Y-%m-%d %H:%M:%S')
-                    util.info(f"Found matching bitfile: {mod_time_string} : {cand}")
-
-            if len(matched) > 1:
-                if self.args['list-bitfiles']:
-                    util.info("Too many matches to continue without adding search terms.  Done.")
-                    if not self.args['test-mode']:
-                        sys.exit(0)
-                else:
-                    util.error("Too many matches, please add search terms...")
+        # self.bitfiles was already set by CommandUpload.process_tokens()
+        if len(self.bitfiles) == 1:
+            bitfile = self.bitfiles[0]
 
-            if not matched and bitfile is None:
-                if self.args['list-bitfiles']:
-                    util.info("No matching bitfiles found, done.")
-                    if not self.args['test-mode']:
-                        sys.exit(0)
-                else:
-                    util.error("Failed to find a matching bitfile")
 
-            if matched and bitfile is None:
-                bitfile = matched[0]
+        # Auto-discover bitfile logic (for when we have no bitfile, and we
+        # weren't called just to listdevice/listusb)
+        if not bitfile and not self.args['list-devices'] and not self.args['list-usbs']:
+
+            # CommandUpload already displayed them, and exited on --list-bitfiles.
+            if len(self.bitfiles) > 1:
+                util.warning("Too many matches to continue without adding search terms,",
+                             "upload not performed.")
+                if not self.args['test-mode']:
+                    self.error('Upload not performed, multiple bit files found, please add',
+                               'search terms...')
+                return
+
+            self.error("Failed to find a matching bitfile")
+            return
 
         # ── Generate TCL script ───────────────────────────────────────────────────
         script_file = Path(self.args['tcl-file'])
@@ -945,10 +1069,11 @@ class CommandUploadVivado(CommandUpload, ToolVivado):
                 w('refresh_hw_device -update_hw_probes false -quiet $hw_device\n')
 
                 if bitfile is not None:
-                    w('set_property PROGRAM.FILE {' + bitfile + '} $hw_device\n')
+                    w('set_property PROGRAM.FILE {' + Path(bitfile).as_posix() + '} $hw_device\n')
                     w('program_hw_devices [current_hw_device]\n')
 
                 w('close_hw_target\n')
+                w('quit\n')
 
         except OSError as exc:
             util.error(f"Cannot create {script_file}: {exc}")
@@ -971,11 +1096,21 @@ class CommandUploadVivado(CommandUpload, ToolVivado):
         ]
         if not util.args['verbose']:
             command_list.append('-notrace')
-        self.exec(Path(util.getcwd()), command_list)
+        _, stdout, _ = self.exec(Path(util.getcwd()), command_list)
+
+        # Do some log scraping
+        for line in stdout.split('\n'):
+            if line.startswith('WARNING:'):
+                self.tool_warning_count += 1
+            elif line.startswith('ERROR:') or line.startswith('[ERROR]'):
+                self.tool_error_count += 1
 
         if not self.args['keep']:
             os.unlink(self.args['tcl-file'])
 
+        self.report_tool_warn_error_counts()
+        self.report_pass_fail()
+
         util.info("Upload done")