f4pga/wrappers/sh/__init__.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright (C) 2020-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
#
#     https://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
#
# Python entrypoints to the shell wrappers moved from arch-defs

from sys import argv as sys_argv, stdout, stderr
from os import environ
from pathlib import Path
from shutil import which
from subprocess import check_call
from argparse import ArgumentParser, RawDescriptionHelpFormatter

from f4pga.context import FPGA_FAM, F4PGA_SHARE_DIR


python3 = which("python3")

ROOT = Path(__file__).resolve().parent

isQuickLogic = FPGA_FAM != "xc7"
SH_SUBDIR = "quicklogic" if isQuickLogic else FPGA_FAM


if not isQuickLogic:
    from f4pga.utils.xc7.create_ioplace import main as xc7_create_ioplace
    from f4pga.utils.xc7.create_place_constraints import main as xc7_create_place_constraints


# Helper functions


def p_run_sh_script(script, env=environ):
    stdout.flush()
    stderr.flush()
    check_call([str(script)] + sys_argv[1:], env=env)


def p_run_bash_cmds(cmds, env=environ):
    stdout.flush()
    stderr.flush()
    check_call(cmds, env=env, shell=True, executable="/bin/bash")


def p_run_pym(module, env=environ):
    stdout.flush()
    stderr.flush()
    check_call([python3, "-m", module] + sys_argv[1:], env=env)


def p_vpr_env_from_args(log_suffix=None):
    vpr_options = environ.get("VPR_OPTIONS")
    if vpr_options is not None:
        vpr_options = p_args_str2list(vpr_options)

    env = environ.copy()
    env.update(
        p_parse_vpr_args(
            vpr_options=vpr_options,
            log_suffix=log_suffix,
            isQuickLogic=isQuickLogic,
        )
    )
    return env


def p_args_str2list(args):
    return [arg for arg in args.strip().split() if arg != ""]


def p_vpr_run(args, env=environ):
    print("[F4PGA] Running (deprecated) vpr run")

    arg_arch_def = env.get("ARCH_DEF")
    if arg_arch_def is None:
        raise (Exception("[F4PGA] vpr run: envvar ARCH_DEF cannot be unset/empty!"))

    arg_eblif = env.get("EBLIF")
    if arg_eblif is None:
        raise (Exception("[F4PGA] vpr run: envvar EBLIF cannot be unset/empty!"))

    arg_vpr_options = env.get("VPR_OPTIONS")
    if arg_vpr_options is None:
        raise (Exception("[F4PGA] vpr run: envvar VPR_OPTIONS cannot be unset/empty!"))

    arg_device_name = env.get("DEVICE_NAME")
    if arg_device_name is None:
        raise (Exception("[F4PGA] vpr run: envvar DEVICE_NAME cannot be unset/empty!"))

    arg_rr_graph = env.get("RR_GRAPH")
    if arg_rr_graph is None:
        raise (Exception("[F4PGA] vpr run: envvar RR_GRAPH cannot be unset/empty!"))

    arg_lookahead = env.get("LOOKAHEAD")
    if arg_lookahead is None:
        raise (Exception("[F4PGA] vpr run: envvar LOOKAHEAD cannot be unset/empty!"))

    arg_place_delay = env.get("PLACE_DELAY")
    if arg_place_delay is None:
        raise (Exception("[F4PGA] vpr run: envvar PLACE_DELAY cannot be unset/empty!"))

    sdc = env.get("SDC")
    if sdc == "":
        sdc = None

    check_call(
        [which("vpr"), arg_arch_def, arg_eblif]
        + p_args_str2list(arg_vpr_options)
        + [
            "--device",
            arg_device_name,
            "--read_rr_graph",
            arg_rr_graph,
            "--read_router_lookahead",
            arg_lookahead,
            "--read_placement_delay_lookup",
            arg_place_delay,
        ]
        + (["--sdc_file", sdc] if sdc is not None else [])
        + args,
    )


