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

opencos/tools/vivado.py

@@ -10,6 +10,10 @@ 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
@@ -30,8 +34,14 @@ class ToolVivado(Tool):
 
     def __init__(self, config: dict):
         super().__init__(config=config) # calls self.get_versions()
-        self.args['xilinx'] = False
-        self.args['part'] = 'xcu200-fsgd2104-2-e'
+        self.args.update({
+            'part': 'xcu200-fsgd2104-2-e',
+            'add-glbl-v': False,
+        })
+        self.args_help.update({
+            'part': 'Device used for commands: synth, build.',
+            'add-glbl-v': '(for simulation) add glbl.v to filelist',
+        })
 
 
     def get_versions(self) -> str:
@@ -48,10 +58,10 @@ class ToolVivado(Tool):
 
         xilinx_vivado = os.environ.get('XILINX_VIVADO')
         if not xilinx_vivado or \
-           os.path.abspath(os.path.join(xilinx_vivado, 'bin', 'vivado')) != \
-               os.path.abspath(self.vivado_exe):
+           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:",
-                      f"{xilinx_vivado=}")
+                      f"XILINX_VIVADO={xilinx_vivado} EXE PATH={self.vivado_exe}")
 
         version = None
         # Note this is commented out b/c it's a bit slow, up to 1.0 second to
@@ -91,12 +101,6 @@ class ToolVivado(Tool):
         self.defines['OC_TOOL_VIVADO'] = None
         def_year_release = f'OC_TOOL_VIVADO_{self.vivado_year:04d}_{self.vivado_release:d}'
         self.defines[def_year_release] = None
-        if self.args['xilinx']:
-            self.defines['OC_LIBRARY_ULTRASCALE_PLUS'] = None
-            self.defines['OC_LIBRARY'] = "1"
-        else:
-            self.defines['OC_LIBRARY_BEHAVIORAL'] = None
-            self.defines['OC_LIBRARY'] = "0"
 
         # Code can be conditional on Vivado versions and often keys of "X or older" ...
         versions = ['2021.1', '2021.2', '2022.1', '2022.2', '2023.1', '2023.2',
@@ -133,9 +137,18 @@ class CommandSimVivado(CommandSim, ToolVivado):
         CommandSim.__init__(self, config)
         ToolVivado.__init__(self, config=self.config)
         # add args specific to this simulator
-        self.args['gui'] = False
-        self.args['tcl-file'] = "sim.tcl"
-        self.args['fpga'] = ""
+        self.args.update({
+            'gui':        False,
+            'tcl-file':   'sim.tcl',
+            'fpga':       '',
+            'add-glbl-v': False,
+        })
+        self.args_help.update({
+            'gui':        'Run Vivado XSim in GUI mode',
+            'tcl-file':   'name of TCL file to be created for XSim',
+            'fpga':       'FPGA device name, can be used for various Xilinx IP or XCIs',
+            'add-glbl-v': 'Use the glbl.v in xvlog for this version of Vivado',
+        })
 
         self.sim_libraries = self.tool_config.get('sim-libraries', [])
         self.xvlog_commands = []
@@ -198,10 +211,13 @@ class CommandSimVivado(CommandSim, ToolVivado):
         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 or self.args['xilinx']:
+        if self.files_v:
             ret.append(
-                self.get_xvlog_commands(files_list=self.files_v, typ='v', add_glbl_v=True)
+                self.get_xvlog_commands(files_list=self.files_v, typ='v')
             )
 
         # compile systemverilog
@@ -218,6 +234,8 @@ class CommandSimVivado(CommandSim, ToolVivado):
             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()
         if self.tool_config.get('elab-waves-args', ''):
@@ -230,7 +248,7 @@ class CommandSimVivado(CommandSim, ToolVivado):
             command_list += ['-debug', 'wave']
         if util.args['verbose']:
             command_list += ['-v', '2']
-        if self.args['xilinx']:
+        if self.args['sim-library'] or self.args['add-glbl-v']:
             self.sim_libraries += self.args['sim-library'] # Add any command line libraries
             for x in self.sim_libraries:
                 command_list += ['-L', x]
@@ -265,11 +283,13 @@ class CommandSimVivado(CommandSim, ToolVivado):
 
         # execute snapshot
         command_list = [ os.path.join(self.vivado_base_path, 'xsim') ]
+        if sys.platform == "win32":
+            command_list[0] += ".bat"
         command_list += self.tool_config.get('simulate-args', 'snapshot --stats').split()
         if self.args['gui']:
             command_list += ['-gui']
         command_list += [
-            '--tclbatch', tcl_name,
+            '--tclbatch', tcl_name.replace('\\','\\\\'),  # needed for windows paths
             "--sv_seed", sv_seed
         ]
         command_list += xsim_plusargs_list
@@ -279,25 +299,21 @@ class CommandSimVivado(CommandSim, ToolVivado):
     def get_post_simulate_command_lists(self, **kwargs) -> list:
         return []
 
-    def get_xvlog_commands(self, files_list: list,
-                           typ: str = 'sv', add_glbl_v: bool = False) -> list:
+    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')
             command_list += self.tool_config.get('compile-args', '').split()
             if util.args['verbose']:
                 command_list += ['-v', '2']
-            if (typ == 'v' or add_glbl_v) and self.args['xilinx']:
-                # Get the right glbl.v for the vivado being used.
-                glbl_v = self.vivado_base_path.replace('bin', 'data/verilog/src/glbl.v')
-                if not os.path.exists(glbl_v):
-                    self.error(f"Could not find file {glbl_v=}")
-                command_list.append(glbl_v)
             for value in self.incdirs:
                 command_list.append('-i')
                 command_list.append(value)
@@ -305,16 +321,27 @@ class CommandSimVivado(CommandSim, ToolVivado):
                 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.append(f"{key}={value}")
             command_list += self.args['compile-args']
             command_list += files_list
         return command_list
 
 
-
+    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')
+        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=}')
+        elif not os.path.exists(glbl_v):
+            self.error(f"Could not find file {glbl_v=}")
+        else:
+            self.files_v.insert(0, glbl_v)
 
 
 class CommandElabVivado(CommandSimVivado):
