wip

Author: robtaylor

chipflow_lib/cli.py

@@ -3,6 +3,7 @@
 import inspect
 import sys
 import traceback
+import logging
 
 from pprint import pformat
 
@@ -16,6 +17,8 @@
 from .pin_lock import PinCommand
 
 
+logging.basicConfig(stream=sys.stdout, level=logging.WARNING)
+
 class UnexpectedError(ChipFlowError):
     pass
 
@@ -34,6 +37,14 @@ def run(argv=sys.argv[1:]):
                                 f"using `{step_reference}`")
 
     parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--verbose", "-v",
+        dest="log_level",
+        action="append_const",
+        const=10,
+    )
+
     command_argument = parser.add_subparsers(dest="command", required=True)
     for command_name, command in commands.items():
         command_subparser = command_argument.add_parser(command_name, help=inspect.getdoc(command))
@@ -44,6 +55,9 @@ def run(argv=sys.argv[1:]):
                                 f"step `{command_name}`")
 
     args = parser.parse_args(argv)
+    if args.log_level:
+        log_level = max(logging.DEBUG, logging.WARNING - sum(args.log_level))
+        logging.getLogger().setLevel(log_level)
 
     try:
         try:

chipflow_lib/pin_lock.py

@@ -9,60 +9,68 @@
 
 from amaranth import Shape
 from chipflow_lib import _parse_config, _get_cls_by_reference
-from chipflow_lib.platforms import PACKAGE_DEFINITIONS, Schemas
+from chipflow_lib.platforms import PACKAGE_DEFINITIONS, PIN_ANNOTATION_SCHEMA
 
-# logging.basicConfig(stream=sys.stdout, level=logging.WARNING)
-logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
+# logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 
 
-def count_pins(member):
-    if member['type'] == 'interface':
+def count_pins(name, member):
+    logger.debug(f"count_pins {name} {member['type']} {member['annotations'] if 'annotations' in member else 'no annotations'}")
+    if member['type']=='interface' and 'annotations' in member \
+       and PIN_ANNOTATION_SCHEMA in member['annotations']:
+        return member['annotations'][PIN_ANNOTATION_SCHEMA]['width']
+    elif member['type'] == 'interface':
         width = 0
-        for _, v in member['members'].items():
-            width += count_pins(v)
+        for n, v in member['members'].items():
+            width += count_pins('_'.join([name,n]), v)
         return width
     elif member['type'] == 'port':
         return member['width']
 
+def count_old_pins(d):
+    match d:
+        case {'type':t, 'pins':p}:
+            return len(p)
+        case _:
+            return sum([count_old_pins(v) for v in d.values()])
 
 def allocate_pins(name, member, pins:list):
     pin_map = {}
-    logger.debug(f"allocate_pins: name={name}, member={member}, pins={pins}")
-
-    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
+    logger.debug(f"allocate_pins: name={name},  pins={pins}")
+    logger.debug(f"member={pformat(member)}")
+
+    if member['type']=='interface' and 'annotations' in member \
+       and PIN_ANNOTATION_SCHEMA in member['annotations']:
+        logger.debug("matched PinSignature {sig}")
+        name = name
+        sig = member['annotations'][PIN_ANNOTATION_SCHEMA]
+        width = sig['width']
+        direction = sig['direction']
+        pin_map[name] = {'pins':pins[0:width], 
+                         'direction':direction,
+                         'type':'io'}
+        return pin_map, pins[width:]
+    elif member['type'] == 'interface':
+        logger.warning("member without PinSignature, pin allocation likely to be wrong")
+        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
+    elif member['type'] == 'port':
+        logger.warning(f"Component `{name}` in this design is not using PinSignature")
+        name = name
+        width = member['width']
+        direction = member['dir']
+        pin_map[name] = {'pins':pins[0:width], 
+                         'direction':direction,
+                         'type': 'io'}
+        return pin_map, pins[width:]
+    else:
+        logging.debug(f"Shouldnt get here. member = {member}")
+        assert False
 
 
 def check_pins(name, member, old_map, new_map):
@@ -72,11 +80,8 @@ def check_pins(name, member, old_map, new_map):
             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 'pins' in old_map[name]
-            assert len(old_map[name]['pins']) == width
+        assert 'pins' in old_map[name]
+        assert len(old_map[name]['pins']) == width
         new_map[name] = old_map[name]
 
 def lock_pins():
@@ -87,13 +92,10 @@ def lock_pins():
     if lockfile.exists():
         with open(lockfile) as f:
             old_lock = json.load(f)
-            old_interfaces = old_lock['interfaces']
             old_map = old_lock['map']
     else:
         old_map = {}
