wip

Author: robtaylor

chipflow_lib/pin_lock.py

@@ -2,19 +2,12 @@
 import inspect
 import logging
 
-from pprint import pformat
 from pathlib import Path
-from typing import Any, List, Dict, Tuple
 
-from chipflow_lib import _parse_config, _ensure_chipflow_root, ChipFlowError
+from chipflow_lib import _parse_config, _ensure_chipflow_root
 from chipflow_lib.platforms import (
-        PACKAGE_DEFINITIONS,
-        PIN_ANNOTATION_SCHEMA,
         top_components,
-        LockFile,
-        Package,
-        PortMap,
-        Port
+        LockFile
 )
 from chipflow_lib.config_models import Config
 

chipflow_lib/platforms/utils.py

@@ -5,8 +5,9 @@
 import pydantic
 
 from collections import OrderedDict, deque
-from collections.abc import MutableMapping
+from collections.abc import MutableMapping, Sequence
 from enum import Enum, IntEnum, StrEnum, auto
+from math import ceil, floor
 from pprint import pformat
 from typing import Any, Dict, List, Set, Tuple, Optional, Union, Literal
 
@@ -580,7 +581,7 @@ def bringup_pins(self) -> BringupPins:
 
 
     def _allocate(self, available: PinSet, width: int) -> PinList:
-        avail_n = self.sortpins(available)
+        avail_n = self._sortpins(available)
         logger.debug(f"BareDiePackageDef.allocate {width} from {len(avail_n)} remaining")
         ret = _find_contiguous_sequence(self._ordered_pins, avail_n, width)
         logger.debug(f"BareDiePackageDef.returned {ret}")
@@ -646,9 +647,6 @@ def _allocate(self, available: Set[str], width: int) -> List[str]:
         assert len(ret) == width
         return ret
 
-    def sortpins(self, pins: Union[List[str], Set[str]]) -> List[str]:
-        return sorted(list(pins), key=int)
-
     @property
     def bringup_pins(self) -> BringupPins:
         return BringupPins(
@@ -774,83 +772,64 @@ class GAPackageDef(BasePackageDef):
     additional_pins: Optional[Set[GAPin]]
 
     def model_post_init(self, __context):
+        def int_to_alpha(i: int):
+            while i > 0:
+                char = i % 26
+                i = i // 26
+                out = chr(ord('A')+char-1) + out
+            return out
+
+        def pins_for_range(h1, h2, w1, w2):
+            return set([[(int_to_alpha(h),w) for h in range(h1, h2)] for w in range(w1, w2)])
+
         match self.layout_type:
             case GALayout.FULL:
-                pins = ([(chr(h),w) for h in range(ord('a'), ord('a') + self.height + 10 )])
+                pins = pins_for_range(1, self.height, 1, self.width)
+
             case GALayout.PERIMETER:
-                pins = set([str(i) for i in range(8, self.width * 2 + self.height * 2)] - )
-            case GALayout.CHANNEL:
+                pins = pins_for_range(1, self.height, 1, self.width) - \
+                       pins_for_range(1 + self.channel_width, self.height-self.channel_width,  1 + self.channel_width, self.width - self.channel_width)
+
             case GALayout.ISLAND:
+                pins = pins_for_range(1, self.height, 1, self.width) - \
+                       pins_for_range(1 + self.channel_width, self.height-self.channel_width,  1 + self.channel_width, self.width - self.channel_width) + \
+                       pins_for_range(ceil(self.height/ 2 - self.island_width /2), floor(self.height/2 + self.island_width /2),
+                                      ceil(self.width / 2 - self.island_width /2), floor(self.width /2 + self.island_width /2))
+
+            case GALayout.CHANNEL:
+                pins = pins_for_range(1, self.channel_width + 1, 1, self.width) + \
+                       pins_for_range(self.height - self.channel_width, self.height, 1, self.width)
 
-        pins =(
-            set([str(i) for i in range(8, self.width * 2 + self.height * 2)])
-            - set(self.power.values())
-            - set(self.power.clocks.values())
-            - set(self.power.jtag.values())
-        )
         self._ordered_pins = sorted(pins)
         return super().model_post_init(__context)
 
 
-    def allocate(self, available: Set[str], width: int) -> List[str]:
+    def _allocate(self, available: Set[str], width: int) -> List[str]:
         avail_n = sorted(available)
         logger.debug(f"GAPackageDef.allocate {width} from {len(avail_n)} remaining: {available}")
         ret = _find_contiguous_sequence(self._ordered_pins, avail_n, width)
         logger.debug(f"GAPackageDef.returned {ret}")
         assert len(ret) == width
         return ret
 
-    def sortpins(self, pins: Union[List[str], Set[str]]) -> List[str]:
-        return sorted(list(pins), key=int)
-
     @property
-    def power(self) -> List[Tuple[Pin, Pin]]:
-        """
-        The set of power pins for a quad package.
-        Power pins are always a matched pair in the middle of a side, with the number
-        varying with the size of the package.
-        We don't move power pins from these locations to allow for easier bring up test.
-        """
-        pins = []
-        n = (self.width + self.height)//12
-        # Left
-        pins.append((str(self.height//2), str(self.height//2 +1)))
-        # Bottom
-        start = self.height
-        if n > 2:
-            pins.append((str(start + self.width//2), str(start + self.width//2 +1)))
-        # Right
-        start = start + self.width
-        if n > 1:
-            pins.append((str(start + self.height//2), str(start + self.height//2 +1)))
-        # Top
-        start = start + self.height
-        if n > 3:
-            pins.append((str(start + self.width//2), str(start + self.width//2 +1)))
-        return pins
-
+    def bringup_pins(self) -> BringupPins:
+        return BringupPins(
+            core_power=[self._power],
+            core_clock={0: str(2)},
+            core_reset={0: str(1)},
+            core_heartbeat={0: str(self.width * 2 + self.height * 2 - 1)},
+            core_jtag=self._jtag
+        )
 
 
     @property
-    def resets(self) -> Dict[int, Pin]:
-        """
-        Numbered set of reset pins for the package
-        Default implementation with one reset pin
-        near the beginning of the package
-        """
-        return {0: str(1)}  # Second pin
+    def _power(self) -> List[PowerPins]:
+        return [PowerPins(1,2)]
 
-    @property
-    def clocks(self) -> Dict[int, Pin]:
-        """
-        Numbered set of clock pins for the package
-        Default implementation with one clock pin
-        near the beginning of the package
-        """
-        return {0: str(2)}  # Third pin
 
     @property
-    def jtag(self) -> Dict[JTAGWire, Pin]:
+    def _jtag(self) -> Dict[JTAGWire, Pin]:
         """
         Map of JTAG pins for the package
         """

tests/test_package_pins.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: BSD-2-Clause
 import unittest
-from unittest import mock
 
 from chipflow_lib.platforms.utils import (
     _BareDiePackageDef, _PGAPackageDef,

tests/test_utils_additional.py

@@ -14,7 +14,6 @@
     PIN_ANNOTATION_SCHEMA,
     IOSignature,
     _Side,
-    _BasePackageDef,
     _BareDiePackageDef,
     _PGAPackageDef,
     Package,