Instance Constructors
-
new
Acquire()
Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
def
##[T <: Data](right: T): Acquire.this.type
-
def
##(b: Node): Node
-
final
def
##(): Int
-
def
+(other: Bundle): Bundle
-
def
:=(that: Data): Unit
-
def
<>(src: Node): Unit
-
final
def
==(arg0: AnyRef): Boolean
-
final
def
==(arg0: Any): Boolean
-
def
===[T <: Data](right: T): Bool
-
def
W0Wtransform(): Unit
-
def
^^(src: Node): Unit
-
val
_id: Int
-
def
_isComplementOf(x: Node): Boolean
-
val
a_type: UInt
-
def
addConsumers(): Unit
-
def
addr(dummy: Int = 0): UInt
-
val
addrByteMSB: Int
-
val
addrByteOff: Int
-
val
addr_beat: UInt
-
val
addr_block: UInt
-
def
addr_byte(dummy: Int = 0): UInt
-
def
allocate(dummy: Int = 0): Bool
-
val
amoAluOperandBits: Int
-
def
amo_shift_bits(dummy: Int = 0): UInt
-
def
apply(name: String): Data
-
def
asDirectionless(): Acquire.this.type
-
def
asInput(): Acquire.this.type
-
final
def
asInstanceOf[T0]: T0
-
def
asOutput(): Acquire.this.type
-
def
assign(src: Node): Unit
-
def
canCSE: Boolean
-
lazy val
chiselName: String
-
val
client_xact_id: UInt
-
var
clock: Clock
-
def
clone(): Acquire.this.type
-
var
cntrIdx: Int
-
def
colonEquals(src: Bundle): Unit
-
def
colonEquals[T <: Data](that: Iterable[T]): Unit
-
def
colonEquals(that: Bits): Unit
-
var
comp: proc
-
var
component: Module
-
def
componentOf: Module
-
def
conflicts(addr: UInt): Bool
-
-
val
consumers: LinkedHashSet[Node]
-
def
contains(name: String): Boolean
-
val
data: UInt
-
def
dblLitValue: Double
-
var
depth: Int
-
var
driveRand: Boolean
-
lazy val
elements: LinkedHashMap[String, Data]
-
lazy val
emitIndex: Int
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(that: Any): Boolean
-
def
equalsForCSE(x: Node): Boolean
-
def
extract(b: Bundle): List[Node]
-
def
extract(widths: Array[Int]): List[UInt]
-
def
finalize(): Unit
-
def
flatten: Array[(String, Bits)]
-
def
flip(): Acquire.this.type
-
def
floLitValue: Float
-
def
forceMatchingWidths: Unit
-
def
fromBits(b: Bits): Acquire.this.type
-
def
fromMap(elemmap: Map[String, Data]): Acquire.this.type
-
def
fromNode(n: Node): Acquire.this.type
-
def
full_wmask(dummy: Int = 0): UInt
-
def
getBuiltInGrantType(dummy: Int = 0): UInt
-
final
def
getClass(): Class[_]
-
def
getLit: Literal
-
def
getNode: Node
-
def
getWidth(): Int
-
def
getWidthW(): Width
-
def
hasData(dummy: Int = 0): Bool
-
def
hasMultibeatData(dummy: Int = 0): Bool
-
def
hashCode(): Int
-
def
hashCodeForCSE: Int
-
def
illegalAssignment(that: Any): Unit
-
def
infer: Boolean
-
var
inferWidth: (⇒ Node) ⇒ Width
-
def
init(n: String, w: Int, ins: Node*): Node
-
def
init(n: String, widthFunc: (⇒ Node) ⇒ Width, ins: Node*): Node
-
def
initOf(n: String, widthfunc: (⇒ Node) ⇒ Width, ins: Iterable[Node]): Node
-
val
inputs: ArrayBuffer[Node]
-
def
is(t: UInt): Bool
-
def
isBuiltInType(t: UInt): Bool
-
def
isBuiltInType(dummy: Int = 0): Bool
-
def
isByValue: Boolean
-
def
isDirectionless: Boolean
-
lazy val
isInObject: Boolean
-
lazy val
isInVCD: Boolean
-
final
def
isInstanceOf[T0]: Boolean
-
def
isIo: Boolean
-
def
isIo_=(isIo: Boolean): Unit
-
def
isKnownWidth: Boolean
-
final
def
isLit: Boolean
-
def
isPrefetch(dummy: Int = 0): Bool
-
def
isReg: Boolean
-
def
isSubBlockType(dummy: Int = 0): Bool
-
def
isTopLevelIO: Boolean
-
var
isTypeNode: Boolean
-
def
isUsedByClockHi: Boolean
-
var
isWidthWalked: Boolean
-
val
is_builtin_type: Bool
-
val
line: StackTraceElement
-
def
litOf: Literal
-
def
litValue(default: BigInt): BigInt
-
def
matchWidth(w: Width): Node
-
def
maybeFlatten: Seq[Node]
-
var
modified: Boolean
-
var
name: String
-
var
nameHolder: nameable
-
def
nameIt(path: String, isNamingIo: Boolean): Unit
-
var
named: Boolean
-
final
def
ne(arg0: AnyRef): Boolean
-
def
needWidth(): Int
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
val
opCodeOff: Int
-
val
opSizeOff: Int
-
def
op_code(dummy: Int = 0): UInt
-
def
op_size(dummy: Int = 0): UInt
-
def
params: Parameters
-
var
parents: LinkedHashSet[Node]
-
def
printTree(writer: PrintStream, depth: Int, indent: String): Unit
-
var
prune: Boolean
-
def
removeTypeNodes(): Unit
-
def
replaceTree(newNode: Node): Unit
-
def
requiresSelfProbe(dummy: Int = 0): Bool
-
def
review(): Unit
-
var
sccIndex: Int
-
var
sccLowlink: Int
-
def
setIsTypeNode: Unit
-
def
setName(n: String): Unit
-
def
setWidth(w: Int): Unit
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
val
tlAcquireTypeBits: Int
-
val
tlAcquireUnionBits: Int
-
val
tlBeatAddrBits: Int
-
val
tlBlockAddrBits: Int
-
val
tlByteAddrBits: Int
-
val
tlClientIdBits: Int
-
val
tlClientXactIdBits: Int
-
-
val
tlDataBeats: Int
-
val
tlDataBits: Int
-
val
tlDataBytes: Int
-
val
tlGrantTypeBits: Int
-
val
tlManagerIdBits: Int
-
val
tlManagerXactIdBits: Int
-
val
tlMaxClientXacts: Int
-
val
tlMaxClientsPerPort: Int
-
val
tlMaxManagerXacts: Int
-
val
tlMemoryOpcodeBits: Int
-
val
tlMemoryOperandSizeBits: Int
-
val
tlNCachelessClients: Int
-
val
tlNCachingClients: Int
-
val
tlNClients: Int
-
val
tlNManagers: Int
-
val
tlNetworkDoesNotInterleaveBeats: Boolean
-
val
tlNetworkPreservesPointToPointOrdering: Boolean
-
val
tlWriteMaskBits: Int
-
def
toBits(): UInt
-
def
toBool(): Bool
-
lazy val
toNode: Node
-
def
toString(): String
-
val
union: UInt
-
def
usesInClockHi(i: Node): Boolean
-
val
view: Seq[String]
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
var
width_: Width
-
def
wmask(dummy: Int = 0): UInt
Inherited from UsesParameters
Inherited from Bundle
Inherited from Aggregate
Inherited from Data
Inherited from Node
Inherited from nameable
Inherited from AnyRef
Inherited from Any
The Acquire channel is used to intiate coherence protocol transactions in order to gain access to a cache block's data with certain permissions enabled. Messages sent over this channel may be custom types defined by a uncore.CoherencePolicy for cached data accesse or may be built-in types used for uncached data accesses. Acquires may contain data for Put or PutAtomic built-in types. After sending an Acquire, clients must wait for a manager to send them a uncore.Grant message in response.