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 = {}