wip

Author: robtaylor

chipflow_lib/pin_lock.py

@@ -1,13 +1,19 @@
 import inspect
 import json
+import logging
 import re
+import sys
 
-from pprint import pprint
+from pprint import pformat
 from pathlib import Path
 
 from amaranth import Shape
 from chipflow_lib import _parse_config, _get_cls_by_reference
-from chipflow_lib.platforms import PACKAGE_DEFINITIONS
+from chipflow_lib.platforms import PACKAGE_DEFINITIONS, PIN_ANNOTATION_SCHEMA
+
+logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
 
 def has_consecutive_numbers(lst):
     if not lst:
@@ -56,23 +62,26 @@ def count_pins(member):
     elif member['type'] == 'port':
         return member['width']
 
-def allocate_pins(name, member, pins, pin_map):
-    print(f"allocate_pins: {pins}")
+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])
-            pins = allocate_pins(n, v, pins, pin_map)
-        return pins
-    elif member['type'] == 'port':
+            _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
-        width = member['width']
+        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] = {'start':pins[0], 
-                             'end':pins[width-1], 
-                             'type':member['dir']}
-        return pins[width:]
+            pin_map[name] = {'pins':pins, 
+                             'direction':direction}
+        return pin_map, pins[width:]
 
 
 def check_pins(name, member, old_map, new_map):
@@ -85,27 +94,10 @@ def check_pins(name, member, old_map, new_map):
         if width == 1:
             assert 'pin' in old_map[name]
         else:
-            assert 'start' in old_map[name]
-            assert 'end' in old_map[name]
-            assert old_map[name]['end'] - old_map[name]['start'] + 1 == width
+            assert 'pins' in old_map[name]
+            assert len(old_map[name]['pins']) == width
         new_map[name] = old_map[name]
 
-def connect_pins(pin_map):
-    for k,v in interfaces.items():
-        if member['type'] == 'interface':
-            for k, v in member['members'].items():
-                n = '_'.join([name,k])
-                check_pins(n, v, old_map, new_map)
-        elif member['type'] == 'port':
-            width = member['width']
-            if width == 1:
-                assert 'pin' in old_map[name]
-            else:
-                assert 'start' in old_map[name]
-                assert 'end' in old_map[name]
-                assert old_map[name]['end'] - old_map[name]['start'] + 1 == width
-            new_map[name] = old_map[name]
-
 def lock_pins():
     config = _parse_config()
     used_pins = set()
@@ -124,11 +116,11 @@ def lock_pins():
     package_name = config["chipflow"]["silicon"]["pad_ring"]
 
     if package_name not in PACKAGE_DEFINITIONS:
-        print(f"Package '{package} is unknown")
+        logger.debug(f"Package '{package} is unknown")
     package = PACKAGE_DEFINITIONS[package_name]
 
     for d in ("pads", "power"):
-        print(f"Checking [chipflow.silicon.{d}]:")
+        logger.debug(f"Checking [chipflow.silicon.{d}]:")
         for k, v in config["chipflow"]["silicon"][d].items():
             pin = v['loc']
             used_pins.add(pin)
@@ -141,11 +133,11 @@ def lock_pins():
                 'type': v['type'] if 'type' in v else None}
 
 
-    print(f'Pins in use: {sorted(used_pins)}')
+    logger.debug(f'Pins in use: {sorted(used_pins)}')
 
     unallocated = package.pins - used_pins
 
-    print(f"unallocated pins = {sorted(unallocated)}")
+    logger.debug(f"unallocated pins = {sorted(unallocated)}")
     interfaces = {}
     top_components = config["chipflow"]["top"].items()
     component_configs = {}
@@ -154,7 +146,7 @@ def lock_pins():
     for name, conf in top_components:
         if '.' in name:
             assert conf is dict
-            print("Config found for {name}")
+            logger.debug("Config found for {name}")
             component_configs[name.split('.')[0]] = conf
 
     for name, ref in top_components:
@@ -163,36 +155,36 @@ def lock_pins():
             top[name] = cls(component_configs[name])
         else:
             top[name] = cls()
-        pprint(top[name].metadata.origin.signature.members)
+        logger.debug(pformat(top[name].metadata.origin.signature.members))
         metadata = top[name].metadata.as_json()
         interfaces |= metadata['interface']['members']
 
-    print(f"All interfaces: {interfaces.keys()}")
+    logger.debug(f"All interfaces: {interfaces.keys()}")
     pin_map_interfaces = {}
 
     # we try to keep pins together for each interface
     for k,v in interfaces.items():
-        print(f"Interface {k}:")
-        pprint(v)
+        logger.debug(f"Interface {k}:")
+        logger.debug(pformat(v))
         width = count_pins(v)
-        print(f"member {k} total width = {width}")
+        logger.debug(f"member {k} total width = {width}")
         pins = package.allocate(unallocated, width)
-        print(f"allocated range: {pins}")
+        logger.debug(f"allocated range: {pins}")
         if len(pins) == 0:
-            print("ERROR")
+            logger.error("No pins were allocation by {package}")
+            exit(1)
         if k in old_interfaces:
-            if old_interfaces[k]['start'] != pins.start or \
-            old_interfaces[k]['end'] != pins.stop:
+            if len(old_interfaces[k]['pins']) != len(pins):
                 # TODO: option to allocate new pins nonconsecutively
                 print("top level interface has changed size")
                 exit(1)
             check_pins(k, v, old_map, pin_map)
-            pin_map_interfaces[k] = {'top': True, 'start':pins.start, 'end':pins.stop}
+            pin_map_interfaces[k] = {'top': True, 'pins':pins}
         else:
-            pin_map_interfaces[k] = {'top': True, 'start':pins.start, 'end':pins.stop}
-            newpins = unallocated[pins]
-            unallocated[pins] = []
-            allocate_pins(k, v, newpins, pin_map)
+            pin_map_interfaces[k] = {'top': True, 'pins':pins}
+            unallocated = unallocated - set(pins)
+            _map,_ = allocate_pins(k, v, pins)
+            pin_map |= _map
 
     with open('pins.lock', 'w') as f:
         newlock = {'interfaces': pin_map_interfaces,
@@ -210,7 +202,7 @@ def build_cli_parser(self, parser):
             "lock", help=inspect.getdoc(self.lock).splitlines()[0])
 
     def run_cli(self, args):
-        print(f"command {args}")
+        logger.debug(f"command {args}")
         if args.action == "lock":
             self.lock()
 

chipflow_lib/platforms/__init__.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
-from typing import Set
+from typing import Set, List
 
+from amaranth import Shape
 from amaranth.lib import wiring, io, meta
 from amaranth.lib.wiring import In, Out
 from pydantic import BaseModel, ConfigDict
@@ -68,10 +69,13 @@ 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 PinSignature(wiring.Signature):
-    def __init__(self, direction, width=1):
+    def __init__(self, direction, width=1, init=None):
         self._direction = direction
         self._width = width
+        self._init = init
         match direction:
             case io.Direction.Bidir:
                 sig = {
@@ -90,7 +94,11 @@ def __init__(self, direction, width=1):
 
     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})"
 
@@ -163,7 +171,7 @@ class PGAPackageDef:
     def pins(self) -> Set[str]:
         return set([str(i) for i in range(self.size-1)])
 
-    def allocate(self, available: Set[str], width:int):
+    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}")
         ret = find_contiguous_sequence(avail_n, width)