librelane 3.0.0.dev23__py3-none-any.whl → 3.0.0.dev25__py3-none-any.whl

librelane/scripts/pyosys/ys_common.py

@@ -50,48 +50,28 @@ def _Design_read_verilog_files(
     synth_parameters: Iterable[str],
     includes: Iterable[str],
     defines: Iterable[str],
-    use_synlig: bool = False,
-    synlig_defer: bool = False,
+    use_slang: bool = False,
 ):
     files = list(files)  # for easier concatenation
     include_args = [f"-I{dir}" for dir in includes]
     define_args = [f"-D{define}" for define in defines]
     chparams = {}
-    synlig_chparam_args = []
+    slang_chparam_args = []
     for chparam in synth_parameters:
         param, value = chparam.split("=", maxsplit=1)  # validate
         chparams[param] = value
-        synlig_chparam_args.append(f"-P{param}={value}")
+        slang_chparam_args.append(f"-G{param}={value}")
 
-    if use_synlig and synlig_defer:
-        self.run_pass("plugin", "-i", "synlig-sv")
-        for file in files:
-            self.run_pass(
-                "read_systemverilog",
-                "-defer",
-                "-sverilog",
-                *define_args,
-                *include_args,
-                file,
-            )
-        self.run_pass(
-            "read_systemverilog",
-            "-link",
-            "-sverilog",
-            "-top",
-            top,
-            *synlig_chparam_args,
-        )
-    elif use_synlig:
-        self.run_pass("plugin", "-i", "synlig-sv")
+    ys.log("use_slang" if use_slang else "wtaf")
+    if use_slang:
+        self.run_pass("plugin", "-i", "slang")
         self.run_pass(
-            "read_systemverilog",
-            "-sverilog",
-            "-top",
+            "read_slang",
+            "--top",
             top,
             *define_args,
             *include_args,
-            *synlig_chparam_args,
+            *slang_chparam_args,
             *files,
         )
     else:

librelane/state/design_format.py

@@ -157,6 +157,13 @@ DesignFormat(
     alts=["NETLIST"],
 ).register()
 
