Pin Locking now working

Author: robtaylor

chipflow_lib/pin_lock.py

@@ -9,50 +9,13 @@
 
 from amaranth import Shape
 from chipflow_lib import _parse_config, _get_cls_by_reference
-from chipflow_lib.platforms import PACKAGE_DEFINITIONS, PIN_ANNOTATION_SCHEMA
+from chipflow_lib.platforms import PACKAGE_DEFINITIONS, Schemas
 
+# logging.basicConfig(stream=sys.stdout, level=logging.WARNING)
 logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 
 
-def has_consecutive_numbers(lst):
-    if not lst:
-        return False
-    lst.sort()
-    return all(lst[i] + 1 == lst[i + 1] for i in range(len(lst) - 1))
-
-def strip_pin_suffix(name):
-    """Strip _i, _o, and _oe suffixes from a pin name.
-    
-    Args:
-        name: Pin name string
-        
-    Returns:
-        Name with suffix removed
-    """
-    return re.sub(r'(_i|_o|_oe)$', '', name)
-
-def signature_width(signature):
-    width = 0
-    obj = signature.create()
-    for a,b,c in signature.flatten(obj):
-        shape = Shape.cast(b.shape)
-        width += shape.width
-    return width
-
-def member_width(member):
-    if member.is_signature:
-        return signature_width(member.signature)
-    else:
-        shape = Shape.cast(member.shape)
-        return shape.width
-
-MATCH_TRIPLE = re.compile(r'(_i|_o|_oe)$')
-
-def coalesce_triples(sig: dict) -> None:
-    if sig['type'] == 'port':
-        pass
-
 def count_pins(member):
     if member['type'] == 'interface':
         width = 0
@@ -62,26 +25,44 @@ def count_pins(member):
     elif member['type'] == 'port':
         return member['width']
 
+
 def allocate_pins(name, member, pins:list):
     pin_map = {}
     logger.debug(f"allocate_pins: name={name}, member={member}, pins={pins}")
-    if member['type'] == 'interface':
-        for k, v in member['members'].items():
-            n = '_'.join([name,k])
-            _map, pins = allocate_pins(n, v, pins)
-            pin_map |= _map
-            logger.debug(f"{pin_map},{_map}")
-    elif PIN_ANNOTATION_SCHEMA in member['annotations']:
-        name = name
-        signature = member['annotations'][PIN_ANNOTATION_SCHEMA]
-        width = signature['width']
-        direction = signature['direction']
-        if width == 1:
-            pin_map[name] = {'pin':pins[0], 'type':member['dir']}
-        else:
-            pin_map[name] = {'pins':pins, 
-                             'direction':direction}
-        return pin_map, pins[width:]
+
+    match member:
+        case {'type':'interface', 'annotations':{Schemas.PIN_ANNOTATION: sig}}:
+            logger.debug("matched PinSignature {sig}")
+            name = name
+            width = sig['width']
+            direction = sig['direction']
+            if width == 1:
+                pin_map[name] = {'pin':pins[0], 'direction':direction}
+            else:
+                pin_map[name] = {'pins':pins, 
+                                'direction':direction}
+            return pin_map, pins[width:]
+        case {'type': 'interface'}:
+            for k, v in member['members'].items():
+                n = '_'.join([name,k])
+                _map, pins = allocate_pins(n, v, pins)
+                pin_map |= _map
+                logger.debug(f"{pin_map},{_map}")
+            return pin_map, pins
+        case {'type': 'port'}:
+            logging.warning(f"Component `{name}` in this design is not using PinSignature")
+            name = name
+            width = member['width']
+            direction = member['dir']
+            if width == 1:
+                pin_map[name] = {'pin':pins[0], 'direction':direction}
+            else:
+                pin_map[name] = {'pins':pins, 
+                                'direction':direction}
+            return pin_map, pins[width:]
+        case _:
+            logging.debug(f"Shouldnt get here. member = {member}")
+            assert False
 
 
 def check_pins(name, member, old_map, new_map):

chipflow_lib/platforms/__init__.py

@@ -1,15 +1,21 @@
+import logging
+
+from enum import Enum
 from dataclasses import dataclass
-from typing import Set, List
+from typing import Set, List, TypeVar, Dict
 
 from amaranth import Shape
 from amaranth.lib import wiring, io, meta
 from amaranth.lib.wiring import In, Out
 from pydantic import BaseModel, ConfigDict
 from pprint import pformat
 