@@ -559,6 +586,9 @@ class CommandProjVivado(CommandProj, ToolVivado):
                 f"add_files -norecurse {f} -fileset [get_filesets {fileset}]"
             ]
 
+        tcl_lines += [
+            f"set_property top {self.args['top']} [get_filesets sim_1]"
+        ]
         with open( tcl_file, 'w', encoding='utf-8' ) as fo:
             fo.write('\n'.join(tcl_lines))
 
@@ -570,7 +600,7 @@ class CommandProjVivado(CommandProj, ToolVivado):
         if not util.args['verbose']:
             command_list.append('-notrace')
         self.exec(self.args['work-dir'], command_list)
-        util.info(f"Synthesis done, results are in: {self.args['work-dir']}")
+        util.info(f"Project run done, results are in: {self.args['work-dir']}")
 
 
 class CommandBuildVivado(CommandBuild, ToolVivado):
@@ -600,12 +630,17 @@ class CommandBuildVivado(CommandBuild, ToolVivado):
             '--tool', self.args['tool'],
             self.args['top-path'],
             '--force',
-            '--xilinx',
             '--out', flist_file,
-            '--no-emit-incdir',
-            '--no-single-quote-define', # Needed to run in Command.exec( ... shell=False)
+            #'--no-emit-incdir',
+            #'--no-single-quote-define', # Needed to run in Command.exec( ... shell=False)
             '--no-quote-define',
+            #'--bracket-quote-define',
+            '--quote-define-value',
+            '--escape-define-value',
+            '--no-equal-define',
+            '--bracket-quote-path',
             # on --prefix- items, use shlex.quote(str) so spaces work with subprocess shell=False:
