Packages

package lib

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. lib
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. class AnyPimped[T] extends AnyRef
  2. implicit class BigIntRicher extends LiteralRicher
  3. implicit class BinIntsRicher extends AnyRef
  4. implicit class BinaryBuilder extends AnyRef
  5. implicit class BinaryBuilder2 extends AnyRef
  6. class BitAggregator extends AnyRef
  7. class BoolPimped extends AnyRef
  8. class BufferCC[T <: Data] extends Component
  9. implicit class ByteRicher extends LiteralRicher
  10. class ClockDomainPimped extends AnyRef
  11. class Counter extends ImplicitArea[UInt]
  12. class CounterUpDown extends ImplicitArea[UInt]
  13. trait DataCarrier[T <: Data] extends AnyRef
  14. class DataCarrierFragmentBitsPimped extends AnyRef
  15. class DataCarrierFragmentPimped[T <: Data] extends AnyRef
  16. case class DataOr[T <: Data](dataType: HardType[T]) extends Area with Product with Serializable
  17. type Event = Stream[NoData]
  18. case class EventEmitter(on: Event) extends Product with Serializable
  19. class EventFactory extends MSFactory
  20. class Flow[T <: Data] extends Bundle with IMasterSlave with DataCarrier[T]
  21. class FlowBitsPimped extends AnyRef
  22. class FlowCCByToggle[T <: Data] extends Component
  23. class FlowCmdRsp[T <: Data, T2 <: Data] extends Bundle with IMasterSlave
  24. class FlowFactory extends MSFactory
  25. class FlowFragmentBitsRouter extends AnyRef
  26. class FlowFragmentFactory extends MSFactory
  27. class FlowFragmentPimped[T <: Data] extends AnyRef
  28. class Fragment[T <: Data] extends Bundle
  29. class FragmentFactory extends AnyRef
  30. class GrowableAnyPimped[T] extends AnyRef
  31. class HistoryModifyable[T <: Data] extends Component
  32. trait IMasterSlave extends AnyRef

    Master/slave interface

  33. implicit class IntRicher extends LiteralRicher
  34. trait LiteralRicher extends AnyRef
  35. implicit class LongRicher extends LiteralRicher
  36. sealed trait MS extends AnyRef

    Declare a port as master or slave

    Declare a port as master or slave

    There are 4 available syntaxes, which are all equivalent:

    val braces = master(Flow(Bool))

val short = master Flow (Bool)

val spaceful = master port Flow(Bool)

