def main():
parser = argparse.ArgumentParser(
description="SDRAM Loopback SoC on Marble*")
builder_args(parser)
soc_core_args(parser)
parser.add_argument("--with-ethernet",
action="store_true",
help="enable Ethernet support")
parser.add_argument("--ethernet-phy",
default="rgmii",
help="select Ethernet PHY (rgmii or 1000basex)")
parser.add_argument("-p",
"--program-only",
action="store_true",
help="Don't build, just program the existing bitfile")
parser.add_argument("--build",
action="store_true",
help="Build FPGA bitstream")
parser.add_argument("--load", action="store_true", help="program FPGA")
args = parser.parse_args()
if args.build:
soc = SDRAMLoopbackSoC(with_ethernet=args.with_ethernet,
**soc_core_argdict(args))
builder = Builder(soc, **builder_argdict(args))
# discard result, or save in vns?
builder.build(run=not args.program_only)
if args.load:
prog = kc705.Platform().create_programmer()
prog.load_bitstream(
os.path.join("build", "kc705", "gateware", "kc705.bit"))
def main():
parser = argparse.ArgumentParser(description="LiteX SoC on MarbleMini")
builder_args(parser)
soc_sdram_args(parser)
# soc_core_args(parser)
parser.add_argument("--with-ethernet",
action="store_true",
help="enable Ethernet support")
parser.add_argument("--ethernet-phy",
default="rgmii",
help="select Ethernet PHY (rgmii or 1000basex)")
parser.add_argument("-p",
"--program-only",
action="store_true",
help="select Ethernet PHY (rgmii or 1000basex)")
args = parser.parse_args()
if args.with_ethernet:
soc = LTCSocDev(phy=args.ethernet_phy, **soc_sdram_argdict(args))
# soc = EthernetSoC(phy=args.ethernet_phy, **soc_sdram_argdict(args))
# soc = EthernetSoC(phy=args.ethernet_phy, **soc_core_argdict(args))
else:
soc = BaseSoC(**soc_sdram_argdict(args))
builder = Builder(soc, **builder_argdict(args))
if not args.program_only:
vns = builder.build()
if False:
soc.analyzer.do_exit(vns)
prog = soc.platform.create_programmer()
import os
prog.load_bitstream(os.path.join(builder.gateware_dir, "marblemini.bit"))
def main():
parser = argparse.ArgumentParser(description="LiteX SoC on Leech")
parser.add_argument("--sys-clk-freq",
type=float,
default=48e6,
help="Select system clock frequency")
parser.add_argument(
"--document-only",
action="store_true",
help="Do not build a soc. Only generate documentation.")
builder_args(parser)
soc_core_args(parser)
args = parser.parse_args()
# Create the SOC
soc = BaseSoC(sys_clk_freq=int(args.sys_clk_freq),
**soc_core_argdict(args))
# Configure command line parameter defaults
# Don't build software: we don't have CPU.
builder_kwargs = builder_argdict(args)
builder_kwargs["compile_software"] = False
if args.document_only:
builder_kwargs["compile_gateware"] = False
if builder_kwargs["csr_svd"] is None:
builder_kwargs["csr_svd"] = "../litex-pac/soc.svd"
# Create and run the builder
builder = Builder(soc, **builder_kwargs)
builder.build()
def main():
parser = argparse.ArgumentParser(
description="Build test file for dummy or eptri module")
builder_args(parser)
soc_core_args(parser)
parser.add_argument('--dir',
metavar='DIRECTORY',
default='build',
help='Output directory (defauilt: %(default)s)')
parser.add_argument('--csr',
metavar='CSR',
default='csr.csv',
help='csr file (default: %(default)s)')
parser.add_argument("--rom-init", default=None, help="rom_init file")
args = parser.parse_args()
soc_kwargs = soc_core_argdict(args)
if args.rom_init is not None:
soc_kwargs["integrated_rom_init"] = \
get_mem_data(args.rom_init, endianness='little')
output_dir = args.dir
platform = Platform()
soc = BaseSoC(platform, **soc_kwargs)
builder = Builder(soc,
output_dir=output_dir,
csr_csv=args.csr,
compile_software=False)
vns = builder.build(run=False)
soc.do_exit(vns)
print("""Simulation build complete. Output files:
{}/gateware/dut.v Source Verilog file. Run this under Cocotb.
""".format(output_dir))
def main():
parser = argparse.ArgumentParser(description="LiteX SoC on iCEBreaker")
parser.add_argument("--sys-clk-freq", type=float, default=48e6, help="Select system clock frequency")
parser.add_argument("--document-only", action="store_true", help="Do not build a soc. Only generate documentation.")
parser.add_argument("--flash", action="store_true", help="Load bitstream")
builder_args(parser)
soc_core_args(parser)
args = parser.parse_args()
# Create the SOC
soc = BaseSoC(sys_clk_freq=int(args.sys_clk_freq), **soc_core_argdict(args))
# Configure command line parameter defaults
# Don't build software -- we don't include it since we just jump to SPI flash.
builder_kwargs = builder_argdict(args)
builder_kwargs["compile_software"] = False
if args.document_only:
builder_kwargs["compile_gateware"] = False
if builder_kwargs["csr_svd"] is None:
builder_kwargs["csr_svd"] = "../litex-pac/soc.svd"
# Create and run the builder
builder = Builder(soc, **builder_kwargs)
builder.build()
# If requested load the resulting bitstream onto the iCEBreaker
if args.flash:
IceStormProgrammer().flash(0x00000000, "build/icebreaker/gateware/icebreaker.bin")
def main():
parser = argparse.ArgumentParser(description="SDRAM Loopback SoC on Marble*")
builder_args(parser)
soc_core_args(parser)
parser.add_argument("--ip", default="192.168.19.70",
help="Assign an ip address")
parser.add_argument("--ethernet-phy", default="rgmii",
help="select Ethernet PHY (rgmii or 1000basex)")
parser.add_argument("-p", "--program-only", action="store_true",
help="Don't build, just program the existing bitfile")
parser.add_argument("--build", action="store_true",
help="Build FPGA bitstream")
parser.add_argument("--load", action="store_true",
help="program FPGA")
parser.add_argument("--threads", default=4,
help="set number of threads (default=4)")
parser.add_argument("--trace", action="store_true",
help="enable VCD tracing")
parser.add_argument("-s", "--sim", action="store_true",
help="Simulate")
args = parser.parse_args()
if args.sim:
soc_kwargs = soc_core_argdict(args)
sim_config = SimConfig(default_clk="sys_clk")
soc_kwargs["integrated_main_ram_size"] = 0x10000
soc_kwargs = soc_core_argdict(args)
soc_kwargs["uart_name"] = "sim"
# sim_config.add_module("serial2console", "serial")
sim_config.add_module(
'ethernet',
"eth",
args={"interface": "xxx1",
"ip": "192.168.88.101",
"vcd_name": "foo.vcd"})
soc = SDRAMSimSoC(phy="rgmii",
with_ethernet=True,
with_etherbone=True,
with_sdram=True,
etherbone_ip_address="192.168.88.50",
etherbone_mac_address=0x12345678abcd,
**soc_kwargs)
builder = Builder(soc, **builder_argdict(args))
# discard result, or save in vns?
builder.build(
threads=args.threads,
trace=args.trace,
sim_config=sim_config)
kwargs = soc_core_argdict(args)
# soc = SDRAMLoopbackSoC(ip=args.ip, phy=args.ethernet_phy, **kwargs)
soc = SDRAMDevSoC(ip=args.ip, phy=args.ethernet_phy, **kwargs)
builder = Builder(soc, **builder_argdict(args))
builder.build()
if args.load:
prog = marble.Platform().create_programmer()
prog.load_bitstream(os.path.join("build", "marble", "gateware", "marble.bit"))
def main():
parser = argparse.ArgumentParser(description="LiteX SoC on Arty")
builder_args(parser)
soc_core_args(parser)
args = parser.parse_args()
cls = BaseSoC
soc = cls(**soc_core_argdict(args))
builder = Builder(soc, **builder_argdict(args))
builder.build()
def main():
parser = argparse.ArgumentParser(description="LiteX SoC on Arty")
builder_args(parser)
soc_sdram_args(parser)
vivado_build_args(parser)
args = parser.parse_args()
cls = MinSoC
soc = cls(**soc_sdram_argdict(args))
builder = Builder(soc, **builder_argdict(args))
builder.build(**vivado_build_argdict(args))
def main():
parser = argparse.ArgumentParser(description="LiteX SoC on TinyFPGA_BX")
parser.add_argument("--build", action="store_true", help="Build bitstream")
parser.add_argument("--seed", default=0, help="Seed to use in Nextpnr")
parser.add_argument("--placer", default="heap", choices=["sa", "heap"], help="Which placer to use in Nextpnr")
builder_args(parser)
soc_core_args(parser)
args = parser.parse_args()
soc = BaseSoC(pnr_placer=args.placer, pnr_seed=args.seed, debug=True, **soc_core_argdict(args))
builder = Builder(soc, **builder_argdict(args))
builder.build(run=args.build)
def main():
parser = argparse.ArgumentParser(description="Datapipe simulation SoC*")
builder_args(parser)
soc_core_args(parser)
# soc_core_args(parser)
parser.add_argument("--with-ethernet",
action="store_true",
help="enable Ethernet support")
parser.add_argument("--ethernet-phy",
default="rgmii",
help="select Ethernet PHY (rgmii or 1000basex)")
parser.add_argument("-p",
"--program-only",
action="store_true",
help="Don't build, just program the existing bitfile")
parser.add_argument("--build",
action="store_true",
help="Build FPGA bitstream")
parser.add_argument("--load", action="store_true", help="program FPGA")
parser.add_argument("--threads",
default=4,
help="set number of threads (default=4)")
parser.add_argument("--trace",
action="store_true",
help="enable VCD tracing")
args = parser.parse_args()
soc_kwargs = soc_core_argdict(args)
sim_config = SimConfig(default_clk="sys_clk")
soc_kwargs["integrated_main_ram_size"] = 0x10000
soc_kwargs = soc_core_argdict(args)
soc_kwargs["uart_name"] = "sim"
# sim_config.add_module("serial2console", "serial")
sim_config.add_module('ethernet',
"eth",
args={
"interface": "xxx1",
"ip": "192.168.88.101",
"vcd_name": "foo.vcd"
})
soc = SDRAMSimSoC(phy="rgmii",
with_ethernet=True,
with_etherbone=True,
with_sdram=True,
etherbone_ip_address="192.168.88.50",
etherbone_mac_address=0x12345678abcd,
**soc_kwargs)
builder = Builder(soc, **builder_argdict(args))
# discard result, or save in vns?
builder.build(threads=args.threads,
trace=args.trace,
sim_config=sim_config)
def parse_workflow_args(input: List[str] = None) -> argparse.Namespace:
"""Parses command-line style flags for the workflow.
All unknown args are discarded to allow multiple parses on args.
Args:
input: An optional list of strings in the style of sys.argv. Will
default to argparse's interpretation of sys.argv if omitted.
Returns:
An argparse Namespace with the parsed, known arguments.
"""
parser = argparse.ArgumentParser(description='LiteX SoC')
parser.add_argument('--build', action='store_true', help='Build bitstream')
parser.add_argument('--load', action='store_true', help='Load bitstream')
parser.add_argument('--toolchain',
help=('Specify toolchain for implementing '
'gateware (\'vivado\' or \'symbiflow\')'))
parser.add_argument('--sys-clk-freq',
type=float,
help='System clock frequency')
builder_args(parser)
soc_core_args(parser)
vivado_build_args(parser)
parser.add_argument('--with-ethernet',
action='store_true',
help='Enable Ethernet support')
parser.add_argument('--with-etherbone',
action='store_true',
help='Enable Etherbone support')
parser.add_argument('--with-mapped-flash',
action='store_true',
help='Add litespi SPI flash')
parser.add_argument("--with-spi-sdcard",
action="store_true",
help="Enable SPI-mode SDCard support")
parser.add_argument("--with-video-framebuffer",
action="store_true",
help="Enable Video Framebuffer (HDMI)")
parser.add_argument('--target',
default='digilent_arty',
help='Specify target board')
parser.set_defaults(csr_csv='csr.csv',
uart_name='serial',
uart_baudrate=921600,
cpu_variant='full+cfu',
with_etherbone=False)
# Return only the known args
if input:
return parser.parse_known_args(input)[0]
else:
return parser.parse_known_args()[0]
def main():
parser = argparse.ArgumentParser(description="Arty LiteX SoC")
builder_args(parser)
parser.add_argument("--nocompile-gateware", action="store_true")
args = parser.parse_args()
platform = arty.Platform()
soc = EtherboneSoC(platform)
builder = Builder(soc,
output_dir="build",
compile_gateware=not args.nocompile_gateware,
csr_csv="test/csr.csv")
vns = builder.build()
def main():
parser = argparse.ArgumentParser(description="LiteX SoC on iCEBreaker")
parser.add_argument("--flash-offset",
default=0x40000,
help="Boot offset in SPI Flash")
parser.add_argument("--sys-clk-freq",
type=float,
default=21e6,
help="Select system clock frequency")
parser.add_argument(
"--document-only",
action="store_true",
help="Do not build a soc. Only generate documentation.")
parser.add_argument("--flash", action="store_true", help="Load bitstream")
builder_args(parser)
soc_core_args(parser)
args = parser.parse_args()
# Create the SOC
soc = BaseSoC(flash_offset=args.flash_offset,
sys_clk_freq=int(args.sys_clk_freq),
**soc_core_argdict(args))
# Configure command line parameter defaults
# Don't build software -- we don't include it since we just jump to SPI flash.
builder_kwargs = builder_argdict(args)
builder_kwargs["compile_software"] = False
if args.document_only:
builder_kwargs["compile_gateware"] = False
if builder_kwargs["csr_svd"] is None:
builder_kwargs["csr_svd"] = "../litex-pac/soc.svd"
if builder_kwargs["memory_x"] is None:
builder_kwargs["memory_x"] = "../litex-pac/memory.x"
# Create and run the builder
builder = Builder(soc, **builder_kwargs)
builder.build()
lxsocdoc.generate_docs(soc,
"build/documentation/",
project_name="iCEBreaker LiteX RISC-V Example SOC",
author="Piotr Esden-Tempski")
# If requested load the resulting bitstream onto the iCEBreaker
if args.flash:
prog = soc.platform.create_programmer()
prog.flash(0x00000000, "build/icebreaker/gateware/icebreaker.bin")
def main():
parser = argparse.ArgumentParser(description="LiteX SoC on iCEBreaker")
parser.add_argument("--seed", default=0, help="seed to use in nextpnr")
parser.add_argument("--placer",
default="heap",
choices=["sa", "heap"],
help="which placer to use in nextpnr")
parser.add_argument("--cpu",
action="store_true",
help="Add a CPU to the build")
parser.add_argument(
"--debug",
action="store_true",
help="Add debug features. UART has to be used with the wishbone-tool.")
builder_args(parser)
soc_core_args(parser)
args = parser.parse_args()
kwargs = builder_argdict(args)
print(kwargs)
if args.cpu:
kwargs["cpu_type"] = "vexriscv"
kwargs["cpu_variant"] = "min"
soc = BaseSoC(pnr_placer=args.placer,
pnr_seed=args.seed,
debug=args.debug,
**kwargs)
kwargs = builder_argdict(args)
# Don't build software -- we don't include it since we just jump
# to SPI flash.
kwargs["compile_software"] = False
builder = Builder(soc, **kwargs)
vns = builder.build()
soc.do_exit(vns)
lxsocdoc.generate_docs(soc,
"build/documentation/",
project_name="iCEBreaker LiteX Riscv Example SOC",
author="Piotr Esden-Tempski")
def main():
parser = argparse.ArgumentParser(
description=__doc__, formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument("--build", action="store_true", help="Build bitstream")
parser.add_argument("--load", action="store_true", help="Load bitstream")
parser.add_argument("--sys-clk-freq",
default=125e6,
help="System clock frequency (default: 125MHz)")
parser.add_argument("--with-ethernet",
action="store_true",
help="Enable Ethernet support")
parser.add_argument("--with-etherbone",
action="store_true",
help="Enable Etherbone support")
parser.add_argument("--with-rts-reset",
action="store_true",
help="Connect UART RTS line to sys_clk reset")
parser.add_argument("--with-bist",
action="store_true",
help="Add DDR3 BIST Generator/Checker")
parser.add_argument(
"--spd-dump",
type=str,
help=
"DDR3 configuration file, dumped using the `spdread` command in LiteX BIOS"
)
builder_args(parser)
soc_core_args(parser)
args = parser.parse_args()
soc = BaseSoC(sys_clk_freq=int(float(args.sys_clk_freq)),
with_ethernet=args.with_ethernet,
with_etherbone=args.with_etherbone,
with_bist=args.with_bist,
spd_dump=args.spd_dump,
**soc_core_argdict(args))
builder = Builder(soc, **builder_argdict(args))
builder.build(run=args.build)
if args.load:
prog = soc.platform.create_programmer()
prog.load_bitstream(
os.path.join(builder.gateware_dir, soc.build_name + ".bit"))
def main():
soc_cls = BaseSoC
cpu = VexRiscv
parser = argparse.ArgumentParser(description="LiteX SoC")
builder_args(parser)
soc_core_args(parser)
parser.add_argument("--build_gateware", action='store_true')
parser.add_argument("--yosys", action="store_true")
parser.add_argument("--sim", action="store_true")
parser.add_argument("--run", action="store_true")
args = parser.parse_args()
builder_kwargs = builder_argdict(args)
soc_kwargs = soc_core_argdict(args)
platform = sim_platform2.Platform() if args.sim else platform1.Platform()
output_dir = builder_kwargs['output_dir'] = 'build'
fw_file = os.path.join(output_dir, "software", "firmware", "firmware.bin")
soc_kwargs['integrated_rom_size'] = 32 * 1024
soc_kwargs["integrated_main_ram_size"] = 16 * 1024
try:
soc_kwargs['integrated_main_ram_init'] = get_mem_data(
fw_file, cpu.endianness)
except OSError:
pass
soc = BaseSoC(platform,
cpu=cpu,
sim=args.sim,
output_dir=output_dir,
**soc_kwargs)
builder = Builder(soc, **builder_kwargs)
builder.add_software_package("firmware",
src_dir=os.path.join(os.getcwd(), 'src',
'firmware'))
if args.sim:
sim_config = SimConfig(default_clk="sys_clk")
sim_config.add_module("serial2console", "serial")
builder.build(run=False, sim_config=sim_config, opt_level='O3')
if args.run:
builder.build(build=False, sim_config=sim_config)
else:
builder.build(run=args.build_gateware,
synth_mode="yosys" if args.yosys else "vivado")
def main():
parser = argparse.ArgumentParser(
description="LiteX SoC on the Arrow/Terasic SoCKit")
parser.add_argument(
"--single-rate-sdram",
action="store_true",
help="clock SDRAM with 1x the sytem clock (instead of 2x)")
parser.add_argument(
"--mister-sdram-xs-v22",
action="store_true",
help=
"Use optional MiSTer SDRAM module XS v2.2 on J2 on GPIO daughter card")
parser.add_argument(
"--mister-sdram-xs-v24",
action="store_true",
help=
"Use optional MiSTer SDRAM module XS v2.4 on J2 on GPIO daughter card")
parser.add_argument("--build", action="store_true", help="Build bitstream")
parser.add_argument("--load", action="store_true", help="Load bitstream")
parser.add_argument("--revision",
default="revd",
help="Board revision: revb (default), revc or revd")
parser.add_argument("--sys-clk-freq",
default=50e6,
help="System clock frequency (default: 50MHz)")
builder_args(parser)
soc_sdram_args(parser)
args = parser.parse_args()
soc = BaseSoC(sys_clk_freq=int(float(args.sys_clk_freq)),
revision=args.revision,
sdram_rate="1:1" if args.single_rate_sdram else "1:2",
mister_sdram="xs_v22" if args.mister_sdram_xs_v22 else
"xs_v24" if args.mister_sdram_xs_v24 else None,
**soc_sdram_argdict(args))
builder = Builder(soc, **builder_argdict(args))
builder.build(run=args.build)
if args.load:
prog = soc.platform.create_programmer()
prog.load_bitstream(
os.path.join(builder.gateware_dir, soc.build_name + ".sof"))
def main():
import argparse
parser = argparse.ArgumentParser(description="10GbE test setup on KC705")
parser.add_argument("--build", action="store_true", help="Build bitstream")
parser.add_argument("--load", action="store_true", help="Load bitstream")
parser.add_argument("--with-ethernet", action="store_true", help="Enable Ethernet support")
builder_args(parser)
soc_core_args(parser)
args = parser.parse_args()
print(args)
if args.build:
soc = DevSoC(sys_clk_freq=int(125e6), with_ethernet=args.with_ethernet, **soc_core_argdict(args))
builder = Builder(soc, **builder_argdict(args))
vns = builder.build(run=args.build)
# soc.analyzer.do_exit(vns)
if args.load:
prog = Platform().create_programmer()
prog.load_bitstream('build/xilinx_kc705/gateware/xilinx_kc705.bit')
def main():
parser = argparse.ArgumentParser(description="LiteX SoC on Fomu")
parser.add_argument(
"--board", choices=["evt", "pvt", "hacker"], required=True,
help="build for a particular hardware board"
)
parser.add_argument(
"--seed", default=0, help="seed to use in nextpnr"
)
parser.add_argument(
"--placer", default="heap", choices=["sa", "heap"], help="which placer to use in nextpnr"
)
builder_args(parser)
soc_core_args(parser)
args = parser.parse_args()
soc = BaseSoC(board=args.board, pnr_placer=args.placer, pnr_seed=args.seed,
debug=True, **soc_core_argdict(args))
builder = Builder(soc, **builder_argdict(args))
builder.build()
def main():
parser = argparse.ArgumentParser(description=__doc__)
builder_args(parser)
MySoc.basesoc_args(parser)
parser.add_argument("--trace", action="store_true",
help="enable VCD tracing")
parser.add_argument("--rom-init", default=None,
help="rom_init file")
parser.set_defaults(
integrated_rom_size=0x8000,
integrated_main_ram_size=0x8000,
# integrated_sram_size=0, # Litex will complain if 0!
cpu_type="vexriscv",
platform="cmod_a7_sim",
clk_freq=int(1e6),
with_uart=False # We will add our own mock uart
)
args = parser.parse_args()
soc_kwargs = vars(args)
if args.rom_init:
soc_kwargs["integrated_rom_init"] = get_mem_data(args.rom_init)
soc = MySoc(crg=CRG, **soc_kwargs)
# Push in a fake uart
soc.submodules.uart_phy = uart.RS232PHYModel(soc.platform.request("serial"))
soc.submodules.uart = uart.UART(soc.uart_phy)
sim_config = SimConfig(default_clk="sys_clk")
# sim_config.add_module("ethernet", "eth", args={"interface": "tap0", "ip": "192.168.1.100"})
sim_config.add_module("serial2console", "serial")
# sim_config.add_module("serial2tcp", "serial", args={"port": 55555})
# now you can do these 2 things to get a terminal
# telnet localhost 55555
# litex_term socket://localhost:55555
# soc.add_constant("TFTP_SERVER_PORT", int(tftp_port))
builder = Builder(soc, **builder_argdict(args))
builder.build(run=False, sim_config=sim_config, trace=args.trace)
def parser_args(parser, sys_clk_freq):
parser.add_argument("--build", action="store_true", help="Build bitstream")
parser.add_argument("--load", action="store_true", help="Load bitstream")
parser.add_argument("--docs",
action="store_true",
help="Generate documentation")
parser.add_argument("--sim",
action="store_true",
help="Build and run in simulation mode")
parser.add_argument("--sys-clk-freq",
default=sys_clk_freq,
help="System clock frequency")
parser.add_argument("--no-memory-bist",
action="store_true",
help="Disable memory BIST module")
parser.add_argument("--pattern-data-size",
default="1024",
help="BIST pattern data memory size in bytes")
parser.add_argument("--no-payload-executor",
action="store_true",
help="Disable Payload Executor module")
parser.add_argument("--payload-size",
default="1024",
help="Payload memory size in bytes")
parser.add_argument("--scratchpad-size",
default="1024",
help="Scratchpad memory size in bytes")
parser.add_argument("--ip-address",
default="192.168.100.50",
help="Use given IP address")
parser.add_argument("--mac-address",
default="0x10e2d5000001",
help="Use given MAC address")
parser.add_argument("--udp-port",
default="1234",
help="Use given UDP port")
builder_args(parser)
soc_core_args(parser)
def main():
parser = argparse.ArgumentParser(description="LiteX SoC on iCEBreaker")
parser.add_argument("--nextpnr-seed",
default=0,
help="Select nextpnr pseudo random seed")
parser.add_argument("--nextpnr-placer",
default="heap",
choices=["sa", "heap"],
help="Select nextpnr placer algorithm")
parser.add_argument(
"--debug",
action="store_true",
help=
"Enable debug features. (UART has to be used with the wishbone-tool.)")
parser.add_argument(
"--document-only",
action="store_true",
help="Do not build a soc. Only generate documentation.")
builder_args(parser)
soc_core_args(parser)
args = parser.parse_args()
soc = BaseSoC(debug=args.debug, **soc_core_argdict(args))
soc.set_yosys_nextpnr_settings(nextpnr_seed=args.nextpnr_seed,
nextpnr_placer=args.nextpnr_placer)
# Don't build software -- we don't include it since we just jump to SPI flash.
builder_kwargs = builder_argdict(args)
builder_kwargs["compile_software"] = False
if args.document_only:
builder_kwargs["compile_gateware"] = False
builder = Builder(soc, **builder_kwargs)
vns = builder.build()
soc.do_exit(vns)
lxsocdoc.generate_docs(soc,
"build/documentation/",
project_name="iCEBreaker LiteX Riscv Example SOC",
author="Piotr Esden-Tempski")
def main():
parser = argparse.ArgumentParser(description="LiteX SoC on SoCKit")
parser.add_argument("--build", action="store_true", help="Build bitstream")
parser.add_argument("--load", action="store_true", help="Load bitstream")
parser.add_argument("--revision",
default="revd",
help="Board revision: revb (default), revc or revd")
parser.add_argument("--sys-clk-freq",
default=50e6,
help="System clock frequency (default: 50MHz)")
builder_args(parser)
soc_sdram_args(parser)
args = parser.parse_args()
soc = BaseSoC(sys_clk_freq=int(float(args.sys_clk_freq)),
revision=args.revision,
**soc_sdram_argdict(args))
builder = Builder(soc, **builder_argdict(args))
builder.build(run=args.build)
if args.load:
prog = soc.platform.create_programmer()
prog.load_bitstream(
os.path.join(builder.gateware_dir, soc.build_name + ".sof"))
def main():
parser = argparse.ArgumentParser(
description="Generic LiteX SoC Simulation")
builder_args(parser.add_argument_group(title="Builder"))
soc_sdram_args(parser.add_argument_group(title="SoC SDRAM"))
group = parser.add_argument_group(title="LPDDR4 simulation")
group.add_argument("--sdram-verbosity",
default=0,
help="Set SDRAM checker verbosity")
group.add_argument("--trace", action="store_true", help="Enable Tracing")
group.add_argument("--trace-fst",
action="store_true",
help="Enable FST tracing (default=VCD)")
group.add_argument("--trace-start",
default=0,
help="Cycle to start tracing")
group.add_argument("--trace-end", default=-1, help="Cycle to end tracing")
group.add_argument("--trace-reset",
default=0,
help="Initial traceing state")
group.add_argument("--sys-clk-freq",
default="50e6",
help="Core clock frequency")
group.add_argument("--auto-precharge",
action="store_true",
help="Use DRAM auto precharge")
group.add_argument("--no-refresh",
action="store_true",
help="Disable DRAM refresher")
group.add_argument("--log-level",
default="all=INFO",
help="Set simulation logging level")
group.add_argument("--disable-delay",
action="store_true",
help="Disable CPU delays")
group.add_argument("--gtkw-savefile",
action="store_true",
help="Generate GTKWave savefile")
group.add_argument("--no-masked-write",
action="store_true",
help="Use LPDDR4 WRITE instead of MASKED-WRITE")
group.add_argument("--no-run",
action="store_true",
help="Don't run the simulation, just generate files")
group.add_argument("--double-rate-phy",
action="store_true",
help="Use sim PHY with 2-stage serialization")
group.add_argument("--finish-after-memtest",
action="store_true",
help="Stop simulation after DRAM memory test")
args = parser.parse_args()
soc_kwargs = soc_sdram_argdict(args)
builder_kwargs = builder_argdict(args)
sim_config = SimConfig()
sys_clk_freq = int(float(args.sys_clk_freq))
clocks = get_clocks(sys_clk_freq)
clocks.add_io(_io)
clocks.add_clockers(sim_config)
# Configuration --------------------------------------------------------------------------------
if soc_kwargs["uart_name"] == "serial":
soc_kwargs["uart_name"] = "sim"
sim_config.add_module("serial2console", "serial")
args.with_sdram = True
soc_kwargs["integrated_main_ram_size"] = 0x0
soc_kwargs["sdram_verbosity"] = int(args.sdram_verbosity)
# SoC ------------------------------------------------------------------------------------------
soc = SimSoC(clocks=clocks,
auto_precharge=args.auto_precharge,
with_refresh=not args.no_refresh,
trace_reset=int(args.trace_reset),
log_level=args.log_level,
disable_delay=args.disable_delay,
masked_write=not args.no_masked_write,
double_rate_phy=args.double_rate_phy,
finish_after_memtest=args.finish_after_memtest,
**soc_kwargs)
# Build/Run ------------------------------------------------------------------------------------
builder_kwargs["csr_csv"] = "csr.csv"
builder = Builder(soc, **builder_kwargs)
build_kwargs = dict(sim_config=sim_config,
trace=args.trace,
trace_fst=args.trace_fst,
trace_start=int(args.trace_start),
trace_end=int(args.trace_end))
vns = builder.build(run=False, **build_kwargs)
if args.gtkw_savefile:
generate_gtkw_savefile(builder, vns, trace_fst=args.trace_fst)
if not args.no_run:
builder.build(build=False, **build_kwargs)
def hps_soc_args(parser: argparse.ArgumentParser):
builder_args(parser)
radiant_build_args(parser)
oxide_args(parser)
def main():
parser = argparse.ArgumentParser(
description="LiteX SoC on Colorlight 5A-75X")
parser.add_argument("--build", action="store_true", help="Build bitstream")
parser.add_argument("--flash-offset",
default=0x100000,
help="Boot offset in SPI Flash")
parser.add_argument("--sys-clk-freq",
type=float,
default=50e6,
help="Select system clock frequency")
parser.add_argument(
"--debug",
action="store_true",
help=
"Enable debug features. (UART has to be used with the wishbone-tool.)")
parser.add_argument("--board",
default="5a-75b",
help="Board type: 5a-75b (default) or 5a-75e")
parser.add_argument("--revision",
default="7.0",
type=str,
help="Board revision 7.0 (default), 6.0 or 6.1")
parser.add_argument("--with-ethernet",
action="store_true",
help="Enable Ethernet support")
parser.add_argument("--with-etherbone",
action="store_true",
help="Enable Etherbone support")
parser.add_argument("--eth-phy",
default=0,
type=int,
help="Ethernet PHY 0 or 1 (default=0)")
parser.add_argument("--use-internal-osc",
action="store_true",
help="Use internal oscillator")
parser.add_argument(
"--sdram-rate",
default="1:1",
help="SDRAM Rate 1:1 Full Rate (default), 1:2 Half Rate")
parser.add_argument(
"--document-only",
action="store_true",
help="Do not build a soc. Only generate documentation.")
parser.add_argument("--flash",
action="store_true",
help="Load bitstream to flash")
parser.add_argument("--load",
action="store_true",
help="Load bitstream to SRAM")
builder_args(parser)
soc_core_args(parser)
trellis_args(parser)
args = parser.parse_args()
assert not (args.with_ethernet and args.with_etherbone)
# Create the SOC
soc = BaseSoC(board=args.board,
revision=args.revision,
debug=args.debug,
flash_offset=args.flash_offset,
sys_clk_freq=int(args.sys_clk_freq),
with_ethernet=args.with_ethernet,
with_etherbone=args.with_etherbone,
eth_phy=args.eth_phy,
use_internal_osc=args.use_internal_osc,
sdram_rate=args.sdram_rate,
**soc_core_argdict(args))
# Configure command line parameter defaults
# Don't build software -- we don't include it since we just jump to SPI flash.
builder_kwargs = builder_argdict(args)
builder_kwargs["compile_software"] = False
if args.document_only:
builder_kwargs["compile_gateware"] = False
if builder_kwargs["csr_svd"] is None:
builder_kwargs["csr_svd"] = "../rust/litex-pac/clSOC.svd"
if builder_kwargs["memory_x"] is None:
builder_kwargs["memory_x"] = "../rust/litex-pac/memory.x"
# Create and run the builder
builder = Builder(soc, **builder_kwargs)
builder.build(**trellis_argdict(args), run=args.build)
lxsocdoc.generate_docs(soc,
"build/documentation/",
project_name="Colorlight 5A-75x LiteX Riscv SOC",
author="DerFetzer")
modify_memory_x(builder_kwargs)
modify_svd(builder_kwargs)
# If requested load the resulting bitstream onto the 5A-75X
if args.flash or args.load:
prog = ECP5Programmer()
if args.load:
prog.load_bitstream(
os.path.join(builder.gateware_dir, soc.build_name + ".bit"))
if args.flash:
prog.flash(
0x00000000,
os.path.join(builder.gateware_dir, soc.build_name + ".bit"))
def _add_common(self, *, sys_clk_freq, module):
# Actions
g = self.add_argument_group(title="Actions")
self.add(g, "--build", action="store_true", help="Build bitstream")
self.add(g, "--load", action="store_true", help="Load bitstream")
self.add(g,
"--load-bios",
action="store_true",
help="(debug) Reload BIOS (requires writable BIOS memory)")
self.add(g, "--flash", action="store_true", help="Flash bitstream")
self.add(g,
"--docs",
action="store_true",
help="Generate documentation")
self.add(g,
"--sim",
action="store_true",
help="Build and run in simulation mode")
# Target args
g = self.add_argument_group(title="Row Hammer tester")
self.add(g,
"--sys-clk-freq",
default=sys_clk_freq,
help="System clock frequency")
self.add(g,
"--rw-bios-mem",
action="store_true",
help="(debug) Make BIOS memory writable")
self.add(g, "--module", default=module, help="DRAM module")
self.add(
g,
"--from-spd",
required=False,
help="Use DRAM module data from given file. Overwrites --module")
self.add(
g,
"--speedgrade",
default=None,
help="DRAM module speedgrade, default value depends on module")
self.add(g,
"--no-memory-bist",
action="store_true",
help="Disable memory BIST module")
self.add(g,
"--pattern-data-size",
default="1024",
help="BIST pattern data memory size in bytes")
self.add(g,
"--no-payload-executor",
action="store_true",
help="Disable Payload Executor module")
self.add(g,
"--payload-size",
default="1024",
help="Payload memory size in bytes")
self.add(g,
"--scratchpad-size",
default="1024",
help="Scratchpad memory size in bytes")
self.add(g,
"--ip-address",
default="192.168.100.50",
help="Use given IP address")
self.add(g,
"--mac-address",
default="0x10e2d5000001",
help="Use given MAC address")
self.add(g, "--udp-port", default="1234", help="Use given UDP port")
self.add(
g,
"--bist-inversion-rowbits",
default="5",
help="Number of row bits used for BIST data inversion feature")
# Litex args
builder_args(self.add_argument_group(title="Builder"))
soc_core_args(self.add_argument_group(title="SoC Core"))
def parser_args(parser, *, sys_clk_freq, module):
# Print defaults only for the arguments added here, as Litex has defaults embedded in help messages
class CustomArgumentDefaultHelpFormatter(argparse.HelpFormatter):
ARG_NAMES = []
def add_default(
self,
action): # logic from argparse.ArgumentDefaultsHelpFormatter
help = action.help
if '%(default)' not in action.help:
if action.default is not argparse.SUPPRESS:
defaulting_nargs = [
argparse.OPTIONAL, argparse.ZERO_OR_MORE
]
if action.option_strings or action.nargs in defaulting_nargs:
help += ' (default: %(default)s)'
return help
def _get_help_string(self, action):
for s in action.option_strings:
if s in self.ARG_NAMES:
return self.add_default(action)
return action.help
parser.formatter_class = CustomArgumentDefaultHelpFormatter
def add_argument(*args, **kwargs):
CustomArgumentDefaultHelpFormatter.ARG_NAMES.extend(args)
parser.add_argument(*args, **kwargs)
# Target args
add_argument("--build", action="store_true", help="Build bitstream")
add_argument("--load", action="store_true", help="Load bitstream")
add_argument("--docs", action="store_true", help="Generate documentation")
add_argument("--sim",
action="store_true",
help="Build and run in simulation mode")
add_argument("--sys-clk-freq",
default=sys_clk_freq,
help="System clock frequency")
add_argument("--module", default=module, help="DRAM module")
add_argument("--no-memory-bist",
action="store_true",
help="Disable memory BIST module")
add_argument("--pattern-data-size",
default="1024",
help="BIST pattern data memory size in bytes")
add_argument("--no-payload-executor",
action="store_true",
help="Disable Payload Executor module")
add_argument("--payload-size",
default="1024",
help="Payload memory size in bytes")
add_argument("--scratchpad-size",
default="1024",
help="Scratchpad memory size in bytes")
add_argument("--ip-address",
default="192.168.100.50",
help="Use given IP address")
add_argument("--mac-address",
default="0x10e2d5000001",
help="Use given MAC address")
add_argument("--udp-port", default="1234", help="Use given UDP port")
add_argument(
"--bist-inversion-rowbits",
default="5",
help="Number of row bits used for BIST data inversion feature")
# Litex args
builder_args(parser)
soc_core_args(parser)
def main():
parser = argparse.ArgumentParser(description="LiteX SoC on iCEBreaker")
parser.add_argument("--flash-offset",
default=0x40000,
help="Boot offset in SPI Flash")
parser.add_argument("--sys-clk-freq",
type=float,
default=21e6,
help="Select system clock frequency")
parser.add_argument("--nextpnr-seed",
default=0,
help="Select nextpnr pseudo random seed")
parser.add_argument("--nextpnr-placer",
default="heap",
choices=["sa", "heap"],
help="Select nextpnr placer algorithm")
parser.add_argument(
"--debug",
action="store_true",
help=
"Enable debug features. (UART has to be used with the wishbone-tool.)")
parser.add_argument(
"--document-only",
action="store_true",
help="Do not build a soc. Only generate documentation.")
parser.add_argument("--flash", action="store_true", help="Load bitstream")
builder_args(parser)
soc_core_args(parser)
args = parser.parse_args()
# Create the SOC
soc = BaseSoC(debug=args.debug,
flash_offset=args.flash_offset,
sys_clk_freq=int(args.sys_clk_freq),
**soc_core_argdict(args))
soc.set_yosys_nextpnr_settings(nextpnr_seed=args.nextpnr_seed,
nextpnr_placer=args.nextpnr_placer)
# Configure command line parameter defaults
# Don't build software -- we don't include it since we just jump to SPI flash.
builder_kwargs = builder_argdict(args)
builder_kwargs["compile_software"] = False
if args.document_only:
builder_kwargs["compile_gateware"] = False
if builder_kwargs["csr_svd"] is None:
builder_kwargs["csr_svd"] = "../rust/icebesoc-pac/iCEBESOC.svd"
if builder_kwargs["memory_x"] is None:
builder_kwargs["memory_x"] = "../rust/icebesoc-pac/memory.x"
# Create and run the builder
builder = Builder(soc, **builder_kwargs)
builder.build()
lxsocdoc.generate_docs(soc,
"build/documentation/",
project_name="iCEBreaker LiteX Riscv Example SOC",
author="Piotr Esden-Tempski")
# If requested load the resulting bitstream onto the iCEBreaker
if args.flash:
IceStormProgrammer().flash(0x00000000,
"soc_basesoc_icebreaker/gateware/top.bin")
