f4pga/utils/quicklogic/qlf_k4n8/create_ioplace.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright (C) 2022 F4PGA 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.
#
# SPDX-License-Identifier: Apache-2.0
"""
Convert a PCF file into a VPR io.place file.
"""
import argparse
import csv
import sys
import re
from collections import defaultdict

import f4pga.utils.vpr_io_place as vpr_io_place
from f4pga.utils.quicklogic.pinmap_parse import read_pinmapfile_data
from f4pga.utils.quicklogic.pinmap_parse import vec_to_scalar

from f4pga.utils.pcf import parse_simple_pcf

# =============================================================================

BLOCK_INSTANCE_RE = re.compile(r"^(?P<name>\S+)\[(?P<index>[0-9]+)\]$")


# =============================================================================
def gen_io_def(args):
    """
    Generate io.place file from pcf file
    """
    io_place = vpr_io_place.IoPlace()
    io_place.read_io_list_from_eblif(args.blif)
    io_place.load_block_names_from_net_file(args.net)

    # Load all the necessary data from the pinmap_xml
    io_cells, port_map = read_pinmapfile_data(args.pinmap_xml)

    # Map of pad names to VPR locations.
    pad_map = defaultdict(lambda: dict())

    with open(args.csv_file, mode="r") as csv_fp:
        reader = csv.DictReader(csv_fp)
        for line in reader:
            port_name_list = vec_to_scalar(line["port_name"])
            pin_name = vec_to_scalar(line["mapped_pin"])
            gpio_type = line["GPIO_type"]

            if len(port_name_list) != len(pin_name):
                print(
                    'CSV port name "{}" length does not match with mapped pin name "{}" length'.format(
                        line["port_name"], line["mapped_pin"]
                    ),
                    file=sys.stderr,
                )
                sys.exit(1)

            for port, pin in zip(port_name_list, pin_name):
                if port in port_map:
                    curr_map = port_map[port]
                    if gpio_type is None or gpio_type == "":
                        pad_map[pin] = (int(curr_map.x), int(curr_map.y), int(curr_map.z))
                    else:
                        gpio_pin = pin + ":" + gpio_type.strip()
                        pad_map[gpio_pin] = (int(curr_map.x), int(curr_map.y), int(curr_map.z))
                else:
                    print(
                        'Port name "{}" specified in csv file "{}" is invalid. {} "{}"'.format(
                            line["port_name"], args.csv_file, "Specify from port names in xml file", args.pinmap_xml
                        ),
                        file=sys.stderr,
                    )
                    sys.exit(1)

    for pcf_constraint in parse_simple_pcf(args.pcf):
        if type(pcf_constraint).__name__ == "PcfIoConstraint":
            pad_name = pcf_constraint.pad
            if not io_place.is_net(pcf_constraint.net):
                print(
                    'PCF constraint "{}" from line {} constraints net {} {}:\n{}'.format(
                        pcf_constraint.line_str,
                        pcf_constraint.line_num,
                        pcf_constraint.net,
                        "\n".join(io_place.get_nets()),
                        "which is not in available netlist",
                    ),
                    file=sys.stderr,
                )
                sys.exit(1)

            if pad_name not in pad_map:
                print(
                    'PCF constraint "{}" from line {} constraints pad {} {}:\n{}'.format(
                        pcf_constraint.line_str,
                        pcf_constraint.line_num,
                        pad_name,
                        "\n".join(sorted(pad_map.keys())),
                        "which is not in available pad map",
                    ),
                    file=sys.stderr,
                )
                sys.exit(1)

            # Get the top-level block instance, strip its index
            inst = io_place.get_top_level_block_instance_for_net(pcf_constraint.net)
            if inst is None:
                continue

            match = BLOCK_INSTANCE_RE.match(inst)
            assert match is not None, inst

            inst = match.group("name")

            # Constraint the net (block)
            locs = pad_map[pad_name]
            io_place.constrain_net(net_name=pcf_constraint.net, loc=locs, comment=pcf_constraint.line_str)

    if io_place.constraints:
        io_place.output_io_place(args.output)


# =============================================================================


def main():
    """
    Convert a PCF file into a VPR io.place file
    """
    parser = argparse.ArgumentParser(description="Convert a PCF file into a VPR io.place file.")
    parser.add_argument("--pcf", "-p", "-P", type=argparse.FileType("r"), required=True, help="PCF input file")
    parser.add_argument("--blif", "-b", type=argparse.FileType("r"), required=True, help="BLIF / eBLIF file")
    parser.add_argument(
        "--output", "-o", "-O", type=argparse.FileType("w"), default=sys.stdout, help="The output io.place file"
    )
    parser.add_argument("--net", "-n", type=argparse.FileType("r"), required=True, help="top.net file")

    parser.add_argument("--pinmap_xml", type=str, required=True, help="Input pin-mapping xml file")
    parser.add_argument("--csv_file", type=str, required=True, help="Input user-defined pinmap CSV file")

    args = parser.parse_args()

    gen_io_def(args)


# =============================================================================

if __name__ == "__main__":
    main()