tilelink2: Monitor should report which TL connection was the problem
This commit is contained in:
Wesley W. Terpstra
parent
cb54df0a8a
commit
1a081b4dd5
@ -3,12 +3,19 @@
|
||||
package uncore.tilelink2
|
||||
|
||||
import Chisel._
|
||||
import chisel3.internal.sourceinfo.SourceInfo
|
||||
import chisel3.internal.sourceinfo.{SourceInfo, SourceLine}
|
||||
|
||||
object TLMonitor
|
||||
{
|
||||
def extra(implicit sourceInfo: SourceInfo) = {
|
||||
sourceInfo match {
|
||||
case SourceLine(filename, line, col) => s" (connected at $filename:$line:$col)"
|
||||
case _ => ""
|
||||
}
|
||||
}
|
||||
|
||||
def legalizeFormatA(bundle: TLBundleA, edge: TLEdgeOut)(implicit sourceInfo: SourceInfo) = {
|
||||
assert (TLMessages.isA(bundle.opcode), "'A' channel has invalid opcode")
|
||||
assert (TLMessages.isA(bundle.opcode), "'A' channel has invalid opcode" + extra)
|
||||
|
||||
// Reuse these subexpressions to save some firrtl lines
|
||||
val source_ok = edge.client.contains(bundle.source)
|
||||
@ -16,65 +23,65 @@ object TLMonitor
|
||||
val mask = edge.fullMask(bundle.address, bundle.size)
|
||||
|
||||
when (bundle.opcode === TLMessages.Acquire) {
|
||||
assert (edge.manager.supportsAcquire(bundle.address, bundle.size), "'A' channel carries Acquire type unsupported by manager")
|
||||
assert (source_ok, "'A' channel Acquire carries invalid source ID")
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'A' channel Acquire smaller than a beat")
|
||||
assert (is_aligned, "'A' channel Acquire address not aligned to size")
|
||||
assert (TLPermissions.isGrow(bundle.param), "'A' channel Acquire carries invalid grow param")
|
||||
assert (bundle.mask === SInt(-1).asUInt, "'A' channel Acquire contains invalid mask")
|
||||
assert (edge.manager.supportsAcquire(bundle.address, bundle.size), "'A' channel carries Acquire type unsupported by manager" + extra)
|
||||
assert (source_ok, "'A' channel Acquire carries invalid source ID" + extra)
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'A' channel Acquire smaller than a beat" + extra)
|
||||
assert (is_aligned, "'A' channel Acquire address not aligned to size" + extra)
|
||||
assert (TLPermissions.isGrow(bundle.param), "'A' channel Acquire carries invalid grow param" + extra)
|
||||
assert (bundle.mask === SInt(-1).asUInt, "'A' channel Acquire contains invalid mask" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.Get) {
|
||||
assert (edge.manager.supportsGet(bundle.address, bundle.size), "'A' channel carries Get type unsupported by manager")
|
||||
assert (source_ok, "'A' channel Get carries invalid source ID")
|
||||
assert (is_aligned, "'A' channel Get address not aligned to size")
|
||||
assert (bundle.param === UInt(0), "'A' channel Get carries invalid param")
|
||||
assert (bundle.mask === mask, "'A' channel Get contains invalid mask")
|
||||
assert (edge.manager.supportsGet(bundle.address, bundle.size), "'A' channel carries Get type unsupported by manager" + extra)
|
||||
assert (source_ok, "'A' channel Get carries invalid source ID" + extra)
|
||||
assert (is_aligned, "'A' channel Get address not aligned to size" + extra)
|
||||
assert (bundle.param === UInt(0), "'A' channel Get carries invalid param" + extra)
|
||||
assert (bundle.mask === mask, "'A' channel Get contains invalid mask" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.PutFullData) {
|
||||
assert (edge.manager.supportsPutFull(bundle.address, bundle.size), "'A' channel carries PutFull type unsupported by manager")
|
||||
assert (source_ok, "'A' channel PutFull carries invalid source ID")
|
||||
assert (is_aligned, "'A' channel PutFull address not aligned to size")
|
||||
assert (bundle.param === UInt(0), "'A' channel PutFull carries invalid param")
|
||||
assert (bundle.mask === mask, "'A' channel PutFull contains invalid mask")
|
||||
assert (edge.manager.supportsPutFull(bundle.address, bundle.size), "'A' channel carries PutFull type unsupported by manager" + extra)
|
||||
assert (source_ok, "'A' channel PutFull carries invalid source ID" + extra)
|
||||
assert (is_aligned, "'A' channel PutFull address not aligned to size" + extra)
|
||||
assert (bundle.param === UInt(0), "'A' channel PutFull carries invalid param" + extra)
|
||||
assert (bundle.mask === mask, "'A' channel PutFull contains invalid mask" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.PutPartialData) {
|
||||
assert (edge.manager.supportsPutPartial(bundle.address, bundle.size), "'A' channel carries PutPartial type unsupported by manager")
|
||||
assert (source_ok, "'A' channel PutPartial carries invalid source ID")
|
||||
assert (is_aligned, "'A' channel PutPartial address not aligned to size")
|
||||
assert (bundle.param === UInt(0), "'A' channel PutPartial carries invalid param")
|
||||
assert ((bundle.mask & ~mask) === UInt(0), "'A' channel PutPartial contains invalid mask")
|
||||
assert (bundle.mask =/= UInt(0), "'A' channel PutPartial has a zero mask")
|
||||
assert (edge.manager.supportsPutPartial(bundle.address, bundle.size), "'A' channel carries PutPartial type unsupported by manager" + extra)
|
||||
assert (source_ok, "'A' channel PutPartial carries invalid source ID" + extra)
|
||||
assert (is_aligned, "'A' channel PutPartial address not aligned to size" + extra)
|
||||
assert (bundle.param === UInt(0), "'A' channel PutPartial carries invalid param" + extra)
|
||||
assert ((bundle.mask & ~mask) === UInt(0), "'A' channel PutPartial contains invalid mask" + extra)
|
||||
assert (bundle.mask =/= UInt(0), "'A' channel PutPartial has a zero mask" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.ArithmeticData) {
|
||||
assert (edge.manager.supportsArithmetic(bundle.address, bundle.size), "'A' channel carries Arithmetic type unsupported by manager")
|
||||
assert (source_ok, "'A' channel Arithmetic carries invalid source ID")
|
||||
assert (is_aligned, "'A' channel Arithmetic address not aligned to size")
|
||||
assert (TLAtomics.isArithmetic(bundle.param), "'A' channel Arithmetic carries invalid opcode param")
|
||||
assert (bundle.mask === mask, "'A' channel Arithmetic contains invalid mask")
|
||||
assert (edge.manager.supportsArithmetic(bundle.address, bundle.size), "'A' channel carries Arithmetic type unsupported by manager" + extra)
|
||||
assert (source_ok, "'A' channel Arithmetic carries invalid source ID" + extra)
|
||||
assert (is_aligned, "'A' channel Arithmetic address not aligned to size" + extra)
|
||||
assert (TLAtomics.isArithmetic(bundle.param), "'A' channel Arithmetic carries invalid opcode param" + extra)
|
||||
assert (bundle.mask === mask, "'A' channel Arithmetic contains invalid mask" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.LogicalData) {
|
||||
assert (edge.manager.supportsLogical(bundle.address, bundle.size), "'A' channel carries Logical type unsupported by manager")
|
||||
assert (source_ok, "'A' channel Logical carries invalid source ID")
|
||||
assert (is_aligned, "'A' channel Logical address not aligned to size")
|
||||
assert (TLAtomics.isLogical(bundle.param), "'A' channel Logical carries invalid opcode param")
|
||||
assert (bundle.mask === mask, "'A' channel Logical contains invalid mask")
|
||||
assert (edge.manager.supportsLogical(bundle.address, bundle.size), "'A' channel carries Logical type unsupported by manager" + extra)
|
||||
assert (source_ok, "'A' channel Logical carries invalid source ID" + extra)
|
||||
assert (is_aligned, "'A' channel Logical address not aligned to size" + extra)
|
||||
assert (TLAtomics.isLogical(bundle.param), "'A' channel Logical carries invalid opcode param" + extra)
|
||||
assert (bundle.mask === mask, "'A' channel Logical contains invalid mask" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.Hint) {
|
||||
assert (edge.manager.supportsHint(bundle.address), "'A' channel carries Hint type unsupported by manager")
|
||||
assert (source_ok, "'A' channel Hint carries invalid source ID")
|
||||
assert (is_aligned, "'A' channel Hint address not aligned to size")
|
||||
assert (bundle.mask === mask, "'A' channel Hint contains invalid mask")
|
||||
assert (edge.manager.supportsHint(bundle.address), "'A' channel carries Hint type unsupported by manager" + extra)
|
||||
assert (source_ok, "'A' channel Hint carries invalid source ID" + extra)
|
||||
assert (is_aligned, "'A' channel Hint address not aligned to size" + extra)
|
||||
assert (bundle.mask === mask, "'A' channel Hint contains invalid mask" + extra)
|
||||
}
|
||||
}
|
||||
|
||||
def legalizeFormatB(bundle: TLBundleB, edge: TLEdgeIn)(implicit sourceInfo: SourceInfo) = {
|
||||
assert (TLMessages.isB(bundle.opcode), "'B' channel has invalid opcode")
|
||||
assert (TLMessages.isB(bundle.opcode), "'B' channel has invalid opcode" + extra)
|
||||
|
||||
// Reuse these subexpressions to save some firrtl lines
|
||||
val address_ok = edge.manager.contains(bundle.source)
|
||||
@ -82,182 +89,182 @@ object TLMonitor
|
||||
val mask = edge.fullMask(bundle.address, bundle.size)
|
||||
|
||||
when (bundle.opcode === TLMessages.Probe) {
|
||||
assert (edge.client.supportsProbe(bundle.source, bundle.size), "'B' channel carries Probe type unsupported by client")
|
||||
assert (address_ok, "'B' channel Probe carries unmanaged address")
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'B' channel Probe smaller than a beat")
|
||||
assert (is_aligned, "'B' channel Probe address not aligned to size")
|
||||
assert (TLPermissions.isCap(bundle.param), "'B' channel Probe carries invalid cap param")
|
||||
assert (bundle.mask === SInt(-1).asUInt, "'B' channel Probe contains invalid mask")
|
||||
assert (edge.client.supportsProbe(bundle.source, bundle.size), "'B' channel carries Probe type unsupported by client" + extra)
|
||||
assert (address_ok, "'B' channel Probe carries unmanaged address" + extra)
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'B' channel Probe smaller than a beat" + extra)
|
||||
assert (is_aligned, "'B' channel Probe address not aligned to size" + extra)
|
||||
assert (TLPermissions.isCap(bundle.param), "'B' channel Probe carries invalid cap param" + extra)
|
||||
assert (bundle.mask === SInt(-1).asUInt, "'B' channel Probe contains invalid mask" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.Get) {
|
||||
assert (edge.client.supportsGet(bundle.source, bundle.size), "'B' channel carries Get type unsupported by client")
|
||||
assert (address_ok, "'B' channel Get carries unmanaged address")
|
||||
assert (is_aligned, "'B' channel Get address not aligned to size")
|
||||
assert (bundle.param === UInt(0), "'B' channel Get carries invalid param")
|
||||
assert (bundle.mask === mask, "'A' channel Get contains invalid mask")
|
||||
assert (edge.client.supportsGet(bundle.source, bundle.size), "'B' channel carries Get type unsupported by client" + extra)
|
||||
assert (address_ok, "'B' channel Get carries unmanaged address" + extra)
|
||||
assert (is_aligned, "'B' channel Get address not aligned to size" + extra)
|
||||
assert (bundle.param === UInt(0), "'B' channel Get carries invalid param" + extra)
|
||||
assert (bundle.mask === mask, "'A' channel Get contains invalid mask" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.PutFullData) {
|
||||
assert (edge.client.supportsPutFull(bundle.source, bundle.size), "'B' channel carries PutFull type unsupported by client")
|
||||
assert (address_ok, "'B' channel PutFull carries unmanaged address")
|
||||
assert (is_aligned, "'B' channel PutFull address not aligned to size")
|
||||
assert (bundle.param === UInt(0), "'B' channel PutFull carries invalid param")
|
||||
assert (bundle.mask === mask, "'B' channel PutFull contains invalid mask")
|
||||
assert (edge.client.supportsPutFull(bundle.source, bundle.size), "'B' channel carries PutFull type unsupported by client" + extra)
|
||||
assert (address_ok, "'B' channel PutFull carries unmanaged address" + extra)
|
||||
assert (is_aligned, "'B' channel PutFull address not aligned to size" + extra)
|
||||
assert (bundle.param === UInt(0), "'B' channel PutFull carries invalid param" + extra)
|
||||
assert (bundle.mask === mask, "'B' channel PutFull contains invalid mask" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.PutPartialData) {
|
||||
assert (edge.client.supportsPutPartial(bundle.source, bundle.size), "'B' channel carries PutPartial type unsupported by client")
|
||||
assert (address_ok, "'B' channel PutPartial carries unmanaged address")
|
||||
assert (is_aligned, "'B' channel PutPartial address not aligned to size")
|
||||
assert (bundle.param === UInt(0), "'B' channel PutPartial carries invalid param")
|
||||
assert ((bundle.mask & ~mask) === UInt(0), "'B' channel PutPartial contains invalid mask")
|
||||
assert (bundle.mask =/= UInt(0), "'B' channel PutPartial has a zero mask")
|
||||
assert (edge.client.supportsPutPartial(bundle.source, bundle.size), "'B' channel carries PutPartial type unsupported by client" + extra)
|
||||
assert (address_ok, "'B' channel PutPartial carries unmanaged address" + extra)
|
||||
assert (is_aligned, "'B' channel PutPartial address not aligned to size" + extra)
|
||||
assert (bundle.param === UInt(0), "'B' channel PutPartial carries invalid param" + extra)
|
||||
assert ((bundle.mask & ~mask) === UInt(0), "'B' channel PutPartial contains invalid mask" + extra)
|
||||
assert (bundle.mask =/= UInt(0), "'B' channel PutPartial has a zero mask" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.ArithmeticData) {
|
||||
assert (edge.client.supportsArithmetic(bundle.source, bundle.size), "'B' channel carries Arithmetic type unsupported by client")
|
||||
assert (address_ok, "'B' channel Arithmetic carries unmanaged address")
|
||||
assert (is_aligned, "'B' channel Arithmetic address not aligned to size")
|
||||
assert (TLAtomics.isArithmetic(bundle.param), "'B' channel Arithmetic carries invalid opcode param")
|
||||
assert (bundle.mask === mask, "'B' channel Arithmetic contains invalid mask")
|
||||
assert (edge.client.supportsArithmetic(bundle.source, bundle.size), "'B' channel carries Arithmetic type unsupported by client" + extra)
|
||||
assert (address_ok, "'B' channel Arithmetic carries unmanaged address" + extra)
|
||||
assert (is_aligned, "'B' channel Arithmetic address not aligned to size" + extra)
|
||||
assert (TLAtomics.isArithmetic(bundle.param), "'B' channel Arithmetic carries invalid opcode param" + extra)
|
||||
assert (bundle.mask === mask, "'B' channel Arithmetic contains invalid mask" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.LogicalData) {
|
||||
assert (edge.client.supportsLogical(bundle.source, bundle.size), "'B' channel carries Logical type unsupported by client")
|
||||
assert (address_ok, "'B' channel Logical carries unmanaged address")
|
||||
assert (is_aligned, "'B' channel Logical address not aligned to size")
|
||||
assert (TLAtomics.isLogical(bundle.param), "'B' channel Logical carries invalid opcode param")
|
||||
assert (bundle.mask === mask, "'B' channel Logical contains invalid mask")
|
||||
assert (edge.client.supportsLogical(bundle.source, bundle.size), "'B' channel carries Logical type unsupported by client" + extra)
|
||||
assert (address_ok, "'B' channel Logical carries unmanaged address" + extra)
|
||||
assert (is_aligned, "'B' channel Logical address not aligned to size" + extra)
|
||||
assert (TLAtomics.isLogical(bundle.param), "'B' channel Logical carries invalid opcode param" + extra)
|
||||
assert (bundle.mask === mask, "'B' channel Logical contains invalid mask" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.Hint) {
|
||||
assert (edge.client.supportsHint(bundle.source), "'B' channel carries Hint type unsupported by client")
|
||||
assert (address_ok, "'B' channel Hint carries unmanaged address")
|
||||
assert (is_aligned, "'B' channel Hint address not aligned to size")
|
||||
assert (bundle.mask === mask, "'B' channel Hint contains invalid mask")
|
||||
assert (edge.client.supportsHint(bundle.source), "'B' channel carries Hint type unsupported by client" + extra)
|
||||
assert (address_ok, "'B' channel Hint carries unmanaged address" + extra)
|
||||
assert (is_aligned, "'B' channel Hint address not aligned to size" + extra)
|
||||
assert (bundle.mask === mask, "'B' channel Hint contains invalid mask" + extra)
|
||||
}
|
||||
}
|
||||
|
||||
def legalizeFormatC(bundle: TLBundleC, edge: TLEdgeOut)(implicit sourceInfo: SourceInfo) = {
|
||||
assert (TLMessages.isC(bundle.opcode), "'C' channel has invalid opcode")
|
||||
assert (TLMessages.isC(bundle.opcode), "'C' channel has invalid opcode" + extra)
|
||||
|
||||
val source_ok = edge.client.contains(bundle.source)
|
||||
val is_aligned = edge.isAligned(bundle.address, bundle.size)
|
||||
val address_ok = edge.manager.contains(bundle.source)
|
||||
|
||||
when (bundle.opcode === TLMessages.ProbeAck) {
|
||||
assert (address_ok, "'C' channel ProbeAck carries unmanaged address")
|
||||
assert (address_ok, "'C' channel ProbeAck carries unmanaged address" + extra)
|
||||
// source is ignored
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'C' channel ProbeAck smaller than a beat")
|
||||
assert (is_aligned, "'C' channel ProbeAck address not aligned to size")
|
||||
assert (TLPermissions.isReport(bundle.param), "'C' channel ProbeAck carries invalid report param")
|
||||
assert (!bundle.error, "'C' channel Probe carries an error")
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'C' channel ProbeAck smaller than a beat" + extra)
|
||||
assert (is_aligned, "'C' channel ProbeAck address not aligned to size" + extra)
|
||||
assert (TLPermissions.isReport(bundle.param), "'C' channel ProbeAck carries invalid report param" + extra)
|
||||
assert (!bundle.error, "'C' channel Probe carries an error" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.ProbeAckData) {
|
||||
assert (address_ok, "'C' channel ProbeAckData carries unmanaged address")
|
||||
assert (address_ok, "'C' channel ProbeAckData carries unmanaged address" + extra)
|
||||
// source is ignored
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'C' channel ProbeAckData smaller than a beat")
|
||||
assert (is_aligned, "'C' channel ProbeAckData address not aligned to size")
|
||||
assert (TLPermissions.isReport(bundle.param), "'C' channel ProbeAckData carries invalid report param")
|
||||
assert (!bundle.error, "'C' channel ProbeData carries an error")
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'C' channel ProbeAckData smaller than a beat" + extra)
|
||||
assert (is_aligned, "'C' channel ProbeAckData address not aligned to size" + extra)
|
||||
assert (TLPermissions.isReport(bundle.param), "'C' channel ProbeAckData carries invalid report param" + extra)
|
||||
assert (!bundle.error, "'C' channel ProbeData carries an error" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.Release) {
|
||||
assert (edge.manager.supportsAcquire(bundle.address, bundle.size), "'C' channel carries Release type unsupported by manager")
|
||||
assert (source_ok, "'C' channel Release carries invalid source ID")
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'C' channel Release smaller than a beat")
|
||||
assert (is_aligned, "'C' channel Release address not aligned to size")
|
||||
assert (TLPermissions.isShrink(bundle.param), "'C' channel Release carries invalid shrink param")
|
||||
assert (!bundle.error, "'C' channel Release carries an error")
|
||||
assert (edge.manager.supportsAcquire(bundle.address, bundle.size), "'C' channel carries Release type unsupported by manager" + extra)
|
||||
assert (source_ok, "'C' channel Release carries invalid source ID" + extra)
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'C' channel Release smaller than a beat" + extra)
|
||||
assert (is_aligned, "'C' channel Release address not aligned to size" + extra)
|
||||
assert (TLPermissions.isShrink(bundle.param), "'C' channel Release carries invalid shrink param" + extra)
|
||||
assert (!bundle.error, "'C' channel Release carries an error" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.ReleaseData) {
|
||||
assert (edge.manager.supportsAcquire(bundle.address, bundle.size), "'C' channel carries ReleaseData type unsupported by manager")
|
||||
assert (source_ok, "'C' channel ReleaseData carries invalid source ID")
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'C' channel ReleaseData smaller than a beat")
|
||||
assert (is_aligned, "'C' channel ReleaseData address not aligned to size")
|
||||
assert (TLPermissions.isShrink(bundle.param), "'C' channel ReleaseData carries invalid shrink param")
|
||||
assert (!bundle.error, "'C' channel ReleaseData carries an error")
|
||||
assert (edge.manager.supportsAcquire(bundle.address, bundle.size), "'C' channel carries ReleaseData type unsupported by manager" + extra)
|
||||
assert (source_ok, "'C' channel ReleaseData carries invalid source ID" + extra)
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'C' channel ReleaseData smaller than a beat" + extra)
|
||||
assert (is_aligned, "'C' channel ReleaseData address not aligned to size" + extra)
|
||||
assert (TLPermissions.isShrink(bundle.param), "'C' channel ReleaseData carries invalid shrink param" + extra)
|
||||
assert (!bundle.error, "'C' channel ReleaseData carries an error" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.AccessAck) {
|
||||
assert (address_ok, "'C' channel AccessAck carries unmanaged address")
|
||||
assert (address_ok, "'C' channel AccessAck carries unmanaged address" + extra)
|
||||
// source is ignored
|
||||
assert (is_aligned, "'C' channel AccessAck address not aligned to size")
|
||||
assert (bundle.param === UInt(0), "'C' channel AccessAck carries invalid param")
|
||||
assert (is_aligned, "'C' channel AccessAck address not aligned to size" + extra)
|
||||
assert (bundle.param === UInt(0), "'C' channel AccessAck carries invalid param" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.AccessAckData) {
|
||||
assert (address_ok, "'C' channel AccessAckData carries unmanaged address")
|
||||
assert (address_ok, "'C' channel AccessAckData carries unmanaged address" + extra)
|
||||
// source is ignored
|
||||
assert (is_aligned, "'C' channel AccessAckData address not aligned to size")
|
||||
assert (bundle.param === UInt(0), "'C' channel AccessAckData carries invalid param")
|
||||
assert (is_aligned, "'C' channel AccessAckData address not aligned to size" + extra)
|
||||
assert (bundle.param === UInt(0), "'C' channel AccessAckData carries invalid param" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.HintAck) {
|
||||
assert (address_ok, "'C' channel HintAck carries unmanaged address")
|
||||
assert (address_ok, "'C' channel HintAck carries unmanaged address" + extra)
|
||||
// source is ignored
|
||||
assert (is_aligned, "'C' channel HintAck address not aligned to size")
|
||||
assert (bundle.param === UInt(0), "'C' channel HintAck carries invalid param")
|
||||
assert (!bundle.error, "'C' channel HintAck carries an error")
|
||||
assert (is_aligned, "'C' channel HintAck address not aligned to size" + extra)
|
||||
assert (bundle.param === UInt(0), "'C' channel HintAck carries invalid param" + extra)
|
||||
assert (!bundle.error, "'C' channel HintAck carries an error" + extra)
|
||||
}
|
||||
}
|
||||
|
||||
def legalizeFormatD(bundle: TLBundleD, edge: TLEdgeIn)(implicit sourceInfo: SourceInfo) = {
|
||||
assert (TLMessages.isD(bundle.opcode), "'D' channel has invalid opcode")
|
||||
assert (TLMessages.isD(bundle.opcode), "'D' channel has invalid opcode" + extra)
|
||||
|
||||
val source_ok = edge.client.contains(bundle.source)
|
||||
val sink_ok = edge.manager.containsById(bundle.sink)
|
||||
|
||||
when (bundle.opcode === TLMessages.ReleaseAck) {
|
||||
assert (source_ok, "'D' channel ReleaseAck carries invalid source ID")
|
||||
assert (source_ok, "'D' channel ReleaseAck carries invalid source ID" + extra)
|
||||
// sink is ignored
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'D' channel ReleaseAck smaller than a beat")
|
||||
assert (bundle.param === UInt(0), "'D' channel ReleaseeAck carries invalid param")
|
||||
assert (!bundle.error, "'D' channel ReleaseAck carries an error")
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'D' channel ReleaseAck smaller than a beat" + extra)
|
||||
assert (bundle.param === UInt(0), "'D' channel ReleaseeAck carries invalid param" + extra)
|
||||
assert (!bundle.error, "'D' channel ReleaseAck carries an error" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.Grant) {
|
||||
assert (source_ok, "'D' channel Grant carries invalid source ID")
|
||||
assert (sink_ok, "'D' channel Grant carries invalid sink ID")
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'D' channel Grant smaller than a beat")
|
||||
assert (TLPermissions.isCap(bundle.param), "'D' channel Grant carries invalid cap param")
|
||||
assert (source_ok, "'D' channel Grant carries invalid source ID" + extra)
|
||||
assert (sink_ok, "'D' channel Grant carries invalid sink ID" + extra)
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'D' channel Grant smaller than a beat" + extra)
|
||||
assert (TLPermissions.isCap(bundle.param), "'D' channel Grant carries invalid cap param" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.GrantData) {
|
||||
assert (source_ok, "'D' channel GrantData carries invalid source ID")
|
||||
assert (sink_ok, "'D' channel GrantData carries invalid sink ID")
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'D' channel GrantData smaller than a beat")
|
||||
assert (TLPermissions.isCap(bundle.param), "'D' channel GrantData carries invalid cap param")
|
||||
assert (source_ok, "'D' channel GrantData carries invalid source ID" + extra)
|
||||
assert (sink_ok, "'D' channel GrantData carries invalid sink ID" + extra)
|
||||
assert (bundle.size >= UInt(log2Ceil(edge.manager.beatBytes)), "'D' channel GrantData smaller than a beat" + extra)
|
||||
assert (TLPermissions.isCap(bundle.param), "'D' channel GrantData carries invalid cap param" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.AccessAck) {
|
||||
assert (source_ok, "'D' channel AccessAck carries invalid source ID")
|
||||
assert (source_ok, "'D' channel AccessAck carries invalid source ID" + extra)
|
||||
// sink is ignored
|
||||
// size is ignored
|
||||
assert (bundle.param === UInt(0), "'D' channel AccessAck carries invalid param")
|
||||
assert (bundle.param === UInt(0), "'D' channel AccessAck carries invalid param" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.AccessAckData) {
|
||||
assert (source_ok, "'D' channel AccessAckData carries invalid source ID")
|
||||
assert (source_ok, "'D' channel AccessAckData carries invalid source ID" + extra)
|
||||
// sink is ignored
|
||||
// size is ignored
|
||||
assert (bundle.param === UInt(0), "'D' channel AccessAckData carries invalid param")
|
||||
assert (bundle.param === UInt(0), "'D' channel AccessAckData carries invalid param" + extra)
|
||||
}
|
||||
|
||||
when (bundle.opcode === TLMessages.HintAck) {
|
||||
assert (source_ok, "'D' channel HintAck carries invalid source ID")
|
||||
assert (source_ok, "'D' channel HintAck carries invalid source ID" + extra)
|
||||
// sink is ignored
|
||||
// size is ignored
|
||||
assert (bundle.param === UInt(0), "'D' channel HintAck carries invalid param")
|
||||
assert (!bundle.error, "'D' channel HintAck carries an error")
|
||||
assert (bundle.param === UInt(0), "'D' channel HintAck carries invalid param" + extra)
|
||||
assert (!bundle.error, "'D' channel HintAck carries an error" + extra)
|
||||
}
|
||||
}
|
||||
|
||||
def legalizeFormatE(bundle: TLBundleE, edge: TLEdgeOut)(implicit sourceInfo: SourceInfo) = {
|
||||
assert (edge.manager.containsById(bundle.sink), "'E' channels carries invalid sink ID")
|
||||
assert (edge.manager.containsById(bundle.sink), "'E' channels carries invalid sink ID" + extra)
|
||||
}
|
||||
|
||||
def legalizeFormat(bundleOut: TLBundle, edgeOut: TLEdgeOut, bundleIn: TLBundle, edgeIn: TLEdgeIn)(implicit sourceInfo: SourceInfo) = {
|
||||
@ -276,11 +283,11 @@ object TLMonitor
|
||||
val source = Reg(UInt())
|
||||
val address = Reg(UInt())
|
||||
when (a.valid && counter =/= UInt(0)) {
|
||||
assert (a.bits.opcode === opcode, "'A' channel opcode changed within multibeat operation")
|
||||
assert (a.bits.param === param, "'A' channel param changed within multibeat operation")
|
||||
assert (a.bits.size === size, "'A' channel size changed within multibeat operation")
|
||||
assert (a.bits.source === source, "'A' channel source changed within multibeat operation")
|
||||
assert (a.bits.address=== address,"'A' channel address changed with multibeat operation")
|
||||
assert (a.bits.opcode === opcode, "'A' channel opcode changed within multibeat operation" + extra)
|
||||
assert (a.bits.param === param, "'A' channel param changed within multibeat operation" + extra)
|
||||
assert (a.bits.size === size, "'A' channel size changed within multibeat operation" + extra)
|
||||
assert (a.bits.source === source, "'A' channel source changed within multibeat operation" + extra)
|
||||
assert (a.bits.address=== address,"'A' channel address changed with multibeat operation" + extra)
|
||||
}
|
||||
when (a.fire()) {
|
||||
counter := counter - UInt(1)
|
||||
@ -303,11 +310,11 @@ object TLMonitor
|
||||
val source = Reg(UInt())
|
||||
val address = Reg(UInt())
|
||||
when (b.valid && counter =/= UInt(0)) {
|
||||
assert (b.bits.opcode === opcode, "'B' channel opcode changed within multibeat operation")
|
||||
assert (b.bits.param === param, "'B' channel param changed within multibeat operation")
|
||||
assert (b.bits.size === size, "'B' channel size changed within multibeat operation")
|
||||
assert (b.bits.source === source, "'B' channel source changed within multibeat operation")
|
||||
assert (b.bits.address=== address,"'B' channel address changed with multibeat operation")
|
||||
assert (b.bits.opcode === opcode, "'B' channel opcode changed within multibeat operation" + extra)
|
||||
assert (b.bits.param === param, "'B' channel param changed within multibeat operation" + extra)
|
||||
assert (b.bits.size === size, "'B' channel size changed within multibeat operation" + extra)
|
||||
assert (b.bits.source === source, "'B' channel source changed within multibeat operation" + extra)
|
||||
assert (b.bits.address=== address,"'B' channel address changed with multibeat operation" + extra)
|
||||
}
|
||||
when (b.fire()) {
|
||||
counter := counter - UInt(1)
|
||||
@ -330,11 +337,11 @@ object TLMonitor
|
||||
val source = Reg(UInt())
|
||||
val address = Reg(UInt())
|
||||
when (c.valid && counter =/= UInt(0)) {
|
||||
assert (c.bits.opcode === opcode, "'C' channel opcode changed within multibeat operation")
|
||||
assert (c.bits.param === param, "'C' channel param changed within multibeat operation")
|
||||
assert (c.bits.size === size, "'C' channel size changed within multibeat operation")
|
||||
assert (c.bits.source === source, "'C' channel source changed within multibeat operation")
|
||||
assert (c.bits.address=== address,"'C' channel address changed with multibeat operation")
|
||||
assert (c.bits.opcode === opcode, "'C' channel opcode changed within multibeat operation" + extra)
|
||||
assert (c.bits.param === param, "'C' channel param changed within multibeat operation" + extra)
|
||||
assert (c.bits.size === size, "'C' channel size changed within multibeat operation" + extra)
|
||||
assert (c.bits.source === source, "'C' channel source changed within multibeat operation" + extra)
|
||||
assert (c.bits.address=== address,"'C' channel address changed with multibeat operation" + extra)
|
||||
}
|
||||
when (c.fire()) {
|
||||
counter := counter - UInt(1)
|
||||
@ -357,11 +364,11 @@ object TLMonitor
|
||||
val source = Reg(UInt())
|
||||
val sink = Reg(UInt())
|
||||
when (d.valid && counter =/= UInt(0)) {
|
||||
assert (d.bits.opcode === opcode, "'D' channel opcode changed within multibeat operation")
|
||||
assert (d.bits.param === param, "'D' channel param changed within multibeat operation")
|
||||
assert (d.bits.size === size, "'D' channel size changed within multibeat operation")
|
||||
assert (d.bits.source === source, "'D' channel source changed within multibeat operation")
|
||||
assert (d.bits.sink === sink, "'D' channel sink changed with multibeat operation")
|
||||
assert (d.bits.opcode === opcode, "'D' channel opcode changed within multibeat operation" + extra)
|
||||
assert (d.bits.param === param, "'D' channel param changed within multibeat operation" + extra)
|
||||
assert (d.bits.size === size, "'D' channel size changed within multibeat operation" + extra)
|
||||
assert (d.bits.source === source, "'D' channel source changed within multibeat operation" + extra)
|
||||
assert (d.bits.sink === sink, "'D' channel sink changed with multibeat operation" + extra)
|
||||
}
|
||||
when (d.fire()) {
|
||||
counter := counter - UInt(1)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user