def p_parse_vpr_args(vpr_options=None, log_suffix=None, isQuickLogic=False):
    if isQuickLogic:
        return p_parse_vpr_args_quicklogic(vpr_options, log_suffix)
    else:
        return p_parse_vpr_args_xc7(vpr_options, log_suffix)


def p_parse_vpr_args_xc7(vpr_options=None, log_suffix=None):
    parser = ArgumentParser(description=__doc__, formatter_class=RawDescriptionHelpFormatter)
    parser.add_argument("--device", "-d", required=False, type=str, help="")
    parser.add_argument("--eblif", "-e", required=True, type=str, help="")
    parser.add_argument("--pcf", "-p", required=False, type=str, help="")
    parser.add_argument("--net", "-n", required=False, type=str, help="")
    parser.add_argument("--part", "-P", required=False, type=str, help="")
    parser.add_argument("--sdc", "-s", required=False, type=str, help="")
    parser.add_argument("additional_vpr_options", nargs="*", type=str, help="")
    args = parser.parse_args()

    device = args.device
    if device is None and args.part is not None:
        parts_dir = F4PGA_SHARE_DIR
        # Try to find device name.
        # Accept only when exactly one is found.
        # PART_DIRS=(${F4PGA_SHARE_DIR}/arch/*/${PART})
        # if [ ${#PART_DIRS[@]} -eq 1 ]; then DEVICE=$(basename $(dirname "${PART_DIRS[0]}")); fi

    if device is None:
        raise Exception("Please provide device name")

    noisy_warnings = "" if log_suffix is None else f"noisy_warnings-{device}_{log_suffix}.log"

    if vpr_options is None:
        print("Using default VPR options")
        vpr_options = [
            "--max_router_iterations",
            "500",
            "--routing_failure_predictor",
            "off",
            "--router_high_fanout_threshold",
            "-1",
            "--constant_net_method",
            "route",
            "--route_chan_width",
            "500",
            "--router_heap",
            "bucket",
            "--clock_modeling",
            "route",
            "--place_delta_delay_matrix_calculation_method",
            "dijkstra",
            "--place_delay_model",
            "delta",
            "--router_lookahead",
            "extended_map",
            "--check_route",
            "quick",
            "--strict_checks",
            "off",
            "--allow_dangling_combinational_nodes",
            "on",
            "--disable_errors",
            "check_unbuffered_edges:check_route",
            "--congested_routing_iteration_threshold",
            "0.8",
            "--incremental_reroute_delay_ripup",
            "off",
            "--base_cost_type",
            "delay_normalized_length_bounded",
            "--bb_factor",
            "10",
            "--acc_fac",
            "0.7",
            "--astar_fac",
            "1.8",
            "--initial_pres_fac",
            "2.828",
            "--pres_fac_mult",
            "1.2",
            "--check_rr_graph",
            "off",
            "--suppress_warnings",
            noisy_warnings
            + ",sum_pin_class:check_unbuffered_edges:load_rr_indexed_data_T_values:check_rr_node:trans_per_R:check_route:set_rr_graph_tool_comment:calculate_average_switch",
        ]

    arch_dir = F4PGA_SHARE_DIR / "arch" / device

    envvars = {
        "DEVICE": device,
        "DEVICE_NAME": device.replace("_", "-"),
        "EBLIF": args.eblif,
        "VPR_OPTIONS": " ".join(vpr_options + args.additional_vpr_options),
        "ARCH_DIR": str(arch_dir),
        "ARCH_DEF": str(arch_dir / "arch.timing.xml"),
        "RR_GRAPH": str(arch_dir / f"rr_graph_{device}.rr_graph.real.bin"),
        "RR_GRAPH_XML": str(arch_dir / f"rr_graph_{device}.rr_graph.real.xml"),
        "PLACE_DELAY": str(arch_dir / f"rr_graph_{device}.place_delay.bin"),
        "LOOKAHEAD": str(arch_dir / f"rr_graph_{device}.lookahead.bin"),
    }

    if args.pcf is not None:
        envvars["PCF"] = args.pcf
    if args.net is not None:
        envvars["NET"] = args.net
    if args.part is not None:
        envvars["PART"] = args.part
    if args.sdc is not None:
        envvars["SDC"] = args.sdc

    if log_suffix is not None:
        envvars["OUT_NOISY_WARNINGS"] = noisy_warnings

    return envvars


