2.7-Spinal-core-Clock-domain.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"top\"></a><img src=\"source/SpinalHDL.png\" alt=\"SpinalHDL based on Scala\" style=\"width:320px;\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  Before running Spinal HDL code, be sure to load SpinalHDL Libraries  \n",
    "**Note** : This may be a little slow when the first time load, please wait a moment to download Lib from remote.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val path = System.getProperty(\"user.dir\") + \"/source/load-spinal.sc\"\n",
    "interp.load.module(ammonite.ops.Path(java.nio.file.FileSystems.getDefault().getPath(path)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Example\n",
    "##### default Clock and Reset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Top extends Component{\n",
    "    val a = in Bits(8 bits)\n",
    "    val b = RegNext(a) init 0\n",
    "}\n",
    "showRtl(new Top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### specific your owen Clock and Reset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Top extends Component{\n",
    "    val myclk,myrst = in Bool()\n",
    "    val a = in Bits(8 bits)\n",
    "    val b = out Bits()\n",
    "    new ClockingArea(ClockDomain(myclk,myrst)){\n",
    "      val reg0 = RegNext(a) init 0\n",
    "      b := reg0\n",
    "    }\n",
    "    \n",
    "}\n",
    "showRtl(new Top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### set Asynchronous Reset with Falling edge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Top extends Component{\n",
    "    val myclk,myrst = in Bool()\n",
    "    val a = in Bits(8 bits)\n",
    "    val b = out Bits()\n",
    "    new ClockingArea(ClockDomain(myclk,myrst, config = ClockDomainConfig(\n",
    "      clockEdge        = RISING,\n",
    "      resetKind        = ASYNC,\n",
    "      resetActiveLevel = LOW\n",
    "    ))){\n",
    "      val reg0 = RegNext(a) init 0\n",
    "      b := reg0\n",
    "    }\n",
    "}\n",
    "showRtl(new Top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Override the default clock of the sub module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SUB extends Component{\n",
    "    val a = in Bits(8 bits)\n",
    "    val b = out(RegNext(a) init 0)\n",
    "}\n",
    "class Top extends Component{\n",
    "   val myclk,myrst = in Bool()\n",
    "   val cd = ClockDomain(myclk,myrst, \n",
    "      config = ClockDomainConfig(\n",
    "      clockEdge        = RISING,\n",
    "      resetKind        = ASYNC,\n",
    "      resetActiveLevel = LOW))\n",
    "    val u_sub0 = cd(new SUB)\n",
    "}\n",
    "showRtl(new Top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clock domains\n",
    "In SpinalHDL, clock and reset signals can be combined to create a clock domain. Clock domains can be applied to some areas of the design and then all synchronous elements instantiated into those areas will then implicitly use this clock domain.\n",
    "\n",
    "Clock domain application works like a stack, which means that if you are in a given clock domain you can still apply another clock domain locally.\n",
    "\n",
    "The syntax to define a clock domain is as follows (using EBNF syntax):\n",
    "```scala\n",
    "ClockDomain(\n",
    "  clock: Bool\n",
    "  [,reset: Bool]\n",
    "  [,softReset: Bool]\n",
    "  [,clockEnable: Bool]\n",
    "  [,frequency: IClockDomainFrequency]\n",
    "  [,config: ClockDomainConfig]\n",
    ")\n",
    "```\n",
    "defualt ClockDomain \n",
    "```scala \n",
    "case class ClockDomainConfig(clockEdge: EdgeKind = RISING,\n",
    "                             resetKind: ResetKind = ASYNC,\n",
    "                             resetActiveLevel: Polarity = HIGH,\n",
    "                             softResetActiveLevel: Polarity = HIGH,\n",
    "                             clockEnableActiveLevel: Polarity = HIGH)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Internal Clock \n",
    "An alternative syntax to create a clock domain is the following:\n",
    "```\n",
    "ClockDomain.internal(\n",
    "  name: String,\n",
    "  [config: ClockDomainConfig,]\n",
    "  [withReset: Boolean,]\n",
    "  [withSoftReset: Boolean,]\n",
    "  [withClockEnable: Boolean,]\n",
    "  [frequency: IClockDomainFrequency]\n",
    ")\n",
    "```\n",
    "Its advantage is to create clock and reset signals with a specified name instead of an inherited one. Then you have to assign those ClockDomain’s signals as shown in the example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pll extends Component{\n",
    "  val io = new Bundle {\n",
    "    val clkIn = in Bool()\n",
    "    val clkOut  = out Bool()\n",
    "    val reset  = out Bool()\n",
    "  }\n",
    "  io.clkOut := io.clkIn\n",
    "  io.reset  := False\n",
    "}\n",
    "class InternalClockWithPllExample extends Component {\n",
    "  val io = new Bundle {\n",
    "    val clk100M = in Bool()\n",
    "    val aReset  = in Bool()\n",
    "    val result  = out UInt (4 bits)\n",
    "  }\n",
    "  // myClockDomain.clock will be named myClockName_clk\n",
    "  // myClockDomain.reset will be named myClockName_reset\n",
    "  val myClockDomain = ClockDomain.internal(\"myClockName\")\n",
    "\n",
    "  // Instanciate a PLL (probably a BlackBox)\n",
    "  val pll = new Pll()\n",
    "  pll.io.clkIn := io.clk100M\n",
    "\n",
    "  // Assign myClockDomain signals with something\n",
    "  myClockDomain.clock := pll.io.clkOut\n",
    "  myClockDomain.reset := io.aReset || !pll.io.reset\n",
    "\n",
    "  // Do whatever you want with myClockDomain\n",
    "  val myArea = new ClockingArea(myClockDomain){\n",
    "    val myReg = Reg(UInt(4 bits)) init(7)\n",
    "    myReg := myReg + 1\n",
    "\n",
    "    io.result := myReg\n",
    "  }\n",
    "}\n",
    "showRtl(new InternalClockWithPllExample)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### External clock\n",
    "\n",
    "You can define a clock domain which is driven by the outside anywhere in your source. It will then automatically add clock and reset wire from the top level inputs to all synchronous elements. \n",
    "```\n",
    "ClockDomain.external(\n",
    "  name: String,\n",
    "  [config: ClockDomainConfig,]\n",
    "  [withReset: Boolean,]\n",
    "  [withSoftReset: Boolean,]\n",
    "  [withClockEnable: Boolean,]\n",
    "  [frequency: IClockDomainFrequency]\n",
    ")\n",
    "```\n",
    "The arguments to the `ClockDomain.external` function are exactly the same as in the `ClockDomain.internal` function. Below an example of a design using `ClockDomain.external`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExternalClockExample extends Component {\n",
    "  val io = new Bundle {\n",
    "    val result = out UInt (4 bits)\n",
    "  }\n",
    "\n",
    "  // On top level you have two signals  :\n",
    "  //     myClockName_clk and myClockName_reset\n",
    "  val myClockDomain = ClockDomain.external(\"myClockName\")\n",
    "\n",
    "  val myArea = new ClockingArea(myClockDomain){\n",
    "    val myReg = Reg(UInt(4 bits)) init(7)\n",
    "    myReg := myReg + 1\n",
    "\n",
    "    io.result := myReg\n",
    "  }\n",
    "}\n",
    "showRtl(new ExternalClockExample)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Context\n",
    "You can retrieve in which clock domain you are by calling `ClockDomain.current` anywhere.\n",
    "The returned ClockDomain instance has the following functions that can be called:\n",
    "\n",
    "name | Description | Return\n",
    "-|-|-\n",
    "frequency.getValue | Return the frequency of the clock domain | Double\n",
    "hasResetSignal  | Return if the clock domain has a reset signal | Boolean\n",
    "hasSoftResetSignal | Return if the clock domain has a reset signal |Boolean\n",
    "hasClockEnableSignal | Return if the clock domain has a clock enable signal|Boolean\n",
    "readClockWire | Return a signal derived by the clock signal | Bool\n",
    "readResetWire | Return a signal derived by the reset signal | Bool\n",
    "readSoftResetWire | Return a signal derived by the reset signal | Bool\n",
    "readClockEnableWire | Return a signal derived by the clock enable signal | Bool\n",
    "isResetActive | Return True when the reset is active | Bool\n",
    "isSoftResetActive | Return True when the softReset is active | Bool\n",
    "isClockEnableActive | Return True when the clock enable is active | Bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class T0 extends Component {\n",
    "  println(ClockDomain.current)\n",
    "  val coreClock,coreReset = in Bool()\n",
    "  val coreClockDomain = ClockDomain(coreClock, coreReset, frequency=FixedFrequency(99 MHz) )\n",
    "  println(coreClockDomain.hasResetSignal)\n",
    "  println(coreClockDomain.frequency.getValue)\n",
    "  println(coreClockDomain.hasSoftResetSignal)\n",
    "  println(coreClockDomain.isResetActive)  \n",
    "}\n",
    "showRtl(new T0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clock domain crossing\n",
    "SpinalHDL checks at compile time that there is no unwanted/unspecified cross clock domain signal reads. If you want to read a signal that is emitted by another ClockDomain area, you should add the crossClockDomain tag to the destination signal as depicted in the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//             _____                        _____             _____\n",
    "//            |     |  (crossClockDomain)  |     |           |     |\n",
    "//  dataIn -->|     |--------------------->|     |---------->|     |--> dataOut\n",
    "//            | FF  |                      | FF  |           | FF  |\n",
    "//  clkA   -->|     |              clkB -->|     |   clkB -->|     |\n",
    "//  rstA   -->|_____|              rstB -->|_____|   rstB -->|_____|\n",
    "\n",
    "\n",
    "\n",
    "// Implementation where clock and reset pins are given by components IO\n",
    "class CrossingExample extends Component {\n",
    "  val io = new Bundle {\n",
    "    val clkA = in Bool()\n",
    "    val rstA = in Bool()\n",
    "\n",
    "    val clkB = in Bool()\n",
    "    val rstB = in Bool()\n",
    "\n",
    "    val dataIn  = in Bool()\n",
    "    val dataOut = out Bool()\n",
    "  }\n",
    "\n",
    "  // sample dataIn with clkA\n",
    "  val area_clkA = new ClockingArea(ClockDomain(io.clkA,io.rstA)){\n",
    "    val reg = RegNext(io.dataIn) init(False)\n",
    "  }\n",
    "\n",
    "  // 2 register stages to avoid metastability issues\n",
    "  val area_clkB = new ClockingArea(ClockDomain(io.clkB,io.rstB)){\n",
    "    val buf0   = RegNext(area_clkA.reg) init(False) addTag(crossClockDomain)\n",
    "    val buf1   = RegNext(buf0)          init(False)\n",
    "  }\n",
    "\n",
    "  io.dataOut := area_clkB.buf1\n",
    "}\n",
    "showRtl(new CrossingExample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//Alternative implementation where clock domains are given as parameters\n",
    "class CrossingExample(clkA : ClockDomain,clkB : ClockDomain) extends Component {\n",
    "  val io = new Bundle {\n",
    "    val dataIn  = in Bool()\n",
    "    val dataOut = out Bool()\n",
    "  }\n",
    "\n",
    "  // sample dataIn with clkA\n",
    "  val area_clkA = new ClockingArea(clkA){\n",
    "    val reg = RegNext(io.dataIn) init(False)\n",
    "  }\n",
    "\n",
    "  // 2 register stages to avoid metastability issues\n",
    "  val area_clkB = new ClockingArea(clkB){\n",
    "    val buf0   = RegNext(area_clkA.reg) init(False) addTag(crossClockDomain)\n",
    "    val buf1   = RegNext(buf0)          init(False)\n",
    "  }\n",
    "\n",
    "  io.dataOut := area_clkB.buf1\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set the default clock domain for different modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MYSub0(cd: ClockDomain) extends Component {\n",
    "  val io = new Bundle{\n",
    "    val ai = in UInt(8 bits)\n",
    "    val ao = out UInt(8 bits)\n",
    "  }\n",
    "  io.ao := RegNext(io.ai) init(0)\n",
    "}\n",
    "\n",
    "class MYSub1(cd: ClockDomain) extends Component {\n",
    "  val io = new Bundle{\n",
    "    val ai = in UInt(8 bits)\n",
    "    val ao = out UInt(8 bits)\n",
    "    val a2 = out UInt(8 bits)\n",
    "  } \n",
    "  io.ao := RegNext(io.ai) init(0)\n",
    "  val cd2 = ClockDomain.external(\"adc\")\n",
    "  //alow another clockDomain not confict to default clockdomain \n",
    "  val area = new ClockingArea(cd2){\n",
    "    val tmp = RegNext(io.ai) init(0)\n",
    "    val tmp2 = tmp + (RegNext(io.ai) init(0))\n",
    "  } \n",
    "  io.a2 := area.tmp2\n",
    "}     \n",
    "\n",
    "class Top00 extends Component {\n",
    "  val io = new Bundle{\n",
    "    val a = in UInt(8 bits)\n",
    "    val b0 = out UInt(8 bits)\n",
    "    val b1 = out UInt(8 bits)\n",
    "    val b2 = out UInt(8 bits)\n",
    "  }\n",
    "  val cd0 = ClockDomain.external(\"cp\")\n",
    "  val cd1 = ClockDomain.external(\"ap\")\n",
    "\n",
    "  val u_sub0 = cd0(new MYSub0(cd0)) // set u_sub0's default clockDomain with cd0\n",
    "  val u_sub1 = cd1(new MYSub1(cd1)) // it allow anoter clockDomain in ther module\n",
    "\n",
    "  u_sub0.io.ai := io.a\n",
    "  u_sub1.io.ai := io.a\n",
    "\n",
    "  io.b0 := u_sub0.io.ao\n",
    "  io.b1 := u_sub1.io.ao\n",
    "  io.b2 := u_sub1.io.a2\n",
    "\n",
    "  val tmp = RegNext(io.a) init(0)\n",
    "}\n",
    "\n",
    "showRtl(new Top00)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ResetArea\n",
    "A ResetArea is used to create a new clock domain area where a special reset signal is combined with the current clock domain reset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TopLevel extends Component {\n",
    "\n",
    "  val specialReset = in Bool()\n",
    "\n",
    "  // The reset of this area is done with the specialReset signal\n",
    "  val areaRst_1 = new ResetArea(reset=specialReset, cumulative=false){\n",
    "    val counter = out(CounterFreeRun(16).value)\n",
    "  }\n",
    "\n",
    "  // The reset of this area is a combination between the current reset and the specialReset\n",
    "  val areaRst_2 = new ResetArea(reset=specialReset, cumulative=true){\n",
    "    val counter = out(CounterFreeRun(16).value)\n",
    "  }\n",
    "}\n",
    "showRtl(new TopLevel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ClockEnableArea\n",
    "A ClockEnableArea is used to add an additional clock enable in the current clock domain.ResetArea\n",
    "A ResetArea is used to create a new clock domain area where a special reset signal is combined with the current clock domain reset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TopLevel extends Component {\n",
    "\n",
    "  val clockEnable = in Bool()\n",
    "\n",
    "  // Add a clock enable for this area\n",
    "  val area_1 = new ClockEnableArea(clockEnable){\n",
    "    val counter = out(CounterFreeRun(16).value)\n",
    "  }\n",
    "}\n",
    "showRtl(new TopLevel)"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ClockDomain SetSyncWith\n",
    "\n",
    "Sometimes you may need to divide the clock or gate it,\n",
    "\n",
    "However, these operations may not affect their synchronous clock relationship, but the new two clockdomains will be considered as two different clock domains by SpinalHDL as default\n",
    "\n",
    "Therefore, they need to be manually set to be synchronized. Perhaps in future versions, the processing of these synchronizations can be completed automatically.\n",
    "\n",
    "But it's also very easy to set the two clocks-family to be synchronous. Only `setSyncWith` is needed\n",
    "\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class gate_cell extends Component{\n",
    "    val io = new {\n",
    "      val TSE,CLK,E = in Bool()\n",
    "      val ECK = out Bool()        \n",
    "    }\n",
    "    noIoPrefix()\n",
    "    \n",
    "    val clk_n = !io.CLK\n",
    "    val lock_en = Bool.noCombLoopCheck\n",
    "    when (clk_n) {\n",
    "        lock_en := io.E\n",
    "    }.otherwise {\n",
    "        lock_en := lock_en\n",
    "    }\n",
    "    io.ECK := lock_en && io.CLK\n",
    "}\n",
    "\n",
    "implicit class ClockGateExtend(cd: ClockDomain){\n",
    "    def gateBy(en: Bool, tse: Bool): ClockDomain = {\n",
    "      val cg = new gate_cell\n",
    "      cg.io.CLK := cd.readClockWire\n",
    "      cg.io.TSE := tse\n",
    "      cg.io.E   := en\n",
    "      val cde = ClockDomain(clock = cg.io.ECK,\n",
    "        reset = cd.readResetWire\n",
    "      )\n",
    "      cde.setSynchronousWith(cd)\n",
    "      cde\n",
    "    }\n",
    "  }\n",
    "\n",
    "class A extends Component{\n",
    "    \n",
    "val clk,rstn,E,TSE = in Bool()\n",
    "val clk_cg = out Bool()\n",
    "val cd =ClockDomain(clk,rstn)\n",
    "clk_cg := clockDomain.gateBy(E, TSE).readClockWire\n",
    "    \n",
    "}\n",
    "showRtl(new A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "clockGate Usage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MySub extends Component {\n",
    "    val io = new Bundle{\n",
    "        val a = in UInt(8 bits)\n",
    "        val b = out UInt(8 bits)\n",
    "    }\n",
    "    io.b := RegNext(io.a) init(0)\n",
    "}\n",
    "\n",
    "class Top extends Component {\n",
    "    val io = new Bundle{\n",
    "        val a0,a1 = in UInt(8 bits)\n",
    "        val cg_en0,cg_en1 = in Bool()\n",
    "        val b  = out UInt(8 bits)\n",
    "        val test_mode = in Bool()\n",
    "    }\n",
    " \n",
    "    val cgd0 = clockDomain.gateBy(io.cg_en0, io.test_mode)\n",
    "    val cgd1 = clockDomain.gateBy(io.cg_en1, io.test_mode)\n",
    "     \n",
    "    val u_sub0 = cgd0(new MySub)\n",
    "    val u_sub1 = cgd1(new MySub)\n",
    "    \n",
    "    u_sub0.io.a := io.a0\n",
    "    u_sub1.io.a := io.a1 \n",
    "    \n",
    "    io.b := RegNext(u_sub0.io.b + u_sub1.io.b) init 0\n",
    "}\n",
    "\n",
    "showRtl(new Top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "gate Cell with BlackBox "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class gate_cell extends BlackBox {\n",
    "  val io = new Bundle{\n",
    "    val CLK = in Bool()\n",
    "    val TSE = in Bool()\n",
    "    val E   = in Bool()\n",
    "    val ECK = out Bool()\n",
    "  }\n",
    "\n",
    "  noIoPrefix()\n",
    "\n",
    "  val clk_n   = !io.CLK\n",
    "  val lock_en = Bool().noCombLoopCheck\n",
    "\n",
    "  when(clk_n){\n",
    "    lock_en := io.E\n",
    "  }.otherwise{\n",
    "    lock_en := lock_en\n",
    "  }\n",
    "\n",
    "  io.ECK := (lock_en && io.CLK)\n",
    "  if(CommonCellBlackBox.clear){this.clearBlackBox()}\n",
    "}\n",
    "\n",
    "implicit class ClockGateExtend(cd: ClockDomain){\n",
    "    def gateBy(en: Bool, tse: Bool): ClockDomain = {\n",
    "      val cg = new gate_cell\n",
    "      cg.io.CLK := cd.readClockWire\n",
    "      cg.io.TSE := tse\n",
    "      cg.io.E   := en\n",
    "      val cde = ClockDomain(clock = cg.io.ECK,\n",
    "        reset = cd.readResetWire\n",
    "      )\n",
    "      cde.setSynchronousWith(cd)\n",
    "      cde\n",
    "    }\n",
    "  }\n",
    "\n",
    "protected object CommonCellBlackBox {\n",
    "    private var _clear: Boolean = false\n",
    "    def clear: Boolean = _clear\n",
    "    def clear_=(x: Boolean) { _clear = x}\n",
    "  }\n",
    "\n",
    "  object clearCCBB{\n",
    "    def apply() = CommonCellBlackBox.clear = true\n",
    "  }\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Top extends Component {\n",
    "    val io = new Bundle{\n",
    "      val clken = in Bool()\n",
    "      val test_mode = in Bool()\n",
    "      val clkout = out Bool()\n",
    "    }\n",
    " \n",
    "    val cgd0 = clockDomain.gateBy(io.clken, io.test_mode)\n",
    "    \n",
    "    io.clkout := cgd0.readClockWire\n",
    "}\n",
    "// clearCCBB()  //open and try\n",
    "showRtl(new Top)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Scala",
   "language": "scala",
   "name": "scala"
  },
  "language_info": {
   "codemirror_mode": "text/x-scala",
   "file_extension": ".scala",
   "mimetype": "text/x-scala",
   "name": "scala",
   "nbconvert_exporter": "script",
   "version": "2.11.12"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}