| 1 |
import json |
| 2 |
import os |
| 3 |
import re |
| 4 |
from enum import Enum |
| 5 |
from tileconn import apply_tileconn |
| 6 |
from parse_sdf import parse_sdf_file |
| 7 |
from dataclasses import dataclass |
| 8 |
from typing import Optional |
| 9 |
# Represents Xilinx device data from PrjXray etc |
| 10 |
|
| 11 |
@dataclass |
| 12 |
class WireData: |
| 13 |
index: int |
| 14 |
name: str |
| 15 |
intent: str = "" |
| 16 |
tied_value: Optional[int] = None |
| 17 |
resistance: float = 0 |
| 18 |
capacitance: float = 0 |
| 19 |
|
| 20 |
@dataclass |
| 21 |
class PIPData: |
| 22 |
index: int |
| 23 |
from_wire: int |
| 24 |
to_wire: int |
| 25 |
is_bidi: bool = False |
| 26 |
is_route_thru: bool = False |
| 27 |
is_buffered: bool = False |
| 28 |
min_delay: float = 0 |
| 29 |
max_delay: float = 0 |
| 30 |
resistance: float = 0 |
| 31 |
capacitance: float = 0 |
| 32 |
|
| 33 |
@dataclass |
| 34 |
class SiteWireData: |
| 35 |
name: str |
| 36 |
is_pin: bool = False |
| 37 |
|
| 38 |
@dataclass |
| 39 |
class SiteBELPinData: |
| 40 |
name: str |
| 41 |
pindir: str |
| 42 |
site_wire_idx: int |
| 43 |
|
| 44 |
@dataclass |
| 45 |
class SiteBELData: |
| 46 |
name: str |
| 47 |
bel_type: str |
| 48 |
bel_class: str |
| 49 |
pins: list[SiteBELPinData] |
| 50 |
|
| 51 |
@dataclass |
| 52 |
class SitePIPData: |
| 53 |
bel_idx: int |
| 54 |
bel_input: str |
| 55 |
from_wire_idx: int |
| 56 |
to_wire_idx: int |
| 57 |
|
| 58 |
@dataclass |
| 59 |
class SitePinData: |
| 60 |
name: str |
| 61 |
pindir: str |
| 62 |
site_wire_idx: int |
| 63 |
prim_pin_name: str |
| 64 |
|
| 65 |
class SiteData: |
| 66 |
def __init__(self, site_type): |
| 67 |
self.site_type = site_type |
| 68 |
self.wires = [] |
| 69 |
self.bels = [] |
| 70 |
self.pips = [] |
| 71 |
self.pins = [] |
| 72 |
self.variants = {} |
| 73 |
|
| 74 |
class TileSitePinData: |
| 75 |
def __init__(self, wire_idx): |
| 76 |
self.wire_idx = wire_idx |
| 77 |
self.min_delay = 0 |
| 78 |
self.max_delay = 0 |
| 79 |
self.resistance = 0 |
| 80 |
self.capacitance = 0 |
| 81 |
|
| 82 |
class TileData: |
| 83 |
def __init__(self, tile_type): |
| 84 |
self.tile_type = tile_type |
| 85 |
self.wires = [] |
| 86 |
self.wires_by_name = {} |
| 87 |
self.pips = [] |
| 88 |
self.sitepin_data = {} # (type, relxy, pin) -> TileSitePinData |
| 89 |
self.cell_timing = None |
| 90 |
|
| 91 |
class PIP: |
| 92 |
def __init__(self, tile, index): |
| 93 |
self.tile = tile |
| 94 |
self.index = index |
| 95 |
self.data = tile.get_pip_data(index) |
| 96 |
def src_wire(self): |
| 97 |
return Wire(self.tile, self.data.from_wire) |
| 98 |
def dst_wire(self): |
| 99 |
return Wire(self.tile, self.data.to_wire) |
| 100 |
def is_route_thru(self): |
| 101 |
return self.data.is_route_thru |
| 102 |
def is_bidi(self): |
| 103 |
return self.data.is_bidi |
| 104 |
def is_buffered(self): |
| 105 |
return self.data.is_buffered |
| 106 |
def min_delay(self): |
| 107 |
return self.data.min_delay |
| 108 |
def max_delay(self): |
| 109 |
return self.data.max_delay |
| 110 |
def resistance(self): |
| 111 |
return self.data.resistance |
| 112 |
def capacitance(self): |
| 113 |
return self.data.capacitance |
| 114 |
|
| 115 |
class Wire: |
| 116 |
def __init__(self, tile, index): |
| 117 |
self.tile = tile |
| 118 |
self.index = index |
| 119 |
self.data = tile.get_wire_data(index) |
| 120 |
def name(self): |
| 121 |
return self.data.name |
| 122 |
def intent(self): |
| 123 |
return self.data.intent |
| 124 |
def node(self): |
| 125 |
if self.index not in self.tile.wire_to_node: |
| 126 |
self.tile.wire_to_node[self.index] = Node(self.tile, [self]) |
| 127 |
return self.tile.wire_to_node[self.index] |
| 128 |
def is_gnd(self): |
| 129 |
return "GND_WIRE" in self.name() |
| 130 |
def is_vcc(self): |
| 131 |
return "VCC_WIRE" in self.name() |
| 132 |
def resistance(self): |
| 133 |
return self.data.resistance |
| 134 |
def capacitance(self): |
| 135 |
return self.data.capacitance |
| 136 |
|
| 137 |
class SiteWire: |
| 138 |
def __init__(self, site, index): |
| 139 |
self.site = site |
| 140 |
self.index = index |
| 141 |
self.data = self.site.get_wire_data(index) |
| 142 |
def name(self): |
| 143 |
return self.data.name |
| 144 |
|
| 145 |
class SiteBELPin: |
| 146 |
def __init__(self, bel, name): |
| 147 |
self.bel = bel |
| 148 |
self.name = name |
| 149 |
self.data = self.bel.data.pins[name] |
| 150 |
def name(self): |
| 151 |
return self.name |
| 152 |
def dir(self): |
| 153 |
return self.data.pindir |
| 154 |
def site_wire(self): |
| 155 |
return SiteWire(self.bel.site, self.data.site_wire_idx) |
| 156 |
|
| 157 |
class SiteBEL: |
| 158 |
def __init__(self, site, index): |
| 159 |
self.site = site |
| 160 |
self.index = index |
| 161 |
self.data = site.get_bel_data(index) |
| 162 |
def name(self): |
| 163 |
return self.data.name |
| 164 |
def bel_type(self): |
| 165 |
return self.data.bel_type |
| 166 |
def bel_class(self): |
| 167 |
return self.data.bel_class |
| 168 |
def pins(self): |
| 169 |
return (SiteBELPin(self, n) for n in self.data.pins.keys()) |
| 170 |
|
| 171 |
class SitePIP: |
| 172 |
def __init__(self, site, index): |
| 173 |
self.site = site |
| 174 |
self.index = index |
| 175 |
self.data = site.get_pip_data(index) |
| 176 |
def bel(self): |
| 177 |
return SiteBEL(self.site, self.data.bel_idx) |
| 178 |
def bel_input(self): |
| 179 |
return self.data.bel_input |
| 180 |
def src_wire(self): |
| 181 |
return SiteWire(self.site, self.data.from_wire_idx) |
| 182 |
def dst_wire(self): |
| 183 |
return SiteWire(self.site, self.data.to_wire_idx) |
| 184 |
|
| 185 |
class SitePin: |
| 186 |
def __init__(self, site, index): |
| 187 |
self.site = site |
| 188 |
self.index = index |
| 189 |
self.data = site.data.pins[index] |
| 190 |
def name(self): |
| 191 |
return self.data.name |
| 192 |
def dir(self): |
| 193 |
return self.data.pindir |
| 194 |
def site_wire(self): |
| 195 |
return SiteWire(self.site, self.data.site_wire_idx) |
| 196 |
def tile_wire(self): |
| 197 |
return self.site.tile.site_pin_wire(self.site.primary.site_type(), self.site.rel_xy(), self.data.prim_pin_name) |
| 198 |
def min_delay(self): |
| 199 |
return self.site.tile.site_pin_timing(self.site.primary.site_type(), self.site.rel_xy(), self.data.prim_pin_name).min_delay |
| 200 |
def max_delay(self): |
| 201 |
return self.site.tile.site_pin_timing(self.site.primary.site_type(), self.site.rel_xy(), self.data.prim_pin_name).max_delay |
| 202 |
def resistance(self): |
| 203 |
return self.site.tile.site_pin_timing(self.site.primary.site_type(), self.site.rel_xy(), self.data.prim_pin_name).resistance |
| 204 |
def capacitance(self): |
| 205 |
return self.site.tile.site_pin_timing(self.site.primary.site_type(), self.site.rel_xy(), self.data.prim_pin_name).capacitance |
| 206 |
|
| 207 |
class Site: |
| 208 |
def __init__(self, tile, name, index, grid_xy, data, primary=None): |
| 209 |
self.tile = tile |
| 210 |
self.name = name |
| 211 |
self.index = index |
| 212 |
self.prefix = name[0:name.rfind('_')] |
| 213 |
self.grid_xy = grid_xy |
| 214 |
self.data = data |
| 215 |
self.primary = primary if primary is not None else self |
| 216 |
self._rel_xy = None # filled later |
| 217 |
self._variants = None #filled later |
| 218 |
def get_bel_data(self, index): |
| 219 |
return self.data.bels[index] |
| 220 |
def get_wire_data(self, index): |
| 221 |
return self.data.wires[index] |
| 222 |
def get_pip_data(self, index): |
| 223 |
return self.data.pips[index] |
| 224 |
def site_type(self): |
| 225 |
return self.data.site_type |
| 226 |
def rel_xy(self): |
| 227 |
if self._rel_xy is None: |
| 228 |
base_x = 999999 |
| 229 |
base_y = 999999 |
| 230 |
for site in self.tile.sites(): |
| 231 |
if site.prefix != self.prefix: |
| 232 |
continue |
| 233 |
base_x = min(base_x, site.grid_xy[0]) |
| 234 |
base_y = min(base_y, site.grid_xy[1]) |
| 235 |
self._rel_xy = (self.grid_xy[0] - base_x, self.grid_xy[1] - base_y) |
| 236 |
return self._rel_xy |
| 237 |
def bels(self): |
| 238 |
return (SiteBEL(self, i) for i in range(len(self.data.bels))) |
| 239 |
def wires(self): |
| 240 |
return (SiteWire(self, i) for i in range(len(self.data.wires))) |
| 241 |
def pips(self): |
| 242 |
return (SitePIP(self, i) for i in range(len(self.data.pips))) |
| 243 |
def pins(self): |
| 244 |
return (SitePin(self, i) for i in range(len(self.data.pins))) |
| 245 |
def pin(self, p): |
| 246 |
for i in range(len(self.data.pins)): |
| 247 |
if self.data.pins[i].name == p: |
| 248 |
return SitePin(self, i) |
| 249 |
return None |
| 250 |
def available_variants(self): |
| 251 |
# Make sure primary type is first |
| 252 |
if self._variants is None: |
| 253 |
self._variants = [] |
| 254 |
self._variants.append(self.site_type()) |
| 255 |
for var in sorted(self.data.variants.keys()): |
| 256 |
if var != self.site_type(): |
| 257 |
self._variants.append(var) |
| 258 |
return self._variants |
| 259 |
def variant(self, vtype): |
| 260 |
vsite = Site(self.tile, self.name, self.index, self.grid_xy, self.data.variants[vtype], self) |
| 261 |
return vsite |
| 262 |
def rel_name(self): |
| 263 |
x, y = self.rel_xy() |
| 264 |
return f"{self.prefix}_X{x}Y{y}" |
| 265 |
|
| 266 |
class Tile: |
| 267 |
def __init__(self, x, y, name, data, interconn_xy, site_insts): |
| 268 |
self.x = x |
| 269 |
self.y = y |
| 270 |
self.name = name |
| 271 |
self.data = data |
| 272 |
self.interconn_xy = interconn_xy |
| 273 |
self.site_insts = site_insts |
| 274 |
self.wire_to_node = {} |
| 275 |
self.node_autoidx = 0 |
| 276 |
self.used_wires = None |
| 277 |
def get_pip_data(self, i): |
| 278 |
return self.data.pips[i] |
| 279 |
def get_wire_data(self, i): |
| 280 |
return self.data.wires[i] |
| 281 |
def tile_type(self): |
| 282 |
return self.data.tile_type |
| 283 |
def wires(self): |
| 284 |
return (Wire(self, i) for i in range(len(self.data.wires))) |
| 285 |
def wire(self, name): |
| 286 |
return Wire(self, self.data.wires_by_name[name].index) |
| 287 |
def pips(self): |
| 288 |
return (PIP(self, i) for i in range(len(self.data.pips))) |
| 289 |
def sites(self): |
| 290 |
return self.site_insts |
| 291 |
def site_pin_wire(self, sitetype, rel_xy, pin): |
| 292 |
wire_idx = self.data.sitepin_data[(sitetype, rel_xy, pin)].wire_idx |
| 293 |
return Wire(self, wire_idx) if wire_idx is not None else None |
| 294 |
def site_pin_timing(self, sitetype, rel_xy, pin): |
| 295 |
return self.data.sitepin_data[(sitetype, rel_xy, pin)] |
| 296 |
def cell_timing(self): |
| 297 |
return self.data.cell_timing |
| 298 |
def used_wire_indices(self): |
| 299 |
if self.used_wires is None: |
| 300 |
self.used_wires = set() |
| 301 |
for pip in self.pips(): |
| 302 |
self.used_wires.add(pip.src_wire().index) |
| 303 |
self.used_wires.add(pip.dst_wire().index) |
| 304 |
for site in self.sites(): |
| 305 |
for v in site.available_variants(): |
| 306 |
variant = site.variant(v) |
| 307 |
for pin in variant.pins(): |
| 308 |
if pin.tile_wire() is not None: |
| 309 |
self.used_wires.add(pin.tile_wire().index) |
| 310 |
return self.used_wires |
| 311 |
def split_name(self): |
| 312 |
prefix, xy = self.name.rsplit("_", 1) |
| 313 |
xy_m = re.match(r"X(\d+)Y(\d+)", xy) |
| 314 |
return prefix, int(xy_m.group(1)), int(xy_m.group(2)) |
| 315 |
|
| 316 |
class Node: |
| 317 |
def __init__(self, tile, wires=[]): |
| 318 |
self.tile = tile |
| 319 |
self.index = tile.node_autoidx |
| 320 |
tile.node_autoidx += 1 |
| 321 |
self.wires = wires |
| 322 |
def unique_index(self): |
| 323 |
return (self.tile.y << 48) | (self.tile.x << 32) | self.index |
| 324 |
def is_vcc(self): |
| 325 |
for wire in self.wires: |
| 326 |
if wire.is_vcc(): |
| 327 |
return True |
| 328 |
return False |
| 329 |
def is_gnd(self): |
| 330 |
for wire in self.wires: |
| 331 |
if wire.is_gnd(): |
| 332 |
return True |
| 333 |
return False |
| 334 |
|
| 335 |
class Package: |
| 336 |
def __init__(self, name): |
| 337 |
self.name = name |
| 338 |
self.pin_map = {} |
| 339 |
|
| 340 |
class Device: |
| 341 |
def __init__(self, name): |
| 342 |
self.name = name |
| 343 |
self.tiles = [] |
| 344 |
self.tiles_by_name = {} |
| 345 |
self.tiles_by_xy = {} |
| 346 |
self.sites_by_name = {} |
| 347 |
self.width = 0 |
| 348 |
self.height = 0 |
| 349 |
self.packages = {} |
| 350 |
def tile(self, name): |
| 351 |
return self.tiles_by_name[name] |
| 352 |
def site(self, name): |
| 353 |
return self.sites_by_name[name] |
| 354 |
|
| 355 |
def import_device(fabricname, prjxray_root, metadata_root): |
| 356 |
site_type_cache = {} |
| 357 |
tile_type_cache = {} |
| 358 |
tile_json_cache = {} |
| 359 |
def parse_xy(xy): |
| 360 |
xpos = xy.rfind("X") |
| 361 |
ypos = xy.rfind("Y") |
| 362 |
return int(xy[xpos+1:ypos]), int(xy[ypos+1:]) |
| 363 |
|
| 364 |
def get_site_type_data(sitetype): |
| 365 |
if sitetype not in site_type_cache: |
| 366 |
sd = SiteData(sitetype) |
| 367 |
sp = metadata_root + "/site_type_" + sitetype + ".json" |
| 368 |
if os.path.exists(sp): |
| 369 |
with open(sp, "r") as jf: |
| 370 |
sj = json.load(jf) |
| 371 |
for vtype, vdata in sorted(sj.items()): # Consider all site variants |
| 372 |
if vtype == sitetype: |
| 373 |
vd = sd # primary variant |
| 374 |
else: |
| 375 |
vd = SiteData(vtype) |
| 376 |
site_wire_by_name = {} |
| 377 |
def wire_index(name): |
| 378 |
if name not in site_wire_by_name: |
| 379 |
idx = len(vd.wires) |
| 380 |
vd.wires.append(SiteWireData(name=name)) |
| 381 |
site_wire_by_name[name] = idx |
| 382 |
return site_wire_by_name[name] |
| 383 |
# Import bels |
| 384 |
bel_idx_by_name = {} |
| 385 |
for bel, beldata in sorted(vdata["bels"].items()): |
| 386 |
belpins = {} |
| 387 |
for pin, pindata in sorted(beldata["pins"].items()): |
| 388 |
belpins[pin] = SiteBELPinData(name=pin, pindir=pindata["dir"], site_wire_idx=wire_index(pindata["wire"])) |
| 389 |
bd = SiteBELData(name=bel, bel_type=beldata["type"], bel_class=beldata["class"], pins=belpins) |
| 390 |
bel_idx_by_name[bel] = len(vd.bels) |
| 391 |
vd.bels.append(bd) |
| 392 |
# Import pips |
| 393 |
for pipdata in vdata["pips"]: |
| 394 |
bel_idx = bel_idx_by_name[pipdata["bel"]] |
| 395 |
bel_data = vd.bels[bel_idx] |
| 396 |
vd.pips.append(SitePIPData(bel_idx=bel_idx_by_name[pipdata["bel"]], bel_input=pipdata["from_pin"], |
| 397 |
from_wire_idx=bel_data.pins[pipdata["from_pin"]].site_wire_idx, |
| 398 |
to_wire_idx=bel_data.pins[pipdata["to_pin"]].site_wire_idx)) |
| 399 |
# Import pins |
| 400 |
for pin, pindata in sorted(vdata["pins"].items()): |
| 401 |
vd.pins.append(SitePinData(name=pin, pindir=pindata["dir"], site_wire_idx=wire_index(pindata["wire"]), |
| 402 |
prim_pin_name=pindata["primary"])) |
| 403 |
sd.variants[vtype] = vd |
| 404 |
else: |
| 405 |
sd.variants[sitetype] = sd |
| 406 |
site_type_cache[sitetype] = sd |
| 407 |
return site_type_cache[sitetype] |
| 408 |
|
| 409 |
def read_tile_type_json(tiletype): |
| 410 |
if tiletype not in tile_json_cache: |
| 411 |
if not os.path.exists(prjxray_root + "/tile_type_" + tiletype + ".json"): |
| 412 |
tile_json_cache[tiletype] = dict(wires={}, pips={}, sites=[]) |
| 413 |
else: |
| 414 |
with open(prjxray_root + "/tile_type_" + tiletype + ".json", "r") as jf: |
| 415 |
tile_json_cache[tiletype] = json.load(jf) |
| 416 |
return tile_json_cache[tiletype] |
| 417 |
|
| 418 |
def get_tile_type_data(tiletype): |
| 419 |
if tiletype not in tile_type_cache: |
| 420 |
td = TileData(tiletype) |
| 421 |
# Import wires and pips |
| 422 |
tj = read_tile_type_json(tiletype) |
| 423 |
for wire, wire_data in sorted(tj["wires"].items()): |
| 424 |
wire_id = len(td.wires) |
| 425 |
wd = WireData(index=wire_id, name=wire, tied_value=None) # FIXME: tied_value |
| 426 |
wd.intent = get_wire_intent(tiletype, wire) |
| 427 |
if wire_data is not None: |
| 428 |
if "res" in wire_data: |
| 429 |
wd.resistance = float(wire_data["res"]) |
| 430 |
if "cap" in wire_data: |
| 431 |
wd.capacitance = float(wire_data["cap"]) |
| 432 |
td.wires.append(wd) |
| 433 |
td.wires_by_name[wire] = wd |
| 434 |
for pip, pipdata in sorted(tj["pips"].items()): |
| 435 |
# FIXME: pip/wire delays |
| 436 |
pip_id = len(td.pips) |
| 437 |
pd = PIPData(index=pip_id, |
| 438 |
from_wire=td.wires_by_name[pipdata["src_wire"]].index, to_wire=td.wires_by_name[pipdata["dst_wire"]].index, |
| 439 |
is_bidi=(not bool(int(pipdata["is_directional"]))), is_route_thru=bool(int(pipdata["is_pseudo"]))) |
| 440 |
if "is_pass_transistor" in pipdata: |
| 441 |
pd.is_buffered = (not bool(int(pipdata["is_pass_transistor"]))) |
| 442 |
if "src_to_dst" in pipdata: |
| 443 |
s2d = pipdata["src_to_dst"] |
| 444 |
if "delay" in s2d and s2d["delay"] is not None: |
| 445 |
pd.min_delay = min(float(s2d["delay"][0]), float(s2d["delay"][1])) |
| 446 |
pd.max_delay = max(float(s2d["delay"][2]), float(s2d["delay"][3])) |
| 447 |
if "res" in s2d and s2d["res"] is not None: |
| 448 |
pd.resistance = float(s2d["res"]) |
| 449 |
if "in_cap" in s2d and s2d["in_cap"] is not None: |
| 450 |
pd.capacitance = float(s2d["in_cap"]) |
| 451 |
td.pips.append(pd) |
| 452 |
for sitedata in tj["sites"]: |
| 453 |
rel_xy = parse_xy(sitedata["name"]) |
| 454 |
sitetype = sitedata["type"] |
| 455 |
for sitepin, pindata in sorted(sitedata["site_pins"].items()): |
| 456 |
if pindata is None: |
| 457 |
tspd = TileSitePinData(None) |
| 458 |
else: |
| 459 |
pinwire = td.wires_by_name[pindata["wire"]].index |
| 460 |
tspd = TileSitePinData(pinwire) |
| 461 |
if "delay" in pindata: |
| 462 |
tspd.min_delay = min(float(pindata["delay"][0]), float(pindata["delay"][1])) |
| 463 |
tspd.max_delay = max(float(pindata["delay"][2]), float(pindata["delay"][3])) |
| 464 |
if "res" in pindata: |
| 465 |
tspd.resistance = float(pindata["res"]) |
| 466 |
if "cap" in pindata: |
| 467 |
tspd.capacitance = float(pindata["cap"]) |
| 468 |
td.sitepin_data[(sitetype, rel_xy, sitepin)] = tspd |
| 469 |
if os.path.exists(prjxray_root + "/timings/" + tiletype + ".sdf"): |
| 470 |
td.cell_timing = parse_sdf_file(prjxray_root + "/timings/" + tiletype + ".sdf") |
| 471 |
|
| 472 |
tile_type_cache[tiletype] = td |
| 473 |
|
| 474 |
return tile_type_cache[tiletype] |
| 475 |
|
| 476 |
def get_wire_intent(tiletype, wirename): |
| 477 |
if tiletype not in ij["tiles"]: |
| 478 |
return "GENERIC" |
| 479 |
if wirename not in ij["tiles"][tiletype]: |
| 480 |
return "GENERIC" |
| 481 |
return ij["intents"][str(ij["tiles"][tiletype][wirename])] |
| 482 |
|
| 483 |
d = Device(fabricname) |
| 484 |
|
| 485 |
# Load intent JSON |
| 486 |
with open(metadata_root + "/wire_intents.json", "r") as ijf: |
| 487 |
ij = json.load(ijf) |
| 488 |
with open(prjxray_root + "/" + fabricname + "/tilegrid.json") as gf: |
| 489 |
tgj = json.load(gf) |
| 490 |
for tile, tiledata in sorted(tgj.items()): |
| 491 |
x = int(tiledata["grid_x"]) |
| 492 |
y = int(tiledata["grid_y"]) |
| 493 |
d.width = max(d.width, x + 1) |
| 494 |
d.height = max(d.height, y + 1) |
| 495 |
tiletype = tiledata["type"] |
| 496 |
t = Tile(x, y, tile, get_tile_type_data(tiletype), (-1, -1), []) |
| 497 |
for idx, (site, sitetype) in enumerate(sorted(tiledata["sites"].items())): |
| 498 |
si = Site(t, site, idx, parse_xy(site), get_site_type_data(sitetype)) |
| 499 |
t.site_insts.append(si) |
| 500 |
d.sites_by_name[site] = si |
| 501 |
d.tiles_by_name[tile] = t |
| 502 |
d.tiles_by_xy[x, y] = t |
| 503 |
d.tiles.append(t) |
| 504 |
|
| 505 |
# Resolve interconnect tile coordinates |
| 506 |
for t in d.tiles: |
| 507 |
for delta in range(0, 30): |
| 508 |
if t.interconn_xy != (-1, -1): |
| 509 |
break # found, done |
| 510 |
for direction in (-1, +1): |
| 511 |
nxy = (t.x + direction * delta, t.y) |
| 512 |
if nxy not in d.tiles_by_xy: |
| 513 |
continue |
| 514 |
if d.tiles_by_xy[nxy].tile_type not in ("INT", "INT_L", "INT_R"): |
| 515 |
continue |
| 516 |
t.interconn_xy = nxy |
| 517 |
break |
| 518 |
# Read package pins |
| 519 |
for entry in os.scandir(prjxray_root): |
| 520 |
if not entry.is_dir() or not entry.name.startswith(fabricname): |
| 521 |
continue |
| 522 |
device_postfix = entry.name[len(fabricname):] |
| 523 |
if len(device_postfix) == 0: |
| 524 |
continue |
| 525 |
package_name = device_postfix.split("-")[0] |
| 526 |
if package_name in d.packages: |
| 527 |
continue # already seen in a different speed grade |
| 528 |
with open(prjxray_root + "/" + entry.name + "/package_pins.csv") as ppf: |
| 529 |
pkg = Package(name=package_name) |
| 530 |
for line in ppf: |
| 531 |
sl = line.strip().split(",") |
| 532 |
if len(sl) < 3: |
| 533 |
continue |
| 534 |
if sl[2] == "site": |
| 535 |
continue # header |
| 536 |
pkg.pin_map[sl[0]] = sl[2] |
| 537 |
d.packages[package_name] = pkg |
| 538 |
with open(prjxray_root + "/" + fabricname + "/tileconn.json", "r") as tcf: |
| 539 |
apply_tileconn(tcf, d) |
| 540 |
return d |
| 541 |
|
| 542 |
if __name__ == '__main__': |
| 543 |
import sys |
| 544 |
import_device(*sys.argv[1:]) |