def p_parse_vpr_args_quicklogic(vpr_options=None, log_suffix=None):
    parser = ArgumentParser(description=__doc__, formatter_class=RawDescriptionHelpFormatter)
    parser.add_argument("--device", "-d", required=True, type=str, help="")
    parser.add_argument("--family", "-f", required=True, type=str, help="")
    parser.add_argument("--eblif", "-e", required=True, type=str, help="")
    parser.add_argument("--pcf", "-p", required=False, type=str, help="")
    parser.add_argument("--net", "-n", required=False, type=str, help="")
    parser.add_argument("--part", "-P", required=False, type=str, help="")
    parser.add_argument("--json", "-j", required=False, type=str, help="")
    parser.add_argument("--sdc", "-s", required=False, type=str, help="")
    parser.add_argument("--top", "-t", required=False, type=str, help="")
    parser.add_argument("--corner", "-c", required=False, type=str, help="")
    args = parser.parse_args()

    if vpr_options is None:
        print("Using default VPR options")
        vpr_options = [
            "--max_router_iterations",
            "500",
            "--routing_failure_predictor",
            "off",
            "--router_high_fanout_threshold",
            "-1",
            "--constant_net_method",
            "route",
        ]

    noisy_warnings = "" if log_suffix is None else f"noisy_warnings-{args.device}_{log_suffix}.log"

    vpr_options.extend(
        [
            "--place_delay_model",
            "delta_override",
            "--router_lookahead",
            "extended_map",
            "--allow_dangling_combinational_nodes",
            "on",
        ]
        + (
            [
                "--route_chan_width",
                "10",
                "--clock_modeling",
                "ideal",
                "--place_delta_delay_matrix_calculation_method",
                "dijkstra",
                "--absorb_buffer_luts",
                "off",
            ]
            if args.device == "qlf_k4n8_qlf_k4n8"
            else [
                "--route_chan_width",
                "100",
                "--clock_modeling",
                "route",
                "--check_route",
                "quick",
                "--strict_checks",
                "off",
                "--disable_errors",
                "check_unbuffered_edges:check_route",
                "--congested_routing_iteration_threshold",
                "0.8",
                "--incremental_reroute_delay_ripup",
                "off",
                "--base_cost_type",
                "delay_normalized_length_bounded",
                "--bb_factor",
                "10",
                "--initial_pres_fac",
                "4.0",
                "--check_rr_graph",
                "off",
                "--pack_high_fanout_threshold",
                "PB-LOGIC:18",
                "--suppress_warnings",
                noisy_warnings
                + ",sum_pin_class:check_unbuffered_edges:load_rr_indexed_data_T_values:check_rr_node:trans_per_R:check_route:set_rr_graph_tool_comment",
            ]
        )
    )

    device_2 = None
    if args.device == "qlf_k4n8_qlf_k4n8":
        device_1 = f"qlf_k4n8-qlf_k4n8_umc22_{args.corner}"
    elif args.device == "qlf_k6n10_qlf_k6n10":
        device_1 = "qlf_k6n10-qlf_k6n10_gf12"
    else:
        device_1 = args.device
        device_2 = "wlcsp"
    if device_2 is None:
        device_2 = device_1

    device_arch = f"{device_1}_{device_2}"
    arch_dir = F4PGA_SHARE_DIR / "arch" / device_arch

    rr_graph = arch_dir / f"{device_1}.rr_graph.bin"
    # qlf* devices use different naming scheme than pp3* ones.
    if not rr_graph.exists():
        rr_graph = arch_dir / f"rr_graph_{device_arch}.rr_graph.real.bin"

    envvars = {
        "DEVICE": args.device,
        "FAMILY": args.family,
        "EBLIF": args.eblif,
        "VPR_OPTIONS": " ".join(vpr_options),
        "ARCH_DIR": str(arch_dir),
        "ARCH_DEF": str(arch_dir / f"arch_{device_arch}.xml"),
        "RR_GRAPH": str(rr_graph),
        "PLACE_DELAY": str(arch_dir / f"rr_graph_{device_arch}.place_delay.bin"),
        "LOOKAHEAD": str(arch_dir / f"rr_graph_{device_arch}.lookahead.bin"),
        "DEVICE_NAME": device_1,
    }

    if args.pcf is not None:
        envvars["PCF"] = args.pcf
    if args.net is not None:
        envvars["NET"] = args.net
    if args.json is not None:
        envvars["JSON"] = args.json
    if args.sdc is not None:
        envvars["SDC"] = args.sdc
    if args.top is not None:
        envvars["TOP"] = args.top
    if args.sdc is not None:
        envvars["CORNER"] = args.corner

    if log_suffix is not None:
        envvars["OUT_NOISY_WARNINGS"] = noisy_warnings

    return envvars