-        old_interfaces = {}
-
-    print(f"Locking pins: {'using pins.lock' if lockfile else ''}")
+    print(f"Locking pins: {'using pins.lock' if lockfile.exists() else ''}")
     package_name = config["chipflow"]["silicon"]["pad_ring"]
 
     if package_name not in PACKAGE_DEFINITIONS:
@@ -103,14 +105,14 @@ def lock_pins():
     for d in ("pads", "power"):
         logger.debug(f"Checking [chipflow.silicon.{d}]:")
         for k, v in config["chipflow"]["silicon"][d].items():
-            pin = v['loc']
+            pin = str(v['loc'])
             used_pins.add(pin)
-            if k in old_map and old_map[k]['pin'] != pin:
+            if k in old_map and old_map[k]['pins'] != [pin]:
                 print(f"chipflow.toml conflicts with pins.lock: "
-                    f"{k} had pin {old_map[k]}, now {pin}.")
+                    f"{k} had pin {old_map[k]['pins']}, now {[pin]}.")
                 exit(1)
             pin_map[k] = {
-                'pin': pin,
+                'pins': [pin],
                 'type': v['type'] if 'type' in v else None}
 
 
@@ -147,29 +149,30 @@ def lock_pins():
     for k,v in interfaces.items():
         logger.debug(f"Interface {k}:")
         logger.debug(pformat(v))
-        width = count_pins(v)
-        logger.debug(f"member {k} total width = {width}")
-        pins = package.allocate(unallocated, width)
-        logger.debug(f"allocated range: {pins}")
-        if len(pins) == 0:
-            logger.error("No pins were allocation by {package}")
-            exit(1)
-        if k in old_interfaces:
-            if len(old_interfaces[k]['pins']) != len(pins):
+        width = count_pins(k, v)
+        print(f"  {k}: total {width} pins")
+        if k in old_map:
+            print(f"  {k} found in pins.lock, reusing")
+            logger.debug(pformat(old_map[k]))
+            old_width = count_old_pins(old_map[k])
+            if old_width != width:
                 # TODO: option to allocate new pins nonconsecutively
-                print("top level interface has changed size")
+                print(f"top level interface has changed size. Old size = {old_width}, new size = {width}")
                 exit(1)
-            check_pins(k, v, old_map, pin_map)
-            pin_map_interfaces[k] = {'top': True, 'pins':pins}
+            pin_map[k] = old_map[k]
         else:
-            pin_map_interfaces[k] = {'top': True, 'pins':pins}
+            pins = package.allocate(unallocated, width)
+            if len(pins) == 0:
+                print("ERROR: No pins were allocation by {package}")
+                exit(1)
+            logger.debug(f"allocated range: {pins}")
             unallocated = unallocated - set(pins)
-            _map,_ = allocate_pins(k, v, pins)
-            pin_map |= _map
+            _map, _ = allocate_pins(k, v, pins)
+            pin_map[k] = _map
 
     with open('pins.lock', 'w') as f:
-        newlock = {'interfaces': pin_map_interfaces,
-                'map': pin_map}
+        newlock = {'map': pin_map,
+                   'metadata': metadata}
 
         json.dump(newlock, f, indent=2, sort_keys=True)
 

chipflow_lib/platforms/__init__.py

@@ -75,7 +75,8 @@ def as_json(self): # type: ignore
         return self.model.model_dump()
 
 class Schemas(Enum):
-    PIN_ANNOTATION = chipflow_schema_uri("pin-annotation",0)
+    PIN_ANNOTATION = str(chipflow_schema_uri("pin-annotation",0))
+PIN_ANNOTATION_SCHEMA = str(chipflow_schema_uri("pin-annotation",0))
 
 class PinSignature(wiring.Signature):
     def __init__(self, direction, width=1, init=None):
@@ -104,16 +105,16 @@ def annotations(self, *args):
     def __repr__(self):
         return f"PinSignature({self._direction}, {self._width})"
 
-def OutputPinSignature(width):
-    return PinSignature(io.Direction.Output)
+def OutputPinSignature(width, **kwargs):
+    return PinSignature(io.Direction.Output, width=width, **kwargs)
 
-def InputPinSignature(width):
-    return PinSignature(io.Direction.Input)
+def InputPinSignature(width, **kwargs):
+    return PinSignature(io.Direction.Input, width=width, **kwargs)
 
-def BidirPinSignature(width):
-    return PinSignature(io.Direction.Bidir)
+def BidirPinSignature(width, **kwargs):
+    return PinSignature(io.Direction.Bidir, width=width, **kwargs)
 
-def group_consecutive_items(lst: List[int]) -> Dict[int, List[int]]:
+def group_consecutive_items(lst: List[int]) -> Dict[int, List[List[int]]]:
     if not lst:
         return {}