chisel - 使用外交时的 IP block 生成/测试。可以给虚拟节点吗？

Question

我一直在研究利用外交的火箭芯片，我对外交运作的整体结构有一定的了解。 (我不完全理解，但足以自己创建一些示例)。我想开发一些 IP，其中的主要目标是通过使用 *RegisterRouter 来获得 regmap。

如果我使用/修改来自 rocket-chip 的 RegisterNodeExamples 之一，我会得到以下结果:

class MyDeviceController(implicit p: Parameters) extends LazyModule {
  val device = new SimpleDevice("my-device", Seq("tutorial,my-device0"))
  val node = APBRegisterNode(
    //address = Seq(AddressSet(0x10028000, 0xfff)), (Modified since not in APBRegisterNode)
    address = AddressSet(0x002000, 0xfff),
    //device = device,  (Removed since not in APBRegisterNode)
    beatBytes = 8)

  lazy val module = new LazyModuleImp(this) {
    
    val bigReg = RegInit(0.U(64.W))
    val mediumReg = RegInit(0.U(32.W))
    val smallReg = RegInit(0.U(16.W))

    val tinyReg0 = RegInit(0.U(4.W))
    val tinyReg1 = RegInit(0.U(4.W))

    node.regmap(
      0x00 -> Seq(RegField(64, bigReg)),
      0x08 -> Seq(RegField(32, mediumReg)),
      0x0C -> Seq(RegField(16, smallReg)),
      0x0E -> Seq(
        RegField(4, tinyReg0),
        RegField(4, tinyReg1)))
  }
}

我目前正在使用 APB，因为我非常熟悉 AMBA 协议(protocol)，并且它在 diplomacy 包下具有最小的代码库。我可以做的是，稍后使用 AMBA 或 TL 协议(protocol)。

我的问题

有没有办法为 MyDeviceController 作为独立组件生成 verilog？

如果有的话，我还没有弄明白。显然，如果我只是尝试实例化 MyDeviceController，我会得到一个错误，因为 node 的内部参数没有被连接。我不确定您是否可以提供“虚拟”节点连接？或者是否有某种方法可以处理该问题。

我为什么要这样做

最好在没有完整 SoC 的情况下在其自己的测试环境中独立测试 IP。

我当前的解决方法/解决方案

为了解决这个问题，我基本上创建了一个“包装器”，它创建了一个 APBMasterNode 并连接到 MyDeviceController 中的 APBRegisterNode。

class APBMaster()(implicit p: Parameters) extends LazyModule {
  val apbMasterParameters = APBMasterParameters(
    name = "apbMaster"
  )

  val apbMasterPortParameters = APBMasterPortParameters(
    masters = Seq(apbMasterParameters)
  )

  val node = APBMasterNode(
    portParams = Seq(apbMasterPortParameters)
  )

  lazy val module = new LazyModuleImp(this) {
    val io = IO(new Bundle {
      val wtf   = Output(Bool())
      val start = Input(Bool())
    })
        
    val myreg = RegInit(0.U(16.W))
    myreg := myreg + 1.U
    
    val prdata = Wire(UInt(64.W))
    prdata := node.out.head._1.prdata
    //seems to need these things to generate the logic
    io.wtf := node.out.head._1.pready && !(node.out.head._1.prdata === 0.U)

    node.out.head._1.pstrb    := 63.U
    node.out.head._1.pprot    := 0.U
        
    when(myreg(3,0) === 8.U && io.start) {
      node.out.head._1.paddr    := myreg
      node.out.head._1.psel     := true.B
      node.out.head._1.penable  := false.B
      node.out.head._1.pwrite   := true.B
      node.out.head._1.pwdata   := myreg + 1.U
    } .elsewhen(myreg(3,0) === 9.U) {
      node.out.head._1.paddr    := myreg
      node.out.head._1.psel     := true.B
      node.out.head._1.penable  := true.B
      node.out.head._1.pwrite   := true.B
      node.out.head._1.pwdata   := myreg
    } otherwise {
      node.out.head._1.paddr    := 0.U
      node.out.head._1.psel     := false.B
      node.out.head._1.penable  := false.B
      node.out.head._1.pwrite   := false.B
      node.out.head._1.pwdata   := 0.U
    }
    
  }
}

其中的一个问题是我必须为每个 APB 信号创建一些控件。如果我不这样做，Chisel/FIRRTL 编译器/生成器将不会为 MyDeviceController 创建任何 Verilog。这就是您在上面看到的 myreg 计数器用于执行一些基本的 APB 事务。

包装器如下所示:

class APBTop()(implicit p: Parameters) extends LazyModule {
  val master = LazyModule(new APBMaster)
  val slave  = LazyModule(new MyDeviceController()(Parameters.empty))

  slave.node := master.node 

  lazy val module = new LazyModuleImp(this) {
    val io = IO(new Bundle {
      val busy = Output(Bool())
      val wtf  = Output(Bool())
      val start = Input(Bool())
    })
    
    io.busy := true.B
    io.wtf  := master.module.io.wtf
    master.module.io.start := io.start
    
  }
}

我可以将此包装器/主控器创建为典型的测试组件，然后在我的 testenv 中实例化 MyDeviceController RTL，但是我想知道是否还有其他解决方案。外交似乎是相当全面的(我理解为什么)，但正在寻找有关如何解决外交基础设施流程的 IP 级别开发的建议。

谢谢

Answer 1

编辑:2021 年 3 月更新

几个月过去了，我花了更多时间在 RocketChip/Chipyard/Diplomacy 上。这是一个更好的解决方案，但将旧的保留在下面。

makeIOs 方法用于多个节点。使用这些我们实际上可以打出相应的 AMBA/TL 接口(interface)。这使您不必使用只有连接的包装器。

与我建议的先前版本相比，这是它的样子

class MyWrapper()(implicit p: Parameters) extends LazyModule {
  //val master = LazyModule(new APBMaster)
  
  val ApbPort = APBMasterNode(
    portParams = Seq(APBMasterPortParameters(masters = Seq(APBMasterParameters(name = "ApbPort"))))
  )
  
  val apbport = InModuleBody {ApbPort.makeIOs()}
  

这也减少了对 APBMaster 虚拟类的需求。

---

为了得到答案，我最终结合了自己和 Jack Koenig 反复研究的内容。

如果时间允许，我会看看是否有办法制作一个"template"或 LazyModule 包装器，用于测试目的(针对每个主要协议(protocol))并将其提交给凿子 repo 。

class APBMaster()(implicit p: Parameters) extends LazyModule {
  val apbMasterParameters = APBMasterParameters(
    name = "apbMaster"
  )

  val apbMasterPortParameters = APBMasterPortParameters(
    masters = Seq(apbMasterParameters)
  )

  val node = APBMasterNode(
    portParams = Seq(apbMasterPortParameters)
  )

  
  lazy val module = new LazyModuleImp(this) {
    //The dontTouch here preserves the interface so logic is generated
    dontTouch(node.out.head._1)
  }
}


class MyWrapper()(implicit p: Parameters) extends LazyModule {
  val master = LazyModule(new APBMaster)
  val slave  = LazyModule(new MySlave()(Parameters.empty))

  slave.node := master.node 

  lazy val module = new LazyModuleImp(this) {
    //nothing???
  }
}

object MyTestextends App {SSVPllFreqDetect)))
  (new ChiselStage).execute(args, Seq(ChiselGeneratorAnnotation(() => LazyModule(new MyWrapper()(Parameters.empty)).module)))
}