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. Protected

Package Members

  1. package blackbox
  2. package bus
  3. package com
  4. package cpu
  5. package dsptool
  6. package eda
  7. package experimental
  8. package fsm
  9. package generator
  10. package generator_backup
  11. package graphic
  12. package io
  13. package logic
  14. package math
  15. package memory
  16. package misc
  17. package pipeline
  18. package sim
  19. package soc
  20. package system
  21. package tools
  22. package wishbone

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. sealed trait Endianness extends AnyRef

    Endianness enumeration

  18. type Event = Stream[NoData]
  19. case class EventEmitter(on: Event) extends Product with Serializable
  20. class EventFactory extends MSFactory
  21. class Flow[T <: Data] extends Bundle with IMasterSlave with DataCarrier[T]
  22. class FlowBitsPimped extends AnyRef
  23. class FlowCCByToggle[T <: Data] extends Component
  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
  33. implicit class IntRicher extends LiteralRicher
  34. trait LiteralRicher extends AnyRef
  35. implicit class LongRicher extends LiteralRicher
  36. trait MS extends AnyRef
  37. trait MSFactory extends AnyRef
  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 PulseCCByToggle extends Component
  47. case class ReadRetLinked[T <: Data, T2 <: Data](readType: HardType[T], linkedType: HardType[T2]) extends Bundle with Product with Serializable
  48. type ScalaStream[T] = scala.collection.immutable.Stream[T]
  49. sealed trait SlicesOrder extends AnyRef

    Enumeration to present order of slices.

  50. class Stream[T <: Data] extends Bundle with IMasterSlave with DataCarrier[T]
  51. 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.

  52. class StreamArbiterFactory extends AnyRef
  53. class StreamBitsPimped extends AnyRef
  54. class StreamCCByToggle[T <: Data] extends Component
  55. class StreamDemux[T <: Data] extends Component
  56. class StreamFactory extends MSFactory
  57. class StreamFifo[T <: Data] extends Component
  58. class StreamFifoCC[T <: Data] extends Component
  59. trait StreamFifoInterface[T <: Data] extends AnyRef
  60. class StreamFifoLowLatency[T <: Data] extends Component
  61. case class StreamFifoMultiChannelPop[T <: Data](payloadType: HardType[T], channelCount: Int) extends Bundle with IMasterSlave with Product with Serializable
  62. case class StreamFifoMultiChannelPush[T <: Data](payloadType: HardType[T], channelCount: Int) extends Bundle with IMasterSlave with Product with Serializable
  63. case class StreamFifoMultiChannelSharedSpace[T <: Data](payloadType: HardType[T], channelCount: Int, depth: Int, withAllocationFifo: Boolean = false) extends Component with Product with Serializable
  64. class StreamFlowArbiter[T <: Data] extends Area
  65. 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).

  66. class StreamForkArea[T <: Data] extends Area
  67. class StreamFragmentBitsDispatcher extends Area
  68. case class StreamFragmentBitsDispatcherElement(sink: Stream[Bits], header: Int) extends Product with Serializable
  69. class StreamFragmentBitsPimped extends AnyRef
  70. class StreamFragmentFactory extends MSFactory
  71. class StreamFragmentPimped[T <: Data] extends AnyRef
  72. class StreamMux[T <: Data] extends Component
  73. trait StreamPipe extends AnyRef
  74. class StreamToStreamFragmentBits[T <: Data] extends Component
  75. class StreamTransactionCounter extends Component
  76. class StreamTransactionExtender[T <: Data, T2 <: Data] extends Component
  77. class StringPimped extends AnyRef
  78. class Timeout extends ImplicitArea[Bool]
  79. class TraversableOnceAnyPimped[T] extends AnyRef
  80. class TraversableOnceAnyTuplePimped[T, T2] extends AnyRef
  81. class TraversableOnceBoolPimped extends AnyRef
  82. class TraversableOncePimped[T <: Data] extends AnyRef
  83. implicit class UIntPimper extends AnyRef

Deprecated Type Members

  1. 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
  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 streamFragmentBitsPimped(that: Stream[Fragment[Bits]]): StreamFragmentBitsPimped
  22. implicit def streamFragmentPimped[T <: Data](that: Stream[Fragment[T]]): StreamFragmentPimped[T]
  23. implicit def stringPimped(that: String): StringPimped
  24. implicit def traversableOnceAnyPimped[T](that: TraversableOnce[T]): TraversableOnceAnyPimped[T]
  25. implicit def traversableOnceAnyTuplePimped[T, T2](that: TraversableOnce[(T, T2)]): TraversableOnceAnyTuplePimped[T, T2]
  26. implicit def traversableOnceBoolPimped(that: TraversableOnce[Bool]): TraversableOnceBoolPimped
  27. implicit def traversableOncePimped[T <: Data](that: TraversableOnce[T]): TraversableOncePimped[T]
  28. object AddWithCarry
  29. object BIG extends Endianness

    Big-Endian

  30. object BufferCC
  31. object Callable
  32. object ClearCount
  33. object CountOne
  34. object CountOneOnEach
  35. object Counter
  36. object CounterFreeRun
  37. object CounterMultiRequest
  38. object CounterUpDown
  39. object DataCarrier
  40. object Delay
  41. object DelayEvent
  42. object DelayWithInit
  43. object DoCmd

    Run command

  44. object EndiannessSwap

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

  45. object Flow extends FlowFactory
  46. object FlowCCByToggle
  47. object FlowFragmentBitsRouter
  48. object Fragment extends FragmentFactory
  49. object FragmentToBitsStates extends SpinalEnum
  50. object GrayCounter
  51. object HIGHER_FIRST extends SlicesOrder

    Slice with higher bits process first

  52. object History
  53. object HistoryModifyable
  54. object KeepAttribute
  55. object LITTLE extends Endianness

    Little-Endian

  56. object LOWER_FIRST extends SlicesOrder

    Slice with lower bits process first

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

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

  79. object StreamDemux

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

  80. object StreamDispatcherSequential

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

  81. object StreamFifo
  82. object StreamFifoCC
  83. object StreamFifoLowLatency
  84. object StreamFifoMultiChannelBench extends App
  85. 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.

  86. object StreamFork
  87. object StreamFork2
  88. object StreamFork3
  89. object StreamFragmentArbiter
  90. object StreamFragmentArbiterAndHeaderAdder
  91. object StreamFragmentGenerator
  92. object StreamFragmentWidthAdapter
  93. 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.

  94. object StreamMux

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

  95. object StreamPipe
  96. object StreamTransactionCounter
  97. object StreamTransactionExtender
  98. object StreamWidthAdapter
  99. object Timeout
  100. object UIntToOh
  101. object ValidFlow

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

  102. object WrapWithReg
  103. object fromGray
  104. object master extends MS
  105. object masterWithNull extends MS
  106. object slave extends MS
  107. object slaveWithNull extends MS
  108. object toGray
  109. object whenIndexed
  110. object whenMasked

Deprecated Value Members

  1. object StreamDispatcherSequencial

    Deprecated

    Do not use

Inherited from AnyRef

Inherited from Any

Ungrouped