+DesignFormat(
+    "logical_nl",
+    "logical_nl.v",
+    "Logical cell-only Verilog Netlist",
+    folder_override="nl",
+).register()
+
 DesignFormat(
     "pnl",
     "pnl.v",

librelane/steps/common_variables.py

@@ -18,204 +18,253 @@ from ..config import Variable
 
 io_layer_variables = [
     Variable(
-        "FP_IO_VEXTEND",
+        "IO_PIN_V_EXTENSION",
         Decimal,
         "Extends the vertical io pins outside of the die by the specified units.",
         default=0,
         units="µm",
+        deprecated_names=["FP_IO_VEXTEND"],
     ),
     Variable(
-        "FP_IO_HEXTEND",
+        "IO_PIN_H_EXTENSION",
         Decimal,
         "Extends the horizontal io pins outside of the die by the specified units.",
         default=0,
         units="µm",
+        deprecated_names=["FP_IO_HEXTEND"],
     ),
     Variable(
-        "FP_IO_VTHICKNESS_MULT",
+        "IO_PIN_V_THICKNESS_MULT",
         Decimal,
         "A multiplier for vertical pin thickness. Base thickness is the pins layer min width.",
         default=2,
+        deprecated_names=["FP_IO_VTHICKNESS_MULT"],
     ),
     Variable(
-        "FP_IO_HTHICKNESS_MULT",
+        "IO_PIN_H_THICKNESS_MULT",
         Decimal,
         "A multiplier for horizontal pin thickness. Base thickness is the pins layer min width.",
         default=2,
+        deprecated_names=["FP_IO_HTHICKNESS_MULT"],
+    ),
+    Variable(
+        "IO_PIN_V_LENGTH",
+        Optional[Decimal],
+        """
+        The length of the pins with a north or south orientation. If unspecified by a PDK, OpenROAD will use whichever is higher of the following two values:
+            * The pin width
+            * The minimum value satisfying the minimum area constraint given the pin width
+        """,
+        units="µm",
+        pdk=True,
+        deprecated_names=["FP_IO_VLENGTH"],
+    ),
+    Variable(
+        "IO_PIN_H_LENGTH",
+        Optional[Decimal],
+        """
+        The length of the pins with an east or west orientation. If unspecified by a PDK, OpenROAD will use whichever is higher of the following two values:
+            * The pin width
+            * The minimum value satisfying the minimum area constraint given the pin width
+        """,
+        units="µm",
+        pdk=True,
+        deprecated_names=["FP_IO_HLENGTH"],
     ),
 ]
 
 pdn_variables = [
     Variable(
-        "FP_PDN_SKIPTRIM",
+        "PDN_SKIPTRIM",
         bool,
         "Enables `-skip_trim` option during pdngen which skips the metal trim step, which attempts to remove metal stubs.",
         default=False,
+        deprecated_names=["FP_PDN_SKIPTRIM"],
     ),
     Variable(
-        "FP_PDN_CORE_RING",
+        "PDN_CORE_RING",
         bool,
         "Enables adding a core ring around the design. More details on the control variables in the PDK config documentation.",
         default=False,
+        deprecated_names=["FP_PDN_CORE_RING"],
     ),
     Variable(
-        "FP_PDN_ENABLE_RAILS",
+        "PDN_ENABLE_RAILS",
         bool,
         "Enables the creation of rails in the power grid.",
         default=True,
+        deprecated_names=["FP_PDN_ENABLE_RAILS"],
     ),
     Variable(
-        "FP_PDN_HORIZONTAL_HALO",
+        "PDN_HORIZONTAL_HALO",
         Decimal,
         "Sets the horizontal halo around the macros during power grid insertion.",
         default=10,
         units="µm",
+        deprecated_names=["FP_PDN_HORIZONTAL_HALO"],
     ),
     Variable(
-        "FP_PDN_VERTICAL_HALO",
+        "PDN_VERTICAL_HALO",
         Decimal,
         "Sets the vertical halo around the macros during power grid insertion.",
         default=10,
         units="µm",
+        deprecated_names=["FP_PDN_VERTICAL_HALO"],
     ),
     Variable(
-        "FP_PDN_MULTILAYER",
+        "PDN_MULTILAYER",
         bool,
         "Controls the layers used in the power grid. If set to false, only the lower layer will be used, which is useful when hardening a macro for integrating into a larger top-level design.",
         default=True,
-        deprecated_names=["DESIGN_IS_CORE"],
+        deprecated_names=["FP_PDN_MULTILAYER", "DESIGN_IS_CORE"],
     ),
     Variable(
-        "FP_PDN_RAIL_OFFSET",
+        "PDN_RAIL_OFFSET",
         Decimal,
         "The offset for the power distribution network rails for first metal layer.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_RAIL_OFFSET"],
     ),
     Variable(
-        "FP_PDN_VWIDTH",
+        "PDN_VWIDTH",
         Decimal,
         "The strap width for the vertical layer in generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_VWIDTH"],
     ),
     Variable(
-        "FP_PDN_HWIDTH",
+        "PDN_HWIDTH",
         Decimal,
         "The strap width for the horizontal layer in generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_HWIDTH"],
     ),
     Variable(
-        "FP_PDN_VSPACING",
+        "PDN_VSPACING",
         Decimal,
         "Intra-spacing (within a set) of vertical straps in generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_VSPACING"],
     ),
     Variable(
-        "FP_PDN_HSPACING",
+        "PDN_HSPACING",
         Decimal,
         "Intra-spacing (within a set) of horizontal straps in generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_HSPACING"],
     ),
     Variable(
-        "FP_PDN_VPITCH",
+        "PDN_VPITCH",
         Decimal,
         "Inter-distance (between sets) of vertical power straps in generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_VPITCH"],
     ),
     Variable(
-        "FP_PDN_HPITCH",
+        "PDN_HPITCH",
         Decimal,
         "Inter-distance (between sets) of horizontal power straps in generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_HPITCH"],
     ),
     Variable(
-        "FP_PDN_VOFFSET",
+        "PDN_VOFFSET",
         Decimal,
         "Initial offset for sets of vertical power straps.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_VOFFSET"],
     ),
     Variable(
-        "FP_PDN_HOFFSET",
+        "PDN_HOFFSET",
         Decimal,
         "Initial offset for sets of horizontal power straps.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_HOFFSET"],
     ),
     Variable(
-        "FP_PDN_CORE_RING_VWIDTH",
+        "PDN_CORE_RING_VWIDTH",
         Decimal,
         "The width for the vertical layer in the core ring of generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_CORE_RING_VWIDTH"],
     ),
     Variable(
-        "FP_PDN_CORE_RING_HWIDTH",
+        "PDN_CORE_RING_HWIDTH",
         Decimal,
         "The width for the horizontal layer in the core ring of generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_CORE_RING_HWIDTH"],
     ),
     Variable(
-        "FP_PDN_CORE_RING_VSPACING",
+        "PDN_CORE_RING_VSPACING",
         Decimal,
         "The spacing for the vertical layer in the core ring of generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_CORE_RING_VSPACING"],
     ),
     Variable(
-        "FP_PDN_CORE_RING_HSPACING",
+        "PDN_CORE_RING_HSPACING",
         Decimal,
         "The spacing for the horizontal layer in the core ring of generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_CORE_RING_HSPACING"],
     ),
     Variable(
-        "FP_PDN_CORE_RING_VOFFSET",
+        "PDN_CORE_RING_VOFFSET",
         Decimal,
         "The offset for the vertical layer in the core ring of generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_CORE_RING_VOFFSET"],
     ),
     Variable(
-        "FP_PDN_CORE_RING_HOFFSET",
+        "PDN_CORE_RING_HOFFSET",
         Decimal,
         "The offset for the horizontal layer in the core ring of generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_CORE_RING_HOFFSET"],
     ),
     Variable(
-        "FP_PDN_RAIL_LAYER",
+        "PDN_RAIL_LAYER",
         str,
         "Defines the metal layer used for PDN rails.",
-        deprecated_names=["FP_PDN_RAILS_LAYER"],
+        deprecated_names=["FP_PDN_RAIL_LAYER", "FP_PDN_RAILS_LAYER"],
         pdk=True,
     ),
     Variable(
-        "FP_PDN_RAIL_WIDTH",
+        "PDN_RAIL_WIDTH",
         Decimal,
         "Defines the width of PDN rails on the `FP_PDN_RAILS_LAYER` layer.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_RAIL_WIDTH"],
     ),
     Variable(
-        "FP_PDN_HORIZONTAL_LAYER",
+        "PDN_HORIZONTAL_LAYER",
         str,
         "Defines the horizontal PDN layer.",
-        deprecated_names=["FP_PDN_UPPER_LAYER"],
+        deprecated_names=["FP_PDN_HORIZONTAL_LAYER", "FP_PDN_UPPER_LAYER"],
         pdk=True,
     ),
     Variable(
-        "FP_PDN_VERTICAL_LAYER",
+        "PDN_VERTICAL_LAYER",
         str,
         "Defines the vertical PDN layer.",
-        deprecated_names=["FP_PDN_LOWER_LAYER"],
+        deprecated_names=["FP_PDN_VERTICAL_LAYER", "FP_PDN_LOWER_LAYER"],
         pdk=True,
     ),
 ]

