使用外交手段时的IP块生成/测试可以提供虚拟节点吗？

如何解决使用外交手段时的IP块生成/测试可以提供虚拟节点吗？

我一直在研究用于利用外交的火箭芯片，并且对外交运作的总体结构有很好的了解。 （我不完全理解它，但是足够我自己创建一些示例）。我想开发一些IP，其主要目标是通过使用regmap来拥有*RegisterRouter。

如果我使用/修改火箭芯片中的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)))
  }
}

由于我对AMBA协议非常熟悉，因此我目前正在使用APB，它在diplomacy包下具有最小的代码库。我可以确定的是，以后可以使用AMBA或TL协议。

我的问题

有没有一种方法可以单独为MyDeviceController生成verilog？

我无法弄清楚是否存在。显然，如果我只是尝试实例化MyDeviceController，则会因为未连接node的向内参数而出现错误。我不确定是否可以提供“虚拟”节点连接？或者，如果有某种方法可以解决这个问题。

我为什么要这样做

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

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

要解决此问题，我实质上创建了一个“包装器”，该包装器创建了APBMasterNode并连接到APBRegisterNode中的MyDeviceController。

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设为无效，但是我想知道是否还有其他解决方案。外交似乎是整体的（我理解为什么），但是他正在寻找有关如何解决外交基础设施流程中的知识产权水平发展的建议。

谢谢

解决方法

只是要回答一个问题，我最终还是结合了自己和杰克·科尼格的来龙去脉。

如果时间允许，我将看看是否有一种方法可以制作“模板”或LazyModule包装器（用于每个主要协议）以进行测试（并将其提交给Chisel仓库）。

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)))
}