| """Provide utilites for converting between FASM and icebox representations. |
| |
| FASM represents enabling features from a default "empty" configuration. |
| IceBox documents what each bit does even if should be set by default (unused). |
| |
| Therefore any differences between ice40 parts are hidden from the FASM |
| portion. For example IE, REN, and Ram PowerUp are inverted for 1k parts comparted to |
| all other families. |
| |
| FASM features attempt to maintain the IceStrom nomenclature. |
| Exceptions: |
| - '/' are replaced with '_' as '/' is not valid for FASM feature name |
| - RAM CBITS are combined into READ_MODE and WRITE_MODE FASM features |
| - IO configuration bits are combined into SimpleInput and SimpleOut FASM features |
| """ |
| |
| from io import StringIO |
| import re |
| import unittest |
| import numpy as np |
| |
| import icebox |
| import fasm |
| from ice40_feature import Feature, IceDbEntry, FasmEntry |
| |
| # hardcoded permutation |
| # * https://github.com/YosysHQ/nextpnr/blob/343569105ddf7c97316922774dc4d70d1d4f7c9f/ice40/bitstream.cc#L460-L468 |
| # * https://github.com/cliffordwolf/icestorm/blob/master/icebox/icebox_hlc2asc.py#L925-L936 |
| # * https://github.com/YosysHQ/arachne-pnr/blob/840bdfdeb38809f9f6af4d89dd7b22959b176fdd/src/place.cc#L1573-L1627 |
| LUT_BITS = [4, 14, 15, 5, 6, 16, 17, 7, 3, 13, 12, 2, 1, 11, 10, 0] |
| LUT_CTRL = { |
| "CarryEnable": 8, |
| "DffEnable": 9, |
| "Set_NoReset": 18, |
| "AsyncSetReset": 19 |
| } |
| |
| |
| def _nibbles_to_bits(line): |
| """Convert from icebox hex string for ramdata in asc files to an array of Bool""" |
| |
| res = [] |
| for ch in line: |
| res += [xx == "1" for xx in "{:4b}".format(int(ch, 16))] |
| res.reverse() |
| return res |
| |
| |
| def _bits_to_nibbles(arr): |
| """Convert from array of Bool to icebox hex string used for ramdata in asc files""" |
| |
| res = [] |
| for ii in range(0, len(arr), 4): |
| nibble_val = sum( |
| (1 << ii) for ii, xx in enumerate(arr[ii:ii + 4]) if xx |
| ) |
| res += "{:x}".format(nibble_val) |
| res.reverse() |
| return "".join(res) |
| |
| |
| def _tile_to_array(tile, is_hex=False): |
| """Convert text icedb tile to a numpy array""" |
| |
| if is_hex: |
| array = np.array([_nibbles_to_bits(line) for line in tile], dtype=bool) |
| else: |
| array = np.array( |
| [[int(xx) for xx in line] for line in tile], dtype=bool |
| ) |
| return array |
| |
| |
| def _array_to_tile(tile_bits, tile, is_hex=False): |
| """Convert a numpy array to text icedb tile |
| |
| Modifies tile in place to simplify updating of iceconfig |
| """ |
| if is_hex: |
| for ii, xx in enumerate(tile_bits): |
| tile[ii] = _bits_to_nibbles(xx) |
| else: |
| for ii, xx in enumerate(tile_bits): |
| tile[ii] = tile_bits.shape[1] * "%d" % tuple(xx) |
| |
| |
| def _lut_to_lc(lut, ctrl): |
| """Convert lut and ctrl dict to permuted lc bits""" |
| |
| res = 20 * [lut[0]] |
| for ii, bit in enumerate(LUT_BITS): |
| res[bit] = lut[ii] |
| for k, v in ctrl.items(): |
| res[LUT_CTRL[k]] = v |
| return res |
| |
| |
| def _lc_to_lut(lc): |
| """Convert from lc bits to unpermuted lut table and control dict""" |
| |
| lut = [lc[val] for val in LUT_BITS] |
| ctrl = {k: lc[v] for k, v in LUT_CTRL.items()} |
| return lut, ctrl |
| |
| |
| def _get_feature_bits(tile, cond): |
| """Get bitmask and values for the tile from an icebox db entry""" |
| |
| bm = np.zeros(tile.shape, dtype=bool) |
| bp = np.zeros(tile.shape, dtype=bool) |
| for ii in cond: |
| neg, x, y = ii |
| bm[x][y] = True |
| bp[x][y] = neg != "!" |
| return bm, bp |
| |
| |
| def _set_feature_bits(ic, loc, bits): |
| """Set bits for a specifc location in an iceconfig""" |
| |
| tile = ic.tile(*loc) |
| tile_bits = _tile_to_array(tile) |
| bm, bv = _get_feature_bits(tile_bits, bits) |
| tile_bits[bm] = bv[bm] |
| _array_to_tile(tile_bits, tile) |
| |
| |
| def _get_iceconfig_bits(tile, cond): |
| """Get bitmask and values for the tile from an icebox db entry""" |
| |
| bm = np.zeros(tile.shape, dtype=bool) |
| bp = np.zeros(tile.shape, dtype=bool) |
| for ii in cond: |
| mm = re.match(r"([\!]?)B([0-9]+)\[([0-9]*)\]", ii) |
| neg = mm.group(1) |
| inds = [int(mm.group(ii)) for ii in range(2, 4)] |
| bm[inds[0]][inds[1]] = 1 |
| bp[inds[0]][inds[1]] = neg != "!" |
| return bm, bp |
| |
| |
| def _check_iceconfig_entry(tile, entry): |
| """Check an entry is set for a tile""" |
| |
| bm, bp = _get_iceconfig_bits(tile, entry[0]) |
| return np.all(bp[bm] == tile[bm]) |
| |
| |
| def _inv_bit_tuple(bit_tuple): |
| if bit_tuple[0] == "": |
| neg = "!" |
| else: |
| neg = "" |
| return tuple(neg) + bit_tuple[1:] |
| |
| |
| class FeatureAccumulator(dict): |
| """Class to help accumulate iCE40 features for output as FASM file or a FASM DB""" |
| |
| def append_feature(self, feature): |
| self[feature.to_fasm_entry().feature] = feature |
| |
| def append_ice_entry( |
| self, tile_type, tile_loc, bits, names, idx, negate=False |
| ): |
| |
| if negate: |
| feature = Feature.from_icedb_entry( |
| IceDbEntry(tile_type, tile_loc, bits, names, idx) |
| ) |
| feature.bit_tuples = [ |
| _inv_bit_tuple(bt) for bt in feature.bit_tuples |
| ] |
| else: |
| feature = Feature.from_icedb_entry( |
| IceDbEntry(tile_type, tile_loc, bits, names, idx) |
| ) |
| |
| self.append_feature(feature) |
| return feature |
| |
| def as_fasm_db(self, outf=StringIO()): |
| for key in sorted(self.keys()): |
| entry = self[key].to_fasm_entry() |
| print( |
| "{} {}".format(entry.feature, " ".join(entry.bits)), file=outf |
| ) |
| return outf |
| |
| def as_fasm(self, outf=StringIO()): |
| for key in sorted(self.keys()): |
| print(key, file=outf) |
| return outf |
| |
| |
| def read_ice_db(ic): |
| """Read icebox database from iceconfig and construct a dictionary of features""" |
| |
| # TODO: undo Hack to invert some specific signals |
| device_1k = ic.device == "1k" |
| |
| accum = FeatureAccumulator() |
| locs = [(x, y) for x in range(ic.max_x + 1) for y in range(ic.max_y + 1)] |
| |
| for tile_loc in locs: |
| if ic.tile(*tile_loc) is None: |
| continue |
| tile_type = ic.tile_type(*tile_loc) |
| |
| for entry in ic.tile_db(*tile_loc): |
| if entry[1].startswith("LC_"): |
| |
| lut, ctrl = _lc_to_lut(entry[0]) |
| for ii, bit in enumerate(lut): |
| names = entry[1:] + ["INIT"] |
| accum.append_ice_entry( |
| tile_type, tile_loc, [bit], names, ii |
| ) |
| |
| for name, bit in ctrl.items(): |
| names = entry[1:] + [name] |
| accum.append_ice_entry( |
| tile_type, tile_loc, [bit], names, None |
| ) |
| |
| # entries to generate the negated case |
| elif ( |
| tile_type == "IO" and device_1k and |
| (entry[-1].startswith("IE_") or entry[-1].startswith("REN_"))): |
| accum.append_ice_entry( |
| tile_type, |
| tile_loc, |
| entry[0], |
| entry[1:], |
| None, |
| negate=True |
| ) |
| elif device_1k and tile_type == "RAMB" and entry[-1] == "PowerUp": |
| accum.append_ice_entry( |
| tile_type, |
| tile_loc, |
| entry[0], |
| entry[1:], |
| None, |
| negate=True |
| ) |
| elif tile_type == "RAMT" and entry[-1].startswith("CBIT"): |
| matches = re.match(r"CBIT_([0-9]+)", entry[-1]) |
| assert matches is not None, "Expected 'CBIT_n' received {}".format( |
| entry[-1] |
| ) |
| |
| cbit_offset = matches.group(1) |
| cbit_translation = { |
| "0": ("WRITE_MODE", 0), |
| "1": ("WRITE_MODE", 1), |
| "2": ("READ_MODE", 0), |
| "3": ("READ_MODE", 1), |
| } |
| val = cbit_translation.get(cbit_offset) |
| if val is not None: |
| ramb_tile_loc = (tile_loc[0], tile_loc[1] - 1) |
| accum.append_ice_entry( |
| "RAMB", ramb_tile_loc, entry[0], [val[0]], val[1] |
| ) |
| else: |
| accum.append_ice_entry( |
| tile_type, tile_loc, entry[0], entry[1:], None |
| ) |
| else: |
| accum.append_ice_entry( |
| tile_type, tile_loc, entry[0], entry[1:], None |
| ) |
| |
| # add RAM data entries features |
| tile_type = "RAMB" |
| for ram_loc in ic.ramb_tiles: |
| for i in range(16): |
| feature_name = "INIT{:X}".format(i) |
| for j in range(256): |
| bit = "B{}[{}]".format(i, j) |
| accum.append_ice_entry( |
| tile_type, ram_loc, [bit], [feature_name], j |
| ) |
| |
| # TODO: extra bits? |
| |
| return accum |
| |
| |
| def _iceboxdb_to_fasmdb(ic, outf=StringIO()): |
| """Read in an icebox config and output the exhaustive list of bits with fasm compatible names |
| |
| expand RAM and LUT INIT bits |
| """ |
| |
| fasmdb = read_ice_db(ic) |
| return fasmdb.as_fasm_db(outf) |
| |
| |
| def generate_fasm_db(outf, device): |
| """Generate FASM style DB for a ice40 device""" |
| |
| ic = icebox.iceconfig() |
| init_method_name = "setup_empty_{}".format(device.lower()[2:]) |
| assert hasattr( |
| ic, init_method_name |
| ), "no icebox method to init empty device" |
| getattr(ic, init_method_name)() |
| |
| return _iceboxdb_to_fasmdb(ic, outf) |
| |
| |
| def asc_to_fasm(filename, outf=StringIO()): |
| """Generate a fasm output from an asc""" |
| |
| ic = icebox.iceconfig() |
| ic.read_file(filename) |
| |
| return iceconfig_to_fasm(ic, outf) |
| |
| |
| def iceconfig_to_fasm(ic, outf=StringIO()): |
| """Read iceconfig and generate FASM features. |
| |
| Useful for generating FASM from ASC file. |
| """ |
| |
| # TODO: undo Hack to invert some specific signals |
| device_1k = ic.device == "1k" |
| |
| accum = FeatureAccumulator() |
| |
| locs = [(x, y) for x in range(ic.max_x + 1) for y in range(ic.max_y + 1)] |
| for tile_loc in locs: |
| bits = ic.tile(*tile_loc) |
| if bits is None: |
| continue |
| tile_bits = _tile_to_array(bits) |
| tile_type = ic.tile_type(*tile_loc) |
| |
| for entry in ic.tile_db(*tile_loc): |
| # LC_ entries are treated differently as it's not a match, but a pattern |
| if entry[1].startswith("LC_"): |
| bm, _ = _get_iceconfig_bits(tile_bits, entry[0]) |
| bits = tile_bits[bm] |
| if np.any(bits): |
| lut, ctrl = _lc_to_lut(bits) |
| for ii, bit in enumerate(lut): |
| if bit: |
| names = entry[1:] + ["INIT"] |
| accum.append_ice_entry( |
| tile_type, tile_loc, [], names, ii |
| ) |
| |
| for name, bit in ctrl.items(): |
| if bit: |
| names = entry[1:] + [name] |
| accum.append_ice_entry( |
| tile_type, tile_loc, [], names, None |
| ) |
| |
| elif ( |
| tile_type == "IO" and device_1k and |
| (entry[-1].startswith("IE_") or entry[-1].startswith("REN_"))): |
| accum.append_ice_entry( |
| tile_type, |
| tile_loc, |
| entry[0], |
| entry[1:], |
| None, |
| negate=True |
| ) |
| elif device_1k and tile_type == "RAMB" and entry[-1] == "PowerUp": |
| accum.append_ice_entry( |
| tile_type, |
| tile_loc, |
| entry[0], |
| entry[1:], |
| None, |
| negate=True |
| ) |
| elif tile_type == "RAMT" and entry[-1].startswith("CBIT"): |
| matches = re.match(r"CBIT_([0-9]+)", entry[-1]) |
| assert matches is not None, "Expected 'CBIT_n' received {}".format( |
| entry[-1] |
| ) |
| |
| cbit_offset = matches.group(1) |
| cbit_translation = { |
| "0": ("WRITE_MODE", 0), |
| "1": ("WRITE_MODE", 1), |
| "2": ("READ_MODE", 0), |
| "3": ("READ_MODE", 1), |
| } |
| val = cbit_translation.get(cbit_offset) |
| if val is not None: |
| ramb_tile_loc = (tile_loc[0], tile_loc[1] - 1) |
| accum.append_ice_entry( |
| "RAMB", ramb_tile_loc, entry[0], [val[0]], val[1] |
| ) |
| else: |
| accum.append_ice_entry( |
| tile_type, tile_loc, entry[0], entry[1:], None |
| ) |
| |
| else: |
| if _check_iceconfig_entry(tile_bits, entry): |
| accum.append_ice_entry( |
| tile_type, tile_loc, entry[0], entry[1:], None |
| ) |
| |
| # ram data |
| for tile_loc, hexd in ic.ram_data.items(): |
| tile_bits = _tile_to_array(hexd, is_hex=True) |
| tile_type = "RAMB" |
| |
| for x, y in zip(*np.where(tile_bits)): |
| feature_name = "INIT{:X}".format(x) |
| bit = "B{}[{}]".format(x, y) |
| entry = [[bit], feature_name] |
| feature = Feature.from_icedb_entry( |
| IceDbEntry(tile_type, tile_loc, entry[0], entry[1:], y) |
| ) |
| print(feature.to_fasm_entry().feature, file=outf) |
| |
| # TODO: extra_bits |
| |
| return accum.as_fasm(outf) |
| |
| |
| def fasm_to_asc(in_fasm, outf, device): |
| """Convert an FASM input to an ASC file |
| |
| Set input enable defaults, RAM powerup, and enables all ColBufCtrl (until modeled in VPR see: #464) |
| """ |
| |
| ic = icebox.iceconfig() |
| |
| init_method_name = "setup_empty_{}".format(device.lower()[2:]) |
| assert hasattr( |
| ic, init_method_name |
| ), "no icebox method to init empty device" |
| getattr(ic, init_method_name)() |
| |
| device_1k = ic.device == "1k" |
| |
| fasmdb = read_ice_db(ic) |
| # TODO: upstream init "default" bitstream |
| locs = [(x, y) for x in range(ic.max_x + 1) for y in range(ic.max_y + 1)] |
| for tile_loc in locs: |
| tile = ic.tile(*tile_loc) |
| if tile is None: |
| continue |
| db = ic.tile_db(*tile_loc) |
| tile_type = ic.tile_type(*tile_loc) |
| for entry in db: |
| if (device_1k and |
| ((tile_type == "IO" and entry[-1] in ["IE_0", "IE_1"]) or |
| (tile_type == "RAMB" and entry[-1] == "PowerUp")) |
| or (entry[-2] == "ColBufCtrl")): |
| tile_bits = _tile_to_array(tile) |
| tile_type = ic.tile_type(*tile_loc) |
| bm, bv = _get_iceconfig_bits(tile_bits, entry[0]) |
| tile_bits[bm] = bv[bm] |
| _array_to_tile(tile_bits, tile) |
| |
| missing_features = [] |
| for line in fasm.parse_fasm_string(in_fasm.read()): |
| if not line.set_feature: |
| continue |
| |
| line_strs = tuple(fasm.fasm_line_to_string(line)) |
| assert len(line_strs) == 1 |
| |
| feature = Feature.from_fasm_entry( |
| FasmEntry(line.set_feature.feature, []) |
| ) |
| |
| def find_ieren(ic, loc, iob): |
| tmap = [ |
| xx[3:] |
| for xx in ic.ieren_db() |
| if xx[:3] == (tuple(loc) + (iob, )) |
| ] |
| assert len(tmap) < 2, "expected 1 IEREN_DB entry found {}".format( |
| len(tmap) |
| ) |
| |
| if len(tmap) == 0: |
| print("no ieren found for {}".format((tile_loc + (iob, )))) |
| return |
| return tmap[0] |
| |
| # fix up for IO |
| if feature.parts[-1] == "SimpleInput": |
| iob = int(feature.parts[-2][-1]) |
| new_ieren = find_ieren(ic, feature.loc, iob) |
| |
| feature.parts[-1] = "PINTYPE_0" |
| db_entry = fasmdb[feature.to_fasm_entry().feature] |
| _set_feature_bits(ic, db_entry.loc, db_entry.bit_tuples) |
| |
| feature.loc = new_ieren[:2] |
| feature.parts[-2] = "IoCtrl" |
| feature.parts[-1] = "IE_{}".format(new_ieren[2]) |
| db_entry = fasmdb[feature.to_fasm_entry().feature] |
| _set_feature_bits(ic, db_entry.loc, db_entry.bit_tuples) |
| feature.parts[-1] = "REN_{}".format(new_ieren[2]) |
| db_entry = fasmdb[feature.to_fasm_entry().feature] |
| _set_feature_bits(ic, db_entry.loc, db_entry.bit_tuples) |
| continue |
| |
| if feature.parts[-1] == "SimpleOutput": |
| iob = int(feature.parts[-2][-1]) |
| new_ieren = find_ieren(ic, feature.loc, iob) |
| |
| feature.parts[-1] = "PINTYPE_3" |
| db_entry = fasmdb[feature.to_fasm_entry().feature] |
| _set_feature_bits(ic, db_entry.loc, db_entry.bit_tuples) |
| feature.parts[-1] = "PINTYPE_4" |
| db_entry = fasmdb[feature.to_fasm_entry().feature] |
| _set_feature_bits(ic, db_entry.loc, db_entry.bit_tuples) |
| |
| feature.loc = new_ieren[:2] |
| feature.parts[-2] = "IoCtrl" |
| feature.parts[-1] = "REN_{}".format(new_ieren[2]) |
| db_entry = fasmdb[feature.to_fasm_entry().feature] |
| _set_feature_bits(ic, db_entry.loc, db_entry.bit_tuples) |
| continue |
| |
| ## special case for RAM INIT values |
| tile_type, loc = feature.tile_type, feature.loc |
| if tile_type == "RAMB" and feature.parts[-1].startswith("INIT"): |
| tloc = tuple(loc) |
| if tloc not in ic.ram_data: |
| ic.ram_data[tloc] = [64 * "0" for _ in range(16)] |
| tile = ic.ram_data[tloc] |
| tile_bits = _tile_to_array(tile, is_hex=True) |
| elif tile_type == "RAMB" and feature.parts[-1].endswith("_MODE"): |
| # hack to force modes to the RAMT |
| tile = ic.tile(loc[0], loc[1] + 1) |
| tile_bits = _tile_to_array(tile) |
| else: |
| tile = ic.tile(*loc) |
| tile_bits = _tile_to_array(tile) |
| |
| # lookup feature and convert |
| for canonical_feature in fasm.canonical_features(line.set_feature): |
| key = fasm.set_feature_to_str(canonical_feature) |
| feature = fasmdb[key] |
| bm, bv = _get_feature_bits(tile_bits, feature.bit_tuples) |
| |
| tile_bits[bm] = bv[bm] |
| |
| if tile_type == "RAMB" and feature.parts[-1].startswith("INIT"): |
| _array_to_tile(tile_bits, tile, is_hex=True) |
| else: |
| _array_to_tile(tile_bits, tile) |
| |
| # TODO: would be nice to upstream a way to write to non-files |
| ic.write_file(outf.name) |
| |
| |
| if __name__ == "__main__": |
| import argparse |
| import sys |
| |
| parser = argparse.ArgumentParser(description="Dump FASM DB from icebox") |
| parser.add_argument("device", help="Device type (eg lp1k, hx8k)") |
| parser.add_argument( |
| "--output", |
| help="Output file", |
| type=argparse.FileType("w"), |
| default=sys.stdout |
| ) |
| args = parser.parse_args() |
| |
| generate_fasm_db(args.output, args.device) |
