| # Copyright 2023 Google LLC |
| # Copyright lowRISC contributors |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| """ Utility functions for topgen |
| """ |
| |
| import logging as log |
| import sys |
| from collections import OrderedDict |
| from mako.template import Template |
| from typing import Dict, Tuple |
| |
| from reggen.ip_block import IpBlock |
| from topgen import lib as lib |
| from topgen.c import TopGenC |
| from topgen.c_test import TopGenCTest |
| |
| |
| class TopGenMatchaC(TopGenC): |
| """ A class to add the Opentitan TopGenC with extra plic rendering methods. |
| """ |
| |
| def __init__(self, top_info, name_to_block: Dict[str, IpBlock]): |
| super().__init__(top_info, name_to_block) |
| # Update plic CEnum objects with appended smc suffix in the name |
| # for the first and last elements to avoid naming collision. |
| self.plic_sources.constants[0][0].parts.append("smc") |
| self.plic_sources.constants[-1][0].parts.append("smc") |
| self.plic_targets.constants[0][0].parts.append("smc") |
| self.plic_targets.constants[-1][0].parts.append("smc") |
| self.plic_interrupts.constants[0][0].parts.append("smc") |
| self.plic_interrupts.constants[-1][0].parts.append("smc") |
| |
| def smc_plic_sources_render(self): |
| return self._smc_c_enum_render(self.plic_sources) |
| |
| def smc_plic_targets_render(self): |
| return self._smc_c_enum_render(self.plic_targets) |
| |
| def smc_plic_interrupts_render(self): |
| return self._smc_c_enum_render(self.plic_interrupts) |
| |
| def smc_plic_interrupts_define_render(self): |
| return self._smc_c_define_render(self.plic_interrupts) |
| |
| def smc_plic_mapping_render_declaration(self): |
| template = ( |
| "extern const ${mapping.output_type_name.as_snake_case()}_smc_t\n" |
| " ${mapping.name.as_snake_case()}_smc[${len(mapping.mapping)}];") |
| return Template(template).render(mapping=self.plic_mapping) |
| |
| def smc_plic_mapping_render_definition(self): |
| template = ( |
| "const ${mapping.output_type_name.as_snake_case()}_smc_t\n" |
| " ${mapping.name.as_snake_case()}_smc[${len(mapping.mapping)}] = {\n" |
| "% for in_name, out_name in mapping.mapping.items():\n" |
| " [${in_name.as_c_enum()}] = ${out_name.as_c_enum()},\n" |
| "% endfor\n" |
| "};\n") |
| return Template(template).render(mapping=self.plic_mapping) |
| |
| def _smc_c_enum_render(self, enum): |
| """ Add the c_helper CEnum rendering code for smc.""" |
| template = ("typedef enum ${enum.name.as_snake_case()}_smc {\n" |
| "% for name, value, docstring in enum.constants:\n" |
| " ${name.as_c_enum()} = ${value}, /**< ${docstring} */\n" |
| "% endfor\n" |
| "} ${enum.name.as_snake_case()}_smc_t;") |
| return Template(template).render(enum=enum) |
| |
| def _smc_c_define_render(self, enum): |
| """ Add the c_helper CDefine rendering code for smc.""" |
| template = ("% for name, value, docstring in enum.constants:\n" |
| "#define ${name.as_c_define()} ${value} /**< ${docstring} */\n" |
| "% endfor\n") |
| return Template(template).render(enum=enum) |
| |
| def _separate_interrupt_modules(top: OrderedDict, name_to_block: Dict[str, |
| IpBlock], |
| intr_to_smc_list: list): |
| """Populate top["interrupt_module"] if necessary |
| |
| Do this by adding each module in top['modules'] that defines at least one |
| interrupt. |
| """ |
| if ("sec_interrupt_module" in top) or ("smc_interrupt_module" in top): |
| return |
| |
| modules_sec = [] |
| modules_smc = [] |
| for module in top["module"]: |
| block = name_to_block[module["type"]] |
| if block.interrupts: |
| if module["name"] in intr_to_smc_list: |
| modules_smc.append(module["name"]) |
| else: |
| modules_sec.append(module["name"]) |
| log.info("the genreate modules_sec is: ", modules_sec) |
| top["sec_interrupt_module"] = modules_sec |
| log.info("the genreate modules_smc is: ", modules_smc) |
| top["smc_interrupt_module"] = modules_smc |
| |
| |
| def create_smc_c_helper(helper: TopGenCTest, topcfg: OrderedDict, |
| name_to_block: Dict[str, IpBlock]) -> TopGenCTest: |
| """ Create the smc-specific c-code helper object. |
| |
| A workaround to append the smc-specific helper rendering functions in |
| addition to the OpenTitan c_helper class. |
| """ |
| smc_helper = TopGenMatchaC(topcfg, name_to_block) |
| helper.smc_helper = smc_helper |
| return helper |
| |
| |
| def create_separate_interrupt_topcfg( |
| top: OrderedDict,) -> Tuple[OrderedDict, OrderedDict]: |
| """ Create two topcfg dictionaries from separated interrupt groups. |
| |
| This is a workaround to use the Opentitan utility infrastructure to generate |
| the c template helpers, which assumes one interrupt list at the top level. |
| """ |
| interrupt_group = ["sec_interrupt", "smc_interrupt", "interrupt"] |
| if not all(x in top for x in interrupt_group): |
| log.error( |
| f"Need to have 'sec_interrupt', 'smc_interrupt, 'interrupt' keys " |
| f"in topcfg") |
| sys.exit(1) |
| sec_topcfg = top.copy() |
| sec_topcfg["interrupt"] = sec_topcfg["sec_interrupt"] |
| sec_topcfg["interrupt_module"] = sec_topcfg["sec_interrupt_module"] |
| smc_topcfg = top.copy() |
| smc_topcfg["num_cores"] = 1 # used to define plic targets. |
| smc_topcfg["interrupt"] = smc_topcfg["smc_interrupt"] |
| smc_topcfg["interrupt_module"] = smc_topcfg["smc_interrupt_module"] |
| return sec_topcfg, smc_topcfg |
| |
| |
| def amend_separate_interrupt(top: OrderedDict, name_to_block: Dict[str, |
| IpBlock], |
| intr_to_smc_list: list) -> OrderedDict: |
| """Check interrupt_module if exists, or just use all modules |
| """ |
| _separate_interrupt_modules(top, name_to_block, intr_to_smc_list) |
| |
| if "sec_interrupt" not in top or top["sec_interrupt"] == "": |
| top["sec_interrupt"] = [] |
| |
| if "smc_interrupt" not in top or top["smc_interrupt"] == "": |
| top["smc_interrupt"] = [] |
| |
| interrupt_module_list = [ |
| top["sec_interrupt_module"], top["smc_interrupt_module"] |
| ] |
| interrupt_list = [top["sec_interrupt"], top["smc_interrupt"]] |
| for idx, l in enumerate(interrupt_module_list): |
| for m in l: |
| ips = list(filter(lambda module: module["name"] == m, |
| top["module"])) |
| if len(ips) == 0: |
| log.warning( |
| "Cannot find IP %s which is used in the interrupt_module" % |
| m) |
| continue |
| |
| ip = ips[0] |
| block = name_to_block[ip["type"]] |
| |
| log.info("Adding interrupts from module %s" % ip["name"]) |
| for signal in block.interrupts: |
| sig_dict = signal.as_nwt_dict('interrupt') |
| qual = lib.add_module_prefix_to_signal(sig_dict, |
| module=m.lower()) |
| interrupt_list[idx].append(qual) |
| return top |
