def init_test(port, retries): bus = RemoteClient(port=port) bus.open() init_done = False for i in range(retries): # Reset PHY bus.regs.sata_phy_enable.write(0) bus.regs.sata_phy_enable.write(1) # Wait time.sleep(10e-3) # Check Status if (bus.regs.sata_phy_status.read() & 0x1) != 0: init_done = True break print(".", end="") sys.stdout.flush() print("") print("Success (retries: {:d})".format(i) if init_done else "Failed") bus.close()
def us_set_sys_clk(clk_freq, vco_freq): import time from litex import RemoteClient bus = RemoteClient() bus.open() # # # # (Re)Configuring sys_clk. print("Configuring sys_clk to {:3.3f}MHz...".format(clk_freq / 1e6)) uspll = USPLL(bus) clkout0_clkreg1 = ClkReg1(uspll.read(0x8)) vco_div = int(vco_freq / clk_freq) clkout0_clkreg1.high_time = vco_div // 2 + vco_div % 2 clkout0_clkreg1.low_time = vco_div // 2 uspll.write(0x08, clkout0_clkreg1.pack()) # Measure/verify sys_clk print("Measuring sys_clk...", end=" ") duration = 5 start = bus.regs.crg_sys_clk_counter.read() time.sleep(duration) end = bus.regs.crg_sys_clk_counter.read() print(": {:3.2f}MHz.".format((end - start) / (1e6 * duration))) # # # bus.close()
def block2mem_test(port, sector, count): wb = RemoteClient(port=port) wb.open() class Block2MemDriver: def __init__(self, base): self.base = base def read(self, sector): wb.regs.sata_block2mem_sector.write(sector) wb.regs.sata_block2mem_base.write(self.base) wb.regs.sata_block2mem_start.write(1) while wb.regs.sata_block2mem_done.read() == 0: time.sleep(0.1) def dump(self): for addr in range(self.base, self.base + 512, 4): if (addr%16 == 0): if addr != self.base: print("") print("0x{:08x}".format(addr), end=" ") data = wb.read(addr) for i in reversed(range(4)): print("{:02x}".format((data >> (8*i)) & 0xff), end=" ") print("") block2mem = Block2MemDriver(base=wb.mems.sram.base) for s in range(sector, sector + count): print("Sector {:d}:".format(s)) block2mem.read(s) block2mem.dump() wb.close()
def main(): parser = argparse.ArgumentParser( description="LiteSDCard Bench on Genesys2") parser.add_argument("--with-analyzer", action="store_true", help="Add Analyzer to Bench") parser.add_argument("--build", action="store_true", help="Build bitstream") parser.add_argument("--load", action="store_true", help="Load bitstream") parser.add_argument("--load-bios", action="store_true", help="Load BIOS over Etherbone and reboot SoC") args = parser.parse_args() bench = BenchSoC(with_analyzer=args.with_analyzer) builder = Builder(bench, csr_csv="csr.csv") builder.build(run=args.build) if args.load: prog = bench.platform.create_programmer() prog.load_bitstream( os.path.join(builder.gateware_dir, bench.build_name + ".bit")) if args.load_bios: from litex import RemoteClient wb = RemoteClient() wb.open() ctrl = SoCCtrl() ctrl.load_rom(wb, os.path.join(builder.software_dir, "bios", "bios.bin")) ctrl.reboot(wb) wb.close()
class CrossoverUART: def __init__(self, host="localhost", base_address=0): # FIXME: add command line arguments self.bus = RemoteClient(host=host, base_address=base_address) def open(self): self.bus.open() self.file, self.name = pty.openpty() self.pty2crossover_thread = multiprocessing.Process(target=self.pty2crossover) self.crossover2pty_thread = multiprocessing.Process(target=self.crossover2pty) self.pty2crossover_thread.start() self.crossover2pty_thread.start() def close(self): self.bus.close() self.pty2crossover_thread.terminate() self.crossover2pty_thread.terminate() def pty2crossover(self): while True: r = os.read(self.file, 1) self.bus.regs.uart_xover_rxtx.write(ord(r)) def crossover2pty(self): while True: if self.bus.regs.uart_txfull.read(): length = 16 elif not self.bus.regs.uart_xover_rxempty.read(): length = 1 else: length = 0 if length: r = self.bus.read(self.bus.regs.uart_xover_rxtx.addr, length=length, burst="fixed") for v in r: os.write(self.file, bytes(chr(v).encode("utf-8")))
def prbs_test(port=1234, mode="prbs7", loopback=False, duration=60): wb = RemoteClient(port=port) wb.open() wb.regs.ctrl_scratch.read() def serdes_reset(): print("Reseting SerDes...") if hasattr(wb.regs, "serdes_clock_aligner_disable"): wb.regs.serdes_clock_aligner_disable.write(0) wb.regs.serdes_tx_prbs_config.write(0) wb.regs.serdes_rx_prbs_config.write(0) time.sleep(1) # Enable Loopback if loopback: print("Enabling SerDes loopback...") wb.regs.serdes_loopback.write(near_end_pma_loopback) # Reset SerDes serdes_reset() # Configure PRBS print(f"Configuring SerDes for {mode.upper()}...") wb.regs.serdes_tx_prbs_config.write(prbs_modes[mode]) wb.regs.serdes_rx_prbs_config.write(prbs_modes[mode]) # Run PRBS/BER Test print("Running PRBS/BER test...") errors_current = 0 errors_last = 0 errors_total = 0 duration_current = 0 interval = 1 try: while duration_current < duration: # Interval / Duration time.sleep(interval) duration_current += interval # Errors errors_current = (wb.regs.serdes_rx_prbs_errors.read() - errors_last) errors_total += errors_current errors_last = errors_current # Log print("Errors: {:12d} / Duration: {:8d}s / BER: {:1.3e} ".format( errors_current, duration_current, errors_total / (duration_current * 5e9))) except KeyboardInterrupt: pass # Reset SerDes serdes_reset() # Disable Loopback if loopback: print("Disabling SerDes loopback...") wb.regs.serdes_loopback.write(0) wb.close()
class BridgeUART: def __init__(self, name="uart_xover", host="localhost", base_address=None, csr_csv=None): self.bus = RemoteClient(host=host, base_address=base_address, csr_csv=csr_csv) present = False for k, v in self.bus.regs.d.items(): if f"{name}_" in k: setattr(self, k.replace(f"{name}_", ""), v) present = True if not present: raise ValueError(f"CrossoverUART {name} not present in design.") # FIXME: On PCIe designs, CSR is remapped to 0 to limit BAR0 size. if base_address is None and hasattr(self.bus.bases, "pcie_phy"): self.bus.base_address = -self.bus.mems.csr.base def open(self): self.bus.open() self.file, self.name = pty.openpty() self.pty2crossover_thread = multiprocessing.Process( target=self.pty2crossover) self.crossover2pty_thread = multiprocessing.Process( target=self.crossover2pty) self.pty2crossover_thread.start() self.crossover2pty_thread.start() def close(self): self.bus.close() self.pty2crossover_thread.terminate() self.crossover2pty_thread.terminate() def pty2crossover(self): while True: r = os.read(self.file, 1) self.rxtx.write(ord(r)) def crossover2pty(self): while True: if self.rxfull.read(): length = 16 elif not self.rxempty.read(): length = 1 else: time.sleep(1e-3) continue r = self.bus.read(self.rxtx.addr, length=length, burst="fixed") for v in r: os.write(self.file, bytes(chr(v).encode("utf-8")))
def ident_test(port): wb = RemoteClient(port=port) wb.open() fpga_identifier = "" for i in range(256): c = chr(wb.read(wb.bases.identifier_mem + 4 * i) & 0xff) fpga_identifier += c if c == "\0": break print(fpga_identifier) wb.close()
def main(): args = parse_args() basename = os.path.splitext(os.path.basename(args.csv))[0] # Check if analyzer file is present and exit if not. if not os.path.exists(args.csv): raise ValueError( "{} not found. This is necessary to load the wires which have been tapped to scope." "Try setting --csv to value of the csr_csv argument to LiteScopeAnalyzer in the SoC." .format(args.csv)) sys.exit(1) # Get list of signals from analyzer configuratio file. signals = get_signals(args.csv, args.group) # If in list mode, list signals and exit. if args.list: for signal in signals: print(signal) sys.exit(0) # Create and open remote control. if not os.path.exists(args.csr_csv): raise ValueError( "{} not found. This is necessary to load the 'regs' of the remote. Try setting --csr-csv here to " "the path to the --csr-csv argument of the SoC build.".format( args.csr_csv)) bus = RemoteClient(csr_csv=args.csr_csv) bus.open() # Configure and run LiteScope analyzer. try: analyzer = LiteScopeAnalyzerDriver(bus.regs, basename, debug=True) analyzer.configure_group(int(args.group, 0)) analyzer.configure_subsampler(int(args.subsampling, 0)) if not add_triggers(args, analyzer, signals): print("No trigger, immediate capture.") analyzer.run( offset=int(args.offset, 0), length=None if args.length is None else int(args.length, 0)) analyzer.wait_done() analyzer.upload() analyzer.save(args.dump) # Close remove control. finally: bus.close()
class BridgeUART: def __init__(self, name="uart_xover", host="localhost", base_address=0): # FIXME: add command line arguments self.bus = RemoteClient(host=host, base_address=base_address) present = False for k, v in self.bus.regs.d.items(): if f"{name}_" in k: setattr(self, k.replace(f"{name}_", ""), v) present = True if not present: raise ValueError(f"CrossoverUART {name} not present in design.") def open(self): self.bus.open() self.file, self.name = pty.openpty() self.pty2crossover_thread = multiprocessing.Process( target=self.pty2crossover) self.crossover2pty_thread = multiprocessing.Process( target=self.crossover2pty) self.pty2crossover_thread.start() self.crossover2pty_thread.start() def close(self): self.bus.close() self.pty2crossover_thread.terminate() self.crossover2pty_thread.terminate() def pty2crossover(self): while True: r = os.read(self.file, 1) self.rxtx.write(ord(r)) def crossover2pty(self): while True: if self.rxfull.read(): length = 16 elif not self.rxempty.read(): length = 1 else: time.sleep(1e-3) continue r = self.bus.read(self.rxtx.addr, length=length, burst="fixed") for v in r: os.write(self.file, bytes(chr(v).encode("utf-8")))
def main(): parser = argparse.ArgumentParser( description="LiteSDCard Bench on Trellis Board") parser.add_argument("--bench", default="soc", help="Bench: soc (default) or phy") parser.add_argument("--variant", default="standard", help="Bench variant") parser.add_argument("--with-sampler", action="store_true", help="Add Sampler to Bench") parser.add_argument("--with-analyzer", action="store_true", help="Add Analyzer to Bench") parser.add_argument("--build", action="store_true", help="Build bitstream") parser.add_argument("--load", action="store_true", help="Load bitstream") parser.add_argument("--load-bios", action="store_true", help="Load BIOS over Etherbone and reboot SoC") args = parser.parse_args() bench = { "soc": BenchSoC, "phy": BenchPHY }[args.bench]( variant=args.variant, with_sampler=args.with_sampler, with_analyzer=args.with_analyzer, ) builder = Builder(bench, csr_csv="csr.csv") builder.build(run=args.build) if args.load: prog = bench.platform.create_programmer() prog.load_bitstream( os.path.join(builder.gateware_dir, bench.build_name + ".svf")) if args.load_bios: from litex import RemoteClient wb = RemoteClient() wb.open() ctrl = SoCCtrl() ctrl.load_rom(wb, os.path.join(builder.software_dir, "bios", "bios.bin")) ctrl.reboot(wb) wb.close()
def sram_test(port): wb = RemoteClient(port=port) wb.open() def mem_dump(base, length): for addr in range(base, base + length, 4): if (addr % 16 == 0): if addr != base: print("") print("0x{:08x}".format(addr), end=" ") data = wb.read(addr) for i in reversed(range(4)): print("{:02x}".format((data >> (8 * i)) & 0xff), end=" ") print("") def mem_write(base, datas): for n, addr in enumerate(range(base, base + 4 * len(datas), 4)): if (addr % 16 == 0): if addr != base: print("") print("0x{:08x}".format(addr), end=" ") data = datas[n] for i in reversed(range(4)): print("{:02x}".format((data >> (8 * i)) & 0xff), end=" ") wb.write(addr, data) print("") print("Fill SRAM with counter:") mem_write(wb.mems.serwb.base, [i for i in range(128)]) print("") print("Dump SRAM:") mem_dump(wb.mems.serwb.base, 128) print("") print("Fill SRAM with 4 32-bit words:") mem_write(wb.mems.serwb.base, [0x01234567, 0x89abcdef, 0x5aa55aa5, 0xa55aa55a]) print("") print("Dump SRAM:") mem_dump(wb.mems.serwb.base, 128) print("") wb.close()
def load_bios(bios_filename): from litex import RemoteClient bus = RemoteClient() bus.open() # # # # Load BIOS and reboot SoC. print("Loading BIOS...") ctrl = BenchController(bus) ctrl.load_rom(bios_filename, delay=1e-4) # FIXME: delay needed @ 115200bauds. ctrl.reboot() # # # bus.close()
def main(): parser = argparse.ArgumentParser( description="Script to test correct DDR behaviour." ) parser.add_argument( '--bitslip', default=None, help="Defines a bitslip value." ) parser.add_argument('--delay', default=None, help="Defines a delay value.") args = parser.parse_args() wb = RemoteClient(debug=False) wb.open() # software control wb.regs.sdram_dfii_control.write(0) # sdram initialization for i, (comment, a, ba, cmd, delay) in enumerate(init_sequence): print(comment) wb.regs.sdram_dfii_pi0_address.write(a) wb.regs.sdram_dfii_pi0_baddress.write(ba) if i < 2: wb.regs.sdram_dfii_control.write(cmd) else: wb.regs.sdram_dfii_pi0_command.write(cmd) wb.regs.sdram_dfii_pi0_command_issue.write(1) # hardware control wb.regs.sdram_dfii_control.write(dfii_control_sel) if args.bitslip is None or args.delay is None: bitslip, delay = find_bitslips_delays(wb) else: bitslip = int(args.bitslip) delay = int(args.delay) set_bitslip_delay(wb, bitslip, delay) start_command_interface(wb) wb.close()
class LTCOnMarblemini(Carrier): def __init__(self, count=10, log_decimation_factor=0, test=False): ADC.bits = 14 ADC.sample_rate = 120000000. self.n_channels = 2 self._db = None self.test = test self.pts_per_ch = 8192 self.subscriptions, self.results = {}, {} self.set_log_decimation_factor(log_decimation_factor) self.wb = RemoteClient() self.wb.open() print(self.wb.regs.acq_buf_full.read()) initLTC(self.wb) def set_log_decimation_factor(self, ldf): ADC.decimation_factor = 1 << ldf ADC.fpga_output_rate = ADC.sample_rate / ADC.decimation_factor if ldf != 0: ''' This feature is missing in gateware ''' raise NotImplementedError def acquire_data(self, *args): if self.test: return self.test_data(*args) while True: # self.wb.regs.acq_acq_start.write(1) d = get_data(self.wb) if d is None: print('recovering') time.sleep(0.1) continue self._db = DataBlock(d, int(time.time())) # ADC count / FULL SCALE => [-1.0, 1.] self._process_subscriptions() # time.sleep(0.1) self.wb.close()
def dma_test(port, mode, sector, count): assert mode in ["r", "r+w"] bus = RemoteClient(port=port) bus.open() dma = DMADriver(bus=bus, base=bus.mems.sram.base) for s in range(sector, sector + count): print("Sector {:d}:".format(s)) error = dma.read(s) dma.dump() print("Error: {:d}".format(error)) if mode == "r+w": s = 1000 dma.fill([i for i in range(512 // 4)]) error = dma.write(s) print("Sector {:d}:".format(s)) error += dma.read(s) dma.dump() print("Error: {:d}".format(error)) bus.close()
#!/usr/bin/env python3 import time from litex import RemoteClient wb = RemoteClient() wb.open() # # # print("Toggling Led...") for i in range(2): wb.regs.led_out.write(1) time.sleep(0.5) wb.regs.led_out.write(0) time.sleep(0.5) # # # wb.close()
def us_bench_test(freq_min, freq_max, freq_step, vco_freq, bios_filename, bios_timeout=40): import time from litex import RemoteClient bus = RemoteClient() bus.open() # # # # Load BIOS and reboot SoC ctrl = BenchController(bus) ctrl.load_rom(bios_filename, delay=1e-4) # FIXME: delay needed @ 115200bauds. ctrl.reboot() # PLL/ClkReg uspll = USPLL(bus) clkout0_clkreg1 = ClkReg1(uspll.read(0x8)) # Run calibration from freq_min to freq_max and log BIOS output. print("-" * 80) print( "Running calibration; sys_clk from {:3.3f}MHz to {:3.2f}MHz (step: {:3.2f}MHz)" .format(freq_min / 1e6, freq_max / 1e6, freq_step / 1e6)) print("-" * 80) print("") tested_vco_divs = [] for clk_freq in range(int(freq_min), int(freq_max), int(freq_step)): # Compute VCO divider, skip if already tested. vco_div = int(vco_freq / clk_freq) if vco_div in tested_vco_divs: continue tested_vco_divs.append(vco_div) print("-" * 40) print("sys_clk = {}MHz...".format(vco_freq / vco_div / 1e6)) print("-" * 40) # Reconfigure PLL to change sys_clk clkout0_clkreg1.high_time = vco_div // 2 + vco_div % 2 clkout0_clkreg1.low_time = vco_div // 2 uspll.write(0x08, clkout0_clkreg1.pack()) # Measure/verify sys_clk duration = 5e-1 start = bus.regs.crg_sys_clk_counter.read() time.sleep(duration) end = bus.regs.crg_sys_clk_counter.read() print("Measured sys_clk: {:3.2f}MHz.".format( (end - start) / (1e6 * duration))) # Reboot SoC and log BIOS output print("-" * 40) print("Reboot SoC and get BIOS log...") print("-" * 40) ctrl.reboot() start = time.time() while (time.time() - start) < bios_timeout: if bus.regs.uart_xover_rxfull.read(): length = 16 elif not bus.regs.uart_xover_rxempty.read(): length = 1 else: time.sleep(1e-3) continue for c in bus.read(bus.regs.uart_xover_rxtx.addr, length=length, burst="fixed"): print("{:c}".format(c), end="") print("") # # # bus.close()
def init_test(port): wb = RemoteClient(port=port) wb.open() # Reset SerWB Master print("Reseting SerWB Master...") wb.regs.serwb_master_phy_control_reset.write(1) # Initialize SerWB Master timeout = 4 print(f"Initializing SerWB Master...") while (wb.regs.serwb_master_phy_control_ready.read() == 0 and wb.regs.serwb_master_phy_control_error.read() == 0 and timeout > 0): time.sleep(0.1) print(f"{timeout:2.2f}s", end="\r") sys.stdout.flush() timeout -= 0.1 print("") if (timeout <= 0): print("Failed.") return else: print("Success.") # Show Master Config print("Master config") print("-------------") if hasattr(wb.regs, "serwb_master_phy_control_delay"): print("delay_min_found: {:d}".format( wb.regs.serwb_master_phy_control_delay_min_found.read())) print("delay_min: {:d}".format( wb.regs.serwb_master_phy_control_delay_min.read())) print("delay_max_found: {:d}".format( wb.regs.serwb_master_phy_control_delay_max_found.read())) print("delay_max: {:d}".format( wb.regs.serwb_master_phy_control_delay_max.read())) print("delay: {:d}".format( wb.regs.serwb_master_phy_control_delay.read())) print("bitslip: {:d}".format( wb.regs.serwb_master_phy_control_shift.read())) print("ready: {:d}".format(wb.regs.serwb_master_phy_control_ready.read())) print("error: {:d}".format(wb.regs.serwb_master_phy_control_error.read())) print("") # Show Slave Config print("Slave config") print("------------") if hasattr(wb.regs, "serwb_slave_phy_control_delay"): print("delay_min_found: {:d}".format( wb.regs.serwb_slave_phy_control_delay_min_found.read())) print("delay_min: {:d}".format( wb.regs.serwb_slave_phy_control_delay_min.read())) print("delay_max_found: {:d}".format( wb.regs.serwb_slave_phy_control_delay_max_found.read())) print("delay_max: {:d}".format( wb.regs.serwb_slave_phy_control_delay_max.read())) print("delay: {:d}".format( wb.regs.serwb_slave_phy_control_delay.read())) print("bitslip: {:d}".format(wb.regs.serwb_slave_phy_control_shift.read())) print("ready: {:d}".format(wb.regs.serwb_slave_phy_control_ready.read())) print("error: {:d}".format(wb.regs.serwb_slave_phy_control_error.read())) wb.close()