Merge remote-tracking branch 'origin/master' into black_box_regs
This commit is contained in:
commit
5f5989848c
@ -39,10 +39,10 @@ class TLBuffer(entries: Int = 2, pipe: Boolean = false) extends LazyModule
|
|||||||
|
|
||||||
object TLBuffer
|
object TLBuffer
|
||||||
{
|
{
|
||||||
// applied to the TL source node; connect (TLBuffer(x.node) -> y.node)
|
// applied to the TL source node; y.node := TLBuffer(x.node)
|
||||||
def apply(x: TLBaseNode, entries: Int = 2, pipe: Boolean = false)(implicit lazyModule: LazyModule, sourceInfo: SourceInfo): TLBaseNode = {
|
def apply(x: TLBaseNode, entries: Int = 2, pipe: Boolean = false)(implicit sourceInfo: SourceInfo): TLBaseNode = {
|
||||||
val buffer = LazyModule(new TLBuffer(entries, pipe))
|
val buffer = LazyModule(new TLBuffer(entries, pipe))
|
||||||
lazyModule.connect(x -> buffer.node)
|
buffer.node := x
|
||||||
buffer.node
|
buffer.node
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -16,14 +16,22 @@ trait ExampleModule extends HasRegMap
|
|||||||
{
|
{
|
||||||
val params: ExampleParams
|
val params: ExampleParams
|
||||||
val io: ExampleBundle
|
val io: ExampleBundle
|
||||||
|
val interrupts: Vec[Bool]
|
||||||
|
|
||||||
val state = RegInit(UInt(0))
|
val state = RegInit(UInt(0))
|
||||||
io.gpio := state
|
val pending = RegInit(UInt(0xf, width = 4))
|
||||||
|
|
||||||
regmap(0 -> Seq(RegField(params.num, state)))
|
io.gpio := state
|
||||||
|
interrupts := pending.toBools
|
||||||
|
|
||||||
|
regmap(
|
||||||
|
0 -> Seq(
|
||||||
|
RegField(params.num, state)),
|
||||||
|
1 -> Seq(
|
||||||
|
RegField.w1ToClear(4, pending, state)))
|
||||||
}
|
}
|
||||||
|
|
||||||
// Create a concrete TL2 version of the abstract Example slave
|
// Create a concrete TL2 version of the abstract Example slave
|
||||||
class TLExample(p: ExampleParams) extends TLRegisterRouter(p.address)(
|
class TLExample(p: ExampleParams) extends TLRegisterRouter(p.address, 4)(
|
||||||
new TLRegBundle(p, _) with ExampleBundle)(
|
new TLRegBundle(p, _) with ExampleBundle)(
|
||||||
new TLRegModule(p, _, _) with ExampleModule)
|
new TLRegModule(p, _, _) with ExampleModule)
|
||||||
|
@ -240,10 +240,10 @@ class TLFragmenter(minSize: Int, maxSize: Int, alwaysMin: Boolean = false) exten
|
|||||||
|
|
||||||
object TLFragmenter
|
object TLFragmenter
|
||||||
{
|
{
|
||||||
// applied to the TL source node; connect (TLFragmenter(x.node, 256, 4) -> y.node)
|
// applied to the TL source node; y.node := TLFragmenter(x.node, 256, 4)
|
||||||
def apply(x: TLBaseNode, minSize: Int, maxSize: Int, alwaysMin: Boolean = false)(implicit lazyModule: LazyModule, sourceInfo: SourceInfo): TLBaseNode = {
|
def apply(x: TLBaseNode, minSize: Int, maxSize: Int, alwaysMin: Boolean = false)(implicit sourceInfo: SourceInfo): TLBaseNode = {
|
||||||
val fragmenter = LazyModule(new TLFragmenter(minSize, maxSize, alwaysMin))
|
val fragmenter = LazyModule(new TLFragmenter(minSize, maxSize, alwaysMin))
|
||||||
lazyModule.connect(x -> fragmenter.node)
|
fragmenter.node := x
|
||||||
fragmenter.node
|
fragmenter.node
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -90,10 +90,10 @@ class TLHintHandler(supportManagers: Boolean = true, supportClients: Boolean = f
|
|||||||
|
|
||||||
object TLHintHandler
|
object TLHintHandler
|
||||||
{
|
{
|
||||||
// applied to the TL source node; connect (TLHintHandler(x.node) -> y.node)
|
// applied to the TL source node; y.node := TLHintHandler(x.node)
|
||||||
def apply(x: TLBaseNode, supportManagers: Boolean = true, supportClients: Boolean = false, passthrough: Boolean = true)(implicit lazyModule: LazyModule, sourceInfo: SourceInfo): TLBaseNode = {
|
def apply(x: TLBaseNode, supportManagers: Boolean = true, supportClients: Boolean = false, passthrough: Boolean = true)(implicit sourceInfo: SourceInfo): TLBaseNode = {
|
||||||
val hints = LazyModule(new TLHintHandler(supportManagers, supportClients, passthrough))
|
val hints = LazyModule(new TLHintHandler(supportManagers, supportClients, passthrough))
|
||||||
lazyModule.connect(x -> hints.node)
|
hints.node := x
|
||||||
hints.node
|
hints.node
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
94
src/main/scala/uncore/tilelink2/IntNodes.scala
Normal file
94
src/main/scala/uncore/tilelink2/IntNodes.scala
Normal file
@ -0,0 +1,94 @@
|
|||||||
|
// See LICENSE for license details.
|
||||||
|
|
||||||
|
package uncore.tilelink2
|
||||||
|
|
||||||
|
import Chisel._
|
||||||
|
import scala.collection.mutable.ListBuffer
|
||||||
|
import scala.math.max
|
||||||
|
import chisel3.internal.sourceinfo.SourceInfo
|
||||||
|
|
||||||
|
// A potentially empty half-open range; [start, end)
|
||||||
|
case class IntRange(start: Int, end: Int)
|
||||||
|
{
|
||||||
|
require (start >= 0)
|
||||||
|
require (start <= end)
|
||||||
|
def size = end - start
|
||||||
|
def overlaps(x: IntRange) = start < x.end && x.start < end
|
||||||
|
def offset(x: Int) = IntRange(x+start, x+end)
|
||||||
|
}
|
||||||
|
object IntRange
|
||||||
|
{
|
||||||
|
implicit def apply(end: Int): IntRange = apply(0, end)
|
||||||
|
}
|
||||||
|
|
||||||
|
case class IntSourceParameters(device: String, range: IntRange)
|
||||||
|
|
||||||
|
case class IntSinkPortParameters()
|
||||||
|
case class IntSourcePortParameters(sources: Seq[IntSourceParameters])
|
||||||
|
{
|
||||||
|
val num = sources.map(_.range.size).sum
|
||||||
|
// The interrupts mapping must not overlap
|
||||||
|
sources.map(_.range).combinations(2).foreach { case Seq(a, b) => require (!a.overlaps(b)) }
|
||||||
|
// The interrupts must perfectly cover the range
|
||||||
|
require (sources.map(_.range.end).max == num)
|
||||||
|
}
|
||||||
|
case class IntEdge(source: IntSourcePortParameters, sink: IntSinkPortParameters)
|
||||||
|
|
||||||
|
object IntImp extends NodeImp[IntSourcePortParameters, IntSinkPortParameters, IntEdge, IntEdge, Vec[Bool]]
|
||||||
|
{
|
||||||
|
def edgeO(po: IntSourcePortParameters, pi: IntSinkPortParameters): IntEdge = IntEdge(po, pi)
|
||||||
|
def edgeI(po: IntSourcePortParameters, pi: IntSinkPortParameters): IntEdge = IntEdge(po, pi)
|
||||||
|
def bundleO(eo: Seq[IntEdge]): Vec[Vec[Bool]] = {
|
||||||
|
if (eo.isEmpty) Vec(0, Vec(0, Bool())) else
|
||||||
|
Vec(eo.size, Vec(eo.map(_.source.num).max, Bool()))
|
||||||
|
}
|
||||||
|
def bundleI(ei: Seq[IntEdge]): Vec[Vec[Bool]] = {
|
||||||
|
require (!ei.isEmpty)
|
||||||
|
Vec(ei.size, Vec(ei.map(_.source.num).max, Bool())).flip
|
||||||
|
}
|
||||||
|
|
||||||
|
def connect(bo: Vec[Bool], eo: IntEdge, bi: Vec[Bool], ei: IntEdge)(implicit sourceInfo: SourceInfo): Unit = {
|
||||||
|
require (eo == ei)
|
||||||
|
// Cannot use bulk connect, because the widths could differ
|
||||||
|
(bo zip bi) foreach { case (o, i) => i := o }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
case class IntIdentityNode() extends IdentityNode(IntImp)
|
||||||
|
case class IntOutputNode() extends OutputNode(IntImp)
|
||||||
|
case class IntInputNode() extends InputNode(IntImp)
|
||||||
|
|
||||||
|
case class IntSourceNode(device: String, num: Int) extends SourceNode(IntImp)(
|
||||||
|
IntSourcePortParameters(Seq(IntSourceParameters(device, num))),
|
||||||
|
(if (num == 0) 0 else 1) to 1)
|
||||||
|
case class IntSinkNode() extends SinkNode(IntImp)(IntSinkPortParameters())
|
||||||
|
|
||||||
|
case class IntAdapterNode(
|
||||||
|
sourceFn: Seq[IntSourcePortParameters] => IntSourcePortParameters,
|
||||||
|
sinkFn: Seq[IntSinkPortParameters] => IntSinkPortParameters,
|
||||||
|
numSourcePorts: Range.Inclusive = 1 to 1,
|
||||||
|
numSinkPorts: Range.Inclusive = 1 to 1)
|
||||||
|
extends InteriorNode(IntImp)(sourceFn, sinkFn, numSourcePorts, numSinkPorts)
|
||||||
|
|
||||||
|
class IntXbar extends LazyModule
|
||||||
|
{
|
||||||
|
val intnode = IntAdapterNode(
|
||||||
|
numSourcePorts = 1 to 1, // does it make sense to have more than one interrupt sink?
|
||||||
|
numSinkPorts = 1 to 128,
|
||||||
|
sinkFn = { _ => IntSinkPortParameters() },
|
||||||
|
sourceFn = { seq =>
|
||||||
|
IntSourcePortParameters((seq zip seq.map(_.num).scanLeft(0)(_+_).init).map {
|
||||||
|
case (s, o) => s.sources.map(z => z.copy(range = z.range.offset(o)))
|
||||||
|
}.flatten)
|
||||||
|
})
|
||||||
|
|
||||||
|
lazy val module = new LazyModuleImp(this) {
|
||||||
|
val io = new Bundle {
|
||||||
|
val in = intnode.bundleIn
|
||||||
|
val out = intnode.bundleOut
|
||||||
|
}
|
||||||
|
|
||||||
|
val cat = (intnode.edgesIn zip io.in).map{ case (e, i) => i.take(e.source.num) }.flatten
|
||||||
|
io.out.foreach { _ := cat }
|
||||||
|
}
|
||||||
|
}
|
@ -3,12 +3,13 @@
|
|||||||
package uncore.tilelink2
|
package uncore.tilelink2
|
||||||
|
|
||||||
import Chisel._
|
import Chisel._
|
||||||
import chisel3.internal.sourceinfo._
|
import chisel3.internal.sourceinfo.{SourceInfo, SourceLine, UnlocatableSourceInfo}
|
||||||
|
|
||||||
abstract class LazyModule
|
abstract class LazyModule
|
||||||
{
|
{
|
||||||
protected[tilelink2] var bindings = List[() => Unit]()
|
protected[tilelink2] var bindings = List[() => Unit]()
|
||||||
protected[tilelink2] var children = List[LazyModule]()
|
protected[tilelink2] var children = List[LazyModule]()
|
||||||
|
protected[tilelink2] var nodes = List[RootNode]()
|
||||||
protected[tilelink2] var info: SourceInfo = UnlocatableSourceInfo
|
protected[tilelink2] var info: SourceInfo = UnlocatableSourceInfo
|
||||||
protected[tilelink2] val parent = LazyModule.stack.headOption
|
protected[tilelink2] val parent = LazyModule.stack.headOption
|
||||||
|
|
||||||
@ -16,14 +17,14 @@ abstract class LazyModule
|
|||||||
parent.foreach(p => p.children = this :: p.children)
|
parent.foreach(p => p.children = this :: p.children)
|
||||||
|
|
||||||
// Use as: connect(source -> sink, source2 -> sink2, ...)
|
// Use as: connect(source -> sink, source2 -> sink2, ...)
|
||||||
def connect[PO, PI, EO, EI, B <: Bundle](edges: (BaseNode[PO, PI, EO, EI, B], BaseNode[PO, PI, EO, EI, B])*)(implicit sourceInfo: SourceInfo) = {
|
def connect[PO, PI, EO, EI, B <: Data](edges: (BaseNode[PO, PI, EO, EI, B], BaseNode[PO, PI, EO, EI, B])*)(implicit sourceInfo: SourceInfo) = {
|
||||||
edges.foreach { case (source, sink) =>
|
edges.foreach { case (source, sink) => sink := source }
|
||||||
bindings = (source edge sink) :: bindings
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
def name = getClass.getName.split('.').last
|
||||||
|
def line = sourceLine(info)
|
||||||
|
|
||||||
def module: LazyModuleImp
|
def module: LazyModuleImp
|
||||||
implicit val lazyModule = this
|
|
||||||
|
|
||||||
protected[tilelink2] def instantiate() = {
|
protected[tilelink2] def instantiate() = {
|
||||||
children.reverse.foreach { c =>
|
children.reverse.foreach { c =>
|
||||||
@ -43,7 +44,8 @@ object LazyModule
|
|||||||
// Make sure the user put LazyModule around modules in the correct order
|
// Make sure the user put LazyModule around modules in the correct order
|
||||||
// If this require fails, probably some grandchild was missing a LazyModule
|
// If this require fails, probably some grandchild was missing a LazyModule
|
||||||
// ... or you applied LazyModule twice
|
// ... or you applied LazyModule twice
|
||||||
require (!stack.isEmpty && (stack.head eq bc))
|
require (!stack.isEmpty, s"LazyModule() applied to ${bc.name} twice ${sourceLine(sourceInfo)}")
|
||||||
|
require (stack.head eq bc, s"LazyModule() applied to ${bc.name} before ${stack.head.name} ${sourceLine(sourceInfo)}")
|
||||||
stack = stack.tail
|
stack = stack.tail
|
||||||
bc.info = sourceInfo
|
bc.info = sourceInfo
|
||||||
bc
|
bc
|
||||||
@ -53,8 +55,8 @@ object LazyModule
|
|||||||
abstract class LazyModuleImp(outer: LazyModule) extends Module
|
abstract class LazyModuleImp(outer: LazyModule) extends Module
|
||||||
{
|
{
|
||||||
// .module had better not be accessed while LazyModules are still being built!
|
// .module had better not be accessed while LazyModules are still being built!
|
||||||
require (LazyModule.stack.isEmpty)
|
require (LazyModule.stack.isEmpty, s"${outer.name}.module was constructed before LazyModule() was run on ${LazyModule.stack.head.name}")
|
||||||
|
|
||||||
override def desiredName = outer.getClass.getName.split('.').last
|
override def desiredName = outer.name
|
||||||
outer.instantiate()
|
outer.instantiate()
|
||||||
}
|
}
|
||||||
|
@ -10,7 +10,7 @@ import chisel3.internal.sourceinfo.SourceInfo
|
|||||||
// PO = PortOutputParameters
|
// PO = PortOutputParameters
|
||||||
// EI = EdgeInput
|
// EI = EdgeInput
|
||||||
// EO = EdgeOutput
|
// EO = EdgeOutput
|
||||||
abstract class NodeImp[PO, PI, EO, EI, B <: Bundle]
|
abstract class NodeImp[PO, PI, EO, EI, B <: Data]
|
||||||
{
|
{
|
||||||
def edgeO(po: PO, pi: PI): EO
|
def edgeO(po: PO, pi: PI): EO
|
||||||
def edgeI(po: PO, pi: PI): EI
|
def edgeI(po: PO, pi: PI): EI
|
||||||
@ -19,36 +19,56 @@ abstract class NodeImp[PO, PI, EO, EI, B <: Bundle]
|
|||||||
def connect(bo: B, eo: EO, bi: B, ei: EI)(implicit sourceInfo: SourceInfo): Unit
|
def connect(bo: B, eo: EO, bi: B, ei: EI)(implicit sourceInfo: SourceInfo): Unit
|
||||||
}
|
}
|
||||||
|
|
||||||
class BaseNode[PO, PI, EO, EI, B <: Bundle](imp: NodeImp[PO, PI, EO, EI, B])(
|
class RootNode
|
||||||
private val oFn: Option[Seq[PO] => PO],
|
{
|
||||||
private val iFn: Option[Seq[PI] => PI],
|
// You cannot create a Node outside a LazyModule!
|
||||||
|
require (!LazyModule.stack.isEmpty)
|
||||||
|
|
||||||
|
val lazyModule = LazyModule.stack.head
|
||||||
|
lazyModule.nodes = this :: lazyModule.nodes
|
||||||
|
}
|
||||||
|
|
||||||
|
class BaseNode[PO, PI, EO, EI, B <: Data](imp: NodeImp[PO, PI, EO, EI, B])(
|
||||||
|
private val oFn: (Int, Seq[PO]) => Seq[PO],
|
||||||
|
private val iFn: (Int, Seq[PI]) => Seq[PI],
|
||||||
private val numPO: Range.Inclusive,
|
private val numPO: Range.Inclusive,
|
||||||
private val numPI: Range.Inclusive)
|
private val numPI: Range.Inclusive) extends RootNode
|
||||||
{
|
{
|
||||||
// At least 0 ports must be supported
|
// At least 0 ports must be supported
|
||||||
require (!numPO.isEmpty)
|
def name = lazyModule.name + "." + getClass.getName.split('.').last
|
||||||
require (!numPI.isEmpty)
|
require (!numPO.isEmpty, s"No number of outputs would be acceptable to ${name}${lazyModule.line}")
|
||||||
require (numPO.start >= 0)
|
require (!numPI.isEmpty, s"No number of inputs would be acceptable to ${name}${lazyModule.line}")
|
||||||
require (numPI.start >= 0)
|
require (numPO.start >= 0, s"${name} accepts a negative number of outputs${lazyModule.line}")
|
||||||
|
require (numPI.start >= 0, s"${name} accepts a negative number of inputs${lazyModule.line}")
|
||||||
|
|
||||||
val noOs = numPO.size == 1 && numPO.contains(0)
|
val noOs = numPO.size == 1 && numPO.contains(0)
|
||||||
val noIs = numPI.size == 1 && numPI.contains(0)
|
val noIs = numPI.size == 1 && numPI.contains(0)
|
||||||
|
|
||||||
require (noOs || oFn.isDefined)
|
private val accPO = ListBuffer[(Int, BaseNode[PO, PI, EO, EI, B])]()
|
||||||
require (noIs || iFn.isDefined)
|
private val accPI = ListBuffer[(Int, BaseNode[PO, PI, EO, EI, B])]()
|
||||||
|
|
||||||
private val accPO = ListBuffer[BaseNode[PO, PI, EO, EI, B]]()
|
|
||||||
private val accPI = ListBuffer[BaseNode[PO, PI, EO, EI, B]]()
|
|
||||||
private var oRealized = false
|
private var oRealized = false
|
||||||
private var iRealized = false
|
private var iRealized = false
|
||||||
|
|
||||||
private lazy val oPorts = { oRealized = true; require (numPO.contains(accPO.size)); accPO.result() }
|
private def reqO() = require(numPO.contains(accPO.size), s"${name} has ${accPO.size} outputs, expected ${numPO}${lazyModule.line}")
|
||||||
private lazy val iPorts = { iRealized = true; require (numPI.contains(accPI.size)); accPI.result() }
|
private def reqI() = require(numPI.contains(accPI.size), s"${name} has ${accPI.size} inputs, expected ${numPI}${lazyModule.line}")
|
||||||
private lazy val oParams : Option[PO] = oFn.map(_(iPorts.map(_.oParams.get)))
|
protected def reqE(o: Int, i: Int) = require(i == o, s"${name} has ${i} inputs and ${o} outputs; they must match${lazyModule.line}")
|
||||||
private lazy val iParams : Option[PI] = iFn.map(_(oPorts.map(_.iParams.get)))
|
|
||||||
|
|
||||||
lazy val edgesOut = oPorts.map { n => imp.edgeO(oParams.get, n.iParams.get) }
|
private lazy val oPorts = { oRealized = true; reqO(); accPO.result() }
|
||||||
lazy val edgesIn = iPorts.map { n => imp.edgeI(n.oParams.get, iParams.get) }
|
private lazy val iPorts = { iRealized = true; reqI(); accPI.result() }
|
||||||
|
|
||||||
|
private lazy val oParams : Seq[PO] = {
|
||||||
|
val o = oFn(oPorts.size, iPorts.map{ case (i, n) => n.oParams(i) })
|
||||||
|
reqE(oPorts.size, o.size)
|
||||||
|
o
|
||||||
|
}
|
||||||
|
private lazy val iParams : Seq[PI] = {
|
||||||
|
val i = iFn(iPorts.size, oPorts.map{ case (o, n) => n.iParams(o) })
|
||||||
|
reqE(i.size, iPorts.size)
|
||||||
|
i
|
||||||
|
}
|
||||||
|
|
||||||
|
lazy val edgesOut = (oPorts zip oParams).map { case ((i, n), o) => imp.edgeO(o, n.iParams(i)) }
|
||||||
|
lazy val edgesIn = (iPorts zip iParams).map { case ((o, n), i) => imp.edgeI(n.oParams(o), i) }
|
||||||
|
|
||||||
lazy val bundleOut = imp.bundleO(edgesOut)
|
lazy val bundleOut = imp.bundleO(edgesOut)
|
||||||
lazy val bundleIn = imp.bundleI(edgesIn)
|
lazy val bundleIn = imp.bundleI(edgesIn)
|
||||||
@ -56,53 +76,55 @@ class BaseNode[PO, PI, EO, EI, B <: Bundle](imp: NodeImp[PO, PI, EO, EI, B])(
|
|||||||
def connectOut = bundleOut
|
def connectOut = bundleOut
|
||||||
def connectIn = bundleIn
|
def connectIn = bundleIn
|
||||||
|
|
||||||
// source.edge(sink)
|
protected[tilelink2] def := (y: BaseNode[PO, PI, EO, EI, B])(implicit sourceInfo: SourceInfo) = {
|
||||||
protected[tilelink2] def edge(x: BaseNode[PO, PI, EO, EI, B])(implicit sourceInfo: SourceInfo) = {
|
val x = this // x := y
|
||||||
require (!noOs)
|
val info = sourceLine(sourceInfo, " at ", "")
|
||||||
require (!oRealized)
|
require (!LazyModule.stack.isEmpty, s"${y.name} cannot be connected to ${x.name} outside of LazyModule scope" + info)
|
||||||
require (!x.noIs)
|
require (!y.noOs, s"${y.name}${y.lazyModule.line} was incorrectly connected as a source" + info)
|
||||||
require (!x.iRealized)
|
require (!y.oRealized, s"${y.name}${y.lazyModule.line} was incorrectly connected as a source after it's .module was used" + info)
|
||||||
|
require (!x.noIs, s"${x.name}${x.lazyModule.line} was incorrectly connected as a sink" + info)
|
||||||
|
require (!x.iRealized, s"${x.name}${x.lazyModule.line} was incorrectly connected as a sink after it's .module was used" + info)
|
||||||
val i = x.accPI.size
|
val i = x.accPI.size
|
||||||
val o = accPO.size
|
val o = y.accPO.size
|
||||||
accPO += x
|
y.accPO += ((i, x))
|
||||||
x.accPI += this
|
x.accPI += ((o, y))
|
||||||
() => {
|
LazyModule.stack.head.bindings = (() => {
|
||||||
imp.connect(connectOut(o), edgesOut(o), x.connectIn(i), x.edgesIn(i))
|
imp.connect(y.connectOut(o), y.edgesOut(o), x.connectIn(i), x.edgesIn(i))
|
||||||
}
|
}) :: LazyModule.stack.head.bindings
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
class IdentityNode[PO, PI, EO, EI, B <: Bundle](imp: NodeImp[PO, PI, EO, EI, B])
|
class IdentityNode[PO, PI, EO, EI, B <: Data](imp: NodeImp[PO, PI, EO, EI, B])
|
||||||
extends BaseNode(imp)(Some{case Seq(x) => x}, Some{case Seq(x) => x}, 1 to 1, 1 to 1)
|
extends BaseNode(imp)({case (_, s) => s}, {case (_, s) => s}, 0 to 999, 0 to 999)
|
||||||
|
|
||||||
class OutputNode[PO, PI, EO, EI, B <: Bundle](imp: NodeImp[PO, PI, EO, EI, B]) extends IdentityNode(imp)
|
class OutputNode[PO, PI, EO, EI, B <: Data](imp: NodeImp[PO, PI, EO, EI, B]) extends IdentityNode(imp)
|
||||||
{
|
{
|
||||||
override def connectOut = bundleOut
|
override def connectOut = bundleOut
|
||||||
override def connectIn = bundleOut
|
override def connectIn = bundleOut
|
||||||
}
|
}
|
||||||
|
|
||||||
class InputNode[PO, PI, EO, EI, B <: Bundle](imp: NodeImp[PO, PI, EO, EI, B]) extends IdentityNode(imp)
|
class InputNode[PO, PI, EO, EI, B <: Data](imp: NodeImp[PO, PI, EO, EI, B]) extends IdentityNode(imp)
|
||||||
{
|
{
|
||||||
override def connectOut = bundleIn
|
override def connectOut = bundleIn
|
||||||
override def connectIn = bundleIn
|
override def connectIn = bundleIn
|
||||||
}
|
}
|
||||||
|
|
||||||
class SourceNode[PO, PI, EO, EI, B <: Bundle](imp: NodeImp[PO, PI, EO, EI, B])(po: PO, num: Range.Inclusive = 1 to 1)
|
class SourceNode[PO, PI, EO, EI, B <: Data](imp: NodeImp[PO, PI, EO, EI, B])(po: PO, num: Range.Inclusive = 1 to 1)
|
||||||
extends BaseNode(imp)(Some{case Seq() => po}, None, num, 0 to 0)
|
extends BaseNode(imp)({case (n, Seq()) => Seq.fill(n)(po)}, {case (0, _) => Seq()}, num, 0 to 0)
|
||||||
{
|
{
|
||||||
require (num.end >= 1)
|
require (num.end >= 1, s"${name} is a source which does not accept outputs${lazyModule.line}")
|
||||||
}
|
}
|
||||||
|
|
||||||
class SinkNode[PO, PI, EO, EI, B <: Bundle](imp: NodeImp[PO, PI, EO, EI, B])(pi: PI, num: Range.Inclusive = 1 to 1)
|
class SinkNode[PO, PI, EO, EI, B <: Data](imp: NodeImp[PO, PI, EO, EI, B])(pi: PI, num: Range.Inclusive = 1 to 1)
|
||||||
extends BaseNode(imp)(None, Some{case Seq() => pi}, 0 to 0, num)
|
extends BaseNode(imp)({case (0, _) => Seq()}, {case (n, Seq()) => Seq.fill(n)(pi)}, 0 to 0, num)
|
||||||
{
|
{
|
||||||
require (num.end >= 1)
|
require (num.end >= 1, s"${name} is a sink which does not accept inputs${lazyModule.line}")
|
||||||
}
|
}
|
||||||
|
|
||||||
class InteriorNode[PO, PI, EO, EI, B <: Bundle](imp: NodeImp[PO, PI, EO, EI, B])
|
class InteriorNode[PO, PI, EO, EI, B <: Data](imp: NodeImp[PO, PI, EO, EI, B])
|
||||||
(oFn: Seq[PO] => PO, iFn: Seq[PI] => PI, numPO: Range.Inclusive, numPI: Range.Inclusive)
|
(oFn: Seq[PO] => PO, iFn: Seq[PI] => PI, numPO: Range.Inclusive, numPI: Range.Inclusive)
|
||||||
extends BaseNode(imp)(Some(oFn), Some(iFn), numPO, numPI)
|
extends BaseNode(imp)({case (n,s) => Seq.fill(n)(oFn(s))}, {case (n,s) => Seq.fill(n)(iFn(s))}, numPO, numPI)
|
||||||
{
|
{
|
||||||
require (numPO.end >= 1)
|
require (numPO.end >= 1, s"${name} is an adapter which does not accept outputs${lazyModule.line}")
|
||||||
require (numPI.end >= 1)
|
require (numPI.end >= 1, s"${name} is an adapter which does not accept inputs${lazyModule.line}")
|
||||||
}
|
}
|
||||||
|
@ -97,6 +97,7 @@ object RegField
|
|||||||
trait HasRegMap
|
trait HasRegMap
|
||||||
{
|
{
|
||||||
def regmap(mapping: RegField.Map*): Unit
|
def regmap(mapping: RegField.Map*): Unit
|
||||||
|
val interrupts: Vec[Bool]
|
||||||
}
|
}
|
||||||
|
|
||||||
// See GPIO.scala for an example of how to use regmap
|
// See GPIO.scala for an example of how to use regmap
|
||||||
|
@ -75,29 +75,39 @@ object TLRegisterNode
|
|||||||
// register mapped device from a totally abstract register mapped device.
|
// register mapped device from a totally abstract register mapped device.
|
||||||
// See GPIO.scala in this directory for an example
|
// See GPIO.scala in this directory for an example
|
||||||
|
|
||||||
abstract class TLRegisterRouterBase(address: AddressSet, concurrency: Option[Int], beatBytes: Int) extends LazyModule
|
abstract class TLRegisterRouterBase(address: AddressSet, interrupts: Int, concurrency: Option[Int], beatBytes: Int) extends LazyModule
|
||||||
{
|
{
|
||||||
val node = TLRegisterNode(address, concurrency, beatBytes)
|
val node = TLRegisterNode(address, concurrency, beatBytes)
|
||||||
|
val intnode = IntSourceNode(name + s" @ ${address.base}", interrupts)
|
||||||
}
|
}
|
||||||
|
|
||||||
class TLRegBundle[P](val params: P, val in: Vec[TLBundle]) extends Bundle
|
case class TLRegBundleArg(interrupts: Vec[Vec[Bool]], in: Vec[TLBundle])
|
||||||
|
|
||||||
class TLRegModule[P, B <: Bundle](val params: P, bundleBuilder: => B, router: TLRegisterRouterBase)
|
class TLRegBundleBase(arg: TLRegBundleArg) extends Bundle
|
||||||
|
{
|
||||||
|
val interrupts = arg.interrupts
|
||||||
|
val in = arg.in
|
||||||
|
}
|
||||||
|
|
||||||
|
class TLRegBundle[P](val params: P, arg: TLRegBundleArg) extends TLRegBundleBase(arg)
|
||||||
|
|
||||||
|
class TLRegModule[P, B <: TLRegBundleBase](val params: P, bundleBuilder: => B, router: TLRegisterRouterBase)
|
||||||
extends LazyModuleImp(router) with HasRegMap
|
extends LazyModuleImp(router) with HasRegMap
|
||||||
{
|
{
|
||||||
val io = bundleBuilder
|
val io = bundleBuilder
|
||||||
|
val interrupts = if (io.interrupts.isEmpty) Vec(0, Bool()) else io.interrupts(0)
|
||||||
def regmap(mapping: RegField.Map*) = router.node.regmap(mapping:_*)
|
def regmap(mapping: RegField.Map*) = router.node.regmap(mapping:_*)
|
||||||
}
|
}
|
||||||
|
|
||||||
class TLRegisterRouter[B <: Bundle, M <: LazyModuleImp]
|
class TLRegisterRouter[B <: TLRegBundleBase, M <: LazyModuleImp]
|
||||||
(base: BigInt, size: BigInt = 4096, concurrency: Option[Int] = None, beatBytes: Int = 4)
|
(base: BigInt, interrupts: Int = 0, size: BigInt = 4096, concurrency: Option[Int] = None, beatBytes: Int = 4)
|
||||||
(bundleBuilder: Vec[TLBundle] => B)
|
(bundleBuilder: TLRegBundleArg => B)
|
||||||
(moduleBuilder: (=> B, TLRegisterRouterBase) => M)
|
(moduleBuilder: (=> B, TLRegisterRouterBase) => M)
|
||||||
extends TLRegisterRouterBase(AddressSet(base, size-1), concurrency, beatBytes)
|
extends TLRegisterRouterBase(AddressSet(base, size-1), interrupts, concurrency, beatBytes)
|
||||||
{
|
{
|
||||||
require (size % 4096 == 0) // devices should be 4K aligned
|
require (size % 4096 == 0) // devices should be 4K aligned
|
||||||
require (isPow2(size))
|
require (isPow2(size))
|
||||||
require (size >= 4096)
|
require (size >= 4096)
|
||||||
|
|
||||||
lazy val module = moduleBuilder(bundleBuilder(node.bundleIn), this)
|
lazy val module = moduleBuilder(bundleBuilder(TLRegBundleArg(intnode.bundleOut, node.bundleIn)), this)
|
||||||
}
|
}
|
||||||
|
@ -171,10 +171,10 @@ class TLWidthWidget(innerBeatBytes: Int) extends LazyModule
|
|||||||
|
|
||||||
object TLWidthWidget
|
object TLWidthWidget
|
||||||
{
|
{
|
||||||
// applied to the TL source node; connect (WidthWidget(x.node, 16) -> y.node)
|
// applied to the TL source node; y.node := WidthWidget(x.node, 16)
|
||||||
def apply(x: TLBaseNode, innerBeatBytes: Int)(implicit lazyModule: LazyModule, sourceInfo: SourceInfo): TLBaseNode = {
|
def apply(x: TLBaseNode, innerBeatBytes: Int)(implicit sourceInfo: SourceInfo): TLBaseNode = {
|
||||||
val widget = LazyModule(new TLWidthWidget(innerBeatBytes))
|
val widget = LazyModule(new TLWidthWidget(innerBeatBytes))
|
||||||
lazyModule.connect(x -> widget.node)
|
widget.node := x
|
||||||
widget.node
|
widget.node
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1,11 +1,18 @@
|
|||||||
package uncore
|
package uncore
|
||||||
|
|
||||||
import Chisel._
|
import Chisel._
|
||||||
|
import chisel3.internal.sourceinfo.{SourceInfo, SourceLine, UnlocatableSourceInfo}
|
||||||
|
|
||||||
package object tilelink2
|
package object tilelink2
|
||||||
{
|
{
|
||||||
type TLBaseNode = BaseNode[TLClientPortParameters, TLManagerPortParameters, TLEdgeOut, TLEdgeIn, TLBundle]
|
type TLBaseNode = BaseNode[TLClientPortParameters, TLManagerPortParameters, TLEdgeOut, TLEdgeIn, TLBundle]
|
||||||
|
type IntBaseNode = BaseNode[IntSourcePortParameters, IntSinkPortParameters, IntEdge, IntEdge, Vec[Bool]]
|
||||||
def OH1ToUInt(x: UInt) = OHToUInt((x << 1 | UInt(1)) ^ x)
|
def OH1ToUInt(x: UInt) = OHToUInt((x << 1 | UInt(1)) ^ x)
|
||||||
def UIntToOH1(x: UInt, width: Int) = ~(SInt(-1, width=width).asUInt << x)(width-1, 0)
|
def UIntToOH1(x: UInt, width: Int) = ~(SInt(-1, width=width).asUInt << x)(width-1, 0)
|
||||||
def trailingZeros(x: Int) = if (x > 0) Some(log2Ceil(x & -x)) else None
|
def trailingZeros(x: Int) = if (x > 0) Some(log2Ceil(x & -x)) else None
|
||||||
|
|
||||||
|
def sourceLine(sourceInfo: SourceInfo, prefix: String = " (", suffix: String = ")") = sourceInfo match {
|
||||||
|
case SourceLine(filename, line, col) => s"$prefix$filename:$line:$col$suffix"
|
||||||
|
case _ => ""
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
Loading…
Reference in New Issue
Block a user