| # Copyright 2020 Project U-Ray Authors |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| import re |
| import sys |
| import json |
| |
| tiles = {} |
| site_to_tile = {} |
| tile_to_bits = {} # (frame, bit start, bit size) |
| |
| with open(sys.argv[1], 'r') as tilef: |
| for line in tilef: |
| sl = line.strip().split(",") |
| if len(sl) < 4: |
| continue |
| x = int(sl[0]) |
| y = int(sl[1]) |
| name = sl[2] |
| ttype = sl[3] |
| tiles[(x, y)] = (name + ":" + ttype, ttype, []) |
| for site in sl[4:]: |
| sitename, sitetype = site.split(":") |
| tiles[(x, y)][2].append((sitename, sitetype)) |
| site_to_tile[sitename] = (x, y) |
| |
| ll_line_re = re.compile( |
| r'Bit\s+\d+\s+(0x[0-9A-Fa-f]+)\s+(\d+)\s+SLR\d\s+\d+\s+Block=([A-Za-z0-9_]+).*' |
| ) |
| site_re = re.compile(r'SLICE_X(\d+)Y(\d+)') |
| with open(sys.argv[2], 'r') as llf: |
| for line in llf: |
| m = ll_line_re.match(line) |
| if not m: |
| continue |
| frame = int(m.group(1), 16) |
| bit = int(m.group(2)) |
| start_bit = bit - 2 |
| site = m.group(3) |
| bus = (frame >> 24) & 0x7 |
| half = (frame >> 23) & 0x1 |
| row = (frame >> 18) & 0x1F |
| col = (frame >> 8) & 0x3FF |
| m = frame & 0xFF |
| |
| sm = site_re.match(site) |
| site_x = int(sm.group(1)) |
| site_y = int(sm.group(2)) |
| frame_upper = frame & ~0xFF |
| |
| if site not in site_to_tile: |
| continue |
| tx, ty = site_to_tile[site] |
| tiledata = tiles[tx, ty] |
| tile_to_bits[tiledata[0]] = [] |
| for m in range(16): |
| tile_to_bits[tiledata[0]].append((frame_upper | m, start_bit, 48)) |
| |
| def process_nonlogic(x, y, icol): |
| if (x, y) not in tiles: |
| return |
| itiledata = tiles[x, y] |
| if itiledata[1] == "INT": |
| if (x + 1, y) not in tiles: |
| return |
| |
| int_frame_base = (frame_upper & ~0x3FFFF) | (icol << 8) |
| tile_to_bits[itiledata[0]] = [] |
| for m in range(76): |
| tile_to_bits[itiledata[0]].append((int_frame_base | m, |
| start_bit, 48)) |
| process_clock(x, y - 1, int_frame_base, start_bit + 48, 76) |
| process_cmt(x - 2, y, icol - 2) |
| process_int_intf(x - 1, y, icol - 1) |
| elif itiledata[1] == "BRAM": |
| bram_frame_base = (frame_upper & ~0x3FFFF) | (icol << 8) |
| tile_to_bits[itiledata[0]] = [] |
| for m in range(6): |
| tile_to_bits[itiledata[0]].append((bram_frame_base | m, |
| start_bit, 5 * 48)) |
| process_clock(x, y - 5, bram_frame_base, start_bit + 5 * 48, 6) |
| elif itiledata[1] == "DSP": |
| dsp_frame_base = (frame_upper & ~0x3FFFF) | (icol << 8) |
| tile_to_bits[itiledata[0]] = [] |
| for m in range(8): |
| tile_to_bits[itiledata[0]].append((dsp_frame_base | m, |
| start_bit, 5 * 48)) |
| process_clock(x, y - 5, dsp_frame_base, start_bit + 5 * 48, 8) |
| |
| if (x - 1, y) in tiles and "INT_INTF" in tiles[x - 1, y][1]: |
| process_clock(x - 1, y - 5, dsp_frame_base, |
| start_bit + 5 * 48, 8) |
| |
| def process_clock(cx, cy, frame_base, end_bit, height): |
| if (cx, cy) not in tiles: |
| return |
| if end_bit != (1392 + 48): |
| return |
| ctiledata = tiles[cx, cy] |
| if not ctiledata[1].startswith("RCLK"): |
| return |
| tile_to_bits[ctiledata[0]] = [] |
| for m in range(height): |
| tile_to_bits[ctiledata[0]].append((frame_base | m, |
| end_bit + 48, 48)) |
| |
| def process_cmt(x, y, icol): |
| if (x, y) not in tiles: |
| return |
| ctiledata = tiles[x, y] |
| if not ctiledata[1] in ("CMT_L", "CMT_RIGHT"): |
| return |
| cmt_frame_base = (frame_upper & ~0x3FFFF) | (icol << 8) |
| tile_to_bits[ctiledata[0]] = [] |
| for m in range(12): |
| tile_to_bits[ctiledata[0]].append((cmt_frame_base | m, |
| start_bit, 60 * 48)) |
| |
| def process_int_intf(x, y, icol): |
| if (x, y) not in tiles: |
| return |
| itiledata = tiles[x, y] |
| if not itiledata[1] in ("INT_INTF_L_IO", "INT_INTF_R_IO"): |
| return |
| int_frame_base = (frame_upper & ~0x3FFFF) | (icol << 8) |
| tile_to_bits[itiledata[0]] = [] |
| for m in range(4): |
| tile_to_bits[itiledata[0]].append((int_frame_base | m, |
| start_bit, 48)) |
| |
| process_nonlogic(tx - 1, ty, col - 1) |
| process_nonlogic(tx + 1, ty, col + 1) |
| process_clock(tx, ty - 1, frame_upper, start_bit + 48, 16) |
| # Original JSON |
| with open(sys.argv[3], 'w') as tj: |
| tj.write( |
| json.dumps( |
| tile_to_bits, sort_keys=True, indent=4, separators=(',', ': '))) |
| tj.write("\n") |
| # New simplified text format |
| with open(sys.argv[4], 'w') as tf: |
| for loc, tiledata in sorted(tiles.items()): |
| print( |
| ".tile %s %s %d %d" % (tiledata[0].split(":")[0], tiledata[1], |
| loc[0], loc[1]), |
| file=tf) |
| for site in tiledata[2]: |
| print("site %s %s" % site, file=tf) |
| if tiledata[0] in tile_to_bits: |
| for frame, offset, size in tile_to_bits[tiledata[0]]: |
| print( |
| "frame 0x%08x bits %d +: %d" % (frame, offset, size), |
| file=tf) |
