trait PeripheryPWM {
this: TopNetwork { val pwmConfigs: Seq[PWMConfig] } =>
- val pwmDevices = (pwmConfigs.zipWithIndex) map { case (c, i) =>
- val pwm = LazyModule(new TLPWM(c) { override lazy val valName = Some(s"pwm$i") })
+ val pwm = (pwmConfigs.zipWithIndex) map { case (c, i) =>
+ val pwm = LazyModule(new TLPWM(c))
pwm.node := TLFragmenter(peripheryBusConfig.beatBytes, cacheBlockBytes)(peripheryBus.node)
intBus.intnode := pwm.intnode
pwm
val outer: PeripheryPWM
val io: PeripheryPWMBundle
} =>
- (io.pwms.zipWithIndex zip outer.pwmDevices) foreach { case ((io, i), device) =>
+ (io.pwms.zipWithIndex zip outer.pwm) foreach { case ((io, i), device) =>
io.port := device.module.io.gpio
}
}
object SPIProtocol {
val width = 2
- val Single = UInt(0, width)
- val Dual = UInt(1, width)
- val Quad = UInt(2, width)
+ def Single = UInt(0, width)
+ def Dual = UInt(1, width)
+ def Quad = UInt(2, width)
- val cases = Seq(Single, Dual, Quad)
+ def cases = Seq(Single, Dual, Quad)
def decode(x: UInt): Seq[Bool] = cases.map(_ === x)
}
object SPIDirection {
val width = 1
- val Rx = UInt(0, width)
- val Tx = UInt(1, width)
+ def Rx = UInt(0, width)
+ def Tx = UInt(1, width)
}
object SPIEndian {
val width = 1
- val MSB = UInt(0, width)
- val LSB = UInt(1, width)
+ def MSB = UInt(0, width)
+ def LSB = UInt(1, width)
}
object SPICSMode {
val width = 2
- val Auto = UInt(0, width)
- val Hold = UInt(2, width)
- val Off = UInt(3, width)
+ def Auto = UInt(0, width)
+ def Hold = UInt(2, width)
+ def Off = UInt(3, width)
}
trait PeripherySPI {
this: TopNetwork { val spiConfigs: Seq[SPIConfig] } =>
- val spiDevices = (spiConfigs.zipWithIndex) map {case (c, i) =>
- val spi = LazyModule(new TLSPI(c) { override lazy val valName = Some(s"spi$i") } )
+ val spi = (spiConfigs.zipWithIndex) map {case (c, i) =>
+ val spi = LazyModule(new TLSPI(c))
spi.rnode := TLFragmenter(peripheryBusConfig.beatBytes, cacheBlockBytes)(peripheryBus.node)
intBus.intnode := spi.intnode
spi
val outer: PeripherySPI
val io: PeripherySPIBundle
} =>
- (io.spis zip outer.spiDevices).foreach { case (io, device) =>
+ (io.spis zip outer.spi).foreach { case (io, device) =>
io <> device.module.io.port
}
}
}
object SPIMicroOp {
- val Transfer = UInt(0, 1)
- val Delay = UInt(1, 1)
+ def Transfer = UInt(0, 1)
+ def Delay = UInt(1, 1)
}
class SPIPhyControl(c: SPIConfigBase) extends SPIBundle(c) {
this: TopNetwork {
val uartConfigs: Seq[UARTConfig]
} =>
- val uartDevices = uartConfigs.zipWithIndex.map { case (c, i) =>
- val uart = LazyModule(new UART(c) { override lazy val valName = Some(s"uart$i") } )
+ val uart = uartConfigs.zipWithIndex.map { case (c, i) =>
+ val uart = LazyModule(new UART(c))
uart.node := TLFragmenter(peripheryBusConfig.beatBytes, cacheBlockBytes)(peripheryBus.node)
intBus.intnode := uart.intnode
uart
val outer: PeripheryUART
val io: PeripheryUARTBundle
} =>
- (io.uarts zip outer.uartDevices).foreach { case (io, device) =>
+ (io.uarts zip outer.uart).foreach { case (io, device) =>
io <> device.module.io.port
}
}
val xilinxvc707mig = LazyModule(new XilinxVC707MIG)
require(p(BankedL2Config).nMemoryChannels == 1, "Coreplex must have 1 master memory port")
- val mem = Seq(xilinxvc707mig.node)
+ xilinxvc707mig.node := mem(0).node
}
trait PeripheryXilinxVC707MIGBundle extends TopNetworkBundle {
import Chisel._
import diplomacy.LazyModule
-import rocketchip.{L2Crossbar,L2CrossbarModule,L2CrossbarBundle}
+import rocketchip.{TopNetwork,TopNetworkModule,TopNetworkBundle}
import uncore.tilelink2.TLWidthWidget
-trait PeripheryXilinxVC707PCIeX1 extends L2Crossbar {
+trait PeripheryXilinxVC707PCIeX1 extends TopNetwork {
val xilinxvc707pcie = LazyModule(new XilinxVC707PCIeX1)
l2.node := xilinxvc707pcie.master
intBus.intnode := xilinxvc707pcie.intnode
}
-trait PeripheryXilinxVC707PCIeX1Bundle extends L2CrossbarBundle {
+trait PeripheryXilinxVC707PCIeX1Bundle extends TopNetworkBundle {
val xilinxvc707pcie = new XilinxVC707PCIeX1IO
}
-trait PeripheryXilinxVC707PCIeX1Module extends L2CrossbarModule {
+trait PeripheryXilinxVC707PCIeX1Module extends TopNetworkModule {
val outer: PeripheryXilinxVC707PCIeX1
val io: PeripheryXilinxVC707PCIeX1Bundle
class VC707AXIToPCIeX1(implicit p:Parameters) extends LazyModule
{
- val slave = AXI4SlaveNode(AXI4SlavePortParameters(
+ val slave = AXI4SlaveNode(Seq(AXI4SlavePortParameters(
slaves = Seq(AXI4SlaveParameters(
address = List(AddressSet(0x60000000L, 0x1fffffffL)),
executable = true,
supportsWrite = TransferSizes(1, 256),
supportsRead = TransferSizes(1, 256),
interleavedId = Some(0))), // the Xilinx IP is friendly
- beatBytes = 8))
+ beatBytes = 8)))
- val control = AXI4SlaveNode(AXI4SlavePortParameters(
+ val control = AXI4SlaveNode(Seq(AXI4SlavePortParameters(
slaves = Seq(AXI4SlaveParameters(
address = List(AddressSet(0x50000000L, 0x03ffffffL)),
supportsWrite = TransferSizes(1, 4),
supportsRead = TransferSizes(1, 4),
interleavedId = Some(0))), // no read interleaving b/c AXI-lite
- beatBytes = 4))
+ beatBytes = 4)))
- val master = AXI4MasterNode(AXI4MasterPortParameters(
+ val master = AXI4MasterNode(Seq(AXI4MasterPortParameters(
masters = Seq(AXI4MasterParameters(
id = IdRange(0, 1),
- aligned = false))))
+ aligned = false)))))
lazy val module = new LazyModuleImp(this) {
// The master on the control port must be AXI-lite