From 6f3ff634f2642ec6206c31265e08ad93493a78bf Mon Sep 17 00:00:00 2001
From: "Wesley W. Terpstra" <wesley@sifive.com>
Date: Mon, 20 Nov 2017 18:09:57 -0800
Subject: [PATCH] DTS: collect common DTS nodes and move timebase-frequency to
 cores

Putting the common DTS nodes into a shared object makes them get
emitted only one time. Plus it's better style.

timebase-frequency should really have been in the cpu nodes in the
first place according to the spec anyway. I was foolishly trying to
save bytes. However, now we really want it there in case it differs.
---
 src/main/scala/coreplex/BaseCoreplex.scala | 44 +++++-----------------
 src/main/scala/diplomacy/Resources.scala   | 37 ++++++++++++++++++
 src/main/scala/tile/RocketTile.scala       |  4 +-
 3 files changed, 49 insertions(+), 36 deletions(-)

diff --git a/src/main/scala/coreplex/BaseCoreplex.scala b/src/main/scala/coreplex/BaseCoreplex.scala
index b00b0681..bba04d0d 100644
--- a/src/main/scala/coreplex/BaseCoreplex.scala
+++ b/src/main/scala/coreplex/BaseCoreplex.scala
@@ -54,46 +54,22 @@ abstract class BaseCoreplex(implicit p: Parameters) extends BareCoreplex
     with HasMemoryBus {
   override val module: BaseCoreplexModule[BaseCoreplex]
 
-  val root = new Device {
-    def describe(resources: ResourceBindings): Description = {
-      val width = resources("width").map(_.value)
-      Description("/", Map(
-        "#address-cells" -> width,
-        "#size-cells"    -> width,
-        "model"          -> Seq(ResourceString(p(DTSModel))),
-        "compatible"     -> (p(DTSModel) +: p(DTSCompat)).map(s => ResourceString(s + "-dev"))))
-    }
-  }
-
-  val soc = new Device {
-    def describe(resources: ResourceBindings): Description = {
-      val width = resources("width").map(_.value)
-      Description("soc", Map(
-        "#address-cells" -> width,
-        "#size-cells"    -> width,
-        "compatible"     -> ((p(DTSModel) +: p(DTSCompat)).map(s => ResourceString(s + "-soc")) :+ ResourceString("simple-bus")),
-        "ranges"         -> Nil))
-    }
-  }
-
-  val cpus = new Device {
-    def describe(resources: ResourceBindings): Description = {
-      Description("cpus", Map(
-        "#address-cells"     -> Seq(ResourceInt(1)),
-        "#size-cells"        -> Seq(ResourceInt(0)),
-        "timebase-frequency" -> Seq(ResourceInt(p(DTSTimebase)))))
-    }
-  }
-
   // Make topManagers an Option[] so as to avoid LM name reflection evaluating it...
   lazy val topManagers = Some(ManagerUnification(sharedMemoryTLEdge.manager.managers))
   ResourceBinding {
     val managers = topManagers.get
     val max = managers.flatMap(_.address).map(_.max).max
     val width = ResourceInt((log2Ceil(max)+31) / 32)
-    Resource(root, "width").bind(width)
-    Resource(soc,  "width").bind(width)
-    Resource(cpus, "null").bind(ResourceString(""))
+    val model = p(DTSModel)
+    val compat = p(DTSCompat)
+    val devCompat = (model +: compat).map(s => ResourceString(s + "-dev"))
+    val socCompat = (model +: compat).map(s => ResourceString(s + "-soc"))
+    devCompat.foreach { Resource(ResourceAnchors.root, "compat").bind(_) }
+    socCompat.foreach { Resource(ResourceAnchors.soc,  "compat").bind(_) }
+    Resource(ResourceAnchors.root, "model").bind(ResourceString(model))
+    Resource(ResourceAnchors.root, "width").bind(width)
+    Resource(ResourceAnchors.soc,  "width").bind(width)
+    Resource(ResourceAnchors.cpus, "width").bind(ResourceInt(1))
 
     managers.foreach { case manager =>
       val value = manager.toResource
diff --git a/src/main/scala/diplomacy/Resources.scala b/src/main/scala/diplomacy/Resources.scala
index 8c22c5e3..b6729874 100644
--- a/src/main/scala/diplomacy/Resources.scala
+++ b/src/main/scala/diplomacy/Resources.scala
@@ -285,3 +285,40 @@ object ResourceBinding
     scope.get.resourceBindingFns = { () => block } +: scope.get.resourceBindingFns
   }
 }
+
+object ResourceAnchors
+{
+  val root = new Device {
+    def describe(resources: ResourceBindings): Description = {
+      val width = resources("width").map(_.value)
+      val model = resources("model").map(_.value)
+      val compat = resources("compat").map(_.value)
+      Description("/", Map(
+        "#address-cells" -> width,
+        "#size-cells"    -> width,
+        "model"          -> model,
+        "compatible"     -> compat))
+    }
+  }
+
+  val soc = new Device {
+    def describe(resources: ResourceBindings): Description = {
+      val width = resources("width").map(_.value)
+      val compat = resources("compat").map(_.value) :+ ResourceString("simple-bus")
+      Description("soc", Map(
+        "#address-cells" -> width,
+        "#size-cells"    -> width,
+        "compatible"     -> compat,
+        "ranges"         -> Nil))
+    }
+  }
+
+  val cpus = new Device {
+    def describe(resources: ResourceBindings): Description = {
+      val width = resources("width").map(_.value)
+      Description("cpus", Map(
+        "#address-cells" -> width,
+        "#size-cells"    -> Seq(ResourceInt(0))))
+    }
+  }
+}
diff --git a/src/main/scala/tile/RocketTile.scala b/src/main/scala/tile/RocketTile.scala
index 436efeea..432fc3af 100644
--- a/src/main/scala/tile/RocketTile.scala
+++ b/src/main/scala/tile/RocketTile.scala
@@ -107,8 +107,8 @@ class RocketTile(val rocketParams: RocketTileParams)(implicit p: Parameters) ext
         "compatible"           -> Seq(ResourceString("sifive,rocket0"), ResourceString("riscv")),
         "status"               -> ofStr("okay"),
         "clock-frequency"      -> Seq(ResourceInt(rocketParams.core.bootFreqHz)),
-        "riscv,isa"            -> ofStr(isa))
-        ++ dcache ++ icache ++ nextlevel ++ mmu ++ itlb ++ dtlb ++ dtim ++ itim ++ incoherent)
+        "riscv,isa"            -> ofStr(isa),
+        "timebase-frequency"   -> Seq(ResourceInt(p(DTSTimebase)))) ++ dcache ++ icache ++ nextlevel ++ mmu ++ itlb ++ dtlb ++ dtim ++ itim ++ incoherent)
     }
   }
   val intcDevice = new Device {