| #!/usr/bin/env python3 |
| # -*- coding: utf-8 -*- |
| # |
| # Copyright (C) 2017-2020 The Project X-Ray Authors. |
| # |
| # Use of this source code is governed by a ISC-style |
| # license that can be found in the LICENSE file or at |
| # https://opensource.org/licenses/ISC |
| # |
| # SPDX-License-Identifier: ISC |
| |
| # https://symbiflow.github.io/prjxray-db/ |
| # https://symbiflow.github.io/prjxray-db/artix7/ |
| |
| import os, sys, json, re |
| from io import StringIO |
| from prjxray.util import get_fabric_for_part |
| |
| |
| def mk_get_setting(settings_filename): |
| if settings_filename: |
| settings = {} |
| with open(settings_filename) as f: |
| for line in f: |
| line = line.strip() |
| if not line.startswith("export "): |
| continue |
| key, value = line[7:].split('=', 1) |
| settings[key] = value[1:-1] |
| |
| assert len(settings), (settings_filename, settings) |
| assert settings['XRAY_DATABASE'], pprint.pformat(settings) |
| settings['XRAY_DATABASE_DIR'] = os.path.abspath( |
| os.path.join( |
| os.path.dirname(settings_filename), |
| '..', |
| 'database', |
| ), ) |
| return lambda name: settings[name] |
| else: |
| return os.getenv |
| |
| |
| get_setting = mk_get_setting(None) |
| |
| |
| def db_open(fn, db_dir): |
| filename = os.path.join(db_dir, fn) |
| if not os.path.exists(filename): |
| return StringIO("") |
| return open(os.path.join(db_dir, fn)) |
| |
| |
| def out_open(fn, output): |
| os.makedirs(output, exist_ok=True) |
| fp = os.path.join(output, fn) |
| print("Writing %s" % fp) |
| return open(fp, "w") |
| |
| |
| class UnionFind: |
| def __init__(self): |
| self.parents = dict() |
| |
| def make(self, value): |
| if value not in self.parents: |
| self.parents[value] = value |
| |
| def find(self, value): |
| self.make(value) |
| if self.parents[value] != value: |
| retval = self.find(self.parents[value]) |
| self.parents[value] = retval |
| return self.parents[value] |
| |
| def union(self, v1, v2): |
| a = self.find(v1) |
| b = self.find(v2) |
| if a != b: |
| self.parents[a] = b |
| |
| |
| def db_read(dbstate, tiletype, db_dir): |
| dbstate.cfgbits[tiletype] = dict() |
| dbstate.cfgbits_r[tiletype] = dict() |
| dbstate.maskbits[tiletype] = set() |
| dbstate.ppips[tiletype] = dict() |
| dbstate.routebits[tiletype] = dict() |
| dbstate.routezbits[tiletype] = dict() |
| |
| def add_pip_bits(tag, bits): |
| if tag not in dbstate.routebits[tiletype]: |
| dbstate.routebits[tiletype][tag] = set() |
| dbstate.routezbits[tiletype][tag] = set() |
| for bit in bits: |
| if bit[0] == "!": |
| if bit[1:] not in dbstate.routezbits[tiletype]: |
| dbstate.routezbits[tiletype][bit[1:]] = set() |
| dbstate.routezbits[tiletype][bit[1:]].add(tag) |
| else: |
| if bit not in dbstate.routebits[tiletype]: |
| dbstate.routebits[tiletype][bit] = set() |
| dbstate.routebits[tiletype][bit].add(tag) |
| |
| def add_cfg_bits(tag, bits): |
| if tag not in dbstate.cfgbits[tiletype]: |
| dbstate.cfgbits[tiletype][tag] = set() |
| for bit in bits: |
| dbstate.cfgbits[tiletype][tag].add(bit) |
| if bit not in dbstate.cfgbits_r[tiletype]: |
| dbstate.cfgbits_r[tiletype][bit] = set() |
| dbstate.cfgbits_r[tiletype][bit].add(tag) |
| |
| with db_open("segbits_%s.db" % tiletype, db_dir) as f: |
| for line in f: |
| line = line.split() |
| tag, bits = line[0], line[1:] |
| |
| if tiletype in ["int_l", "int_r", "hclk_l", "hclk_r"]: |
| add_pip_bits(tag, bits) |
| |
| elif tiletype in ["clbll_l", "clbll_r", "clblm_l", "clblm_r"] and \ |
| re.search(r"(\.[ABCD].*MUX\.)|(\.PRECYINIT\.)", tag): |
| add_pip_bits(tag, bits) |
| |
| else: |
| add_cfg_bits(tag, bits) |
| |
| with db_open("ppips_%s.db" % tiletype, db_dir) as f: |
| for line in f: |
| tag, typ = line.split() |
| dbstate.ppips[tiletype][tag] = typ |
| |
| if tiletype not in ["int_l", "int_r"]: |
| with db_open("mask_%s.db" % tiletype, db_dir) as f: |
| for line in f: |
| tag, bit = line.split() |
| assert tag == "bit" |
| dbstate.maskbits[tiletype].add(bit) |
| else: |
| for t in ["clbll_l", "clbll_r", "clblm_l", "clblm_r", "dsp_l", "dsp_r", |
| "bram_l", "bram_r"]: |
| with db_open("mask_%s.db" % t, db_dir) as f: |
| for line in f: |
| tag, bit = line.split() |
| assert tag == "bit" |
| frameidx, bitidx = bit.split("_") |
| dbstate.maskbits[tiletype].add( |
| "%02d_%02d" % (int(frameidx), int(bitidx) % 64)) |
| |
| |
| def init_bitdb(): |
| clb_bitgroups_db = [ |
| # copy&paste from zero_db in dbfixup.py |
| "00_21 00_22 00_26 01_28|00_25 01_20 01_21 01_24", |
| "00_23 00_30 01_22 01_25|00_27 00_29 01_26 01_29", |
| "01_12 01_14 01_16 01_18|00_10 00_11 01_09 01_10", |
| "00_13 01_17 00_15 00_17|00_18 00_19 01_13 00_14", |
| "00_34 00_38 01_33 01_37|00_35 00_39 01_38 01_40", |
| "00_33 00_41 01_32 01_34|00_37 00_42 01_36 01_41", |
| |
| # other manual groupings for individual bits |
| "00_02 00_05 00_09 01_04|00_07 01_05 01_06", |
| "00_01 00_06 01_00 01_08|00_03 01_01 01_02", |
| "00_59 01_54 01_58 01_61|00_57 00_58 01_56", |
| "00_55 00_63 01_57 01_62|00_61 00_62 01_60", |
| "00_43 00_47 00_50 00_53 00_54 01_42|00_51 01_50 01_52", |
| "00_49 01_44 01_45 01_48 01_49 01_53|00_45 00_46 01_46", |
| ] |
| |
| hclk_bitgroups_db = [ |
| # manual groupings |
| "03_14 03_15 04_14 04_15|00_15 00_16 01_14 01_15", |
| "02_16 03_16 04_16 05_16|02_14 02_15 05_14 05_15", |
| "02_18 02_19 05_18 05_19|00_17 00_18 01_16 01_17", |
| "03_18 03_19 04_18 04_19|02_17 03_17 04_17 05_17", |
| "02_20 02_21 05_20 05_21|02_22 03_22 04_22 05_22", |
| "02_29 03_29 04_29 05_29|03_30 03_31 04_30 04_31", |
| "02_26 02_27 05_26 05_27|02_28 03_28 04_28 05_28", |
| "02_23 03_23 04_23 05_23|03_24 03_25 04_24 04_25", |
| ] |
| |
| # groupings for SNWE bits in frames 2..7 |
| for i in range(0, 64, 4): |
| clb_bitgroups_db.append( |
| "02_%02d 03_%02d 05_%02d 06_%02d 07_%02d|05_%02d 03_%02d 04_%02d 04_%02d" |
| % (i + 1, i, i, i, i + 1, i + 3, i + 1, i + 1, i + 2)) |
| clb_bitgroups_db.append( |
| "02_%02d 04_%02d 05_%02d 05_%02d 06_%02d|02_%02d 03_%02d 04_%02d 07_%02d" |
| % (i + 2, i, i + 1, i + 2, i + 2, i + 3, i + 2, i + 3, i + 3)) |
| |
| return clb_bitgroups_db, hclk_bitgroups_db |
| |
| |
| def init_hclk_bits(hclk_bitgroups_db): |
| hclk_left_bits = set() |
| hclk_right_bits = set() |
| |
| for entry in hclk_bitgroups_db: |
| a, b = entry.split("|") |
| for bit in a.split(): |
| hclk_left_bits.add(bit) |
| for bit in b.split(): |
| hclk_right_bits.add(bit) |
| |
| return hclk_left_bits, hclk_right_bits |
| |
| |
| def init_clb_bits(clb_bitgroups_db): |
| clb_left_bits = set() |
| clb_right_bits = set() |
| |
| for entry in clb_bitgroups_db: |
| a, b = entry.split("|") |
| for bit in a.split(): |
| clb_left_bits.add(bit) |
| for bit in b.split(): |
| clb_right_bits.add(bit) |
| |
| return clb_left_bits, clb_right_bits |
| |
| |
| class DBState(): |
| def __init__(self): |
| self.cfgbits = dict() |
| self.cfgbits_r = dict() |
| self.maskbits = dict() |
| self.ppips = dict() |
| self.routebits = dict() |
| self.routezbits = dict() |
| |
| |
| class Tweaks(): |
| def __init__(self): |
| pass |
| |
| |
| def load_tilegrid(db_dir, fabric, verbose=False, allow_fake=False): |
| print("Loading tilegrid.") |
| with db_open(os.path.join(fabric, "tilegrid.json"), db_dir) as f: |
| data = f.read() |
| if not data: |
| assert allow_fake, 'No tilegrid.json found' |
| print('WARNING: loading fake tilegrid') |
| grid = { |
| "NULL": { |
| "grid_x": 0, |
| "grid_y": 0, |
| "type": "NULL", |
| } |
| } |
| else: |
| grid = json.loads(data) |
| return grid |
| |
| |
| def db_reads(dbstate, db_dir): |
| |
| db_read(dbstate, "int_l", db_dir) |
| db_read(dbstate, "int_r", db_dir) |
| |
| db_read(dbstate, "hclk_l", db_dir) |
| db_read(dbstate, "hclk_r", db_dir) |
| |
| db_read(dbstate, "clbll_l", db_dir) |
| db_read(dbstate, "clbll_r", db_dir) |
| |
| db_read(dbstate, "clblm_l", db_dir) |
| db_read(dbstate, "clblm_r", db_dir) |
| |
| db_read(dbstate, "dsp_l", db_dir) |
| db_read(dbstate, "dsp_r", db_dir) |
| |
| db_read(dbstate, "bram_l", db_dir) |
| db_read(dbstate, "bram_r", db_dir) |
| |
| |
| def place_tiles(grid): |
| grid_map = dict() |
| grid_range = None |
| |
| for tilename, tiledata in grid.items(): |
| grid_x = tiledata["grid_x"] |
| grid_y = tiledata["grid_y"] |
| grid_map[(grid_x, grid_y)] = tilename |
| |
| if grid_range is None: |
| grid_range = [grid_x, grid_y, grid_x, grid_y] |
| else: |
| grid_range[0] = min(grid_range[0], grid_x) |
| grid_range[1] = min(grid_range[1], grid_y) |
| grid_range[2] = max(grid_range[2], grid_x) |
| grid_range[3] = max(grid_range[3], grid_y) |
| return grid_map, grid_range |
| |
| |
| def tile_bgcolor(tiledata): |
| bgcolor = "#eeeeee" |
| |
| # INT - Blue |
| if tiledata["type"] in ["INT_L", "INT_R"]: bgcolor = "#aaaaff" |
| elif "INT_FEEDTHRU" in tiledata["type"]: bgcolor = "#ddddff" |
| |
| # CLBL - Yellow |
| if tiledata["type"] in ["CLBLL_L", "CLBLL_R"]: bgcolor = "#ffffaa" |
| # CLBM - Red |
| if tiledata["type"] in ["CLBLM_L", "CLBLM_R"]: bgcolor = "#ffaaaa" |
| |
| # CLK - Green |
| if tiledata["type"] in ["HCLK_L", "HCLK_R"]: bgcolor = "#aaffaa" |
| elif "CLK" in tiledata["type"]: bgcolor = "#66ff66" |
| elif "CMT" in tiledata["type"]: bgcolor = "#22ff22" |
| |
| # BRAM - Cyan |
| if tiledata["type"] in ["BRAM_INT_INTERFACE_L", "BRAM_L"]: |
| bgcolor = "#aaffff" |
| if tiledata["type"] in ["BRAM_INT_INTERFACE_R", "BRAM_R"]: |
| bgcolor = "#aaffff" |
| |
| # DSP - Purple |
| if tiledata["type"] in ["INT_INTERFACE_L", "DSP_L"]: |
| bgcolor = "#ffaaff" |
| if tiledata["type"] in ["INT_INTERFACE_R", "DSP_R"]: |
| bgcolor = "#ffaaff" |
| |
| if "IO" in tiledata["type"]: |
| bgcolor = "#dddddd" |
| |
| # Unused - grey |
| if tiledata["type"] in ["NULL", "VBRK"] or "BRK" in tiledata["type"]: |
| bgcolor = "#aaaaaa" |
| |
| return bgcolor |
| |
| |
| def tile_print_td(f, title, tilename, bgcolor, tiledata, dbstate): |
| tilename = tilename.replace("INT_INTERFACE_", "INTF_") |
| tilename = tilename.replace("_X", "<br/>X") |
| tilename = tilename.replace("B_TERM", "B<br/>TERM") |
| |
| print( |
| "<td bgcolor=\"%s\" align=\"center\" title=\"%s\"><span style=\"font-size:10px\">" |
| % (bgcolor, "\n".join(title)), |
| file=f) |
| if tiledata["type"].lower() in dbstate.cfgbits: |
| print( |
| "<a style=\"text-decoration: none; color: black\" href=\"tile_%s.html\">%s</a></span></td>" |
| % (tiledata["type"].lower(), tilename.replace("_X", "<br/>X")), |
| file=f) |
| else: |
| print( |
| "%s</span></td>" % tilename.replace("_X", "<br/>X").replace( |
| "B_TERM", "B<br/>TERM"), |
| file=f) |
| |
| |
| def tile_title(tilename, tiledata, grid_x, grid_y, grid): |
| title = [tilename] |
| segdata = None |
| |
| if "segment" in tiledata: |
| # FIXME: BRAM support |
| segdata = grid[tilename]['bits'].get('CLB_IO_CLK', None) |
| title.append(tiledata["segment"]) |
| |
| title.append("GRID_POSITION: %d %d" % (grid_x, grid_y)) |
| |
| if "sites" in tiledata: |
| for sitename, sitetype in tiledata["sites"].items(): |
| title.append("%s site: %s" % (sitetype, sitename)) |
| |
| if segdata: |
| if "baseaddr" in segdata: |
| #title.append("Baseaddr: %s %d" % tuple(segdata["baseaddr"])) |
| title.append("Baseaddr: %s" % segdata["baseaddr"]) |
| else: |
| print( |
| "Warning: no baseaddr in segment %s (via tile %s)." % |
| (tiledata["segment"], tilename)) |
| |
| return title |
| |
| |
| def mk_tilegrid_page(dbstate, output, grid): |
| with out_open("index.html", output) as f: |
| print( |
| "<html><title>X-Ray %s Database</title><body>" % |
| get_setting("XRAY_DATABASE").upper(), |
| file=f) |
| print( |
| "<h3>X-Ray %s Database</h3>" % |
| get_setting("XRAY_DATABASE").upper(), |
| file=f) |
| |
| print( |
| "<p><b>Part: %s<br/>ROI TILEGRID: %s<br/>ROI Frames: %s</b></p>" % |
| ( |
| get_setting("XRAY_PART"), get_setting("XRAY_ROI_TILEGRID"), |
| get_setting("XRAY_ROI_FRAMES")), |
| file=f) |
| |
| grid_map, grid_range = place_tiles(grid) |
| |
| print("<table border>", file=f) |
| |
| for grid_y in range(grid_range[1], grid_range[3] + 1): |
| print("<tr>", file=f) |
| |
| for grid_x in range(grid_range[0], grid_range[2] + 1): |
| tilename = grid_map[(grid_x, grid_y)] |
| tiledata = grid[tilename] |
| |
| bgcolor = tile_bgcolor(tiledata) |
| title = tile_title(tilename, tiledata, grid_x, grid_y, grid) |
| tile_print_td(f, title, tilename, bgcolor, tiledata, dbstate) |
| |
| print("</tr>", file=f) |
| |
| print("</table>", file=f) |
| print("</body></html>", file=f) |
| |
| |
| def get_bit_name(dbstate, frameidx, bitidx, bit_pos, tiletype): |
| bit_name = dbstate.cfgbits_r[tiletype][ |
| bit_pos] if bit_pos in dbstate.cfgbits_r[tiletype] else None |
| |
| if bit_name is None and bit_pos in dbstate.routebits[tiletype]: |
| bit_name = dbstate.routebits[tiletype][bit_pos] |
| |
| if bit_name is None and bit_pos in dbstate.routezbits[tiletype]: |
| bit_name = dbstate.routezbits[tiletype][bit_pos] |
| |
| if bit_name is None and tiletype in ["clbll_l", "clbll_r", "clblm_l", |
| "clblm_r", "dsp_l", "dsp_r", "bram_l", |
| "bram_r"]: |
| int_tile_type = "int_" + tiletype[-1] |
| bit_int_pos = "%02d_%02d" % (frameidx, bitidx % 64) |
| bit_name = dbstate.cfgbits_r[int_tile_type][ |
| bit_int_pos] if bit_int_pos in dbstate.cfgbits_r[ |
| int_tile_type] else None |
| |
| if bit_name is None and bit_int_pos in dbstate.routebits[int_tile_type]: |
| bit_name = dbstate.routebits[int_tile_type][bit_int_pos] |
| |
| if bit_name is None and bit_int_pos in dbstate.routezbits[ |
| int_tile_type]: |
| bit_name = dbstate.routezbits[int_tile_type][bit_int_pos] |
| |
| if bit_name is not None: |
| if len(bit_name) <= 1: |
| bit_name = "".join(bit_name) |
| else: |
| for n in bit_name: |
| bit_name = ".".join(n.split(".")[:-1]) |
| |
| return bit_name |
| |
| |
| def get_bit_info(dbstate, frameidx, bitidx, tiletype): |
| bit_pos = "%02d_%02d" % (frameidx, bitidx) |
| |
| bit_name = get_bit_name(dbstate, frameidx, bitidx, bit_pos, tiletype) |
| |
| label = None |
| title = [bit_pos] |
| bgcolor = "#aaaaaa" |
| |
| if bit_pos not in dbstate.maskbits[tiletype]: |
| label = " " |
| bgcolor = "#444444" |
| title.append("UNUSED ?") |
| |
| if (tiletype in ["hclk_l", "hclk_r"]) and bitidx < 13: |
| label = "ECC" |
| bgcolor = "#44aa44" |
| |
| if bit_name is not None: |
| bgcolor = "#ff0000" |
| title.append(bit_name) |
| |
| if "LUT.INIT" in bit_name: |
| bgcolor = "#ffffaa" |
| m = re.search(r"(.)LUT.INIT\[(..)\]", bit_name) |
| label = m.group(1) + m.group(2) |
| |
| m = re.search(r"\.([ABCD])LUT\.([A-Z]+)$", bit_name) |
| if m: |
| bgcolor = "#ffffaa" |
| if m.group(2) == "RAM": |
| label = m.group(1) + "LR" |
| elif m.group(2) == "SMALL": |
| label = m.group(1) + "LS" |
| elif m.group(2) == "SRL": |
| label = m.group(1) + "SR" |
| else: |
| bgcolor = "#ff0000" |
| |
| m = re.search(r"\.([ABCD])LUT\.([A-Z]+)$", bit_name) |
| if m: |
| bgcolor = "#ffffaa" |
| if m.group(2) == "RAM": |
| label = m.group(1) + "LR" |
| elif m.group(2) == "SMALL": |
| label = m.group(1) + "LS" |
| elif m.group(2) == "SRL": |
| label = m.group(1) + "SR" |
| else: |
| bgcolor = "#ff0000" |
| |
| m = re.search(r"\.([ABCD]5?)FF\.([A-Z]+(\.A|\.B)?)$", bit_name) |
| if m: |
| bgcolor = "#aaffaa" |
| if m.group(2) == "ZINI": |
| label = m.group(1) + "ZI" |
| elif m.group(2) == "ZRST": |
| label = m.group(1) + "ZR" |
| elif m.group(2) == "MUX.A": |
| label = m.group(1) + "MA" |
| elif m.group(2) == "MUX.B": |
| label = m.group(1) + "MB" |
| else: |
| bgcolor = "#ff0000" |
| |
| m = re.search(r"\.([ABCD])LUT.DI1MUX\.", bit_name) |
| if m: |
| bgcolor = "#ffffaa" |
| label = m.group(1) + "DI1" |
| |
| m = re.search(r"\.(WA[78])USED$", bit_name) |
| if m: |
| bgcolor = "#ffffaa" |
| label = m.group(1) |
| |
| if ".WEMUX." in bit_name: |
| bgcolor = "#ffffaa" |
| label = "WE" |
| |
| m = re.search(r"\.CARRY4\.([A-Z0-9]+)$", bit_name) |
| if m: |
| bgcolor = "#88cc00" |
| label = m.group(1) |
| |
| if re.search(r"\.LATCH$", bit_name): |
| bgcolor = "#aaffaa" |
| label = "LAT" |
| |
| if re.search(r"\.FFSYNC$", bit_name): |
| bgcolor = "#aaffaa" |
| label = "SYN" |
| |
| if re.search(r"\.[ABCD]LUT5$", bit_name): |
| bgcolor = "#cccc88" |
| label = bit_name[-5] + "5" |
| |
| if re.search(r"\.(CE|SR)USEDMUX$", bit_name): |
| bgcolor = "#ffaa00" |
| label = bit_name[-9:-7] + "M" |
| |
| if re.search(r"\.CLKINV$", bit_name): |
| bgcolor = "#ffaa00" |
| label = "CLKI" |
| |
| if ".ENABLE_BUFFER." in bit_name: |
| bgcolor = "#ffaa00" |
| label = "BUF" |
| |
| if re.match("^INT_[LR].[SNWE][SNWERL]", bit_name): |
| if bit_name[8] == "1": |
| bgcolor = "#4466bb" |
| elif bit_name[8] == "2": |
| bgcolor = "#aa88ff" |
| elif bit_name[6:9] in "SS6 SE6 NN6 NW6".split(): |
| bgcolor = "#7755ff" |
| else: |
| bgcolor = "#88aaff" |
| label = bit_name[6:9] |
| |
| if re.match("^INT_[LR].IMUX", bit_name): |
| m = re.match("^INT_[LR].IMUX(_L)?(\\d+)", bit_name) |
| bgcolor = "#88aaff" |
| label = "IM" + m.group(2) |
| |
| if re.match("^INT_[LR].BYP_ALT", bit_name): |
| bgcolor = "#7755ff" |
| label = "BA" + bit_name[13] |
| |
| if re.match("^INT_[LR].FAN_ALT", bit_name): |
| bgcolor = "#4466bb" |
| label = "FA" + bit_name[13] |
| |
| if re.match("^INT_[LR].CLK", bit_name): |
| bgcolor = "#4466bb" |
| label = "CLK" |
| |
| if re.match("^INT_[LR].CTRL", bit_name): |
| bgcolor = "#7755ff" |
| label = "CTRL" |
| |
| if re.match("^INT_[LR].GFAN", bit_name): |
| bgcolor = "#7755ff" |
| label = "GFAN" |
| |
| if re.match("^INT_[LR].LVB", bit_name): |
| bgcolor = "#88aaff" |
| label = "LVB" |
| |
| if re.match("^INT_[LR].LV", bit_name): |
| bgcolor = "#88aaff" |
| label = "LV" |
| |
| if re.match("^INT_[LR].LH", bit_name): |
| bgcolor = "#4466bb" |
| label = "LH" |
| |
| if re.match("^CLBL[LM]_[LR].SLICE[LM]_X[01].[ABCD]5?FFMUX", bit_name): |
| bgcolor = "#88aaff" |
| label = "DMX" |
| |
| if re.match("^CLBL[LM]_[LR].SLICE[LM]_X[01].[ABCD]OUTMUX", bit_name): |
| bgcolor = "#aa88ff" |
| label = "OMX" |
| |
| if re.match("^CLBL[LM]_[LR].SLICE[LM]_X[01].PRECYINIT", bit_name): |
| bgcolor = "#88aaff" |
| label = "CYI" |
| |
| if re.match("^HCLK_[LR]", bit_name) and "_B_BOT" in bit_name: |
| bgcolor = "#4466bb" |
| label = "BOT" |
| |
| if re.match("^HCLK_[LR]", bit_name) and "_B_TOP" in bit_name: |
| bgcolor = "#7755ff" |
| label = "TOP" |
| |
| if re.match("^DSP_[LR].DSP_[01].(PATTERN|MASK)", bit_name): |
| bgcolor = "#ffffaa" |
| label = bit_name[12] + bit_name[10] |
| |
| return bit_pos, label, title, bgcolor |
| |
| |
| def gen_table(dbstate, tiletype, f): |
| print( |
| """ |
| <script><!-- |
| var grp2bits = { }; |
| var bit2grp = { } |
| var highlight_bits = [ ]; |
| var highlight_cache = { }; |
| |
| function ome(bit) { |
| // console.log("ome: " + bit); |
| if (bit in bit2grp) { |
| grp = bit2grp[bit]; |
| for (i in grp2bits[grp]) { |
| b = grp2bits[grp][i]; |
| // console.log(" -> " + b); |
| if (!(b in highlight_cache)) { |
| el = document.getElementById("bit" + b); |
| highlight_cache[b] = el.bgColor; |
| el.bgColor = "#ffffff"; |
| highlight_bits.push(b); |
| } |
| } |
| } |
| } |
| |
| function oml() { |
| // console.log("oml"); |
| for (i in highlight_bits) { |
| b = highlight_bits[i]; |
| el = document.getElementById("bit" + b); |
| el.bgColor = highlight_cache[b]; |
| delete highlight_cache[b]; |
| el.style.fontWeight = "normal"; |
| } |
| highlight_bits.length = 0; |
| } |
| //--></script> |
| """, |
| file=f) |
| |
| num_frames = 36 |
| unused_bits = 0 |
| unknown_bits = 0 |
| known_bits = 0 |
| hideframes = set() |
| |
| if tiletype in ["int_l", "int_r", "hclk_l", "hclk_r"]: |
| num_frames = 26 |
| |
| if tiletype in ["bram_l", "bram_r", "dsp_l", "dsp_r"]: |
| for i in range(5, 25): |
| hideframes.add(i) |
| num_frames = 28 |
| |
| height = 2 |
| if tiletype in ["hclk_l", "hclk_r"]: |
| height = 1 |
| if tiletype in ["dsp_l", "dsp_r", "bram_l", "bram_r"]: |
| height = 10 |
| |
| if height > 2: |
| print("<table><tr><td>", file=f) |
| |
| def print_table_header(): |
| print("<table border>", file=f) |
| print("<tr>", file=f) |
| print("<th width=\"30\"></th>", file=f) |
| for frameidx in range(num_frames): |
| if frameidx in hideframes: |
| continue |
| print( |
| "<th width=\"30\"><span style=\"font-size:10px\">%d</span></th>" |
| % frameidx, |
| file=f) |
| print("</tr>", file=f) |
| |
| print_table_header() |
| |
| for bitidx in range(32 * height - 1, -1, -1): |
| print("<tr>", file=f) |
| print( |
| "<th align=\"right\"><span style=\"font-size:10px\">%d</span></th>" |
| % bitidx, |
| file=f) |
| for frameidx in range(num_frames): |
| if frameidx in hideframes: |
| continue |
| |
| bit_pos, label, title, bgcolor = get_bit_info( |
| dbstate, frameidx, bitidx, tiletype) |
| |
| if label is None: |
| label = " " |
| |
| if label == "INT": |
| onclick = " onmousedown=\"location.href = 'tile_int_%s.html#b%s'\"" % ( |
| tiletype[-1], bit_pos) |
| else: |
| onclick = " onmousedown=\"location.href = '#b%s'\"" % bit_pos |
| |
| if bgcolor == "#aaaaaa": |
| unknown_bits += 1 |
| elif bgcolor == "#444444": |
| unused_bits += 1 |
| else: |
| known_bits += 1 |
| |
| print( |
| "<td id=\"bit%s\" onmouseenter=\"ome('%s');\" onmouseleave=\"oml();\" bgcolor=\"%s\" align=\"center\" title=\"%s\"%s><span style=\"font-size:10px\">%s</span></td>" |
| % |
| (bit_pos, bit_pos, bgcolor, "\n".join(title), onclick, label), |
| file=f) |
| print("</tr>", file=f) |
| |
| if bitidx > 0 and bitidx % 80 == 0: |
| print("</table></td><td>", file=f) |
| print_table_header() |
| |
| print("</table>", file=f) |
| |
| if height > 2: |
| print("</td></tr></table>", file=f) |
| |
| print( |
| " unused: %d, unknown: %d, known: %d, total: %d, percentage: %.2f%% (%.2f%%)" |
| % ( |
| unused_bits, unknown_bits, known_bits, |
| unused_bits + unknown_bits + known_bits, 100 * known_bits / |
| (unknown_bits + unused_bits + known_bits), 100 * |
| (known_bits + unused_bits) / |
| (unknown_bits + unused_bits + known_bits))) |
| |
| |
| def mk_segment_pages(dbstate, output, tweaks): |
| for tiletype in sorted(dbstate.cfgbits.keys()): |
| with out_open("tile_%s.html" % tiletype, output) as f: |
| print( |
| "<html><title>X-Ray %s Database: %s</title><body>" % |
| (get_setting("XRAY_DATABASE").upper(), tiletype.upper()), |
| file=f) |
| print( |
| "<h3><a href=\"index.html\">X-Ray %s Database</a>: %s Segment</h3>" |
| % (get_setting("XRAY_DATABASE").upper(), tiletype.upper()), |
| file=f) |
| |
| gen_table(dbstate, tiletype, f) |
| |
| print("<div>", file=f) |
| |
| bits_by_prefix = dict() |
| |
| for bit_name, bits_pos in dbstate.cfgbits[tiletype].items(): |
| prefix = ".".join(bit_name.split(".")[0:-1]) |
| |
| if prefix not in bits_by_prefix: |
| bits_by_prefix[prefix] = set() |
| |
| for bit_pos in bits_pos: |
| bits_by_prefix[prefix].add((bit_name, bit_pos)) |
| |
| for prefix, bits in sorted(bits_by_prefix.items()): |
| for bit_name, bit_pos in sorted(bits): |
| print("<a id=\"b%s\"/>" % bit_pos, file=f) |
| |
| print("<p/>", file=f) |
| print("<h4>%s</h4>" % prefix, file=f) |
| print("<table cellspacing=0>", file=f) |
| print( |
| "<tr><th width=\"400\" align=\"left\">Bit Name</th><th>Position</th></tr>", |
| file=f) |
| |
| trstyle = "" |
| for bit_name, bit_pos in sorted(bits): |
| trstyle = " bgcolor=\"#dddddd\"" if trstyle == "" else "" |
| print( |
| "<tr%s><td>%s</td><td>%s</td></tr>" % |
| (trstyle, bit_name, bit_pos), |
| file=f) |
| |
| print("</table>", file=f) |
| |
| ruf = UnionFind() |
| routebits_routezbits = list(dbstate.routebits[tiletype].items()) |
| routebits_routezbits += list(dbstate.routezbits[tiletype].items()) |
| |
| for bit, pips in routebits_routezbits: |
| for pip in pips: |
| grp = ".".join(pip.split('.')[:-1]) |
| ruf.union(grp, bit) |
| |
| rgroups = dict() |
| rgroup_names = dict() |
| |
| for bit, pips in routebits_routezbits: |
| for pip in pips: |
| grp_name = ".".join(pip.split('.')[:-1]) |
| grp = ruf.find(grp_name) |
| if grp not in rgroup_names: |
| rgroup_names[grp] = set() |
| rgroup_names[grp].add(grp_name) |
| if grp not in rgroups: |
| rgroups[grp] = dict() |
| if pip not in rgroups[grp]: |
| rgroups[grp][pip] = set() |
| rgroups[grp][pip].add(bit) |
| |
| shared_bits = dict() |
| for bit, pips in routebits_routezbits: |
| for pip in pips: |
| grp_name = ".".join(pip.split('.')[:-1]) |
| if bit not in shared_bits: |
| shared_bits[bit] = set() |
| shared_bits[bit].add(grp_name) |
| |
| rgroups_with_title = list() |
| |
| for grp, gdata in sorted(rgroups.items()): |
| title = "PIPs driving " + ", ".join(sorted(rgroup_names[grp])) |
| rgroups_with_title.append((title, grp, gdata)) |
| |
| for title, grp, gdata in sorted(rgroups_with_title): |
| grp_bits = set() |
| for pip, bits in gdata.items(): |
| grp_bits |= bits |
| |
| def bit_key(b): |
| if tiletype in ["hclk_l", "hclk_r"]: |
| if b in tweaks.hclk_left_bits: |
| return "a" + b |
| if b in tweaks.hclk_right_bits: |
| return "c" + b |
| if tiletype in ["clblm_l", "clblm_r", "clbll_l", "clbll_r", |
| "int_l", "int_r"]: |
| if b in tweaks.clb_left_bits: |
| return "a" + b |
| if b in tweaks.clb_right_bits: |
| return "c" + b |
| return "b" + b |
| |
| grp_bits = sorted(grp_bits, key=bit_key) |
| |
| for bit in grp_bits: |
| print("<a id=\"b%s\"/>" % bit, file=f) |
| |
| print("<script><!--", file=f) |
| print( |
| "grp2bits['%s'] = ['%s'];" % |
| (grp_bits[0], "', '".join(grp_bits)), |
| file=f) |
| for bit in grp_bits: |
| print("bit2grp['%s'] = '%s';" % (bit, grp_bits[0]), file=f) |
| print("//--></script>", file=f) |
| |
| print("<p/>", file=f) |
| print("<h4>%s</h4>" % title, file=f) |
| print("<table cellspacing=0>", file=f) |
| print("<tr><th width=\"400\" align=\"left\">PIP</th>", file=f) |
| |
| for bit in grp_bits: |
| print("<th> %s </th>" % bit, file=f) |
| print("</tr>", file=f) |
| |
| lines = list() |
| for pip, bits in sorted(gdata.items()): |
| line = " --><td>%s</td>" % (pip) |
| for bit in grp_bits: |
| c = "-" |
| if bit in dbstate.routebits[ |
| tiletype] and pip in dbstate.routebits[ |
| tiletype][bit]: |
| c = "1" |
| if bit in dbstate.routezbits[ |
| tiletype] and pip in dbstate.routezbits[ |
| tiletype][bit]: |
| c = "0" |
| line = "%s%s<td align=\"center\">%s</td>" % ( |
| c, line, c) |
| lines.append(line) |
| |
| trstyle = "" |
| for line in sorted(lines): |
| trstyle = " bgcolor=\"#dddddd\"" if trstyle == "" else "" |
| print("<tr%s><!-- %s</tr>" % (trstyle, line), file=f) |
| |
| print("</table>", file=f) |
| |
| first_note = True |
| for bit in grp_bits: |
| if len(shared_bits[bit]) > 1: |
| if first_note: |
| print("<p><b>Note(s):</b><br/>", file=f) |
| print( |
| "Warning: Groups sharing bit %s: %s." % |
| (bit, ", ".join(sorted(shared_bits[bit])))) |
| print( |
| "Groups sharing bit <b>%s</b>: %s.<br/>" % |
| (bit, ", ".join(sorted(shared_bits[bit]))), |
| file=f) |
| first_note = False |
| if not first_note: |
| print("</p>", file=f) |
| |
| if len(dbstate.ppips[tiletype]) > 0: |
| print("<h4>Pseudo PIPs</h4>", file=f) |
| print("<table cellspacing=0>", file=f) |
| print( |
| "<tr><th width=\"500\" align=\"left\">PIP</th><th>Type</th></tr>", |
| file=f) |
| trstyle = "" |
| for typ, tag in sorted( |
| [(b, a) for a, b in dbstate.ppips[tiletype].items()]): |
| trstyle = " bgcolor=\"#dddddd\"" if trstyle == "" else "" |
| print( |
| "<tr%s><td>%s</td><td>%s</td></tr>" % |
| (trstyle, tag, typ), |
| file=f) |
| print("</table>", file=f) |
| |
| print("</div>", file=f) |
| print("</body></html>", file=f) |
| |
| |
| def run(settings, output, verbose=False, allow_fake=False): |
| global get_setting |
| |
| get_setting = mk_get_setting(settings) |
| |
| if output is None: |
| output = os.path.join( |
| os.path.curdir, 'html', get_setting('XRAY_DATABASE')) |
| |
| db_dir = os.path.join( |
| get_setting("XRAY_DATABASE_DIR"), get_setting("XRAY_DATABASE")) |
| |
| # Load tweaks |
| tweaks = Tweaks() |
| clb_bitgroups_db, hclk_bitgroups_db = init_bitdb() |
| tweaks.hclk_left_bits, tweaks.hclk_right_bits = init_hclk_bits( |
| hclk_bitgroups_db) |
| tweaks.clb_left_bits, tweaks.clb_right_bits = init_clb_bits( |
| clb_bitgroups_db) |
| |
| # Load source data |
| dbstate = DBState() |
| fabric = get_fabric_for_part(db_dir, get_setting("XRAY_PART")) |
| grid = load_tilegrid( |
| db_dir, fabric, verbose=verbose, allow_fake=allow_fake) |
| db_reads(dbstate, db_dir) |
| |
| # Create pages |
| mk_tilegrid_page(dbstate, output, grid) |
| mk_segment_pages(dbstate, output, tweaks) |
| |
| |
| def main(): |
| import argparse |
| |
| parser = argparse.ArgumentParser( |
| description="Generate a pretty HTML version of the documentation.") |
| parser.add_argument('--verbose', action='store_true') |
| parser.add_argument( |
| '--output', |
| default=None, |
| help='Put the generated files in this directory (default current dir).' |
| ) |
| parser.add_argument( |
| '--settings', |
| default=None, |
| help='Read the settings from file (default to environment).', |
| ) |
| parser.add_argument( |
| '--allow-fake', |
| default=False, |
| action='store_true', |
| help="Continue even if tilegrid.json isn't found.", |
| ) |
| |
| args = parser.parse_args() |
| run( |
| settings=args.settings, |
| output=args.output, |
| verbose=args.verbose, |
| allow_fake=args.allow_fake, |
| ) |
| |
| |
| if __name__ == '__main__': |
| main() |
