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__))