def __init__(self, events, *, name=None, src_loc_at=0):
log.debug("Create Interrupt Source")
if name is not None and not isinstance(name, str):
raise TypeError("Name must be a string, not {!r}".format(name))
self.name = name or tracer.get_var_name(depth=2 + src_loc_at)
for event in events:
if not isinstance(event, EventSource):
raise TypeError(
"Event source must be an instance of EventSource, not {!r}"
.format(event))
self._events = list(events)
width = len(events)
self.status = csr.Element(width,
"r",
name="{}_status".format(self.name))
self.pending = csr.Element(width,
"rw",
name="{}_pending".format(self.name))
self.enable = csr.Element(width,
"rw",
name="{}_enable".format(self.name))
self.irq = IRQLine(name="{}_irq".format(self.name))
def __init__(self, *, shape=None, value=None, name=None):
self.shape = shape
self.name = name or tracer.get_var_name(depth=2, default="Complex")
if value is None:
if shape is None:
raise ValueError(f"must specify `shape` argument")
self.real = shape.value(name=self.name+'_real')
self.imag = shape.value(name=self.name+'_imag')
elif isinstance(value, complex):
if shape is None:
raise ValueError(f"must specify `shape` argument for complex value '{value}'")
self.real = shape.value(value.real, name=self.name+'_real')
self.imag = shape.value(value.imag, name=self.name+'_imag')
elif isinstance(value, tuple) and isinstance(value[0], FixedPointValue) and isinstance(value[1], FixedPointValue):
assert shape is None
self.real = value[0]
self.imag = value[1]
assert self.real.shape == self.imag.shape
self.shape = self.real.shape
elif isinstance(value, Value):
assert len(value) == 2*len(shape)
l = int(len(value)/2)
real = value[0:l]
imag = value[l:]
if shape.signed:
real = real.as_signed()
imag = imag.as_signed()
self.real = shape.value(real)
self.imag = shape.value(imag)
self.shape = shape
else:
raise TypeError(f"unsupported value {type(value)}")
def __init__(self, shape=None, *, address=None, read_strobe=None, name=None, src_loc_at=0, **kwargs):
super().__init__()
self._shape = shape
self._kwargs = kwargs
self.name = name or tracer.get_var_name(depth=2 + src_loc_at, default="$signal")
self.address = Address.parse(address)
self.read_strobe = read_strobe
def __init__(self, name=None, src_loc_at=1):
if name is not None and not isinstance(name, str):
raise TypeError("Name must be a string, not {!r}".format(name))
self.name = name or tracer.get_var_name(depth=2 +
src_loc_at).lstrip("_")
self._csr_banks = []
self._windows = []
self._events = []
self._bus = None
self._irq = None
def __init__(self, shape, value=None, name=None):
self.shape = shape
self.name = name or tracer.get_var_name(depth=2, default="FixedPoint")
if value is None:
self.value = Signal(shape.signal_shape(), name=self.name)
elif isinstance(value, Value):
self.value = value
elif isinstance(value, (int, float)):
val = FixedPointConst(value=value, shape=shape)
self.value = Const(val.value, shape=val.shape.signal_shape())
else:
raise TypeError(f"cannot create FixedPointValue from {value}")
def __init__(self, *, mode="level", name=None, src_loc_at=0):
if name is not None and not isinstance(name, str):
raise TypeError("Name must be a string, not {!r}".format(name))
choices = ("level", "rise", "fall")
if mode not in choices:
raise ValueError("Invalid trigger mode {!r}; must be one of {}"
.format(mode, ", ".join(choices)))
self.name = name or tracer.get_var_name(depth=2 + src_loc_at)
self.mode = mode
self.stb = Signal(name="{}_stb".format(self.name))
def __init__(
self,
shape_or_layout,
*,
name=None,
flags=0,
result_size=0,
command_size=0,
request_size=0,
src_loc_at=0,
):
if flags & REVERSE:
raise NotImplementedError('reverse pipe not implemented')
if request_size:
raise NotImplementedError('pipe request not implemented')
if result_size:
raise NotImplementedError('pipe result not implemented')
if command_size:
raise NotImplementedError('pipe command not implemented')
if name is None:
name = tracer.get_var_name(depth=2 + src_loc_at, default='$pipe')
self._data_layout = shape_or_layout
self._name = name
self._flags = flags
self._result_size = result_size
self._command_size = command_size
self._request_size = request_size
self._src_loc_at = src_loc_at
self._connected = False
frame = sys._getframe(1 + src_loc_at)
self._creation_context = {
'filename': frame.f_code.co_filename,
'lineno': frame.f_lineno,
'source': self
}
self._src_end = PipeSourceEnd(
Layout((PipeSourceEnd.prefices[dir] + name, shape)
for (name, shape, dir) in self._signals()),
name='o_' + self._name,
)
self._snk_end = PipeSinkEnd(
Layout((PipeSinkEnd.prefices[dir] + name, shape)
for (name, shape, dir) in self._signals()),
name='i_' + self._name,
)
def csr(self,
width,
access,
*,
addr=None,
alignment=None,
name=None,
src_loc_at=0):
if name is not None and not isinstance(name, str):
raise TypeError("Name must be a string, not {!r}".format(name))
name = name or tracer.get_var_name(depth=2 + src_loc_at).lstrip("_")
prefixed_name = "{}_{}".format(self._prefix, name)
return self._bank.csr(width=width,
access=access,
addr=addr,
alignment=alignment,
name=prefixed_name)
def __init__(self, backing_signal=None, name=None, src_loc_at=1, **kwargs):
self.name = name or tracer.get_var_name(depth=2 + src_loc_at,
default=camel_to_snake(
self.__class__.__name__))
if backing_signal is not None:
if isinstance(backing_signal, Value):
assert len(kwargs) == 0
assert len(backing_signal) == self._PACKED_LEN
self._backing_signal = backing_signal
elif isinstance(backing_signal, int):
from naps.soc.pydriver.hardware_proxy import BitwiseAccessibleInteger
self._backing_signal = BitwiseAccessibleInteger(backing_signal)
else:
assert False, "unsupported type for backing signal"
else:
# we do not create a single backing signal but instead cat multiple signals together for better
# introspection in the generated code and vcd files
def get_signal(name, type):
if name in kwargs:
signal = kwargs[name]
if hasattr(type, "_PACKED_FIELDS"):
assert isinstance(signal, type)
if isinstance(signal, ValueCastable):
signal = signal.as_value()
elif not isinstance(signal, Value):
signal = Const(signal, type)
assert needed_bits(type) == len(
signal
), f"field {name} of type {type} needs {needed_bits(type)} bits but got {len(signal)} bits"
signal.name = f'{self.name}__{name}'
return signal
elif hasattr(type, "_PACKED_FIELDS"):
return type(name=f'{self.name}__{name}')
else:
return Signal(type, name=f'{self.name}__{name}')
self.backing_signals = {
name: get_signal(name, type)
for name, type in self._PACKED_FIELDS.items()
}
self._backing_signal = Cat(self.backing_signals.values())
def socproperty(cls, src_loc_at=0):
name = tracer.get_var_name(depth=2 + src_loc_at)
__name = "__{}".format(name)
def getter(self):
assert isinstance(self, SoC)
attr = getattr(self, __name, None)
if attr is None:
raise NotImplementedError("SoC {!r} does not have a {}".format(
self, name))
return attr
def setter(self, value):
assert isinstance(self, SoC)
if not isinstance(value, cls):
raise TypeError("{} must be an instance of {}, not {!r}".format(
name, cls.__name__, value))
setattr(self, __name, value)
return property(getter, setter)
def csr(self,
width,
access,
*,
addr=None,
alignment=None,
name=None,
desc=None,
src_loc_at=0):
"""Request a CSR register.
Parameters
----------
width : int
Width of the register. See :class:`nmigen_soc.csr.Element`.
access : :class:`Access`
Register access mode. See :class:`nmigen_soc.csr.Element`.
addr : int
Address of the register. See :meth:`nmigen_soc.csr.Multiplexer.add`.
alignment : int
Register alignment. See :class:`nmigen_soc.csr.Multiplexer`.
name : str
Name of the register. If ``None`` (default) the name is inferred from the variable
name this register is assigned to.
desc: str
Documentation for the provided register, if available.
Used to capture register documentation automatically.
Return value
------------
An instance of :class:`nmigen_soc.csr.Element`.
"""
if name is not None and not isinstance(name, str):
raise TypeError("Name must be a string, not {!r}".format(name))
name = name or tracer.get_var_name(depth=2 + src_loc_at).lstrip("_")
elem_name = "{}_{}".format(self._name_prefix, name)
elem = csr.Element(width, access, name=elem_name)
self._csr_regs.append((elem, addr, alignment))
return elem
def csr(self,
width,
access,
*,
addr=None,
alignment=None,
name=None,
src_loc_at=0):
"""Request a CSR register.
Parameters
----------
width : int
Width of the register. See :class:`nmigen_soc.csr.Element`.
access : :class:`Access`
Register access mode. See :class:`nmigen_soc.csr.Element`.
addr : int
Address of the register. See :meth:`nmigen_soc.csr.Multiplexer.add`.
alignment : int
Register alignment. See :class:`nmigen_soc.csr.Multiplexer`.
name : str
Name of the register. If ``None`` (default) the name is inferred from the variable
name this register is assigned to.
Return value
------------
An instance of :class:`nmigen_soc.csr.Element`.
"""
if name is not None and not isinstance(name, str):
raise TypeError("Name must be a string, not {!r}".format(name))
name = name or tracer.get_var_name(depth=2 + src_loc_at).lstrip("_")
elem_name = "{}_{}".format(self._name_prefix, name)
if any(elem.name == elem_name for (elem, _, _) in self._csr_regs):
raise Exception(
"CSR \"{}\" has already been defined".format(elem_name))
elem = csr.Element(width, access, name=elem_name)
self._csr_regs.append((elem, addr, alignment))
return elem
def __init__(self, name=None, src_loc_at=1):
super().__setattr__(
"name", name or tracer.get_var_name(
depth=1 + src_loc_at,
default="$" + camel_to_snake(self.__class__.__name__)))
self._directions = OrderedDict()
def __init__(self, name=None, src_loc_at=1):
super().__init__()
self.name = name or tracer.get_var_name(depth=2 + src_loc_at, default=camel_to_snake(self.__class__.__name__))