# Entrypoints


def generate_constraints():
    print("[F4PGA] Running (deprecated) generate constraints")
    if isQuickLogic:
        (pcf, eblif, net, part, device, arch_def, corner) = sys_argv[1:8]
        place_file_prefix = Path(eblif).stem
        scripts_dir = F4PGA_SHARE_DIR / "scripts"
        archs_dir = F4PGA_SHARE_DIR / "arch"
        p_run_bash_cmds(
            f"""
set -e

if [[ '{device}' =~ ^(qlf_.*)$ ]]; then

  if [[ '{device}' =~ ^(qlf_k4n8_qlf_k4n8)$ ]];then
    DEVICE_PATH='qlf_k4n8-qlf_k4n8_umc22_{corner}'
    PINMAPXML="pinmap_qlf_k4n8_umc22.xml"
  elif [[ '{device}' =~ ^(qlf_k6n10_qlf_k6n10)$ ]];then
    DEVICE_PATH="qlf_k6n10-qlf_k6n10_gf12"
    PINMAPXML="pinmap_qlf_k6n10_gf12.xml"
  else
    echo "ERROR: Unknown qlf device '{device}'"
    exit -1
  fi

  '{python3}' -m f4pga.utils.quicklogic.qlf_k4n8.create_ioplace \
    --pcf '{pcf}' \
    --blif '{eblif}' \
    --pinmap_xml '{archs_dir}'/"${{DEVICE_PATH}}_${{DEVICE_PATH}}/${{PINMAPXML}}" \
    --csv_file '{part}' \
    --net '{net}' \
    > '{place_file_prefix}_io.place'

elif [[ '{device}' =~ ^(ql-.*)$ ]]; then

  if ! [[ '{part}' =~ ^(PU64|WR42|PD64|WD30)$ ]]; then
    PINMAPCSV="pinmap_PD64.csv"
    CLKMAPCSV="clkmap_PD64.csv"
  else
    PINMAPCSV='pinmap_{part}.csv'
    CLKMAPCSV='clkmap_{part}.csv'
  fi

  echo "PINMAP FILE : $PINMAPCSV"
  echo "CLKMAP FILE : $CLKMAPCSV"

  DEVICE_PATH='{device}_wlcsp'
  PINMAP='{archs_dir}'/"${{DEVICE_PATH}}/${{PINMAPCSV}}"

  '{python3}' -m f4pga.utils.quicklogic.pp3.create_ioplace \
    --pcf '{pcf}' \
    --blif '{eblif}' \
    --map "$PINMAP" \
    --net '{net}' \
    > '{place_file_prefix}_io.place'

  '{python3}' -m f4pga.utils.quicklogic.pp3.create_place_constraints \
    --blif '{eblif}' \
    --map '{archs_dir}'/"${{DEVICE_PATH}}/${{CLKMAPCSV}}" \
    -i '{place_file_prefix}_io.place' \
    > '{place_file_prefix}_constraints.place'

  # EOS-S3 IOMUX configuration
  if [[ '{device}' =~ ^(ql-eos-s3)$ ]]; then
"""
            + "\n".join(
                [
                    f"""
    '{python3}' -m f4pga.utils.quicklogic.pp3.eos-s3.iomux_config \
      --eblif '{eblif}' \
      --pcf '{pcf}' \
      --map "$PINMAP" \
      --output-format={fmt[0]} \
      > '{place_file_prefix}_iomux.{fmt[1]}'
"""
                    for fmt in [["jlink", "jlink"], ["openocd", "openocd"], ["binary", "bin"]]
                ]
            )
            + f"""
  fi

else
  echo "FIXME: Unsupported device '{device}'"
  exit -1
fi
"""
        )
    else:
        (eblif, net, part, device, arch_def) = sys_argv[1:6]
        ioplace_file = f"{Path(eblif).stem}.ioplace"
        xc7_create_ioplace(
            blif=eblif,
            map=f"{F4PGA_SHARE_DIR}/arch/{device}/{part}/pinmap.csv",
            net=net,
            output=ioplace_file,
            pcf=Path(sys_argv[6]).open("r") if len(sys_argv) > 6 else None,
        )
        xc7_create_place_constraints(
            blif=eblif,
            net=net,
            arch=arch_def,
            part=part,
            vpr_grid_map=f"{F4PGA_SHARE_DIR}/arch/{device}/vpr_grid_map.csv",
            input=ioplace_file,
            output="constraints.place",
        )