librelane/steps/odb.py

@@ -27,7 +27,7 @@ from ..config import Instance, Macro, Variable
 from ..logging import info, verbose
 from ..state import DesignFormat, State
 
-from .openroad import DetailedPlacement, GlobalRouting
+from .openroad import DetailedPlacement, GlobalRouting, OpenROADStep
 from .openroad_alerts import OpenROADAlert, OpenROADOutputProcessor
 from .common_variables import io_layer_variables, dpl_variables, grt_variables
 from .step import (
@@ -52,6 +52,10 @@ class OdbpyStep(Step):
 
     alerts: Optional[List[OpenROADAlert]] = None
 
+    @classmethod
+    def get_openroad_path(Self) -> str:
+        return OpenROADStep.get_openroad_path()
+
     def on_alert(self, alert: OpenROADAlert) -> OpenROADAlert:
         if alert.code in [
             "ORD-0039",  # .openroad ignored with -python
@@ -155,7 +159,7 @@ class OdbpyStep(Step):
             lefs.append(str(design_lef))
         return (
             [
-                "openroad",
+                self.get_openroad_path(),
                 "-exit",
                 "-no_splash",
                 "-metrics",
@@ -614,31 +618,10 @@ class CustomIOPlacement(OdbpyStep):
 
     config_vars = io_layer_variables + [
         Variable(
-            "FP_IO_VLENGTH",
-            Optional[Decimal],
-            """
-            The length of the pins with a north or south orientation. If unspecified by a PDK, the script will use whichever is higher of the following two values:
-                * The pin width
-                * The minimum value satisfying the minimum area constraint given the pin width
-            """,
-            units="µm",
-            pdk=True,
-        ),
-        Variable(
-            "FP_IO_HLENGTH",
-            Optional[Decimal],
-            """
-            The length of the pins with an east or west orientation. If unspecified by a PDK, the script will use whichever is higher of the following two values:
-                * The pin width
-                * The minimum value satisfying the minimum area constraint given the pin width
-            """,
-            units="µm",
-            pdk=True,
-        ),
-        Variable(
-            "FP_PIN_ORDER_CFG",
+            "IO_PIN_ORDER_CFG",
             Optional[Path],
-            "Path to the configuration file. If set to `None`, this step is skipped.",
+            "Path to a custom pin configuration file.",
+            deprecated_names=["FP_PIN_ORDER_CFG"],
         ),
         Variable(
             "ERRORS_ON_UNMATCHED_IO",
@@ -656,28 +639,28 @@ class CustomIOPlacement(OdbpyStep):
 
     def get_command(self) -> List[str]:
         length_args = []
-        if self.config["FP_IO_VLENGTH"] is not None:
-            length_args += ["--ver-length", self.config["FP_IO_VLENGTH"]]
-        if self.config["FP_IO_HLENGTH"] is not None:
-            length_args += ["--hor-length", self.config["FP_IO_HLENGTH"]]
+        if self.config["IO_PIN_V_LENGTH"] is not None:
+            length_args += ["--ver-length", self.config["IO_PIN_V_LENGTH"]]
+        if self.config["IO_PIN_H_LENGTH"] is not None:
+            length_args += ["--hor-length", self.config["IO_PIN_H_LENGTH"]]
 
         return (
             super().get_command()
             + [
                 "--config",
-                self.config["FP_PIN_ORDER_CFG"],
+                self.config["IO_PIN_ORDER_CFG"],
                 "--hor-layer",
                 self.config["FP_IO_HLAYER"],
                 "--ver-layer",
                 self.config["FP_IO_VLAYER"],
                 "--hor-width-mult",
-                str(self.config["FP_IO_VTHICKNESS_MULT"]),
+                str(self.config["IO_PIN_V_THICKNESS_MULT"]),
                 "--ver-width-mult",
-                str(self.config["FP_IO_HTHICKNESS_MULT"]),
+                str(self.config["IO_PIN_H_THICKNESS_MULT"]),
                 "--hor-extension",
-                str(self.config["FP_IO_HEXTEND"]),
+                str(self.config["IO_PIN_H_EXTENSION"]),
                 "--ver-extension",
-                str(self.config["FP_IO_VEXTEND"]),
+                str(self.config["IO_PIN_V_EXTENSION"]),
                 "--unmatched-error",
                 self.config["ERRORS_ON_UNMATCHED_IO"],
             ]
@@ -685,8 +668,8 @@ class CustomIOPlacement(OdbpyStep):
         )
 
     def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
-        if self.config["FP_PIN_ORDER_CFG"] is None:
-            info(f"No custom floorplan file configured, skipping '{self.id}'…")
+        if self.config["IO_PIN_ORDER_CFG"] is None:
+            info(f"No custom I/O placement file configured, skipping '{self.id}'…")
             return {}, {}
         return super().run(state_in, **kwargs)
 
@@ -946,7 +929,12 @@ class CellFrequencyTables(OdbpyStep):
         lib_list = self.toolbox.filter_views(self.config, self.config["LIB"])
         env_copy["_PNR_LIBS"] = TclStep.value_to_tcl(lib_list)
         super().run_subprocess(
-            ["openroad", "-no_splash", "-exit", self.get_buffer_list_script()],
+            [
+                self.get_openroad_path(),
+                "-no_splash",
+                "-exit",
+                self.get_buffer_list_script(),
+            ],
             env=env_copy,
             log_to=self.get_buffer_list_file(),
         )

librelane/steps/openroad.py

@@ -267,6 +267,10 @@ class OpenROADStep(TclStep):
         ),
     ]
 
+    @classmethod
+    def get_openroad_path(Self) -> str:
+        return os.getenv("_LLN_OVERRIDE_OPENROAD", "openroad")
+
     @abstractmethod
     def get_script_path(self) -> str:
         pass
@@ -469,7 +473,7 @@ class OpenROADStep(TclStep):
     def get_command(self) -> List[str]:
         metrics_path = os.path.join(self.step_dir, "or_metrics_out.json")
         return [
-            "openroad",
+            self.get_openroad_path(),
             ("-gui" if os.getenv("_OPENROAD_GUI", "0") == "1" else "-exit"),
             "-no_splash",
             "-metrics",
@@ -956,7 +960,7 @@ class STAPostPNR(STAPrePNR):
                 lefs.append(lef)
         metrics_path = os.path.join(corner_dir, "filter_unannotated_metrics.json")
         filter_unannotated_cmd = [
-            "openroad",
+            self.get_openroad_path(),
             "-exit",
             "-no_splash",
             "-metrics",
@@ -1173,8 +1177,8 @@ class IOPlacement(OpenROADStep):
     """
     Places I/O pins on a floor-planned ODB file using OpenROAD's built-in placer.
 
-    If ``FP_PIN_ORDER_CFG`` is not ``None``, this step is skipped (for
-    compatibility with LibreLane 1.)
+    If ``IO_PIN_ORDER_CFG`` is not ``None``, this step is skipped (for
+    compatibility with OpenLane.)
     """
 
     id = "OpenROAD.IOPlacement"
@@ -1185,51 +1189,31 @@ class IOPlacement(OpenROADStep):
         + io_layer_variables
         + [
             Variable(
-                "FP_PPL_MODE",
+                "IO_PIN_PLACEMENT_MODE",
                 Literal["matching", "random_equidistant", "annealing"],
                 "Decides the mode of the random IO placement option.",
                 default="matching",
-                deprecated_names=[("FP_IO_MODE", _migrate_ppl_mode)],
+                deprecated_names=[("FP_IO_MODE", _migrate_ppl_mode), "FP_PPL_MODE"],
             ),
             Variable(
-                "FP_IO_MIN_DISTANCE",
+                "IO_PIN_MIN_DISTANCE",
                 Optional[Decimal],
                 "The minimum distance between two pins. If unspecified by a PDK, OpenROAD will use the length of two routing tracks.",
                 units="µm",
                 pdk=True,
+                deprecated_names=["FP_IO_MIN_DISTANCE"],
             ),
             Variable(
-                "FP_PIN_ORDER_CFG",
+                "IO_PIN_ORDER_CFG",
                 Optional[Path],
                 "Path to a custom pin configuration file.",
+                deprecated_names=["FP_PIN_ORDER_CFG"],
             ),
             Variable(
                 "FP_DEF_TEMPLATE",
                 Optional[Path],
                 "Points to the DEF file to be used as a template.",
             ),
-            Variable(
-                "FP_IO_VLENGTH",
-                Optional[Decimal],
-                """
-                The length of the pins with a north or south orientation. If unspecified by a PDK, OpenROAD will use whichever is higher of the following two values:
-                    * The pin width
-                    * The minimum value satisfying the minimum area constraint given the pin width
-                """,
-                units="µm",
-                pdk=True,
-            ),
-            Variable(
-                "FP_IO_HLENGTH",
-                Optional[Decimal],
-                """
-                The length of the pins with an east or west orientation. If unspecified by a PDK, OpenROAD will use whichever is higher of the following two values:
-                    * The pin width
-                    * The minimum value satisfying the minimum area constraint given the pin width
-                """,
-                units="µm",
-                pdk=True,
-            ),
         ]
     )
 
@@ -1237,8 +1221,8 @@ class IOPlacement(OpenROADStep):
         return os.path.join(get_script_dir(), "openroad", "ioplacer.tcl")
 
     def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
-        if self.config["FP_PIN_ORDER_CFG"] is not None:
-            info(f"FP_PIN_ORDER_CFG is set. Skipping '{self.id}'…")
+        if self.config["IO_PIN_ORDER_CFG"] is not None:
+            info(f"IO_PIN_ORDER_CFG is set. Skipping '{self.id}'…")
             return {}, {}
         if self.config["FP_DEF_TEMPLATE"] is not None:
             info(
@@ -1349,10 +1333,10 @@ class GeneratePDN(OpenROADStep):
         + pdn_variables
         + [
             Variable(
-                "FP_PDN_CFG",
+                "PDN_CFG",
                 Optional[Path],
                 "A custom PDN configuration file. If not provided, the default PDN config will be used.",
-                deprecated_names=["PDN_CFG"],
+                deprecated_names=["FP_PDN_CFG"],
             )
         ]
     )
@@ -1362,17 +1346,25 @@ class GeneratePDN(OpenROADStep):
 
     def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
         kwargs, env = self.extract_env(kwargs)
-        if self.config["FP_PDN_CFG"] is None:
-            env["FP_PDN_CFG"] = os.path.join(
+        if self.config["PDN_CFG"] is None:
+            env["PDN_CFG"] = os.path.join(
                 get_script_dir(), "openroad", "common", "pdn_cfg.tcl"
             )
-            info(f"'FP_PDN_CFG' not explicitly set, setting it to {env['FP_PDN_CFG']}…")
+            info(f"'PDN_CFG' not explicitly set, setting it to {env['PDN_CFG']}…")
         views_updates, metrics_updates = super().run(state_in, env=env, **kwargs)
 
+        alerts = self.alerts or []
         error_reports = glob(os.path.join(self.step_dir, "*-grid-errors.rpt"))
         for report in error_reports:
             net = os.path.basename(report).split("-", maxsplit=1)[0]
-            count = get_psm_error_count(open(report, encoding="utf8"))
+            no_terminals = any(
+                alert.code == "PSM-0025" and alert.message.startswith(net)
+                for alert in alerts
+            )
+            if no_terminals:
+                count = 1
+            else:
+                count = get_psm_error_count(open(report, encoding="utf8"))
             metrics_updates[f"design__power_grid_violation__count__net:{net}"] = count
 
         metric_updates_with_aggregates = aggregate_metrics(
@@ -1511,16 +1503,17 @@ class GlobalPlacementSkipIO(_GlobalPlacement):
 
     config_vars = _GlobalPlacement.config_vars + [
         Variable(
-            "FP_PPL_MODE",
+            "IO_PIN_PLACEMENT_MODE",
             Literal["matching", "random_equidistant", "annealing"],
             "Decides the mode of the random IO placement option.",
             default="matching",
-            deprecated_names=[("FP_IO_MODE", _migrate_ppl_mode)],
+            deprecated_names=[("FP_IO_MODE", _migrate_ppl_mode), "FP_PPL_MODE"],
         ),
         Variable(
-            "FP_PIN_ORDER_CFG",
+            "IO_PIN_ORDER_CFG",
             Optional[Path],
             "Path to a custom pin configuration file.",
+            deprecated_names=["FP_PIN_ORDER_CFG"],
         ),
         Variable(
             "FP_DEF_TEMPLATE",
@@ -1536,9 +1529,9 @@ class GlobalPlacementSkipIO(_GlobalPlacement):
                 f"I/O pins were loaded from {self.config['FP_DEF_TEMPLATE']}. Returning state unaltered…"
             )
             return {}, {}
-        if self.config["FP_PIN_ORDER_CFG"] is not None:
+        if self.config["IO_PIN_ORDER_CFG"] is not None:
             info(
-                f"I/O pins to be placed from {self.config['FP_PIN_ORDER_CFG']}. Returning state unaltered…"
+                f"I/O pins to be placed from {self.config['IO_PIN_ORDER_CFG']}. Returning state unaltered…"
             )
             return {}, {}
         env["__PL_SKIP_IO"] = "1"