mirror of https://github.com/openXC7/prjxray.git
234 lines
7.6 KiB
Python
234 lines
7.6 KiB
Python
#!/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 os.path
|
|
import pathlib
|
|
import simplejson as json
|
|
from prjxray import grid
|
|
from prjxray import tile
|
|
from prjxray import tile_segbits
|
|
from prjxray import site_type
|
|
from prjxray import connections
|
|
from prjxray.node_model import NodeModel
|
|
from prjxray.util import get_fabric_for_part
|
|
|
|
|
|
def get_available_databases(prjxray_root):
|
|
""" Return set of available directory to databases given the root directory
|
|
of prjxray-db
|
|
"""
|
|
db_types = set()
|
|
for d in os.listdir(prjxray_root):
|
|
if d.startswith("."):
|
|
continue
|
|
|
|
dpath = os.path.join(prjxray_root, d)
|
|
|
|
if os.path.exists(os.path.join(dpath, "settings.sh")):
|
|
db_types.add(dpath)
|
|
|
|
return db_types
|
|
|
|
|
|
class Database(object):
|
|
def __init__(self, db_root, part):
|
|
""" Create project x-ray Database at given db_root.
|
|
|
|
db_root: Path to directory containing settings.sh, *.db, tilegrid.json and
|
|
tileconn.json
|
|
|
|
"""
|
|
self.db_root = db_root
|
|
self.part = part
|
|
self.fabric = get_fabric_for_part(db_root, part)
|
|
|
|
# tilegrid.json JSON object
|
|
self.tilegrid = None
|
|
self.tileconn = None
|
|
self.tile_types_json = None
|
|
self.node_wires = None
|
|
|
|
self.tile_types = {}
|
|
self.tile_segbits = {}
|
|
self.site_types = {}
|
|
|
|
self.required_features = {}
|
|
|
|
for f in os.listdir(self.db_root):
|
|
if f.endswith('.json') and f.startswith('tile_type_'):
|
|
tile_type = f[len('tile_type_'):-len('.json')].lower()
|
|
|
|
segbits = os.path.join(
|
|
self.db_root, 'segbits_{}.db'.format(tile_type))
|
|
if not os.path.isfile(segbits):
|
|
segbits = None
|
|
|
|
block_ram_segbits = os.path.join(
|
|
self.db_root, 'segbits_{}.block_ram.db'.format(tile_type))
|
|
if not os.path.isfile(block_ram_segbits):
|
|
block_ram_segbits = None
|
|
|
|
ppips = os.path.join(
|
|
self.db_root, 'ppips_{}.db'.format(tile_type))
|
|
if not os.path.isfile(ppips):
|
|
ppips = None
|
|
|
|
mask = os.path.join(
|
|
self.db_root, 'mask_{}.db'.format(tile_type))
|
|
if not os.path.isfile(mask):
|
|
mask = None
|
|
|
|
tile_type_file = os.path.join(
|
|
self.db_root, 'tile_type_{}.json'.format(
|
|
tile_type.upper()))
|
|
if not os.path.isfile(tile_type_file):
|
|
tile_type_file = None
|
|
|
|
self.tile_types[tile_type.upper()] = tile.TileDbs(
|
|
segbits=segbits,
|
|
block_ram_segbits=block_ram_segbits,
|
|
ppips=ppips,
|
|
mask=mask,
|
|
tile_type=tile_type_file,
|
|
)
|
|
|
|
if f.endswith('.json') and f.startswith('site_type_'):
|
|
site_type_name = f[len('site_type_'):-len('.json')]
|
|
|
|
self.site_types[site_type_name] = os.path.join(self.db_root, f)
|
|
|
|
required_features_path = os.path.join(
|
|
self.db_root, self.part, "required_features.fasm")
|
|
if os.path.isfile(required_features_path):
|
|
with open(required_features_path, "r") as fp:
|
|
features = []
|
|
for line in fp:
|
|
line = line.strip()
|
|
if len(line) > 0:
|
|
features.append(line)
|
|
|
|
self.required_features[self.part] = set(features)
|
|
|
|
self.tile_types_obj = {}
|
|
|
|
def get_tile_types(self):
|
|
""" Return list of tile types """
|
|
return self.tile_types.keys()
|
|
|
|
def get_tile_type(self, tile_type):
|
|
""" Return Tile object for given tilename. """
|
|
if tile_type not in self.tile_types_obj:
|
|
self.tile_types_obj[tile_type] = tile.Tile(
|
|
tile_type, self.tile_types[tile_type])
|
|
|
|
return self.tile_types_obj[tile_type]
|
|
|
|
def _read_tilegrid(self):
|
|
""" Read tilegrid database if not already read. """
|
|
if not self.tilegrid:
|
|
with open(os.path.join(self.db_root, self.fabric,
|
|
'tilegrid.json')) as f:
|
|
self.tilegrid = json.load(f)
|
|
|
|
def _read_tileconn(self):
|
|
""" Read tileconn database if not already read. """
|
|
if not self.tileconn:
|
|
with open(os.path.join(self.db_root, self.fabric,
|
|
'tileconn.json')) as f:
|
|
self.tileconn = json.load(f)
|
|
|
|
def _read_node_wires(self):
|
|
""" Read node wires if not already read. """
|
|
if self.node_wires is None:
|
|
with open(os.path.join(self.db_root, self.fabric,
|
|
'node_wires.json')) as f:
|
|
self.node_wires = json.load(f)
|
|
|
|
def grid(self):
|
|
""" Return Grid object for database. """
|
|
self._read_tilegrid()
|
|
return grid.Grid(self, self.tilegrid)
|
|
|
|
def _read_tile_types(self):
|
|
if self.tile_types_json is None:
|
|
self.tile_types_json = {}
|
|
for tile_type, db in self.tile_types.items():
|
|
with open(db.tile_type) as f:
|
|
self.tile_types_json[tile_type] = json.load(f)
|
|
|
|
def _get_tile_wires(self):
|
|
self._read_tile_types()
|
|
tile_wires = dict(
|
|
(tile_type, db['wires'])
|
|
for tile_type, db in self.tile_types_json.items())
|
|
|
|
return tile_wires
|
|
|
|
def connections(self):
|
|
self._read_tilegrid()
|
|
self._read_tileconn()
|
|
|
|
return connections.Connections(
|
|
self.tilegrid, self.tileconn, self._get_tile_wires())
|
|
|
|
def node_model(self, progressbar=lambda x: x):
|
|
""" Get node module for specified part.
|
|
|
|
progressbar - Should be a function that takes an iteraable, and
|
|
yields all elements from that iterable.
|
|
This can be used to generate a progressbar, for example
|
|
the module progressbar satifies this interface.
|
|
|
|
Example:
|
|
|
|
import progressbar
|
|
|
|
db = Database(...)
|
|
node_model = db.node_model(progressbar.progressbar)
|
|
|
|
"""
|
|
self._read_node_wires()
|
|
|
|
return NodeModel(
|
|
grid=self.grid(),
|
|
connections=self.connections(),
|
|
tile_wires=self._get_tile_wires(),
|
|
node_wires=self.node_wires,
|
|
progressbar=progressbar)
|
|
|
|
def get_site_types(self):
|
|
return self.site_types.keys()
|
|
|
|
def get_site_type(self, site_type_name):
|
|
with open(self.site_types[site_type_name]) as f:
|
|
site_type_data = json.load(f)
|
|
|
|
return site_type.SiteType(site_type_data)
|
|
|
|
def get_tile_segbits(self, tile_type):
|
|
if tile_type not in self.tile_segbits:
|
|
self.tile_segbits[tile_type] = tile_segbits.TileSegbits(
|
|
self.tile_types[tile_type.upper()])
|
|
|
|
return self.tile_segbits[tile_type]
|
|
|
|
def get_required_fasm_features(self, part=None):
|
|
"""
|
|
Assembles a set of required fasm features for given part. Returns a list
|
|
of fasm features.
|
|
"""
|
|
|
|
# No required features in the db, return empty list
|
|
if self.required_features is None:
|
|
return set()
|
|
|
|
# Return list of part specific features
|
|
return self.required_features.get(part, set())
|