def pack():
    print("[F4PGA] Running (deprecated) pack")
    extra_args = ["--write_block_usage", "block_usage.json"] if isQuickLogic else []
    p_vpr_run(["--pack"] + extra_args, env=p_vpr_env_from_args("pack"))
    Path("vpr_stdout.log").rename("pack.log")


def place():
    print("[F4PGA] Running (deprecated) place")
    place_cmds = """
if [ -z $NET ]; then echo "Please provide net file name"; exit 1; fi
"""
    if isQuickLogic:
        place_cmds += """
if [ -z $PCF ]; then echo "Please provide pcf file name"; exit 1; fi
PROJECT=$(basename -- "$EBLIF")
PROJECT="${PROJECT%.*}"
VPR_PLACE_FILE="${PROJECT}_constraints.place"
if [ -s $PCF ]; then
  echo "Generating constraints ..."
  python3 -m f4pga.wrappers.sh.generate_constraints $PCF $EBLIF $NET $PART $DEVICE $ARCH_DEF $CORNER
  if [ ! -f ${VPR_PLACE_FILE} ]; then VPR_PLACE_FILE="${PROJECT}_io.place"; fi
else
  # Make a dummy empty constraint file
  touch ${VPR_PLACE_FILE}
fi
"""
    else:
        place_cmds += """
echo "Generating constrains ..."
python3 -m f4pga.wrappers.sh.generate_constraints $EBLIF $NET $PART $DEVICE $ARCH_DEF $PCF
VPR_PLACE_FILE='constraints.place'
"""
    place_cmds += 'python3 -m f4pga.wrappers.sh.vpr_run --fix_clusters "${VPR_PLACE_FILE}" --place'
    p_run_bash_cmds(place_cmds, env=p_vpr_env_from_args("place"))
    Path("vpr_stdout.log").rename("place.log")


