Merge remote-tracking branch 'origin/dev' into offchip-axi-setup

generators/chipyard/src/main/scala/Clocks.scala

@@ -14,6 +14,7 @@ import barstools.iocell.chisel._
 import testchipip.{TLTileResetCtrl}
 
 import chipyard.clocking._
+import chipyard.iobinders._
 
 /**
  * A simple reset implementation that punches out reset ports
@@ -25,7 +26,7 @@ object GenerateReset {
     implicit val p = chiptop.p
     // this needs directionality so generateIOFromSignal works
     val async_reset_wire = Wire(Input(AsyncReset()))
-    val (reset_io, resetIOCell) = IOCell.generateIOFromSignal(async_reset_wire, "reset",
+    val (reset_io, resetIOCell) = IOCell.generateIOFromSignal(async_reset_wire, "reset", p(IOCellKey),
       abstractResetAsAsync = true)
 
     chiptop.iocells ++= resetIOCell
@@ -70,9 +71,10 @@ object ClockingSchemeGenerators {
 
     // Add a control register for each tile's reset
     val resetSetter = chiptop.lazySystem match {
-      case sys: BaseSubsystem with InstantiatesTiles => TLTileResetCtrl(sys)
-      case _ => ClockGroupEphemeralNode()
+      case sys: BaseSubsystem with InstantiatesTiles => Some(TLTileResetCtrl(sys))
+      case _ => None
     }
+    val resetSetterResetProvider = resetSetter.map(_.tileResetProviderNode).getOrElse(ClockGroupEphemeralNode())
 
     val aggregator = LazyModule(new ClockGroupAggregator("allClocks")).node
     // provides the implicit clock to the system
@@ -81,7 +83,6 @@ object ClockingSchemeGenerators {
       := aggregator)
     // provides the system clock (ex. the bus clocks)
     (systemAsyncClockGroup
-      :*= resetSetter
       :*= ClockGroupNamePrefixer()
       :*= aggregator)
 
@@ -91,13 +92,19 @@ object ClockingSchemeGenerators {
     (aggregator
       := ClockGroupFrequencySpecifier(p(ClockFrequencyAssignersKey), p(DefaultClockFrequencyKey))
       := ClockGroupResetSynchronizer()
+      := resetSetterResetProvider
       := dividerOnlyClkGenerator.node
       := referenceClockSource)
 
+    val asyncResetBroadcast = FixedClockBroadcast(None)
+    resetSetter.foreach(_.asyncResetSinkNode := asyncResetBroadcast)
+    val asyncResetSource = ClockSourceNode(Seq(ClockSourceParameters()))
+    asyncResetBroadcast := asyncResetSource
+
     InModuleBody {
       val clock_wire = Wire(Input(Clock()))
       val reset_wire = GenerateReset(chiptop, clock_wire)
-      val (clock_io, clockIOCell) = IOCell.generateIOFromSignal(clock_wire, "clock")
+      val (clock_io, clockIOCell) = IOCell.generateIOFromSignal(clock_wire, "clock", p(IOCellKey))
       chiptop.iocells ++= clockIOCell
 
       referenceClockSource.out.unzip._1.map { o =>
@@ -105,6 +112,11 @@ object ClockingSchemeGenerators {
         o.reset := reset_wire
       }
 
+      asyncResetSource.out.unzip._1.map { o =>
+        o.clock := false.B.asClock // async reset broadcast network does not provide a clock
+        o.reset := reset_wire
+      }
+
       chiptop.harnessFunctions += ((th: HasHarnessSignalReferences) => {
         clock_io := th.harnessClock
         Nil })

generators/chipyard/src/main/scala/ConfigFragments.scala

@@ -151,6 +151,16 @@ class WithNPerfCounters(n: Int = 29) extends Config((site, here, up) => {
   }
 })
 
+class WithNPMPs(n: Int = 8) extends Config((site, here, up) => {
+  case TilesLocated(InSubsystem) => up(TilesLocated(InSubsystem), site) map {
+    case tp: RocketTileAttachParams => tp.copy(tileParams = tp.tileParams.copy(
+      core = tp.tileParams.core.copy(nPMPs = n)))
+    case tp: BoomTileAttachParams => tp.copy(tileParams = tp.tileParams.copy(
+      core = tp.tileParams.core.copy(nPMPs = n)))
+    case other => other
+  }
+})
+
 class WithRocketICacheScratchpad extends Config((site, here, up) => {
   case RocketTilesKey => up(RocketTilesKey, site) map { r =>
     r.copy(icache = r.icache.map(_.copy(itimAddr = Some(0x300000 + r.hartId * 0x10000))))

scripts/build-toolchains.sh

@@ -21,6 +21,7 @@ usage() {
     echo "   --prefix PREFIX : Install destination. If unset, defaults to $(pwd)/riscv-tools-install"
     echo "                     or $(pwd)/esp-tools-install"
     echo "   --ignore-qemu   : Ignore installing QEMU"
+    echo "   --arch -a       : Architecture (e.g., rv64gc)"
     echo "   --help -h       : Display this message"
     exit "$1"
 }
@@ -37,6 +38,7 @@ TOOLCHAIN="riscv-tools"
 EC2FASTINSTALL="false"
 IGNOREQEMU=""
 RISCV=""
+ARCH=""
 
 # getopts does not support long options, and is inflexible
 while [ "$1" != "" ];
@@ -49,6 +51,9 @@ do
             RISCV=$(realpath $1) ;;
         --ignore-qemu )
             IGNOREQEMU="true" ;;
+	-a | --arch )
+	    shift
+	    ARCH=$1 ;;
         riscv-tools | esp-tools)
             TOOLCHAIN=$1 ;;
         ec2fast )
@@ -65,6 +70,15 @@ if [ -z "$RISCV" ] ; then
       RISCV="$(pwd)/$INSTALL_DIR"
 fi
 
+if [ -z "$ARCH" ] ; then
+    XLEN=64
+elif [[ "$ARCH" =~ ^rv(32|64)((i?m?a?f?d?|g?)c?)$ ]]; then
+    XLEN=${BASH_REMATCH[1]}
+else
+    error "invalid arch $ARCH"
+    usage 1
+fi
+
 echo "Installing toolchain to $RISCV"
 
 # install risc-v tools
@@ -118,7 +132,7 @@ else
     esac
 
     module_prepare riscv-gnu-toolchain qemu
-    module_build riscv-gnu-toolchain --prefix="${RISCV}" --with-cmodel=medany
+    module_build riscv-gnu-toolchain --prefix="${RISCV}" --with-cmodel=medany ${ARCH:+--with-arch=${ARCH}}
     echo '==>  Building GNU/Linux toolchain'
     module_make riscv-gnu-toolchain linux
 fi
@@ -129,15 +143,15 @@ echo '==>  Installing libfesvr static library'
 module_make riscv-isa-sim libfesvr.a
 cp -p "${SRCDIR}/riscv-isa-sim/build/libfesvr.a" "${RISCV}/lib/"
 
-CC= CXX= module_all riscv-pk --prefix="${RISCV}" --host=riscv64-unknown-elf
-module_all riscv-tests --prefix="${RISCV}/riscv64-unknown-elf"
+CC= CXX= module_all riscv-pk --prefix="${RISCV}" --host=riscv${XLEN}-unknown-elf
+module_all riscv-tests --prefix="${RISCV}/riscv${XLEN}-unknown-elf" --with-xlen=${XLEN}
 
 # Common tools (not in any particular toolchain dir)
 
-CC= CXX= SRCDIR="$(pwd)/toolchains" module_all libgloss --prefix="${RISCV}/riscv64-unknown-elf" --host=riscv64-unknown-elf
+CC= CXX= SRCDIR="$(pwd)/toolchains" module_all libgloss --prefix="${RISCV}/riscv${XLEN}-unknown-elf" --host=riscv${XLEN}-unknown-elf
 
 if [ -z "$IGNOREQEMU" ] ; then
-SRCDIR="$(pwd)/toolchains" module_all qemu --prefix="${RISCV}" --target-list=riscv64-softmmu
+SRCDIR="$(pwd)/toolchains" module_all qemu --prefix="${RISCV}" --target-list=riscv${XLEN}-softmmu
 fi
 
 # make Dromajo