| #!/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 |
| import copy |
| import json |
| import os |
| from utils import xjson |
| ''' |
| Historically we grouped data into "segments" |
| These were a region of the bitstream that encoded one or more tiles |
| However, this didn't scale with certain tiles like BRAM |
| Some sites had multiple bitstream areas and also occupied multiple tiles |
| |
| Decoding was then shifted to instead describe how each title is encoded |
| A post processing step verifies that two tiles don't reference the same bitstream area |
| ''' |
| |
| import util as localutil |
| |
| |
| def nolr(tile_type): |
| ''' |
| Remove _L or _R suffix tile_type suffix, if present |
| Ex: BRAM_INT_INTERFACE_L => BRAM_INT_INTERFACE |
| Ex: VBRK => VBRK |
| ''' |
| postfix = tile_type[-2:] |
| if postfix in ('_L', '_R'): |
| return tile_type[:-2] |
| else: |
| return tile_type |
| |
| |
| def make_tiles_by_grid(database): |
| # lookup tile names by (X, Y) |
| tiles_by_grid = dict() |
| |
| for tile_name in database: |
| tile = database[tile_name] |
| tiles_by_grid[(tile["grid_x"], tile["grid_y"])] = tile_name |
| |
| return tiles_by_grid |
| |
| |
| def propagate_INT_lr_bits( |
| database, tiles_by_grid, tile_frames_map, verbose=False): |
| '''Populate segment base addresses: L/R along INT column''' |
| |
| int_frames, int_words, _ = localutil.get_entry('INT', 'CLB_IO_CLK') |
| |
| verbose and print('') |
| for tile in database: |
| if database[tile]["type"] not in ["INT_L", "INT_R"]: |
| continue |
| |
| if not database[tile]["bits"]: |
| continue |
| |
| grid_x = database[tile]["grid_x"] |
| grid_y = database[tile]["grid_y"] |
| baseaddr = int(database[tile]["bits"]["CLB_IO_CLK"]["baseaddr"], 0) |
| offset = database[tile]["bits"]["CLB_IO_CLK"]["offset"] |
| |
| if database[tile]["type"] == "INT_L": |
| grid_x += 1 |
| baseaddr = baseaddr + 0x80 |
| elif database[tile]["type"] == "INT_R": |
| grid_x -= 1 |
| baseaddr = baseaddr - 0x80 |
| else: |
| assert 0, database[tile]["type"] |
| |
| # ROI at edge? |
| if (grid_x, grid_y) not in tiles_by_grid: |
| verbose and print(' Skip edge') |
| continue |
| |
| other_tile = tiles_by_grid[(grid_x, grid_y)] |
| |
| if database[tile]["type"] == "INT_L": |
| assert database[other_tile]["type"] == "INT_R" |
| elif database[tile]["type"] == "INT_R": |
| assert database[other_tile]["type"] == "INT_L" |
| else: |
| assert 0 |
| |
| localutil.add_tile_bits( |
| other_tile, database[other_tile], baseaddr, offset, int_frames, |
| int_words, tile_frames_map) |
| |
| |
| def propagate_INT_bits_in_column(database, tiles_by_grid, tile_frames_map): |
| """ Propigate INT offsets up and down INT columns. |
| |
| INT columns appear to be fairly regular, where starting from offset 0, |
| INT tiles next to INT tiles increase the word offset by 2. The HCLK tile |
| is surrounded above and sometimes below by an INT tile. Because the HCLK |
| tile only useds one word, the offset increase by one at the HCLK. |
| |
| """ |
| |
| seen_int = set() |
| |
| int_frames, int_words, _ = localutil.get_entry('INT', 'CLB_IO_CLK') |
| hclk_frames, hclk_words, _ = localutil.get_entry('HCLK', 'CLB_IO_CLK') |
| |
| for tile_name in sorted(database.keys()): |
| tile = database[tile_name] |
| |
| if tile['type'] not in ['INT_L', 'INT_R']: |
| continue |
| |
| l_or_r = tile['type'][-1] |
| |
| if not tile['bits']: |
| continue |
| |
| if tile_name in seen_int: |
| continue |
| |
| # Walk down INT column |
| while True: |
| seen_int.add(tile_name) |
| |
| next_tile = tiles_by_grid[(tile['grid_x'], tile['grid_y'] + 1)] |
| next_tile_type = database[next_tile]['type'] |
| |
| if tile['bits']['CLB_IO_CLK']['offset'] == 0: |
| assert next_tile_type in [ |
| 'B_TERM_INT', 'BRKH_INT', 'BRKH_B_TERM_INT' |
| ], next_tile_type |
| break |
| |
| baseaddr = int(tile['bits']['CLB_IO_CLK']['baseaddr'], 0) |
| offset = tile['bits']['CLB_IO_CLK']['offset'] |
| |
| if tile['type'].startswith( |
| 'INT_') and next_tile_type == tile['type']: |
| # INT next to INT |
| offset -= int_words |
| localutil.add_tile_bits( |
| next_tile, database[next_tile], baseaddr, offset, |
| int_frames, int_words, tile_frames_map) |
| elif tile['type'].startswith('INT_'): |
| # INT above HCLK |
| assert next_tile_type.startswith( |
| 'HCLK_{}'.format(l_or_r)), next_tile_type |
| |
| offset -= hclk_words |
| localutil.add_tile_bits( |
| next_tile, database[next_tile], baseaddr, offset, |
| hclk_frames, hclk_words, tile_frames_map) |
| else: |
| # HCLK above INT |
| assert tile['type'].startswith( |
| 'HCLK_{}'.format(l_or_r)), tile['type'] |
| if next_tile_type == 'INT_{}'.format(l_or_r): |
| offset -= int_words |
| localutil.add_tile_bits( |
| next_tile, database[next_tile], baseaddr, offset, |
| int_frames, int_words, tile_frames_map) |
| else: |
| # Handle special case column where the PCIE tile is present. |
| assert next_tile_type in ['PCIE_NULL'], next_tile_type |
| break |
| |
| tile_name = next_tile |
| tile = database[tile_name] |
| |
| # Walk up INT column |
| while True: |
| seen_int.add(tile_name) |
| |
| next_tile = tiles_by_grid[(tile['grid_x'], tile['grid_y'] - 1)] |
| next_tile_type = database[next_tile]['type'] |
| |
| if tile['bits']['CLB_IO_CLK']['offset'] == 99: |
| assert next_tile_type in [ |
| 'T_TERM_INT', 'BRKH_INT', 'BRKH_TERM_INT', 'BRKH_INT_PSS' |
| ], next_tile_type |
| break |
| |
| baseaddr = int(tile['bits']['CLB_IO_CLK']['baseaddr'], 0) |
| offset = tile['bits']['CLB_IO_CLK']['offset'] |
| |
| if tile['type'].startswith( |
| 'INT_') and next_tile_type == tile['type']: |
| # INT next to INT |
| offset += int_words |
| localutil.add_tile_bits( |
| next_tile, database[next_tile], baseaddr, offset, |
| int_frames, int_words, tile_frames_map) |
| elif tile['type'].startswith('INT_'): |
| # INT below HCLK |
| assert next_tile_type.startswith( |
| 'HCLK_{}'.format(l_or_r)), next_tile_type |
| |
| offset += int_words |
| localutil.add_tile_bits( |
| next_tile, database[next_tile], baseaddr, offset, |
| hclk_frames, hclk_words, tile_frames_map) |
| else: |
| # HCLK below INT |
| assert tile['type'].startswith( |
| 'HCLK_{}'.format(l_or_r)), tile['type'] |
| assert next_tile_type == 'INT_{}'.format( |
| l_or_r), next_tile_type |
| |
| offset += hclk_words |
| localutil.add_tile_bits( |
| next_tile, database[next_tile], baseaddr, offset, |
| int_frames, int_words, tile_frames_map) |
| |
| tile_name = next_tile |
| tile = database[tile_name] |
| |
| |
| def propagate_INT_INTERFACE_bits_in_column( |
| database, tiles_by_grid, int_interface_name, tile_frames_map): |
| """ Propagate INT_INTERFACE column for a given INT_INTERFACE tile name. |
| |
| INT_INTERFACE tiles do not usually have any PIPs or baseaddresses, |
| except for a few cases such as PCIE or GTP INTERFACE tiles. |
| |
| These are very regular tiles, except for the horizontal clock line, |
| which adds a one-word offset. |
| |
| This function replicates the baseaddress and calculates the correct offset |
| for each INT INTERFACE tile in a column, starting from a tile in the column |
| that has the baseaddress calculated from the corresponding tilegrid fuzzer. |
| """ |
| |
| seen_int = set() |
| |
| int_frames, int_words, _ = localutil.get_entry('INT', 'CLB_IO_CLK') |
| hclk_frames, hclk_words, _ = localutil.get_entry('HCLK', 'CLB_IO_CLK') |
| |
| for tile_name in sorted(database.keys()): |
| tile = database[tile_name] |
| |
| if not tile['type'].startswith(int_interface_name): |
| continue |
| |
| if not tile['bits']: |
| continue |
| |
| if tile_name in seen_int: |
| continue |
| |
| # Walk down INT column |
| down_tile = tile |
| down_tile_name = tile_name |
| while True: |
| seen_int.add(down_tile_name) |
| |
| baseaddr = int(down_tile['bits']['CLB_IO_CLK']['baseaddr'], 0) |
| offset = down_tile['bits']['CLB_IO_CLK']['offset'] |
| extra_offset = 0 |
| |
| next_tile = tiles_by_grid[( |
| down_tile['grid_x'], down_tile['grid_y'] + 1)] |
| if next_tile.startswith("HCLK"): |
| next_tile = tiles_by_grid[( |
| down_tile['grid_x'], down_tile['grid_y'] + 2)] |
| extra_offset = hclk_words |
| |
| next_tile_type = database[next_tile]['type'] |
| |
| if next_tile_type != tile['type']: |
| break |
| |
| if next_tile_type == down_tile['type']: |
| # INT next to INT |
| offset -= (int_words + extra_offset) |
| localutil.add_tile_bits( |
| next_tile, database[next_tile], baseaddr, offset, |
| int_frames, int_words, tile_frames_map) |
| |
| down_tile_name = next_tile |
| down_tile = database[down_tile_name] |
| |
| # Walk up INT column |
| up_tile = tile |
| up_tile_name = tile_name |
| while True: |
| seen_int.add(up_tile_name) |
| |
| baseaddr = int(up_tile['bits']['CLB_IO_CLK']['baseaddr'], 0) |
| offset = up_tile['bits']['CLB_IO_CLK']['offset'] |
| extra_offset = 0 |
| |
| next_tile = tiles_by_grid[( |
| up_tile['grid_x'], up_tile['grid_y'] - 1)] |
| if next_tile.startswith("HCLK"): |
| next_tile = tiles_by_grid[( |
| up_tile['grid_x'], up_tile['grid_y'] - 2)] |
| extra_offset = hclk_words |
| |
| next_tile_type = database[next_tile]['type'] |
| |
| if next_tile_type != tile['type']: |
| break |
| |
| if next_tile_type == up_tile['type']: |
| # INT next to INT |
| offset += (int_words + extra_offset) |
| localutil.add_tile_bits( |
| next_tile, database[next_tile], baseaddr, offset, |
| int_frames, int_words, tile_frames_map) |
| |
| up_tile_name = next_tile |
| up_tile = database[up_tile_name] |
| |
| |
| def propagate_rebuf(database, tiles_by_grid): |
| """ Writing a fuzzer for the CLK_BUFG_REBUF tiles is hard, so propigate from CLK_HROW tiles. |
| |
| In the clock column, there is a CLK_BUFG_REBUF above and below the CLK_HROW |
| tile. Each clock column appears to use the same offsets, so propigate |
| the base address and frame count, and update the offset and word count. |
| |
| """ |
| for tile_name in sorted(database.keys()): |
| tile = database[tile_name] |
| |
| if tile['type'] not in ['CLK_HROW_BOT_R', 'CLK_HROW_TOP_R']: |
| continue |
| |
| rebuf_below = tiles_by_grid[(tile['grid_x'], tile['grid_y'] - 12)] |
| assert database[rebuf_below]['type'] == 'CLK_BUFG_REBUF', database[ |
| rebuf_below]['type'] |
| rebuf_above = tiles_by_grid[(tile['grid_x'], tile['grid_y'] + 13)] |
| assert database[rebuf_above]['type'] == 'CLK_BUFG_REBUF', database[ |
| rebuf_below]['type'] |
| |
| assert database[tile_name]['bits']['CLB_IO_CLK'][ |
| 'offset'] == 42, database[tile_name]['bits']['CLB_IO_CLK'] |
| database[rebuf_below]['bits'] = copy.deepcopy( |
| database[tile_name]['bits']) |
| database[rebuf_below]['bits']['CLB_IO_CLK']['offset'] = 73 |
| database[rebuf_below]['bits']['CLB_IO_CLK']['words'] = 4 |
| |
| database[rebuf_above]['bits'] = copy.deepcopy( |
| database[tile_name]['bits']) |
| database[rebuf_above]['bits']['CLB_IO_CLK']['offset'] = 24 |
| database[rebuf_above]['bits']['CLB_IO_CLK']['words'] = 4 |
| |
| |
| def propagate_IOB_SING(database, tiles_by_grid): |
| """ The IOB_SING are half tiles at top and bottom of every IO column. |
| |
| Unlike most tiles, they do not behave consistently. The tile at the top |
| of the column is the bottom half of a full IOB, and the tile at the bottom |
| of the column is the top half of a full IOB. For this reason, explicit |
| bit aliasing is used to map the full IOB bits into the two halves, and a |
| mapping is provided for the site naming. |
| |
| """ |
| |
| seen_iobs = set() |
| for tile in database: |
| if tile in seen_iobs: |
| continue |
| |
| if database[tile]["type"] not in ["LIOB33", "RIOB33", "RIOB18"]: |
| continue |
| |
| while True: |
| prev_tile = tile |
| tile = tiles_by_grid[( |
| database[tile]['grid_x'], database[tile]['grid_y'] + 1)] |
| if '_SING' in database[tile]['type']: |
| break |
| |
| bottom_tile = tile |
| seen_iobs.add(bottom_tile) |
| |
| bits = database[prev_tile]['bits']['CLB_IO_CLK'] |
| |
| while True: |
| tile = tiles_by_grid[( |
| database[tile]['grid_x'], database[tile]['grid_y'] - 1)] |
| seen_iobs.add(tile) |
| |
| if '_SING' in database[tile]['type']: |
| break |
| |
| if 'CLB_IO_CLK' in database[tile]['bits']: |
| assert bits['baseaddr'] == database[tile]['bits'][ |
| 'CLB_IO_CLK']['baseaddr'] |
| assert bits['frames'] == database[tile]['bits']['CLB_IO_CLK'][ |
| 'frames'] |
| assert bits['words'] == database[tile]['bits']['CLB_IO_CLK'][ |
| 'words'] |
| |
| top_tile = tile |
| |
| database[top_tile]['bits']['CLB_IO_CLK'] = copy.deepcopy(bits) |
| database[top_tile]['bits']['CLB_IO_CLK']['words'] = 2 |
| database[top_tile]['bits']['CLB_IO_CLK']['offset'] = 99 |
| database[top_tile]['bits']['CLB_IO_CLK']['alias'] = { |
| 'type': database[prev_tile]['type'], |
| 'start_offset': 0, |
| 'sites': { |
| 'IOB33_Y0': 'IOB33_Y1', |
| } |
| } |
| |
| database[bottom_tile]['bits']['CLB_IO_CLK'] = copy.deepcopy(bits) |
| database[bottom_tile]['bits']['CLB_IO_CLK']['words'] = 2 |
| database[bottom_tile]['bits']['CLB_IO_CLK']['offset'] = 0 |
| database[bottom_tile]['bits']['CLB_IO_CLK']['alias'] = { |
| 'type': database[prev_tile]['type'], |
| 'start_offset': 2, |
| 'sites': { |
| 'IOB33_Y0': 'IOB33_Y0', |
| } |
| } |
| |
| |
| def propagate_IOI_SING(database, tiles_by_grid): |
| """ |
| The IOI_SING, similarly to IOB_SING, are half tiles at top and bottom of every |
| IO column. |
| |
| The tile contains half of the sites that are present in the full IOI, |
| namely one ILOGIC, OLOGIC and IDELAY. |
| """ |
| |
| seen_iois = set() |
| for tile in database: |
| if tile in seen_iois: |
| continue |
| |
| if database[tile]["type"] not in ["LIOI3", "RIOI3", "RIOI"]: |
| continue |
| |
| while True: |
| prev_tile = tile |
| tile = tiles_by_grid[( |
| database[tile]['grid_x'], database[tile]['grid_y'] + 1)] |
| if '_SING' in database[tile]['type']: |
| break |
| |
| bottom_tile = tile |
| seen_iois.add(bottom_tile) |
| |
| bits = database[prev_tile]['bits']['CLB_IO_CLK'] |
| |
| while True: |
| tile = tiles_by_grid[( |
| database[tile]['grid_x'], database[tile]['grid_y'] - 1)] |
| seen_iois.add(tile) |
| |
| if '_SING' in database[tile]['type']: |
| break |
| |
| if 'CLB_IO_CLK' in database[tile]['bits']: |
| if tile.startswith("LIOI") or tile.startswith("RIOI"): |
| assert bits['baseaddr'] == database[tile]['bits'][ |
| 'CLB_IO_CLK']['baseaddr'] |
| assert bits['frames'] == database[tile]['bits'][ |
| 'CLB_IO_CLK']['frames'], "{}:{} == {}".format( |
| tile, bits['frames'], |
| database[tile]['bits']['CLB_IO_CLK']['frames']) |
| assert bits['words'] == database[tile]['bits'][ |
| 'CLB_IO_CLK']['words'], "{}: {} != {}".format( |
| tile, bits['words'], |
| database[tile]['bits']['CLB_IO_CLK']['words']) |
| |
| top_tile = tile |
| |
| database[top_tile]['bits']['CLB_IO_CLK'] = copy.deepcopy(bits) |
| database[top_tile]['bits']['CLB_IO_CLK']['words'] = 2 |
| database[top_tile]['bits']['CLB_IO_CLK']['offset'] = 99 |
| database[top_tile]['bits']['CLB_IO_CLK']['alias'] = { |
| 'type': database[prev_tile]['type'], |
| 'start_offset': 0, |
| 'sites': {} |
| } |
| |
| database[bottom_tile]['bits']['CLB_IO_CLK'] = copy.deepcopy(bits) |
| database[bottom_tile]['bits']['CLB_IO_CLK']['words'] = 2 |
| database[bottom_tile]['bits']['CLB_IO_CLK']['offset'] = 0 |
| database[bottom_tile]['bits']['CLB_IO_CLK']['alias'] = { |
| 'type': database[prev_tile]['type'], |
| 'start_offset': 2, |
| 'sites': {} |
| } |
| |
| |
| def propagate_IOI_Y9(database, tiles_by_grid): |
| """ |
| There are IOI tiles (X0Y9 and X43Y9) that have the frame address 1 frame |
| higher than the rest, just like for some of the SING tiles. |
| |
| """ |
| ioi_tiles = os.getenv('XRAY_IOI3_TILES') |
| |
| assert ioi_tiles is not None, "XRAY_IOI3_TILES env variable not set" |
| tiles = ioi_tiles.split(" ") |
| |
| for tile in tiles: |
| prev_tile = tiles_by_grid[( |
| database[tile]['grid_x'], database[tile]['grid_y'] - 1)] |
| while database[prev_tile]["type"] != database[tile]["type"]: |
| prev_tile = tiles_by_grid[( |
| database[prev_tile]['grid_x'], |
| database[prev_tile]['grid_y'] - 1)] |
| bits = database[prev_tile]['bits']['CLB_IO_CLK'] |
| database[tile]['bits']['CLB_IO_CLK'] = copy.deepcopy(bits) |
| database[tile]['bits']['CLB_IO_CLK']['words'] = 4 |
| database[tile]['bits']['CLB_IO_CLK']['offset'] = 18 |
| |
| |
| def alias_HCLKs(database): |
| """ Generate HCLK aliases for HCLK_[LR] subsets. |
| |
| There are some HCLK_[LR] tiles that are missing some routing due to |
| obstructions, e.g. PCIE hardblock. These tiles do not have southbound |
| clock routing, but are otherwise the same as HCLK_[LR] tiles. |
| |
| Simply alias their segbits. |
| |
| """ |
| for tile in database: |
| if database[tile]['type'] == "HCLK_L_BOT_UTURN": |
| database[tile]['bits']['CLB_IO_CLK']['alias'] = { |
| "sites": {}, |
| "start_offset": 0, |
| "type": "HCLK_L" |
| } |
| elif database[tile]['type'] == "HCLK_R_BOT_UTURN": |
| database[tile]['bits']['CLB_IO_CLK']['alias'] = { |
| "sites": {}, |
| "start_offset": 0, |
| "type": "HCLK_R" |
| } |
| |
| |
| def run(json_in_fn, json_out_fn, verbose=False): |
| # Load input files |
| database = json.load(open(json_in_fn, "r")) |
| tiles_by_grid = make_tiles_by_grid(database) |
| |
| tile_frames_map = localutil.TileFrames() |
| propagate_INT_lr_bits( |
| database, tiles_by_grid, tile_frames_map, verbose=verbose) |
| propagate_INT_bits_in_column(database, tiles_by_grid, tile_frames_map) |
| propagate_INT_INTERFACE_bits_in_column( |
| database, tiles_by_grid, "GTP_INT_INTERFACE", tile_frames_map) |
| propagate_INT_INTERFACE_bits_in_column( |
| database, tiles_by_grid, "GTX_INT_INTERFACE", tile_frames_map) |
| propagate_INT_INTERFACE_bits_in_column( |
| database, tiles_by_grid, "PCIE_INT_INTERFACE", tile_frames_map) |
| propagate_rebuf(database, tiles_by_grid) |
| propagate_IOB_SING(database, tiles_by_grid) |
| propagate_IOI_SING(database, tiles_by_grid) |
| propagate_IOI_Y9(database, tiles_by_grid) |
| alias_HCLKs(database) |
| |
| # Save |
| xjson.pprint(open(json_out_fn, "w"), database) |
| |
| |
| def main(): |
| import argparse |
| |
| parser = argparse.ArgumentParser( |
| description="Generate tilegrid.json from bitstream deltas") |
| |
| parser.add_argument("--verbose", action="store_true", help="") |
| parser.add_argument( |
| "--json-in", |
| default="tiles_basic.json", |
| help="Input .json without addresses") |
| parser.add_argument( |
| "--json-out", default="tilegrid.json", help="Output JSON") |
| args = parser.parse_args() |
| |
| run(args.json_in, args.json_out, verbose=args.verbose) |
| |
| |
| if __name__ == "__main__": |
| main() |