+            '--prefix-incdir', shlex.quote("oc_set_project_incdir "),
             '--prefix-define', shlex.quote("oc_set_project_define "),
             '--prefix-sv', shlex.quote("add_files -norecurse "),
             '--prefix-v', shlex.quote("add_files -norecurse "),
@@ -674,96 +709,202 @@ class CommandUploadVivado(CommandUpload, ToolVivado):
         CommandUpload.__init__(self, config)
         ToolVivado.__init__(self, config=self.config)
         # add args specific to this simulator
-        self.args['gui'] = False
-        self.args['file'] = False
-        self.args['usb'] = True
-        self.args['host'] = "localhost"
-        self.args['port'] = 3121
-        self.args['target'] = 0
-        self.args['tcl-file'] = "upload.tcl"
+        self.args.update({
+            'gui': False,
+            'bitfile': "",
+            'list-usbs': False,
+            'list-devices': False,
+            'list-bitfiles': False,
+            'usb': -1,
+            'device': -1,
+            'host': "localhost",
+            'port': 3121,
+            'tcl-file': "upload.tcl",
+            '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
+    def do_it(self): # pylint: disable=too-many-locals,too-many-branches,too-many-statements
+        # add defines for this job
+        self.set_tool_defines()
+        self.write_eda_config_and_args()
 
-    def do_it(self):
-        if not self.args['file']:
-            util.info("Searching for bitfiles...")
-            found_file = False
-            all_files = []
+        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 file in files:
-                    if file.endswith(".bit"):
-                        found_file = os.path.abspath(os.path.join(root,file))
-                        util.info(f"Found bitfile: {found_file}")
-                        all_files.append(found_file)
-            self.args['file'] = found_file
+                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...")
 
-            if len(all_files) > 1:
-                all_files.sort(key=os.path.getmtime)
-                self.args['file'] = all_files[-1]
-                util.info(f"Choosing: {self.args['file']} (newest)")
+            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]
+
+        # ── Generate TCL script ───────────────────────────────────────────────────
+        script_file = Path(self.args['tcl-file'])
+        log_file    = Path("eda_upload.log")
+
+        try:
+            with script_file.open("w", encoding="utf-8") as fout:
+                w = fout.write   # local alias (brevity)
+
+                w('open_hw_manager\n')
+                w(f'connect_hw_server -url {self.args["host"]}:{self.args["port"]}\n')
+                w('refresh_hw_server -force_poll\n')
+
+                w('set hw_targets [get_hw_targets -quiet */xilinx_tcf/Xilinx/*]\n')
+                w('set num_targets [llength $hw_targets]\n')
+                if self.args['list-usbs']:
+                    w('puts "\\[INFO\\] OC_LOAD_BITFILE TCL $num_targets USB targets found"\n')
+                    w('for {set u 0} {$u < $num_targets} {incr u} {\n')
+                    w('  puts "\\[INFO\\] OC_LOAD_BITFILE TCL: USB $u : [lindex $hw_targets $u]"\n')
+                    w('}\n')
+                    w('if { $num_targets > 1} {\n')
+                    w('  set maxusb [expr $num_targets - 1]\n')
+                    w('  puts "\\[INFO\\] OC_LOAD_BITFILE TCL: With >1 target you need to specify'
+                      '--usb <n> where <n> is 0-$maxusb"\n')
+                    w('}\n')
+                w('if { $num_targets == 0 } {\n')
+                w('  puts "\\[ERROR\\] OC_LOAD_BITFILE TCL: No HW_targets found!"\n')
+                w('  exit\n}\n')
+
+                if self.args['usb'] == -1:
+                    w('if { $num_targets == 1 } {\n')
+                    w('  puts "\\[INFO\\] OC_LOAD_BITFILE TCL: Defaulting to USB #0, since there is'
+                      'only one device"\n')
+                    w('  set usb 0\n} else {\n')
+                    if not self.args['list-usbs']:
+                        w('  set maxusb [expr $num_targets - 1]\n')
+                        w('  puts "\\[ERROR\\] OC_LOAD_BITFILE TCL: Need --usb <n> argument, <n>'
+                          'being 0-$maxusb, use --list-usbs if needed"\n')
+                    w('  exit\n}\n')
+                else:
+                    w(f'set usb {self.args["usb"]}\n')
+
+                w('if { $num_targets <= $usb } {\n')
+                w('  puts "\\[ERROR\\] OC_LOAD_BITFILE TCL: hw_target #$usb doesn\'t exist!!"\n')
+                w('  exit\n}\n')
+                w('set hw_target [lindex $hw_targets $usb]\n')
+                w('current_hw_target $hw_target\n')
+                w('open_hw_target\n')
+                w('refresh_hw_target\n')
+
+                w('set hw_devices [get_hw_devices -quiet]\n')
+                w('set num_devices [llength $hw_devices]\n')
+                if self.args['list-devices']:
+                    w('puts "\\[INFO\\] OC_LOAD_BITFILE TCL $num_devices devices found"\n')
+                    w('for {set d 0} {$d < $num_devices} {incr d} {\n')
+                    w('  puts "\\[INFO\\] OC_LOAD_BITFILE TCL: Device $d :'
+                      '[lindex $hw_devices $d]"\n')
+                    w('}\n')
+
+                if self.args['device'] == -1:
+                    w('if { $num_devices > 1 } {\n')
+                    w('  if { [lindex $hw_devices 0] eq "arm_dap_0" } {\n')
+                    w('    set hw_device [lindex $hw_devices 1]\n  } else {\n')
+                    w('    set hw_device [lindex $hw_devices 0]\n  }\n')
+                    w('}\n')
+                else:
+                    w(f'set hw_device [lindex $hw_devices {self.args["device"]  }]\n')
 
-        if not self.args['file']:
-            self.error("Couldn't find a bitfile to upload, and/or --file not set.")
-
-        if self.args['usb']:
-            util.info(f"Uploading bitfile: {self.args['file']}")
-            util.info(f"Uploading via {self.args['host']}:{self.args['port']}",
-                      f"USB target #{self.args['target']}")
-            self.upload_usb_jtag(
-                self.args['host'], self.args['port'], self.args['target'], self.args['file']
-            )
+                w('puts "HW_DEVICE DID  : [get_property DID $hw_device]"\n')
+                w('puts "HW_DEVICE PART : [get_property PART $hw_device]"\n')
+                w('current_hw_device $hw_device\n')
+                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('program_hw_devices [current_hw_device]\n')
+
+                w('close_hw_target\n')
+
+        except OSError as exc:
+            util.error(f"Cannot create {script_file}: {exc}")
+
+        if bitfile is None:
+            util.info("No bitfile provided or found")
         else:
-            self.error("Only know how to upload via USB for now, args --usb not set.")
-        self.write_eda_config_and_args()
+            if os.path.isfile(bitfile):
+                util.info(f"Using bitfile {bitfile}")
+            else:
+                util.warning(f"Using bitfile {bitfile}, which doesn't exist (or is not a file)")
 
-    def upload_usb_jtag(self, host, port, target, bit_file):
-        '''Returns None, creats and runs a tcl to run in Vivado 'open_hw'. '''
-        # create TCL
-        tcl_file = os.path.abspath(os.path.join(self.args['work-dir'], self.args['tcl-file']))
-        ltx_file = os.path.splitext(bit_file)[0] + ".ltx"
-        if not os.path.exists(ltx_file):
-            ltx_file = False
+        if self.args['test-mode']:
+            util.info(f"test-mode set, upload skipped, {script_file=}")
+            return
 
-        tcl_lines = [
-            "open_hw",
-            f"connect_hw_server -url {host}:{port}",
-            "refresh_hw_server -force_poll",
-            "set hw_targets [get_hw_targets */xilinx_tcf/Xilinx/*]",
-            f"if {{ [llength $hw_targets] <= {target} }} {{",
-            f"  puts \"ERROR: There is no target number {target}\"",
-            "}}",
-            f"current_hw_target [lindex $hw_targets {target}]",
-            "open_hw_target",
-            "refresh_hw_target",
-            "current_hw_device [lindex [get_hw_devices] 0]",
-            "refresh_hw_device [current_hw_device]",
-            f"set_property PROGRAM.FILE {bit_file} [current_hw_device]",
-        ]
-        if ltx_file:
-            tcl_lines += [
-                f"set_property PROBES.FILE {ltx_file} [current_hw_device]",
-            ]
-        tcl_lines += [
-            "program_hw_devices [current_hw_device]",
+        # ── Execute Vivado ───────────────────────────────────────────────────────
+        command_list = [
+            self.vivado_exe, '-mode', 'batch', '-source', str(script_file), '-log', str(log_file)
         ]
-        if self.args['gui']:
-            tcl_lines += [
-                "refresh_hw_device [current_hw_device]",
-                "display_hw_ila_data [ get_hw_ila_data hw_ila_data_1 -of_objects [get_hw_ilas] ]",
-            ]
-        else:
-            tcl_lines += [
-                "close_hw_target",
-                "exit",
-            ]
+        if not util.args['verbose']:
+            command_list.append('-notrace')
+        self.exec(Path(util.getcwd()), command_list)
+
+        util.info("Upload done")
+
+
 
-        with open( tcl_file, 'w', encoding='utf-8' ) as fo:
-            fo.write('\n'.join(tcl_lines))
 
-        # execute Vivado
-        command_list = [ self.vivado_exe, '-source', tcl_file, '-log', "fpga.upload.log" ]
-        if not self.args['gui']:
-            command_list.append('-mode')
-            command_list.append('batch')
-        self.exec(self.args['work-dir'], command_list)
 
 class CommandOpenVivado(CommandOpen, ToolVivado):
     '''CommandOpenVivado command handler class used by: eda open --tool vivado'''

opencos/tools/yosys.py

@@ -66,12 +66,7 @@ class ToolYosys(Tool):
         self.defines.update({
             'OC_TOOL_YOSYS': None
         })
-        if self.args['xilinx']:
-            self.defines.update({
-                'OC_LIBRARY_ULTRASCALE_PLUS': None,
-                'OC_LIBRARY': "1"
-            })
-        else:
+        if 'OC_LIBRARY' not in self.defines:
             self.defines.update({
                 'OC_LIBRARY_BEHAVIORAL': None,
                 'OC_LIBRARY': "0"

opencos/util.py

@@ -451,6 +451,8 @@ def get_oc_root(error_on_fail:bool=False):
             print_didnt_find_it(f'Unable to get a OC_ROOT directory using git rev-parse')
         else:
             _oc_root = cp.stdout.strip()
+            if sys.platform == 'win32':
+                _oc_root = _oc_root.replace('/', '\\') # git gives us /, but we need \
 
     # there is no sense running through this code more than once
     _oc_root_set = True
@@ -580,6 +582,8 @@ def write_shell_command_file(dirpath : str, filename : str, command_lists : list
     assert type(command_lists) is list, f'{command_lists=}'
     fullpath = os.path.join(dirpath, filename)
     with open(fullpath, 'w') as f:
+        if not bash_path:
+            bash_path = "/bin/bash" # we may not get far, but we'll try
         f.write('#!' + bash_path + '\n\n')
         for obj in command_lists:
             assert isinstance(obj, list), f'{obj=} (obj must be list/ShellCommandList) {command_lists=}'

{opencos_eda-0.2.28.dist-info → opencos_eda-0.2.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.2.28
+Version: 0.2.32
 Summary: A simple Python package for wrapping RTL simuliatons and synthesis
 Author-email: Simon Sabato <simon@cognichip.ai>, Drew Ranck <drew@cognichip.ai>
 Project-URL: Homepage, https://github.com/cognichip/opencos