def route():
    print("[F4PGA] Running (deprecated) route")
    extra_args = ["--write_timing_summary", "timing_summary.json"] if isQuickLogic else []
    p_vpr_run(["--route"] + extra_args, env=p_vpr_env_from_args("pack"))
    Path("vpr_stdout.log").rename("route.log")


def synth():
    print("[F4PGA] Running (deprecated) synth")
    env = environ.copy()

    if environ.get("F4PGA_SHARE_DIR") is None:
        env["F4PGA_SHARE_DIR"] = str(F4PGA_SHARE_DIR)

    env["UTILS_PATH"] = str(F4PGA_SHARE_DIR / "scripts")

    if isQuickLogic:
        key = None
        for item in ["-F", "--family"]:
            if item in sys_argv:
                key = item
                break
        if key is None:
            raise Exception("Please specify device family")
        family = sys_argv[sys_argv.index(key) + 1]
        env.update(
            {
                "FAMILY": family,
                "TECHMAP_PATH": str(F4PGA_SHARE_DIR / "techmaps" / family),
            }
        )
    else:
        env["TECHMAP_PATH"] = str(F4PGA_SHARE_DIR / "techmaps/xc7_vpr/techmap")

    p_run_sh_script(ROOT / SH_SUBDIR / "synth.f4pga.sh", env=env)


def write_fasm(genfasm_extra_args=None):
    print("[F4PGA] Running (deprecated) write fasm")
    p_run_bash_cmds(
        f"""
'{which('genfasm')}' \
  ${{ARCH_DEF}} ${{EBLIF}} --device ${{DEVICE_NAME}} \
  ${{VPR_OPTIONS}} \
  --read_rr_graph ${{RR_GRAPH}} {' '.join(genfasm_extra_args) if genfasm_extra_args is not None else ''}
"""
        + """
TOP="${EBLIF%.*}"
FASM_EXTRA="${TOP}_fasm_extra.fasm"
if [ -f $FASM_EXTRA ]; then
  echo "writing final fasm (extra: $FASM_EXTRA)"
  cat $FASM_EXTRA >> ${TOP}.fasm
fi
""",
        env=p_vpr_env_from_args("fasm"),
    )
    Path("vpr_stdout.log").rename("fasm.log")


# Xilinx only


def write_bitstream():
    print("[F4PGA] Running (deprecated) write bitstream")
    p_run_bash_cmds(
        """
set -e
echo "Writing bitstream ..."
FRM2BIT=""
if [ ! -z ${FRAMES2BIT} ]; then FRM2BIT="--frm2bit ${FRAMES2BIT}"; fi
"""
        + f"""
eval set -- $(
  getopt \
    --options=d:f:b:p: \
    --longoptions=device:,fasm:,bit:,part: \
    --name $0 -- {' '.join(sys_argv[1:])}
)
"""
        + """
DEVICE=""
FASM=""
BIT=""
PART=xc7a35tcpg236-1
while true; do
  case "$1" in
    -d|--device) DEVICE=$2; shift 2; ;;
    -p|--part)   PART=$2;   shift 2; ;;
    -f|--fasm)   FASM=$2;   shift 2; ;;
    -b|--bit)    BIT=$2;    shift 2; ;;
    --) break ;;
  esac
done
DATABASE_DIR=${DATABASE_DIR:-$(prjxray-config)}
if [ -z $DEVICE ]; then
  # Try to find device name. Accept only when exactly one is found
  PART_DIRS=(${DATABASE_DIR}/*/${PART})
  if [ ${#PART_DIRS[@]} -eq 1 ]; then
    DEVICE=$(basename $(dirname "${PART_DIRS[0]}"))
  else
    echo "Please provide device name"
    exit 1
  fi
fi
DBROOT=`realpath ${DATABASE_DIR}/${DEVICE}`
if [ -z $FASM ]; then echo "Please provide fasm file name"; exit 1; fi
if [ -z $BIT ]; then echo "Please provide bit file name"; exit 1; fi
xcfasm \
  --db-root ${DBROOT} \
  --part ${PART} \
  --part_file ${DBROOT}/${PART}/part.yaml \
  --sparse \
  --emit_pudc_b_pullup \
  --fn_in ${FASM} \
  --bit_out ${BIT} ${FRM2BIT}
"""
    )