val variadic = Flow(Bool)
master(variadic)

    The "braces" syntax is short and generic, but it uses braces.

    The "short" syntax is short, but it is formatted with a space between the type and its parameters, and it can be used only with:

    • Flow
    • Stream

    The "spaceful" syntax is generic and beatiful, but more verbose.

    The "variadic" syntax can be used with any number of interfaces, but can be used only if the interfaces are already declared.

    See also

    master slave

  37. trait MSFactory extends AnyRef

    Something which can create master/slave interfaces

  38. class MemPimped[T <: Data] extends AnyRef
  39. case class MemReadPort[T <: Data](dataType: T, addressWidth: Int) extends Bundle with IMasterSlave with Product with Serializable
  40. case class MemReadPortAsync[T <: Data](dataType: T, addressWidth: Int) extends Bundle with IMasterSlave with Product with Serializable
  41. case class MemReadWritePort[T <: Data](dataType: T, addressWidth: Int, maskWidth: Int = -1) extends Bundle with IMasterSlave with Product with Serializable
  42. case class MemWriteCmd[T <: Data](mem: Mem[T], maskWidth: Int = -1) extends Bundle with Product with Serializable
  43. case class MemWriteCmdWithMask[T <: Data](mem: Mem[T], maskWidth: Int) extends Bundle with Product with Serializable
  44. class MuxOHImpl extends AnyRef
  45. class NoData extends Bundle
  46. class PackedBundle extends Bundle

    Similar to Bundle but with bit packing capabilities.

    Similar to Bundle but with bit packing capabilities. Use pack implicit functions to assign fields to bit locations - pack(Range, [Endianness]) - Packs the data into Range aligning to bit Endianness if too wide - packFrom(Position) - Packs the data starting (LSB) at Position. Uses full data length - packTo(Position) - Packs the data ending (MSB) at Position. Uses full data length

    Providing no location tag will place the next data value immediately after the last.

    Example: 

    1. val regWord = new PackedBundle {
  val init = Bool().packFrom(0) // Bit 0
  val stop = Bool() // Bit 1
  val result = Bits(16 bit).packTo(31) // Bits 16 to 31
}
  47. class PackedWordBundle extends PackedBundle

    An enhanced form of PackedBundle with Word-centric packing.

    An enhanced form of PackedBundle with Word-centric packing. Offers all the same implicit packing assignment functions, but applies packing to an assigned word. - inWord(WordIndex) - Indicates which word to pack into. Must be used after a pack assigment. If no pack range was given then the entire data length will be assumed. Ranges that exceed the word will wrap into subsequent words.

    Like PackedBundle, providing no pack or word assignments will place data immediately after the last.

    Example: 

    1. val wordPacked = PackedWordBundle(8 bits) {
  val aNumber = UInt(8 bits).word(0) // Bits 7 downto 0
  val bNumber = UInt(8 bits).pack(0 to 7).word(1) // Bits 8 to 15
  val large   = Bits(18 bits).word(2) // Bits 33 downto 16
  val flag    = Bool() // Bit 34
  48. class PulseCCByToggle extends Component
  49. case class ReadRetLinked[T <: Data, T2 <: Data](readType: HardType[T], linkedType: HardType[T2]) extends Bundle with Product with Serializable
  50. type ScalaStream[T] = scala.collection.immutable.Stream[T]
  51. sealed trait SlicesOrder extends AnyRef

    Enumeration to present order of slices.

  52. class Stream[T <: Data] extends Bundle with IMasterSlave with DataCarrier[T]
  53. class StreamArbiter[T <: Data] extends Component

    A StreamArbiter is like a StreamMux, but with built-in complex selection logic that can arbitrate input streams based on a schedule or handle fragmented streams.

    A StreamArbiter is like a StreamMux, but with built-in complex selection logic that can arbitrate input streams based on a schedule or handle fragmented streams. Use a StreamArbiterFactory to create instances of this class.

  54. class StreamArbiterFactory extends AnyRef
  55. class StreamBitsPimped extends AnyRef
  56. class StreamBundlePimped[T <: Bundle] extends AnyRef
  57. class StreamCCByToggle[T <: Data] extends Component
  58. class StreamDemux[T <: Data] extends Component
  59. class StreamFactory extends MSFactory
  60. class StreamFifo[T <: Data] extends Component

    Fully redesigned in release 1.8.2 allowing improved timing closure.

    Fully redesigned in release 1.8.2 allowing improved timing closure. - latency of 0, 1, 2 cycles

  61. class StreamFifoCC[T <: Data] extends Component
  62. trait StreamFifoInterface[T <: Data] extends AnyRef
  63. class StreamFifoLowLatency[T <: Data] extends Component
  64. case class StreamFifoMultiChannelPop[T <: Data](payloadType: HardType[T], channelCount: Int) extends Bundle with IMasterSlave with Product with Serializable
  65. case class StreamFifoMultiChannelPush[T <: Data](payloadType: HardType[T], channelCount: Int) extends Bundle with IMasterSlave with Product with Serializable
  66. case class StreamFifoMultiChannelSharedSpace[T <: Data](payloadType: HardType[T], channelCount: Int, depth: Int, withAllocationFifo: Boolean = false) extends Component with Product with Serializable
  67. class StreamFlowArbiter[T <: Data] extends Area
  68. class StreamFork[T <: Data] extends Component

    A StreamFork will clone each incoming data to all its output streams.

    A StreamFork will clone each incoming data to all its output streams. If synchronous is true, all output streams will always fire together, which means that the stream will halt until all output streams are ready. If synchronous is false, output streams may be ready one at a time, at the cost of an additional flip flop (1 bit per output). The input stream will block until all output streams have processed each item regardlessly.

    Note that this means that when synchronous is true, the valid signal of the outputs depends on their inputs, which may lead to dead locks when used in combination with systems that have it the other way around. It also violates the handshake of the AXI specification (section A3.3.1).

  69. class StreamForkArea[T <: Data] extends Area
  70. class StreamFragmentBitsDispatcher extends Area
  71. case class StreamFragmentBitsDispatcherElement(sink: Stream[Bits], header: Int) extends Product with Serializable
  72. class StreamFragmentBitsPimped extends AnyRef
  73. class StreamFragmentFactory extends MSFactory
  74. class StreamFragmentPimped[T <: Data] extends AnyRef
  75. class StreamMux[T <: Data] extends Component
  76. class StreamPacker[T <: Data] extends Area

    Packs layout's Data into the given stream

    Packs layout's Data into the given stream

    stream is directly driven by this area.

    layout Data is read directly

    io.start indicates when to start packing. All layout's Data is registered before packing.

    io.done indicates when the last word has been packed.

    Use the companion object StreamPapcker to create an instance.

  77. trait StreamPipe extends AnyRef
  78. class StreamToStreamFragmentBits[T <: Data] extends Component
  79. class StreamTransactionCounter extends Component
  80. class StreamTransactionExtender[T <: Data, T2 <: Data] extends Component
  81. class StreamUnpacker[T <: Data] extends Area

    Unpacks stream's words into the given layout's Data.

    Unpacks stream's words into the given layout's Data. stream is directly driven by this area. layout Data are driven through a register.

    io.start starts unpacking io.dones is set of bits indicating when the associated Data in layout is unpacked. io.allDone indicates when the last word has been unpacked.

    Use the companion object StreamUnpacker to create an instance.

  82. class StringPimped extends AnyRef
  83. class Timeout extends ImplicitArea[Bool]
  84. class TraversableOnceAddressTransformerPimped extends AnyRef
  85. class TraversableOnceAnyPimped[T] extends AnyRef
  86. class TraversableOnceAnyTuplePimped[T, T2] extends AnyRef
  87. class TraversableOnceBoolPimped extends AnyRef
  88. class TraversableOncePimped[T <: Data] extends AnyRef
  89. implicit class UIntPimper extends AnyRef
  90. case class WhenBuilder() extends Product with Serializable
  91. class StreamDispatcherSequencial[T <: Data] extends Component

    Deprecated

    Do not use. Use the companion object or a normal regular StreamMux instead.

Value Members

  1. implicit def AnyPimpedDef[T](that: T): AnyPimped[T]
  2. def Event: Stream[NoData]
  3. def NoData(): NoData
  4. val OHMux: MuxOHImpl
  5. def ScalaStream: scala.collection.immutable.Stream.type
  6. def StreamArbiterFactory(): StreamArbiterFactory
  7. implicit def boolPimped(that: Bool): BoolPimped
  8. implicit def clockDomainPimped(cd: ClockDomain): ClockDomainPimped
  9. implicit def dataCarrierFragmentBitsPimped(that: DataCarrier[Fragment[Bits]]): DataCarrierFragmentBitsPimped
  10. implicit def dataCarrierFragmentPimped[T <: Data](that: DataCarrier[Fragment[T]]): DataCarrierFragmentPimped[T]
  11. implicit def easyFragment[T <: Data](that: Fragment[T]): T
  12. implicit def flowBitsPimped(that: Flow[Bits]): FlowBitsPimped
  13. implicit def flowFragmentPimped[T <: Data](that: Flow[Fragment[T]]): FlowFragmentPimped[T]
  14. implicit def growableAnyPimped[T](that: Growable[T]): GrowableAnyPimped[T]
  15. implicit def memPimped[T <: Data](mem: Mem[T]): MemPimped[T]
  16. def sexport[T <: SpinalTag](h: T): T
  17. def sexport[T](name: String, value: Any): ArrayBuffer[() ⇒ Unit]
  18. def sexport[T](h: Handle[T]): Handle[T]
  19. def sexport[T](named: Handle[T], value: ⇒ Any): ArrayBuffer[() ⇒ Unit]
  20. implicit def streamBitsPimped(that: Stream[Bits]): StreamBitsPimped
  21. implicit def streamBundlePimped[T <: Bundle](that: Stream[T]): StreamBundlePimped[T]
  22. implicit def streamFragmentBitsPimped(that: Stream[Fragment[Bits]]): StreamFragmentBitsPimped
  23. implicit def streamFragmentPimped[T <: Data](that: Stream[Fragment[T]]): StreamFragmentPimped[T]
  24. implicit def stringPimped(that: String): StringPimped
  25. implicit def traversableOnceAddressTransformerPimped(that: TraversableOnce[AddressTransformer]): TraversableOnceAddressTransformerPimped
  26. implicit def traversableOnceAnyPimped[T](that: TraversableOnce[T]): TraversableOnceAnyPimped[T]
  27. implicit def traversableOnceAnyTuplePimped[T, T2](that: TraversableOnce[(T, T2)]): TraversableOnceAnyTuplePimped[T, T2]
  28. implicit def traversableOnceBoolPimped(that: TraversableOnce[Bool]): TraversableOnceBoolPimped
  29. implicit def traversableOncePimped[T <: Data](that: TraversableOnce[T]): TraversableOncePimped[T]
  30. object AddWithCarry
  31. object AnalysisUtils
  32. object BufferCC
  33. object Callable
  34. object ClearCount
  35. object CountOne
  36. object CountOneOnEach
  37. object Counter

    Creates a counter

    Creates a counter

    See https://spinalhdl.github.io/SpinalDoc-RTD/master/SpinalHDL/Libraries/utils.html?highlight=counter#counter

  38. object CounterFreeRun

    Creates an always running counter

    Creates an always running counter

    See https://spinalhdl.github.io/SpinalDoc-RTD/master/SpinalHDL/Libraries/utils.html?highlight=counter#counter

  39. object CounterMultiRequest
  40. object CounterUpDown
  41. object DataCarrier
  42. object Delay
  43. object DelayEvent
  44. object DelayWithInit
  45. object DoCmd

    Run command

  46. object EndiannessSwap

    **************************************************************************** Big-Endian <-> Little-Endian

  47. object Flow extends FlowFactory
  48. object FlowCCByToggle
  49. object FlowCmdRsp
  50. object FlowFragmentBitsRouter
  51. object Fragment extends FragmentFactory
  52. object FragmentToBitsStates extends SpinalEnum
  53. object GrayCounter
  54. object HIGHER_FIRST extends SlicesOrder

    Slice with higher bits process first

  55. object History
  56. object HistoryModifyable
  57. object KeepAttribute
  58. object LOWER_FIRST extends SlicesOrder

    Slice with lower bits process first

  59. object LatencyAnalysis
  60. object LeastSignificantBitSet
  61. object MajorityVote
  62. object Max
  63. object Min
  64. object MuxOH extends MuxOHImpl
  65. object OHMasking
  66. object OHToUInt
  67. object OhMux extends MuxOHImpl
  68. object PriorityMux
  69. object PulseCCByToggle
  70. object RegFlow
  71. object Repeat
  72. object ResetCtrl
  73. object Reverse
  74. object SetCount
  75. object SetFromFirstOne
  76. object Shift
  77. object Stream extends StreamFactory
  78. object StreamArbiter
  79. object StreamCCByToggle
  80. object StreamCombinerSequential

    This is equivalent to a StreamMux, but with a counter attached to the port selector.

  81. object StreamDemux

    Demultiplex one stream into multiple output streams, always selecting only one at a time.

  82. object StreamDemuxOh
  83. object StreamDispatcherSequential

    This is equivalent to a StreamDemux, but with a counter attached to the port selector.

  84. object StreamFifo
  85. object StreamFifoCC
  86. object StreamFifoLowLatency
  87. object StreamFifoMultiChannelBench extends App
  88. object StreamFlowArbiter

    Combine a stream and a flow to a new stream.

    Combine a stream and a flow to a new stream. If both input sources fire, the flow will be preferred.

  89. object StreamFork
  90. object StreamFork2
  91. object StreamFork3
  92. object StreamFragmentArbiter
  93. object StreamFragmentArbiterAndHeaderAdder
  94. object StreamFragmentGenerator
  95. object StreamFragmentWidthAdapter
  96. object StreamJoin

    Join multiple streams into one.

    Join multiple streams into one. The resulting stream will only fire if all of them fire, so you may want to buffer the inputs.

  97. object StreamMux

    Multiplex multiple streams into a single one, always only processing one at a time.

  98. object StreamPacker
  99. object StreamPipe
  100. object StreamTransactionCounter
  101. object StreamTransactionExtender
  102. object StreamUnpacker
  103. object StreamWidthAdapter
  104. object Timeout
  105. object UIntToOh
  106. object ValidFlow

    Create a new Flow that is always valid, with a given payload

  107. object WrapWithReg
  108. object fromGray
  109. object master extends MS

    Declare a master port

    Declare a master port

    See MS for syntax help.

  110. object slave extends MS

    Declare a slave port

    Declare a slave port

    See MS for syntax help.

  111. object toGray
  112. object whenIndexed
  113. object whenMasked

Deprecated Value Members

  1. object StreamDispatcherSequencial

    Deprecated

    Do not use

  2. object masterWithNull extends MS
    Annotations
    @deprecated
    Deprecated

    Use apply or port instead: 'val b = master(maybeNull)' or 'val rgb = master port maybeNull'

  3. object slaveWithNull extends MS
    Annotations
    @deprecated
    Deprecated

    Use apply or port instead: 'val b = slave(maybeNull)' or 'val rgb = slave port maybeNull'

Inherited from AnyRef

Inherited from Any

Ungrouped