+from .. import ChipFlowError
 from .silicon import *
 from .sim import *
 
+logger = logging.getLogger(__name__)
+
 def chipflow_schema_uri(name: str, version:int) -> str:
     return f"https://api.chipflow.com/schemas/{version}/{name}"
 
@@ -66,10 +72,10 @@ def origin(self): # type: ignore
         return self.model
 
     def as_json(self): # type: ignore
-        print(f"PinAnnotations: {pformat(self.model.model_dump_json())}")
         return self.model.model_dump()
 
-PIN_ANNOTATION_SCHEMA = chipflow_schema_uri("pin-annotation",0)
+class Schemas(Enum):
+    PIN_ANNOTATION = chipflow_schema_uri("pin-annotation",0)
 
 class PinSignature(wiring.Signature):
     def __init__(self, direction, width=1, init=None):
@@ -95,10 +101,6 @@ def __init__(self, direction, width=1, init=None):
     def annotations(self, *args):
         return wiring.Signature.annotations(self, *args) + (PinAnnotation(direction=self._direction, width=self._width),)
 
-    def create(self, *args, **kwargs):
-        print(f"Calling PinSignature.create({args},{kwargs})")
-        return super().create(*args, **kwargs)
-
     def __repr__(self):
         return f"PinSignature({self._direction}, {self._width})"
 
@@ -111,9 +113,9 @@ def InputPinSignature(width):
 def BidirPinSignature(width):
     return PinSignature(io.Direction.Bidir)
 
-def group_consecutive_items(lst):
+def group_consecutive_items(lst: List[int]) -> Dict[int, List[int]]:
     if not lst:
-        return []
+        return {}
 
     grouped = []
     current_group = [lst[0]]
@@ -131,8 +133,7 @@ def group_consecutive_items(lst):
         d.setdefault(len(g), []).append(g)
     return d
 
-
-def find_contiguous_sequence(lst, n):
+def find_contiguous_sequence(lst: List[int], total: int) -> List[int]:
     """Find the next sequence of n consecutive numbers in a sorted list
     
     Args:
@@ -143,22 +144,22 @@ def find_contiguous_sequence(lst, n):
         A slice indexing the first sequence of n consecutive numbers found within the given list
         if unable to find a consecutive list, allocate as contigously as possible
     """
-    if not lst or len(lst) < n:
-        return None
+    if not lst or len(lst) < total:
+        raise ChipFlowError("Invalid request to find_contiguous_argument")
 
     grouped = group_consecutive_items(lst)
 
-    print(f"grouped list: {pformat(grouped)}")
     ret = []
+    n = total
     for k in sorted(grouped.keys(), reverse=True):
         for g in grouped[k]:
-            print(f"{g} {k} {n}")
+            assert (n+len(ret)==total)
             if k >= n:
-                ret += g[0:min(n-1,k-1)]
+                ret += g[0:min(n,k)]
                 return ret
             else:
                 n = n - k
-                ret += g[0:min(n-1,k-1)]
+                ret += g[0:k]
 
     return ret
 
@@ -173,8 +174,10 @@ def pins(self) -> Set[str]:
 
     def allocate(self, available: Set[str], width:int) -> List[str]:
         avail_n = sorted([int(i) for i in available])
-        print(f"PGAPackageDef.allocate {avail_n}, {width}")
+        logger.debug(f"PGAPackageDef.allocate {width} from {len(avail_n)} remaining")
         ret = find_contiguous_sequence(avail_n, width)
+        logger.debug(f"PGAPackageDef.returned {ret}")
+        assert(len(ret)==width)
         return [str(i) for i in ret]
 
 PACKAGE_DEFINITIONS = {

pyproject.toml

@@ -21,8 +21,6 @@ dependencies = [
     "amaranth>=0.5,<0.7",
     "amaranth-soc @ git+https://github.com/amaranth-lang/amaranth-soc",
     "amaranth-boards @ git+https://github.com/amaranth-lang/amaranth-boards",
-    "amaranth-stdio @ git+https://github.com/amaranth-lang/amaranth-stdio",
-    "amaranth-orchard @ git+https://github.com/ChipFlow/amaranth-orchard",
     "yowasp-yosys>=0.41.0.0",
     "yowasp-nextpnr-ecp5>=0.7",
     "yowasp-runtime",