def convert_field(rdlc: RDLCompiler, obj: node.FieldNode) -> dict: json_obj = dict() json_obj['type'] = 'field' json_obj['inst_name'] = obj.inst_name json_obj['lsb'] = obj.lsb json_obj['msb'] = obj.msb json_obj['reset'] = obj.get_property('reset') json_obj['sw_access'] = obj.get_property('sw').name return json_obj
def get_field_reset(self, field: FieldNode) -> str: """ Get the field reset value """ # Get the value field_reset = field.get_property('reset', default=0) # Format the value field_width = field.width no_of_nib = field_width / 4 # 64bit data if no_of_nib == 16: format_number = no_of_nib + 3 # 32bit data elif no_of_nib == 8: format_number = no_of_nib + 1 # 16bit or 8bit data else: format_number = no_of_nib # format the string to have underscore in hex value format_str = '{:0' + str(int(format_number)) + '_x}' final_value = (format_str.format(field_reset)) return (str(field_width) + "'h" + final_value.upper())
def has_we(self, node: FieldNode) -> bool: """ Field has we input """ if self.strict: # strict RDL says no we unless specified return node.get_property('we') is True if node.get_property('wel') is not False: # can't have we and wel return False return ((node.get_property('we') is True) or # explicit (node.implements_storage and self.is_hw_writable(node) and not node.get_property('intr')) ) # interrupt unlikely to not want we
def has_enum_encoding(field: FieldNode) -> bool: """ Test if field is encoded with an enum """ return "encode" in field.list_properties()
def _get_field_access(self, field: FieldNode) -> str: """ Get field's UVM access string """ sw = field.get_property("sw") onread = field.get_property("onread") onwrite = field.get_property("onwrite") if sw == AccessType.rw: if (onwrite is None) and (onread is None): return "RW" elif (onread == OnReadType.rclr) and (onwrite == OnWriteType.woset): return "W1SRC" elif (onread == OnReadType.rclr) and (onwrite == OnWriteType.wzs): return "W0SRC" elif (onread == OnReadType.rclr) and (onwrite == OnWriteType.wset): return "WSRC" elif (onread == OnReadType.rset) and (onwrite == OnWriteType.woclr): return "W1CRS" elif (onread == OnReadType.rset) and (onwrite == OnWriteType.wzc): return "W0CRS" elif (onread == OnReadType.rset) and (onwrite == OnWriteType.wclr): return "WCRS" elif onwrite == OnWriteType.woclr: return "W1C" elif onwrite == OnWriteType.woset: return "W1S" elif onwrite == OnWriteType.wot: return "W1T" elif onwrite == OnWriteType.wzc: return "W0C" elif onwrite == OnWriteType.wzs: return "W0S" elif onwrite == OnWriteType.wzt: return "W0T" elif onwrite == OnWriteType.wclr: return "WC" elif onwrite == OnWriteType.wset: return "WS" elif onread == OnReadType.rclr: return "WRC" elif onread == OnReadType.rset: return "WRS" else: return "RW" elif sw == AccessType.r: if onread is None: return "RO" elif onread == OnReadType.rclr: return "RC" elif onread == OnReadType.rset: return "RS" else: return "RO" elif sw == AccessType.w: if onwrite is None: return "WO" elif onwrite == OnWriteType.wclr: return "WOC" elif onwrite == OnWriteType.wset: return "WOS" else: return "WO" elif sw == AccessType.rw1: return "W1" elif sw == AccessType.w1: return "WO1" else: # na return "NOACCESS"
def add_field(self, parent: minidom.Element, node: FieldNode) -> None: field = self.doc.createElement(self.ns + "field") parent.appendChild(field) self.add_nameGroup(field, self.get_name(node), node.get_property("name", default=None), node.get_property("desc")) if (self.standard >= Standard.IEEE_1685_2014 ) and not node.get_property("ispresent"): self.add_value(field, self.ns + "isPresent", "0") self.add_value(field, self.ns + "bitOffset", "%d" % node.low) if self.standard >= Standard.IEEE_1685_2014: reset = node.get_property("reset") if reset is not None: resets_el = self.doc.createElement(self.ns + "resets") field.appendChild(resets_el) reset_el = self.doc.createElement(self.ns + "reset") resets_el.appendChild(reset_el) self.add_value(reset_el, self.ns + "value", self.hex_str(reset)) # DNE: <spirit/ipxact:typeIdentifier> self.add_value(field, self.ns + "bitWidth", "%d" % node.width) if node.is_volatile: self.add_value(field, self.ns + "volatile", "true") sw = node.get_property("sw") self.add_value(field, self.ns + "access", typemaps.access_from_sw(sw)) encode = node.get_property("encode") if encode is not None: enum_values_el = self.doc.createElement(self.ns + "enumeratedValues") field.appendChild(enum_values_el) for enum_value in encode: enum_value_el = self.doc.createElement(self.ns + "enumeratedValue") enum_values_el.appendChild(enum_value_el) self.add_nameGroup(enum_value_el, enum_value.name, enum_value.rdl_name, enum_value.rdl_desc) self.add_value(enum_value_el, self.ns + "value", self.hex_str(enum_value.value)) # DNE <spirit/ipxact:vendorExtensions> onwrite = node.get_property("onwrite") if onwrite: self.add_value(field, self.ns + "modifiedWriteValue", typemaps.mwv_from_onwrite(onwrite)) # DNE: <spirit/ipxact:writeValueConstraint> onread = node.get_property("onread") if onread: self.add_value(field, self.ns + "readAction", typemaps.readaction_from_onread(onread)) if node.get_property("donttest"): self.add_value(field, self.ns + "testable", "false") # DNE: <ipxact:reserved> # DNE: <spirit/ipxact:parameters> vendorExtensions = self.doc.createElement(self.ns + "vendorExtensions") self.field_vendorExtensions(vendorExtensions, node) if vendorExtensions.hasChildNodes(): field.appendChild(vendorExtensions)
def __init__(self, **kwargs): """ Constructor for the Verilog Exporter class Parameters ---------- user_template_dir: str Path to a directory where user-defined template overrides are stored. user_template_context: dict Additional context variables to load into the template namespace. """ user_template_dir = kwargs.pop("user_template_dir", None) self.user_template_context = kwargs.pop("user_template_context", dict()) # Check for stray kwargs if kwargs: raise TypeError("got an unexpected keyword argument '%s'" % list(kwargs.keys())[0]) if user_template_dir: loader = jj.ChoiceLoader([ jj.FileSystemLoader(user_template_dir), jj.FileSystemLoader( os.path.join(os.path.dirname(__file__), "templates")), jj.PrefixLoader( { 'user': jj.FileSystemLoader(user_template_dir), 'base': jj.FileSystemLoader( os.path.join(os.path.dirname(__file__), "templates")) }, delimiter=":") ]) else: loader = jj.ChoiceLoader([ jj.FileSystemLoader( os.path.join(os.path.dirname(__file__), "templates")), jj.PrefixLoader( { 'base': jj.FileSystemLoader( os.path.join(os.path.dirname(__file__), "templates")) }, delimiter=":") ]) self.jj_env = jj.Environment(loader=loader, undefined=jj.StrictUndefined) # Define variables used during export RegNode.add_derived_property(self.bit_range) RegNode.add_derived_property(self.signal_prefix) FieldNode.add_derived_property(self.is_hw_writable) FieldNode.add_derived_property(self.is_hw_readable) FieldNode.add_derived_property(self.bit_range) FieldNode.add_derived_property(self.signal_prefix) # Top-level node self.top = None # Dictionary of group-like nodes (addrmap, regfile) and their bus # widths. # key = node path # value = max accesswidth/memwidth used in node's descendants self.bus_width_db = {} # Dictionary of root-level type definitions # key = definition type name # value = representative object # components, this is the original_def (which can be None in some cases) self.namespace_db = {}