# QuickLogic only


def analysis():
    print("[F4PGA] Running (deprecated) analysis")
    p_vpr_run(
        [
            "--analysis",
            "--gen_post_synthesis_netlist",
            "on",
            "--gen_post_implementation_merged_netlist",
            "on",
            "--post_synth_netlist_unconn_inputs",
            "nets",
            "--post_synth_netlist_unconn_outputs",
            "nets",
            "--verify_file_digests",
            "off",
        ],
        env=p_vpr_env_from_args("analysis"),
    )
    Path("vpr_stdout.log").rename("analysis.log")


def repack():
    print("[F4PGA] Running (deprecated) repack")
    p_run_bash_cmds(
        """
DESIGN=${EBLIF/.eblif/}
[ ! -z "${JSON}" ] && JSON_ARGS="--json-constraints ${JSON}" || JSON_ARGS=
[ ! -z "${PCF_PATH}" ] && PCF_ARGS="--pcf-constraints ${PCF_PATH}" || PCF_ARGS=
"""
        + f"""
PYTHONPATH='{F4PGA_SHARE_DIR}/scripts':$PYTHONPATH \
  '{python3}' -m f4pga.utils.quicklogic.repacker.repack \
    --vpr-arch ${{ARCH_DEF}} \
    --repacking-rules ${{ARCH_DIR}}/${{DEVICE_NAME}}.repacking_rules.json \
    $JSON_ARGS \
    $PCF_ARGS \
    --eblif-in ${{DESIGN}}.eblif \
    --net-in ${{DESIGN}}.net \
    --place-in ${{DESIGN}}.place \
    --eblif-out ${{DESIGN}}.repacked.eblif \
    --net-out ${{DESIGN}}.repacked.net \
    --place-out ${{DESIGN}}.repacked.place \
    --absorb_buffer_luts on \
    > repack.log 2>&1
""",
        env=p_vpr_env_from_args(),
    )


def generate_bitstream():
    print("[F4PGA] Running (deprecated) generate_bitstream")
    parser = ArgumentParser(description=__doc__, formatter_class=RawDescriptionHelpFormatter)
    parser.add_argument("--device", "-d", required=True, type=str, help="")
    parser.add_argument("--fasm", "-f", required=True, type=str, help="")
    parser.add_argument("--bit", "-b", required=True, type=str, help="")
    parser.add_argument("--format", "-r", required=False, type=str, help="")
    args = parser.parse_args()

    if not Path(args.fasm).exists():
        raise Exception(f"File <{args.fasm}> does not exist!")

    fmt = "4byte" if args.format is None else args.format
    db_root = F4PGA_SHARE_DIR / "fasm_database" / args.device

    if "qlf_k4n8" in args.device:
        p_run_bash_cmds(
            f"'{which('qlf_fasm')}' --db-root '{db_root}' --format '{fmt}' --assemble '{args.fasm}' '{args.bit}'"
        )
    elif args.device in ["ql-eos-s3", "ql-pp3e"]:
        p_run_bash_cmds(f"qlfasm --dev-type '{args.device}' '{args.fasm}' '{args.bit}'")
    else:
        raise Exception(f"[bitstream generation] Unsupported device '{args.device}'!")


