def main():
devices = database.get_devices()
shutil.rmtree("work_html", ignore_errors=True)
os.mkdir("work_html")
commit_hash = database.get_db_commit()
build_dt = time.strftime('%Y-%m-%d %H:%M:%S')
docs_toc = ""
for architecture in sorted(devices["architectures"].keys()):
docs_toc += "<h3>{} Architecture</h3>".format(architecture.upper())
docs_toc += "<h4>Bitstream Documentation</h4>"
docs_toc += "<ul>"
for part in sorted(
devices["architectures"][architecture]["parts"].keys()):
docs_toc += '<li><a href="{}">{} Documentation</a></li>'.format(
'{}.html'.format(part), part.upper())
html_tilegrid.main([
"html_tilegrid", architecture, part,
path.join("work_html", part + ".html")
])
docs_toc += "</ul>"
index_html = Template(tang_docs_index).substitute(datetime=build_dt,
commit=commit_hash,
docs_toc=docs_toc)
with open(path.join("work_html", "index.html"), 'w') as f:
f.write(index_html)
def main():
devices = database.get_devices()
shutil.rmtree("work_html", ignore_errors=True)
os.mkdir("work_html")
commit_hash = database.get_db_commit()
build_dt = time.strftime('%Y-%m-%d %H:%M:%S')
docs_toc = ""
for family in sorted(devices["families"].keys()):
print("Family: " + family)
docs_toc += "<h3>{} Family</h3>".format(family.upper())
docs_toc += "<h4>Bitstream Documentation</h4>"
docs_toc += "<ul>"
for device in sorted(devices["families"][family]["devices"].keys()):
print("Device: " + device)
docs_toc += '<li><a href="{}">{} Documentation</a></li>'.format('{}.html'.format(device),device.upper())
html_tilegrid.main(["html_tilegrid", family, device, path.join("work_html",device + ".html")])
docs_toc += "</ul>"
index_html = Template(tang_docs_index).substitute(
datetime=build_dt,
commit=commit_hash,
docs_toc=docs_toc
)
with open(path.join("work_html", "index.html"), 'w') as f:
f.write(index_html)
def main():
devices = database.get_devices()
for family in sorted(devices["families"].keys()):
for device in sorted(devices["families"][family]["devices"].keys()):
output_file = path.join(database.get_db_subdir(family, device),
"tilegrid.json")
subprocess.check_call(["./get_device_tilegrid.sh", device])
extract_tilegrid.main([
"extract_tilegrid", device, "../minitests/simple/wire.dump",
output_file
])
def main(argv):
args = parser.parse_args(argv[1:])
tilegrid = database.get_tilegrid(args.architecture, args.part)
device_info = database.get_devices()["architectures"][
args.architecture]["parts"][args.part]
max_row = device_info["max_row"]
max_col = device_info["max_col"]
tiles = []
for i in range(max_row):
row = []
for j in range(max_col):
row.append([])
tiles.append(row)
for row in tilegrid:
for item in row:
x = int(item["x"])
y = int(item["y"])
for data in item["val"]:
colour = get_colour(data["type"])
tiles[y][x].append((data["inst"], data["type"], colour))
f = args.outfile
print("""<html>
<head><title>{} Tiles</title></head>
<body>
<h1>{} Tilegrid</h1>
<table style='font-size: 8pt; border: 2px solid black; text-align: center'>
""".format(args.part.upper(), args.part.upper()),
file=f)
for trow in tiles:
print("<tr>", file=f)
row_max_height = 0
for tloc in trow:
row_max_height = max(row_max_height, len(tloc))
row_height = max(75, 30 * row_max_height)
for tloc in trow:
print("<td style='border: 2px solid black; height: {}px'>".format(
row_height),
file=f)
for tile in tloc:
print(
"<div style='height: {}%; background-color: {}'><em>{}</em><br/><strong>{}</strong></div>"
.format(100 / len(tloc), tile[2], tile[0], tile[1],
tile[1]),
file=f)
print("</td>", file=f)
print("</tr>", file=f)
print("</table></body></html>", file=f)
def main(argv):
args = parser.parse_args(argv[1:])
tilegrid = database.get_tilegrid(args.family, args.device)
device_info = database.get_devices()["families"][args.family]["devices"][
args.device]
max_row = device_info["max_row"]
max_col = device_info["max_col"]
bias = device_info["col_bias"]
tiles = []
for i in range(max_row + 1):
row = []
for j in range(max_col + 1):
row.append([])
tiles.append(row)
for identifier, data in sorted(tilegrid.items()):
name = identifier.split(":")[0]
row, col = tilelib.pos_from_name(name, (max_row, max_col), bias)
colour = get_colour(data["type"])
tiles[row][col].append((name, data["type"], colour))
f = args.outfile
print("""<html>
<head><title>{} Tiles</title></head>
<body>
<h1>{} Tilegrid</h1>
<table style='font-size: 8pt; border: 2px solid black; text-align: center'>
""".format(args.device, args.device),
file=f)
for trow in tiles:
print("<tr>", file=f)
row_max_height = 0
for tloc in trow:
row_max_height = max(row_max_height, len(tloc))
row_height = max(75, 30 * row_max_height)
for tloc in trow:
print("<td style='border: 2px solid black; height: {}px'>".format(
row_height),
file=f)
for tile in tloc:
print(
"<div style='height: {}%; background-color: {}'><em>{}</em><br/><strong><a href='../tilehtml/{}.html' style='color: black'>{}</a></strong></div>"
.format(100 / len(tloc), tile[2], tile[0], tile[1],
tile[1]),
file=f)
print("</td>", file=f)
print("</tr>", file=f)
print("</table></body></html>", file=f)
def main():
devices = database.get_devices()
tang_root = database.get_tangdinasty_root()
shutil.rmtree("work_decrypt", ignore_errors=True)
os.mkdir("work_decrypt")
print("Decrypting all chipdb files...")
for family in devices["families"].keys():
print("Family: " + family)
for device in devices["families"][family]["devices"].keys():
print("Device: " + device)
selected_device = devices["families"][family]["devices"][device]
unc_file = path.join("work_decrypt", device + ".unc")
chipdb = path.join(tang_root, "arch", device + ".db")
unlogic.decode_chipdb(
["decrypt_all", chipdb, "--decrypt", unc_file])
def main():
shutil.rmtree("work_tilegrid", ignore_errors=True)
os.mkdir("work_tilegrid")
shutil.copy(
path.join(database.get_trellis_root(), "minitests", "wire", "wire.v"),
"work_tilegrid/wire.v")
devices = database.get_devices()
for family in sorted(devices["families"].keys()):
for device in sorted(devices["families"][family]["devices"].keys()):
diamond.run(device, "work_tilegrid/wire.v")
output_file = path.join(database.get_db_subdir(family, device),
"tilegrid.json")
extract_tilegrid.main([
"extract_tilegrid", "work_tilegrid/wire.tmp/output.test",
output_file
])
def main():
devices = database.get_devices()
for fam, famdata in sorted(devices["families"].items()):
tdroot = path.join(database.get_db_root(), fam, "tiledata")
if not path.exists(tdroot):
os.mkdir(tdroot)
for device in sorted(famdata["devices"].keys()):
if famdata["devices"][device]["fuzz"]:
tilegrid = database.get_tilegrid(fam, device)
for tilename in sorted(tilegrid.keys()):
tile = tiles.type_from_fullname(tilename)
tile_dir = path.join(tdroot, tile)
if not path.exists(tile_dir):
os.mkdir(tile_dir)
tile_db = path.join(tile_dir, "bits.db")
if not path.exists(tile_db):
with open(tile_db, 'w') as f:
f.write('\n')
def main():
devices = database.get_devices()
tang_root = database.get_tangdinasty_root()
for architecture in devices["architectures"].keys():
print("Architecture: " + architecture)
for part in devices["architectures"][architecture]["parts"].keys():
print("Part: " + part)
selected_part = devices["architectures"][architecture]["parts"][
part]
package = selected_part["packages"][0]
json_file = path.join(database.get_db_subdir(architecture, part),
"tilegrid.json")
chipdb = path.join(tang_root, "arch", part + ".db")
unlogic.decode_chipdb([
"get_tilegrid_all", chipdb, "--tilegrid", json_file,
"--datadir",
path.join("work_decrypt", part)
])
def main():
devices = database.get_devices()
tang_root = database.get_tangdinasty_root()
shutil.rmtree(database.get_db_root(), ignore_errors=True)
os.mkdir(database.get_db_root())
shutil.copy(path.join(database.get_tang_root(), "devices.json"), path.join(database.get_db_root(), "devices.json"))
for family in devices["families"].keys():
print("Family: " + family)
for device in devices["families"][family]["devices"].keys():
print("Device: " + device)
selected_device = devices["families"][family]["devices"][device]
database_dir = database.get_db_subdir(family, device)
if not path.exists(path.join(database_dir,"bits")):
os.mkdir(path.join(database_dir,"bits"))
chipdb = path.join(tang_root, "arch", device + ".db")
unlogic.decode_chipdb(["create_database", chipdb, "--db_dir", database_dir])
def main(argv):
args = parser.parse_args(argv[1:])
if not path.exists(args.fld):
os.mkdir(args.fld)
commit_hash = database.get_db_commit()
build_dt = time.strftime('%Y-%m-%d %H:%M:%S')
docs_toc = ""
pytrellis.load_database(database.get_db_root())
for fam, fam_data in sorted(database.get_devices()["families"].items()):
fdir = path.join(args.fld, fam)
if not path.exists(fdir):
os.mkdir(fdir)
thdir = path.join(fdir, "tilehtml")
if not path.exists(thdir):
os.mkdir(thdir)
docs_toc += "<h3>{} Family</h3>".format(fam)
docs_toc += "<ul>"
tiles = get_device_tiles(fam, fam_data["devices"])
for dev, devdata in sorted(fam_data["devices"].items()):
if devdata["fuzz"]:
ddir = path.join(fdir, dev)
if not path.exists(ddir):
os.mkdir(ddir)
print(
"********* Generating documentation for device {}".format(
dev))
generate_device_docs(fam, dev, ddir)
if (fam, dev) in tiles:
for tile in tiles[fam, dev]:
print(
"*** Generating documentation for tile {}".format(
tile))
generate_tile_docs(fam, dev, tile, thdir)
docs_toc += '<li><a href="{}">{} Documentation</a></li>'.format(
'{}/{}/index.html'.format(fam, dev), dev)
docs_toc += "</ul>"
index_html = Template(trellis_docs_index).substitute(datetime=build_dt,
commit=commit_hash,
docs_toc=docs_toc)
with open(path.join(args.fld, "index.html"), 'w') as f:
f.write(index_html)
def main():
devices = database.get_devices()
tang_root = database.get_tangdinasty_root()
shutil.rmtree("work_decrypt", ignore_errors=True)
os.mkdir("work_decrypt")
print("Decrypting all chipdb files...")
for architecture in devices["architectures"].keys():
print("Architecture: " + architecture)
for part in devices["architectures"][architecture]["parts"].keys():
print("Part: " + part)
selected_part = devices["architectures"][architecture]["parts"][
part]
package = selected_part["packages"][0]
os.mkdir(path.join("work_decrypt", part))
unc_file = path.join("work_decrypt", part + ".unc")
chipdb = path.join(tang_root, "arch", part + ".db")
unlogic.decode_chipdb([
"decrypt_all", chipdb, "--decrypt", unc_file, "--datadir",
path.join("work_decrypt", part)
])
def main():
devices = database.get_devices()
for architecture in devices["architectures"].keys():
for part in devices["architectures"][architecture]["parts"].keys():
shutil.rmtree("work_tilegrid", ignore_errors=True)
os.mkdir("work_tilegrid")
selected_part = devices["architectures"][architecture]["parts"][
part]
package = selected_part["packages"][0]
max_row = int(selected_part["max_row"])
max_col = int(selected_part["max_col"])
prepare_tcl(
path.join(database.get_tang_root(), "minitests", "tilegrid",
"wire.tcl"), "work_tilegrid/wire.tcl", part, package)
prepare_pnl(architecture, part, package, max_row, max_col)
tangdinasty.run("wire.tcl", "work_tilegrid")
tiles = [[0 for y in range(max_col)] for x in range(max_row)]
extract_elements("work_tilegrid/wire.log", tiles, max_row)
file_loc = path.join(database.get_tang_root(), "minitests",
"tilegrid", part + ".v")
if os.path.exists(file_loc):
shutil.copyfile(file_loc,
path.join("work_tilegrid", part + ".v"))
prepare_tcl(
path.join(database.get_tang_root(), "minitests",
"tilegrid", "specific.tcl"),
"work_tilegrid/specific.tcl", part, package)
tangdinasty.run("specific.tcl", "work_tilegrid")
extract_elements("work_tilegrid/" + part + ".log", tiles,
max_row)
output_file = path.join(database.get_db_subdir(architecture, part),
"tilegrid.json")
with open(output_file, "wt") as fout:
json.dump(tiles, fout, sort_keys=True, indent=4)
extract_fuses("work_tilegrid/wire.fuse", architecture, part)
def main(argv):
args = parser.parse_args(argv[1:])
if not path.exists(args.fld):
os.mkdir(args.fld)
commit_hash = database.get_db_commit()
build_dt = time.strftime('%Y-%m-%d %H:%M:%S')
docs_toc = ""
pytrellis.load_database(database.get_db_root())
for fam, fam_data in sorted(database.get_devices()["families"].items()):
if fam == "MachXO2":
continue
fdir = path.join(args.fld, fam)
if not path.exists(fdir):
os.mkdir(fdir)
thdir = path.join(fdir, "tilehtml")
if not path.exists(thdir):
os.mkdir(thdir)
docs_toc += "<h3>{} Family</h3>".format(fam)
docs_toc += "<h4>Bitstream Documentation</h4>"
docs_toc += "<ul>"
tiles = get_device_tiles(fam, fam_data["devices"])
for dev, devdata in sorted(fam_data["devices"].items()):
if devdata["fuzz"]:
ddir = path.join(fdir, dev)
if not path.exists(ddir):
os.mkdir(ddir)
print(
"********* Generating documentation for device {}".format(
dev))
generate_device_docs(fam, dev, ddir)
if (fam, dev) in tiles:
for tile in tiles[fam, dev]:
print(
"*** Generating documentation for tile {}".format(
tile))
generate_tile_docs(fam, dev, tile, thdir)
docs_toc += '<li><a href="{}">{} Documentation</a></li>'.format(
'{}/{}/index.html'.format(fam, dev), dev)
docs_toc += "</ul>"
docs_toc += "<h4>Cell Timing Documentation</h4>"
docs_toc += "<ul>"
for spgrade in ["6", "7", "8", "8_5G"]:
tdir = path.join(fdir, "timing")
if not path.exists(tdir):
os.mkdir(tdir)
docs_toc += '<li><a href="{}">Speed Grade -{}</a></li>'.format(
'{}/timing/cell_timing_{}.html'.format(fam, spgrade), spgrade)
cell_html.make_cell_timing_html(
timing_dbs.cells_db_path(fam, spgrade), fam, spgrade,
path.join(tdir, 'cell_timing_{}.html'.format(spgrade)))
docs_toc += "</ul>"
docs_toc += "<h4>Interconnect Timing Documentation</h4>"
docs_toc += "<ul>"
for spgrade in ["6", "7", "8", "8_5G"]:
tdir = path.join(fdir, "timing")
if not path.exists(tdir):
os.mkdir(tdir)
docs_toc += '<li><a href="{}">Speed Grade -{}</a></li>'.format(
'{}/timing/interconn_timing_{}.html'.format(fam, spgrade),
spgrade)
interconnect_html.make_interconn_timing_html(
timing_dbs.interconnect_db_path(fam, spgrade), fam, spgrade,
path.join(tdir, 'interconn_timing_{}.html'.format(spgrade)))
docs_toc += "</ul>"
index_html = Template(trellis_docs_index).substitute(datetime=build_dt,
commit=commit_hash,
docs_toc=docs_toc)
with open(path.join(args.fld, "index.html"), 'w') as f:
f.write(index_html)
def main(argv):
args = parser.parse_args(argv[1:])
if not path.exists(args.fld):
os.mkdir(args.fld)
commit_hash = database.get_db_commit()
build_dt = time.strftime('%Y-%m-%d %H:%M:%S')
gen_docs_toc = ""
gdir = path.join(args.fld, "general")
if not path.exists(gdir):
os.mkdir(gdir)
for mdfile in glob.glob(path.join(database.get_oxide_root(), "docs", "general", "*.md")):
with open(mdfile, "r") as f:
if f.read(1) != "#":
continue
title = f.readline().strip()
htmlfn = path.basename(mdfile).replace(".md", ".html")
htmlfile = path.join(gdir, htmlfn)
with open(htmlfile, "w") as f:
f.write(libpyprjoxide.md_file_to_html(mdfile))
gen_docs_toc += '<li><a href="general/{}">{}</a></li>\n'.format(htmlfn, title)
docs_toc = ""
for fam, fam_data in sorted(database.get_devices()["families"].items()):
fdir = path.join(args.fld, fam)
if not path.exists(fdir):
os.mkdir(fdir)
thdir = path.join(fdir, "tilehtml")
if not path.exists(thdir):
os.mkdir(thdir)
bhdir = path.join(fdir, "belhtml")
if not path.exists(bhdir):
os.mkdir(bhdir)
docs_toc += "<h3>{} Family</h3>".format(fam)
docs_toc += "<h4>Generated Bitstream Documentation</h4>"
docs_toc += "<ul>"
tiles = get_device_tiles(fam, fam_data["devices"])
for dev, devdata in sorted(fam_data["devices"].items()):
if devdata["fuzz"]:
ddir = path.join(fdir, dev)
if not path.exists(ddir):
os.mkdir(ddir)
print("********* Generating documentation for device {}".format(dev))
generate_device_docs(fam, dev, ddir)
if (fam, dev) in tiles:
for tile in tiles[fam, dev]:
print("*** Generating documentation for tile {}".format(tile))
generate_tile_docs(fam, dev, tile, fdir)
docs_toc += '<li><a href="{}">{} Documentation</a></li>'.format(
'{}/{}/index.html'.format(fam, dev),
dev
)
docs_toc += "</ul>"
index_html = Template(oxide_docs_index).substitute(
datetime=build_dt,
commit=commit_hash,
docs_toc=docs_toc,
gen_docs_toc=gen_docs_toc,
)
with open(path.join(args.fld, "index.html"), 'w') as f:
f.write(index_html)
