diff --git a/block-inclusivecache-sifive b/block-inclusivecache-sifive
index 37d27a8f3b7d288c4663eebd8571018357fd827a..6b818366f86cd7cb61778ef22789323f9a42423e 160000
--- a/block-inclusivecache-sifive
+++ b/block-inclusivecache-sifive
@@ -1 +1 @@
-Subproject commit 37d27a8f3b7d288c4663eebd8571018357fd827a
+Subproject commit 6b818366f86cd7cb61778ef22789323f9a42423e
diff --git a/src/main/scala/device/AXI4DummySD.scala b/src/main/scala/device/AXI4DummySD.scala
index 7f863bf7e083eff9f1629c62ac1f4f3c413c338e..267d4c40c0787c5689a1f0f8549b62dd8914f6fa 100644
--- a/src/main/scala/device/AXI4DummySD.scala
+++ b/src/main/scala/device/AXI4DummySD.scala
@@ -53,7 +53,7 @@ class SDHelper extends BlackBox with HasBlackBoxInline {
 
 class AXI4DummySD
 (
-  address: AddressSet
+  address: Seq[AddressSet]
 )(implicit p: Parameters)
   extends AXI4SlaveModule(address, executable = false) with HasSDConst
 {
diff --git a/src/main/scala/device/AXI4Flash.scala b/src/main/scala/device/AXI4Flash.scala
index 2a92d42a7f58507e0ef6243919c6585d99277eeb..aeee36b7c423d22914771d02d5fe393e35fb0a6d 100644
--- a/src/main/scala/device/AXI4Flash.scala
+++ b/src/main/scala/device/AXI4Flash.scala
@@ -8,7 +8,7 @@ import utils._
 
 class AXI4Flash
 (
-  address: AddressSet
+  address: Seq[AddressSet]
 )(implicit p: Parameters)
   extends AXI4SlaveModule(address, executable = false)
 {
diff --git a/src/main/scala/device/AXI4Keyboard.scala b/src/main/scala/device/AXI4Keyboard.scala
index c6457c43af93555db4d73d8962dad6deada4636e..a649ac71aabbd495af34f2b9f4262def2a426b50 100644
--- a/src/main/scala/device/AXI4Keyboard.scala
+++ b/src/main/scala/device/AXI4Keyboard.scala
@@ -14,7 +14,7 @@ class KeyboardIO extends Bundle {
 // this Module is not tested
 class AXI4Keyboard
 (
-  address: AddressSet
+  address: Seq[AddressSet]
 )(implicit p: Parameters)
   extends AXI4SlaveModule(address, executable = false, _extra = new KeyboardIO)
 {
diff --git a/src/main/scala/device/AXI4RAM.scala b/src/main/scala/device/AXI4RAM.scala
index e88cf66ddfe5276b421e38ec4fabd8d28de113b6..44ee7c33933a150421d6df2444ac46b4d32205cb 100644
--- a/src/main/scala/device/AXI4RAM.scala
+++ b/src/main/scala/device/AXI4RAM.scala
@@ -5,6 +5,7 @@ import chisel3._
 import chisel3.util._
 import freechips.rocketchip.diplomacy.{AddressSet, LazyModule, LazyModuleImp, RegionType}
 import xiangshan.HasXSParameter
+import utils.{MaskExpand}
 
 class RAMHelper(memByte: BigInt) extends BlackBox with HasXSParameter {
   val io = IO(new Bundle {
@@ -20,7 +21,7 @@ class RAMHelper(memByte: BigInt) extends BlackBox with HasXSParameter {
 
 class AXI4RAM
 (
-  address: AddressSet,
+  address: Seq[AddressSet],
   memByte: Long,
   useBlackBox: Boolean = false,
   executable: Boolean = true,
@@ -32,27 +33,33 @@ class AXI4RAM
 
   override lazy val module = new AXI4SlaveModuleImp(this){
 
+    val split = beatBytes / 8
+    val bankByte = memByte / split
     val offsetBits = log2Up(memByte)
     val offsetMask = (1 << offsetBits) - 1
 
 
     def index(addr: UInt) = ((addr & offsetMask.U) >> log2Ceil(beatBytes)).asUInt()
 
-    def inRange(idx: UInt) = idx < (memByte / 8).U
+    def inRange(idx: UInt) = idx < (memByte / beatBytes).U
 
     val wIdx = index(waddr) + writeBeatCnt
     val rIdx = index(raddr) + readBeatCnt
     val wen = in.w.fire() && inRange(wIdx)
+    require(beatBytes >= 8)
 
     val rdata = if (useBlackBox) {
-      val mem = Module(new RAMHelper(memByte))
-      mem.io.clk := clock
-      mem.io.rIdx := rIdx
-      mem.io.wIdx := wIdx
-      mem.io.wdata := in.w.bits.data
-      mem.io.wmask := fullMask
-      mem.io.wen := wen
-      mem.io.rdata
+      val mems = (0 until split).map {_ => Module(new RAMHelper(bankByte))}
+      mems.zipWithIndex map { case (mem, i) =>
+        mem.io.clk := clock
+        mem.io.rIdx := (rIdx << log2Up(split)) + i.U
+        mem.io.wIdx := (wIdx << log2Up(split)) + i.U
+        mem.io.wdata := in.w.bits.data((i + 1) * 64 - 1, i * 64)
+        mem.io.wmask := MaskExpand(in.w.bits.strb((i + 1) * 8 - 1, i * 8))
+        mem.io.wen := wen
+      }
+      val rdata = mems.map {mem => mem.io.rdata}
+      Cat(rdata.reverse)
     } else {
       val mem = Mem(memByte / beatBytes, Vec(beatBytes, UInt(8.W)))
 
diff --git a/src/main/scala/device/AXI4SlaveModule.scala b/src/main/scala/device/AXI4SlaveModule.scala
index bac94067b7c5a1e86692e6e191d87af6956b6f08..de97a2b8e51c642b593efdd0133eef663060008f 100644
--- a/src/main/scala/device/AXI4SlaveModule.scala
+++ b/src/main/scala/device/AXI4SlaveModule.scala
@@ -10,7 +10,7 @@ import xiangshan.HasXSLog
 
 abstract class AXI4SlaveModule[T <: Data]
 (
-  address: AddressSet,
+  address: Seq[AddressSet],
   executable: Boolean = true,
   beatBytes: Int = 8,
   burstLen: Int = 1,
@@ -19,7 +19,7 @@ abstract class AXI4SlaveModule[T <: Data]
 
   val node = AXI4SlaveNode(Seq(AXI4SlavePortParameters(
     Seq(AXI4SlaveParameters(
-      Seq(address),
+      address,
       regionType = RegionType.UNCACHED,
       executable = executable,
       supportsWrite = TransferSizes(1, beatBytes * burstLen),
diff --git a/src/main/scala/device/AXI4Timer.scala b/src/main/scala/device/AXI4Timer.scala
index ee7cd091f58397cfafa7c59dba3f612bc882951a..c97c15bc3955c5a6cc73c0c72423469611cbddc0 100644
--- a/src/main/scala/device/AXI4Timer.scala
+++ b/src/main/scala/device/AXI4Timer.scala
@@ -12,7 +12,7 @@ class TimerIO extends Bundle {
 class AXI4Timer
 (
   sim: Boolean = false,
-  address: AddressSet
+  address: Seq[AddressSet]
 )(implicit p: Parameters)
   extends AXI4SlaveModule(address, executable = false, _extra = new TimerIO)
 {
diff --git a/src/main/scala/device/AXI4UART.scala b/src/main/scala/device/AXI4UART.scala
index 6c57efe04f6a8917ca8fa8db5e0b4c0d234288f5..beea3cb9525005a4518b8d57f7bd2b1eac2688c4 100644
--- a/src/main/scala/device/AXI4UART.scala
+++ b/src/main/scala/device/AXI4UART.scala
@@ -20,7 +20,7 @@ class UARTIO extends Bundle {
 
 class AXI4UART
 (
-  address: AddressSet
+  address: Seq[AddressSet]
 )(implicit p: Parameters)
   extends AXI4SlaveModule(address, executable = false, _extra = new UARTIO)
 {
diff --git a/src/main/scala/device/AXI4VGA.scala b/src/main/scala/device/AXI4VGA.scala
index 9c94aabe0bc480e030c67e4ee5cb4fd7167779f6..d4f96d2536bbbb5adda553b72f06c9320a50b0b8 100644
--- a/src/main/scala/device/AXI4VGA.scala
+++ b/src/main/scala/device/AXI4VGA.scala
@@ -54,7 +54,7 @@ class VGACtrlBundle extends Bundle {
 
 class VGACtrl
 (
-  address: AddressSet
+  address: Seq[AddressSet]
 )(implicit p: Parameters)
   extends AXI4SlaveModule(address, _extra = new VGACtrlBundle, executable = false) with HasVGAParameter {
   override lazy val module = new AXI4SlaveModuleImp[VGACtrlBundle](this) {
@@ -106,8 +106,8 @@ class FBHelper extends BlackBox with HasBlackBoxInline {
 class AXI4VGA
 (
   sim: Boolean = false,
-  fbAddress: AddressSet,
-  ctrlAddress: AddressSet
+  fbAddress: Seq[AddressSet],
+  ctrlAddress: Seq[AddressSet]
 )(implicit p: Parameters)
   extends LazyModule with HasVGAParameter {
 
diff --git a/src/main/scala/system/SoC.scala b/src/main/scala/system/SoC.scala
index 67205d47d9fdf7a5b66fc9423492ba6c1d42d270..c53d90bffaf244fbaa5b62bad1ce21bd6747e541 100644
--- a/src/main/scala/system/SoC.scala
+++ b/src/main/scala/system/SoC.scala
@@ -8,7 +8,11 @@ import freechips.rocketchip.diplomacy.{AddressSet, LazyModule, LazyModuleImp}
 import freechips.rocketchip.tilelink.{TLBuffer, TLFuzzer, TLIdentityNode, TLXbar}
 import utils.DebugIdentityNode
 import xiangshan.{HasXSParameter, XSCore}
-
+import sifive.blocks.inclusivecache.{CacheParameters, InclusiveCache, InclusiveCacheMicroParameters}
+import freechips.rocketchip.diplomacy.{LazyModule, LazyModuleImp, AddressSet}
+import freechips.rocketchip.tilelink.{TLBundleParameters, TLCacheCork, TLBuffer, TLClientNode, TLIdentityNode, TLXbar, TLWidthWidget, TLFilter, TLToAXI4}
+import freechips.rocketchip.devices.tilelink.{TLError, DevNullParams}
+import freechips.rocketchip.amba.axi4.{AXI4ToTL, AXI4IdentityNode, AXI4UserYanker, AXI4Fragmenter, AXI4IdIndexer, AXI4Deinterleaver}
 
 case class SoCParameters
 (
@@ -38,23 +42,94 @@ class DummyCore()(implicit p: Parameters) extends LazyModule {
 
 
 class XSSoc()(implicit p: Parameters) extends LazyModule with HasSoCParameter {
+  val numCores = 1
 
-  private val xsCore = LazyModule(new XSCore())
+  private val cores = Seq.fill(numCores)(LazyModule(new XSCore()))
 
   // only mem and extDev visible externally
-  val mem = xsCore.mem
+  val dma = AXI4IdentityNode()
   val extDev = TLIdentityNode()
 
+  // L2 to L3 network
+  // -------------------------------------------------
+  private val l3_xbar = TLXbar()
+
+  private val l3_banks = (0 until L3NBanks) map (i =>
+      LazyModule(new InclusiveCache(
+        CacheParameters(
+          level = 3,
+          ways = L3NWays,
+          sets = L3NSets,
+          blockBytes = L3BlockSize,
+          beatBytes = L2BusWidth / 8,
+          cacheName = s"L3_$i"
+        ),
+      InclusiveCacheMicroParameters(
+        writeBytes = 8
+      )
+    )))
+
+  cores.foreach(core => l3_xbar := TLBuffer() := DebugIdentityNode() := core.mem)
+
+  // DMA should not go to MMIO
+  val mmioRange = AddressSet(base = 0x0000000000L, mask = 0x007fffffffL)
+  // AXI4ToTL needs a TLError device to route error requests,
+  // add one here to make it happy.
+  val tlErrorParams = DevNullParams(
+    address = Seq(mmioRange),
+    maxAtomic = 8,
+    maxTransfer = 64)
+  val tlError = LazyModule(new TLError(params = tlErrorParams, beatBytes = L2BusWidth / 8))
+  private val tlError_xbar = TLXbar()
+  tlError_xbar :=
+    AXI4ToTL() :=
+    AXI4UserYanker(Some(1)) :=
+    AXI4Fragmenter() :=
+    AXI4IdIndexer(1) :=
+    dma
+  tlError.node := tlError_xbar
+
+  l3_xbar :=
+    TLBuffer() :=
+    DebugIdentityNode() :=
+    tlError_xbar
+
+  def bankFilter(bank: Int) = AddressSet(
+    base = bank * L3BlockSize,
+    mask = ~BigInt((L3NBanks -1) * L3BlockSize))
+
+  for(i <- 0 until L3NBanks) {
+    val filter = TLFilter(TLFilter.mSelectIntersect(bankFilter(i)))
+    l3_banks(i).node := TLBuffer() := DebugIdentityNode() := filter := l3_xbar
+  }
+
+
+  // L3 to memory network
+  // -------------------------------------------------
+  private val memory_xbar = TLXbar()
+
+  val mem = Seq.fill(L3NBanks)(AXI4IdentityNode())
+  for(i <- 0 until L3NBanks) {
+    mem(i) :=
+      AXI4UserYanker() :=
+      TLToAXI4() :=
+      TLWidthWidget(L3BusWidth / 8) :=
+      TLCacheCork() :=
+      l3_banks(i).node
+  }
+
   private val mmioXbar = TLXbar()
   private val clint = LazyModule(new TLTimer(
     Seq(AddressSet(0x38000000L, 0x0000ffffL)),
     sim = !env.FPGAPlatform
   ))
 
-  mmioXbar :=
+  cores.foreach(core =>
+    mmioXbar :=
     TLBuffer() :=
     DebugIdentityNode() :=
-    xsCore.mmio
+    core.mmio
+  )
 
   clint.node :=
     mmioXbar
@@ -67,9 +142,11 @@ class XSSoc()(implicit p: Parameters) extends LazyModule with HasSoCParameter {
       val meip = Input(Bool())
       val ila = if(env.FPGAPlatform && EnableILA) Some(Output(new ILABundle)) else None
     })
-    xsCore.module.io.externalInterrupt.mtip := clint.module.io.mtip
-    xsCore.module.io.externalInterrupt.msip := clint.module.io.msip
-    xsCore.module.io.externalInterrupt.meip := RegNext(RegNext(io.meip))
+    cores.foreach(core => {
+      core.module.io.externalInterrupt.mtip := clint.module.io.mtip
+      core.module.io.externalInterrupt.msip := clint.module.io.msip
+      core.module.io.externalInterrupt.meip := RegNext(RegNext(io.meip))
+    })
   }
 
 }
diff --git a/src/main/scala/xiangshan/XSCore.scala b/src/main/scala/xiangshan/XSCore.scala
index 4fff1c6d74335e3334f187312d771291e0cc6ca5..94b11adced8021290eb55baafb9e032fffcd876e 100644
--- a/src/main/scala/xiangshan/XSCore.scala
+++ b/src/main/scala/xiangshan/XSCore.scala
@@ -11,9 +11,11 @@ import xiangshan.mem._
 import xiangshan.backend.fu.HasExceptionNO
 import xiangshan.cache.{ICache, DCache, L1plusCache, DCacheParameters, ICacheParameters, L1plusCacheParameters, PTW, Uncache}
 import chipsalliance.rocketchip.config
-import freechips.rocketchip.diplomacy.{LazyModule, LazyModuleImp}
-import freechips.rocketchip.tilelink.{TLBundleParameters, TLCacheCork, TLBuffer, TLClientNode, TLIdentityNode, TLXbar}
+import freechips.rocketchip.diplomacy.{LazyModule, LazyModuleImp, AddressSet}
+import freechips.rocketchip.tilelink.{TLBundleParameters, TLCacheCork, TLBuffer, TLClientNode, TLIdentityNode, TLXbar, TLWidthWidget, TLFilter, TLToAXI4}
+import freechips.rocketchip.devices.tilelink.{TLError, DevNullParams}
 import sifive.blocks.inclusivecache.{CacheParameters, InclusiveCache, InclusiveCacheMicroParameters}
+import freechips.rocketchip.amba.axi4.{AXI4ToTL, AXI4IdentityNode, AXI4UserYanker, AXI4Fragmenter, AXI4IdIndexer, AXI4Deinterleaver}
 import utils._
 
 case class XSCoreParameters
@@ -169,8 +171,6 @@ trait HasXSParameter {
   val PtwL2EntrySize = core.PtwL2EntrySize
   val NumPerfCounters = core.NumPerfCounters
 
-  val l1BusDataWidth = 256
-
   val icacheParameters = ICacheParameters(
     nMissEntries = 2
   )
@@ -190,6 +190,28 @@ trait HasXSParameter {
   )
 
   val LRSCCycles = 100
+
+
+  // cache hierarchy configurations
+  val l1BusDataWidth = 256
+
+  // L2 configurations
+  val L1BusWidth = 256
+  val L2Size = 512 * 1024 // 512KB
+  val L2BlockSize = 64
+  val L2NWays = 8
+  val L2NSets = L2Size / L2BlockSize / L2NWays
+
+  // L3 configurations
+  val L2BusWidth = 256
+  val L3Size = 4 * 1024 * 1024 // 4MB
+  val L3BlockSize = 64
+  val L3NBanks = 4
+  val L3NWays = 8
+  val L3NSets = L3Size / L3BlockSize / L3NBanks / L3NWays
+
+  // on chip network configurations
+  val L3BusWidth = 256
 }
 
 trait HasXSLog { this: RawModule =>
@@ -240,39 +262,42 @@ object AddressSpace extends HasXSParameter {
 
 
 
-class XSCore()(implicit p: config.Parameters) extends LazyModule {
+class XSCore()(implicit p: config.Parameters) extends LazyModule with HasXSParameter {
 
+  // inner nodes
   val dcache = LazyModule(new DCache())
   val uncache = LazyModule(new Uncache())
   val l1pluscache = LazyModule(new L1plusCache())
   val ptw = LazyModule(new PTW())
 
+  // out facing nodes
   val mem = TLIdentityNode()
   val mmio = uncache.clientNode
 
-  // TODO: refactor these params
+  // L1 to L2 network
+  // -------------------------------------------------
+  private val l2_xbar = TLXbar()
+
   private val l2 = LazyModule(new InclusiveCache(
     CacheParameters(
       level = 2,
-      ways = 4,
-      sets = 512 * 1024 / (64 * 4),
-      blockBytes = 64,
-      beatBytes = 32 // beatBytes = l1BusDataWidth / 8
+      ways = L2NWays,
+      sets = L2NSets,
+      blockBytes = L2BlockSize,
+      beatBytes = L1BusWidth / 8, // beatBytes = l1BusDataWidth / 8
+      cacheName = s"L2"
     ),
     InclusiveCacheMicroParameters(
       writeBytes = 8
     )
   ))
 
-  private val xbar = TLXbar()
-
-  xbar := TLBuffer() := DebugIdentityNode() := dcache.clientNode
-  xbar := TLBuffer() := DebugIdentityNode() := l1pluscache.clientNode
-  xbar := TLBuffer() := DebugIdentityNode() := ptw.node
-
-  l2.node := xbar
+  l2_xbar := TLBuffer() := DebugIdentityNode() := dcache.clientNode
+  l2_xbar := TLBuffer() := DebugIdentityNode() := l1pluscache.clientNode
+  l2_xbar := TLBuffer() := DebugIdentityNode() := ptw.node
+  l2.node := TLBuffer() := DebugIdentityNode() := l2_xbar
 
-  mem := TLBuffer() := TLCacheCork() := TLBuffer() := l2.node
+  mem := l2.node
 
   lazy val module = new XSCoreImp(this)
 }
diff --git a/src/test/scala/cache/L1plusCacheTest.scala b/src/test/scala/cache/L1plusCacheTest.scala
index 28bc6bc06f4f705ac3da9e9489675c8e46546ba8..e02af4e5e6c48cdc00d8b841da6daccb0a1a40e3 100644
--- a/src/test/scala/cache/L1plusCacheTest.scala
+++ b/src/test/scala/cache/L1plusCacheTest.scala
@@ -51,7 +51,7 @@ class L1plusTestTop()(implicit p: Parameters) extends LazyModule{
   ))
 
   val ram = LazyModule(new AXI4RAM(
-    AddressSet(0x0L, 0xffffffffffL),
+    Seq(AddressSet(0x0L, 0xffffffffffL)),
     memByte = 128 * 1024 * 1024,
     useBlackBox = false
   ))
diff --git a/src/test/scala/cache/L2CacheNonInclusiveGetTest.scala b/src/test/scala/cache/L2CacheNonInclusiveGetTest.scala
index 0c2a985fe2968d2c153f140fa7b0425262343662..a499c4e8cb31bcb3375749cf785c3f28ab41547e 100644
--- a/src/test/scala/cache/L2CacheNonInclusiveGetTest.scala
+++ b/src/test/scala/cache/L2CacheNonInclusiveGetTest.scala
@@ -52,7 +52,7 @@ class L2NonInclusiveGetTestTop()(implicit p: Parameters) extends LazyModule {
       beatBytes = 8))))
 
   val ram = LazyModule(new AXI4RAM(
-    AddressSet(0x0L, 0x7ffffffL),
+    Seq(AddressSet(0x0L, 0x7ffffffL)),
     memByte = 128 * 1024 * 1024,
     useBlackBox = false
   ))
diff --git a/src/test/scala/cache/L2CacheTest.scala b/src/test/scala/cache/L2CacheTest.scala
index 77aeadf87f96e8ace90d4ecdd508e88439f6096d..b8b31baeeb2340301aa2d9ff5539b6d5258dc1af 100644
--- a/src/test/scala/cache/L2CacheTest.scala
+++ b/src/test/scala/cache/L2CacheTest.scala
@@ -101,7 +101,7 @@ class L2TestTop()(implicit p: Parameters) extends LazyModule{
   ))
 
   val ram = LazyModule(new AXI4RAM(
-    AddressSet(0x0L, 0xffffffffffL),
+    Seq(AddressSet(0x0L, 0xffffffffffL)),
     memByte = 128 * 1024 * 1024,
     useBlackBox = false
   ))
diff --git a/src/test/scala/device/AXI4RamTest.scala b/src/test/scala/device/AXI4RamTest.scala
index a4764b9e18ea018d05e30ea9645afbbcbecda94c..9c203fa56329119f38957ce88ab0386008c97d93 100644
--- a/src/test/scala/device/AXI4RamTest.scala
+++ b/src/test/scala/device/AXI4RamTest.scala
@@ -20,7 +20,7 @@ class AXI4RamFuzzTest()(implicit p: Parameters) extends LazyModule {
     inFlight = 10
   ))
   val ident = LazyModule(new DebugIdentityNode())
-  val axiRam = LazyModule(new AXI4RAM(addressSet, memByte = 1024))
+  val axiRam = LazyModule(new AXI4RAM(Seq(addressSet), memByte = 1024))
 
   axiRam.node :=
     AXI4UserYanker() :=
@@ -39,7 +39,7 @@ class AXI4RamBurstTest()(implicit p: Parameters) extends LazyModule {
 
   val addressSet = AddressSet(0x38000000L, 0x0000ffffL)
   val burst = LazyModule(new AXI4BurstMaster(startAddr = addressSet.base.toLong, nOp = 3))
-  val axiRam = LazyModule(new AXI4RAM(addressSet, memByte = 1024))
+  val axiRam = LazyModule(new AXI4RAM(Seq(addressSet), memByte = 1024))
 
   axiRam.node := burst.node
 
@@ -56,7 +56,7 @@ class AXI4RamTLBurstTest()(implicit p: Parameters) extends LazyModule {
 
   val tlburst = LazyModule(new TLBurstMaster(startAddr = addressSet.base.toLong, nOp = 1, burstLen = 32))
   val ident = LazyModule(new DebugIdentityNode())
-  val axiRam = LazyModule(new AXI4RAM(addressSet, memByte = 1024))
+  val axiRam = LazyModule(new AXI4RAM(Seq(addressSet), memByte = 1024))
 
   axiRam.node :=
     AXI4UserYanker() :=
diff --git a/src/test/scala/device/AXI4TimerTest.scala b/src/test/scala/device/AXI4TimerTest.scala
index a1499a2d733c0674aaddd11dfd74390d683942dd..baa5cf91b0465f0a488cbe6a390f90ab8984dab8 100644
--- a/src/test/scala/device/AXI4TimerTest.scala
+++ b/src/test/scala/device/AXI4TimerTest.scala
@@ -16,7 +16,7 @@ class AXI4TimerTestTop(implicit p: Parameters) extends LazyModule {
   val addressSet = AddressSet(0x38000000L, 0x0000ffffL)
   val fuzz = LazyModule(new TLFuzzer(nOperations = 10, overrideAddress = Some(addressSet), inFlight = 1))
   val ident = LazyModule(new DebugIdentityNode())
-  val axiTimer = LazyModule(new AXI4Timer(sim = true, addressSet))
+  val axiTimer = LazyModule(new AXI4Timer(sim = true, Seq(addressSet)))
 
   axiTimer.node :=
     AXI4UserYanker() :=
diff --git a/src/test/scala/top/SimMMIO.scala b/src/test/scala/top/SimMMIO.scala
index 57423e1144f202cb092287c3b57a6553ceba0768..4b6437ea3c483639dbaa500571e203a99eee509d 100644
--- a/src/test/scala/top/SimMMIO.scala
+++ b/src/test/scala/top/SimMMIO.scala
@@ -9,14 +9,14 @@ import freechips.rocketchip.tilelink.{TLErrorEvaluator, TLMasterParameters, TLXb
 
 class SimMMIO()(implicit p: config.Parameters) extends LazyModule {
 
-  val uart = LazyModule(new AXI4UART(AddressSet(0x40600000L, 0xf)))
+  val uart = LazyModule(new AXI4UART(Seq(AddressSet(0x40600000L, 0xf))))
   val vga = LazyModule(new AXI4VGA(
     sim = false,
-    fbAddress = AddressSet(0x50000000L, 0x3fffffL),
-    ctrlAddress = AddressSet(0x40001000L, 0x7L)
+    fbAddress = Seq(AddressSet(0x50000000L, 0x3fffffL)),
+    ctrlAddress = Seq(AddressSet(0x40001000L, 0x7L))
   ))
-  val flash = LazyModule(new AXI4Flash(AddressSet(0x40000000L, 0xfff)))
-  val sd = LazyModule(new AXI4DummySD(AddressSet(0x40002000L, 0xfff)))
+  val flash = LazyModule(new AXI4Flash(Seq(AddressSet(0x40000000L, 0xfff))))
+  val sd = LazyModule(new AXI4DummySD(Seq(AddressSet(0x40002000L, 0xfff))))
 
   val axiBus = AXI4Xbar()
 
diff --git a/src/test/scala/top/XSSim.scala b/src/test/scala/top/XSSim.scala
index f95cae721bfc4983e188bb92fca202142f0d1758..bb96d2d6ff62b6fd9ea9b08b31ae3445f1316c5c 100644
--- a/src/test/scala/top/XSSim.scala
+++ b/src/test/scala/top/XSSim.scala
@@ -6,9 +6,9 @@ import chisel3.util._
 import chipsalliance.rocketchip.config
 import chisel3.stage.ChiselGeneratorAnnotation
 import device._
-import freechips.rocketchip.amba.axi4.{AXI4Fragmenter, AXI4UserYanker}
+import freechips.rocketchip.amba.axi4.{AXI4UserYanker, AXI4Xbar}
 import freechips.rocketchip.diplomacy.{AddressSet, BufferParams, LazyModule, LazyModuleImp}
-import freechips.rocketchip.tilelink.{TLBuffer, TLCacheCork, TLFragmenter, TLFuzzer, TLToAXI4, TLXbar}
+import freechips.rocketchip.tilelink.{TLToAXI4}
 import xiangshan._
 import utils._
 import ExcitingUtils.Debug
@@ -66,23 +66,42 @@ class TrapIO extends XSBundle {
 
 class XSSimTop()(implicit p: config.Parameters) extends LazyModule {
 
-  val memAddressSet = AddressSet(0x0L, 0xffffffffffL)
+  // address space[0G - 1024G)
+  val fullRange = AddressSet(0x0L, 0xffffffffffL)
+  // MMIO address space[0G - 2G)
+  val mmioRange = AddressSet(base = 0x0000000000L, mask = 0x007fffffffL)
+  // DRAM address range[2G - 1024G)
+  val dramRange = fullRange.subtract(mmioRange)
+
+  val L3BusWidth = 256
+  val L3BlockSize = 512
 
   val soc = LazyModule(new XSSoc())
+  // AXIRam
+  // -----------------------------------
   val axiRam = LazyModule(new AXI4RAM(
-    memAddressSet,
+    dramRange,
     memByte = 128 * 1024 * 1024,
-    useBlackBox = true
+    useBlackBox = true,
+    beatBytes = L3BusWidth / 8
   ))
-  val axiMMIO = LazyModule(new SimMMIO())
 
+  val xbar = AXI4Xbar()
+  soc.mem.map{mem => xbar := mem}
   axiRam.node :=
-    AXI4UserYanker() :=
-    TLToAXI4() :=
-    TLBuffer(BufferParams.default) :=
-    DebugIdentityNode() :=
-    soc.mem
-
+    xbar
+
+  // AXI DMA
+  // -----------------------------------
+  val burst = LazyModule(new AXI4BurstMaster(
+    startAddr = 0x80000000L,
+    nOp = 0,
+    beatBytes = L3BusWidth / 8))
+  soc.dma := burst.node
+
+  // AXI MMIO
+  // -----------------------------------
+  val axiMMIO = LazyModule(new SimMMIO())
   axiMMIO.axiBus :=
     AXI4UserYanker() :=
     TLToAXI4() :=