def generate_libfile():
    print("[F4PGA] Running (deprecated) generate_libfile")
    (part, device, corner) = sys_argv[1:4]
    p_run_bash_cmds(
        f"""
set -e
if [[ '{device}' =~ ^(qlf_k4n8_qlf_k4n8)$ ]];then
  DEVICE_1="qlf_k4n8-qlf_k4n8_umc22_{corner}"
  PINMAPXML="pinmap_qlf_k4n8_umc22.xml"
  INTERFACEXML="interface-mapping_24x24.xml"
  DEV="qlf_k4n8_umc22"
else
  DEVICE_1={device}
fi
ARCH_DIR='{F4PGA_SHARE_DIR}/arch/'"${{DEVICE_1}}_${{DEVICE_1}}"
"""
        + """
PINMAP_XML=${ARCH_DIR}/${PINMAPXML}
"""
        + f"""
'{python3}' -m f4pga.utils.quicklogic.create_lib \
  -n "${{DEV}}_0P72_SSM40" \
  -m fpga_top \
  -c '{part}' \
  -x "${{ARCH_DIR}}/lib/${{INTERFACEXML}}" \
  -l "${{DEV}}_0P72_SSM40.lib" \
  -t "${{ARCH_DIR}}/lib"
"""
    )


def ql():
    print("[F4PGA] Running (deprecated) ql")
    env = environ.copy()
    if environ.get("F4PGA_SHARE_DIR") is None:
        env["F4PGA_SHARE_DIR"] = str(F4PGA_SHARE_DIR)
    p_run_sh_script(ROOT / "quicklogic/ql.f4pga.sh", env=env)


def fasm2bels():
    print("[F4PGA] Running (deprecated) fasm2bels")
    parser = ArgumentParser(description=__doc__, formatter_class=RawDescriptionHelpFormatter)
    parser.add_argument("--device", "-d", required=True, type=str, help="")
    parser.add_argument("--bit", "-b", required=True, type=str, help="")
    parser.add_argument("--part", "-P", required=True, type=str, help="")
    parser.add_argument("--pcf", "-p", required=False, type=str, help="")
    parser.add_argument("--out-verilog", "-v", required=False, type=str, help="")
    parser.add_argument("--out-pcf", "-o", required=False, type=str, help="")
    parser.add_argument("--out-qcf", "-q", required=False, type=str, help="")
    args = parser.parse_args()

    if args.device not in ["ql-eos-s3", "ql-pp3e"]:
        raise Exception(f"[fasm2bels] Unsupported device '{args.device}'")

    env = environ.copy()
    env["DEVICE"] = args.device

    pcf_args = "" if args.pcf is None else f"--input-pcf {args.pcf}"
    out_verilog = f"{args.bit}.v" if args.out_verilog is None else args.out_verilog
    out_pcf = f"{args.bit}.v.pcf" if args.out_pcf is None else args.out_pcf
    out_qcf = f"{args.bit}.v.qcf" if args.out_qcf is None else args.out_qcf

    p_run_bash_cmds(
        f"""
'{python3}' -m f4pga.utils.quicklogic.pp3.fasm2bels '{args.bit}' \
  --phy-db '{F4PGA_SHARE_DIR}/arch/{args.device}_wlcsp/db_phy.pickle' \
  --device-name "${{DEVICE/ql-/}}" \
  --package-name '{args.part}' \
  --input-type bitstream \
  --output-verilog '{out_verilog}' \
  {pcf_args} \
  --output-pcf '{out_pcf}' \
  --output-qcf '{out_qcf}'
""",
        env=env,
    )


def write_bitheader():
    print("[F4PGA] Running (deprecated) write bitheader")
    print("Converting bitstream to C Header")
    p_run_pym("quicklogic_fasm.bitstream_to_header")


def write_binary():
    print("[F4PGA] Running (deprecated) write binary")
    print("Converting bitstream to flashable binary format")
    p_run_pym("quicklogic_fasm.bitstream_to_binary")


def write_jlink():
    print("[F4PGA] Running (deprecated) write jlink")
    print("Converting bitstream to JLink script")
    p_run_pym("quicklogic_fasm.bitstream_to_jlink")


def write_openocd():
    print("[F4PGA] Running (deprecated) write openocd")
    print("Converting bitstream to OpenOCD script")
    p_run_pym("quicklogic_fasm.bitstream_to_openocd")