[rdl2ot] Support SoC description in the root level

Now a SoC/Top described in RDL can be parsed and generate RTL for
multiple IP blocks by adding the flag --soc in the CLI.

Signed-off-by: Douglas Reis <[email protected]>

Author: engdoreis

rdl2ot/src/rdl2ot/cli.py

@@ -29,18 +29,23 @@ def main() -> None:
     default="./result",
     type=click.Path(writable=True),
 )
-def export_rtl(input_file: str, out_dir: str) -> None:
+@click.option(
+    "--soc",
+    is_flag=True,
+)
+def export_rtl(input_file: str, out_dir: str, soc:bool=False) -> None:
     """Export opentitan rtl.
 
     INPUT_FILE: The input RDL
     OUT_DIR: The destination dir to generate the output
+    SOC: Indicates that the input RDL is a SoC top
 
     """
-    print("Compiling file: {input_file}...")
+    print(f"Compiling file: {input_file}...")
     rdlc = RDLCompiler()
     rdlc.compile_file(input_file)
     root = rdlc.elaborate()
 
-    rtl_exporter.run(root.top, Path(out_dir))
+    rtl_exporter.run(root.top, Path(out_dir), soc)
 
     print("Successfully finished!\n")

rdl2ot/src/rdl2ot/rtl_exporter.py

@@ -22,26 +22,41 @@ def _camelcase(value: str) -> str:
     return "".join(word.capitalize() for word in words)
 
 
-def run(root_node: node.AddrmapNode, out_dir: Path) -> None:
-    """Export RDL to opentitan RTL."""
+def run(root_node: node.AddrmapNode, out_dir: Path, is_soc: bool = False) -> None:
+    """Export RDL to opentitan RTL.
+    
+    IS_SOC: True if the root node represents an soc with address maps representing peripherals/devices.
+    """
     factory = OtInterfaceBuilder()
-    data = factory.parse_root(root_node)
+    if is_soc:
+        data = factory.parse_soc(root_node)
+    else:
+        data = factory.parse_ip_block(root_node)
 
     Path(out_dir / "rdl.json").write_text(json.dumps(data, indent=2), encoding="utf-8")
 
+    if not is_soc:
+        _export(data, out_dir)
+        return
+
+    for ip_block in data["devices"]:
+        _export(ip_block, out_dir)
+
+
+def _export(ip_block: dict, out_dir: Path) -> None:
     file_loader = FileSystemLoader(TEMPLATES_DIR)
     env = Environment(loader=file_loader)
     env.filters["camelcase"] = _camelcase
 
-    ip_name = data["ip_name"]
+    ip_name = ip_block["ip_name"].lower()
     reg_pkg_tpl = env.get_template("reg_pkg.sv.tpl")
-    stream = reg_pkg_tpl.render(data)
+    stream = reg_pkg_tpl.render(ip_block)
     path = out_dir / f"{ip_name}_reg_pkg.sv"
     path.open("w").write(stream)
     print(f"Generated {path}.")
 
     reg_top_tpl = env.get_template("reg_top.sv.tpl")
-    for interface in data["interfaces"]:
+    for interface in ip_block["interfaces"]:
         name = "_{}".format(interface["name"].lower()) if "name" in interface else ""
         data_ = {"ip_name": ip_name, "interface": interface}
         stream = reg_top_tpl.render(data_).replace(" \n", "\n")
@@ -193,14 +208,10 @@ def get_interface(self, addrmap: node.AddrmapNode, defalt_name: None | str = Non
         self.any_shadowed_reg = False
         self.async_registers.clear()
 
-        if addrmap.is_array:
-            print(f"WARNING: Unsupported array type: {type(addrmap)}, skiping...")
-
         interface = {}
         if defalt_name:
             interface["name"] = addrmap.inst_name or defalt_name
 
-        interface["offset"] = addrmap.address_offset
         interface["regs"] = []
         interface["windows"] = []
         for child in addrmap.children():
@@ -247,25 +258,26 @@ def get_interface(self, addrmap: node.AddrmapNode, defalt_name: None | str = Non
         ]
         return interface
 
-    def parse_root(self, root: node.AddrmapNode) -> dict:
-        """Parse the root node and return a dictionary representing a window."""
-        if root.is_array:
-            print("Error: Unsupported array type on the top")
-            raise RuntimeError
-        if not isinstance(root, node.AddrmapNode):
-            print("Error: Top level must be an addrmap")
-            raise TypeError
-
+    def parse_ip_block(self, ip_block: node.AddrmapNode) -> dict:
+        """Parse the ip_block node of an IP block and return a dictionary."""
         obj = {}
-        params = self.get_paramesters(root)
+        params = self.get_paramesters(ip_block)
         if params:
             obj["parameters"] = params
-        obj["ip_name"] = root.inst_name
-        obj["offset"] = root.address_offset
+        obj["ip_name"] = ip_block.inst_name
+
+        obj["offsets"] = []
+        if ip_block.is_array:
+            offset = ip_block.raw_address_offset
+            for _idx in range(ip_block.array_dimensions[0]):
+                obj["offsets"].append(offset)
+                offset += ip_block.array_stride
+        else:
+            obj["offsets"].append(ip_block.address_offset)
 
         obj["interfaces"] = []
         obj["alerts"] = []
-        for child in root.children():
+        for child in ip_block.children():
             if isinstance(child, node.AddrmapNode):
                 child_obj = self.get_interface(child, DEFAULT_INTERFACE_NAME)
                 obj["interfaces"].append(child_obj)
@@ -279,10 +291,25 @@ def parse_root(self, root: node.AddrmapNode) -> dict:
                 )
                 raise TypeError
 
-        # If the root contain imediate registers, use a default interface name
-        if len(root.registers()) > 0:
-            interface = self.get_interface(root)
+        # If the ip_block contain imediate registers, use a default interface name
+        if len(ip_block.registers()) > 0:
+            interface = self.get_interface(ip_block)
             obj["interfaces"].append(interface)
             obj["alerts"].extend(interface["alerts"])
 
         return obj
+
+    def parse_soc(self, root: node.AddrmapNode) -> dict:
+        """Parse the SoC root node and return a dictionary."""
+        if root.is_array:
+            print("Error: Unsupported array type on the top")
+            raise RuntimeError
+        if not isinstance(root, node.AddrmapNode):
+            print("Error: Top level must be an addrmap")
+            raise TypeError
+
+        obj = {"devices": []}
+        for child in root.children():
+            obj["devices"].append(self.parse_ip_block(child))
+        return obj 
+

rdl2ot/tests/snapshots/soc_strawberry.rdl

@@ -0,0 +1,7 @@
+`include "uart.rdl"
+`include "lc_ctrl.rdl"
+
+addrmap soc_strawberry {
+  uart UART[3];
+  lc_ctrl LC_CTRL;
+};

rdl2ot/tests/test_rdl2ot.py

@@ -22,10 +22,13 @@ def _run_cli_tool(input_file_path: Path, output_dir_path: Path) -> subprocess.Co
         str(input_file_path),
         str(output_dir_path),
     ]
+    if "soc" in input_file_path.name:
+        command.append("--soc")
+
     return subprocess.run(command, capture_output=True, text=True, check=False)  # noqa: S603
 
 
-test_ips = ["lc_ctrl", "uart"]
+test_ips = ["lc_ctrl", "uart", "soc_strawberry"]
 
 
 @pytest.mark.parametrize("ip_block", test_ips)