1/*************************************************************************************** 2* Copyright (c) 2020-2021 Institute of Computing Technology, Chinese Academy of Sciences 3* Copyright (c) 2020-2021 Peng Cheng Laboratory 4* 5* XiangShan is licensed under Mulan PSL v2. 6* You can use this software according to the terms and conditions of the Mulan PSL v2. 7* You may obtain a copy of Mulan PSL v2 at: 8* http://license.coscl.org.cn/MulanPSL2 9* 10* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, 11* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, 12* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. 13* 14* See the Mulan PSL v2 for more details. 15***************************************************************************************/ 16 17package device 18 19import chipsalliance.rocketchip.config.Parameters 20import chisel3._ 21import chisel3.util._ 22import Chisel.BlackBox 23import freechips.rocketchip.amba.axi4.{AXI4SlaveNode, AXI4EdgeParameters, AXI4MasterNode} 24import freechips.rocketchip.diplomacy.{AddressSet, InModuleBody, LazyModule, LazyModuleImp, RegionType} 25import top.HaveAXI4MemPort 26import xiangshan.HasXSParameter 27import utils.MaskExpand 28 29class RAMHelper(memByte: BigInt) extends BlackBox { 30 val DataBits = 64 31 val io = IO(new Bundle { 32 val clk = Input(Clock()) 33 val en = Input(Bool()) 34 val rIdx = Input(UInt(DataBits.W)) 35 val rdata = Output(UInt(DataBits.W)) 36 val wIdx = Input(UInt(DataBits.W)) 37 val wdata = Input(UInt(DataBits.W)) 38 val wmask = Input(UInt(DataBits.W)) 39 val wen = Input(Bool()) 40 }) 41} 42 43class AXI4RAM 44( 45 address: Seq[AddressSet], 46 memByte: Long, 47 useBlackBox: Boolean = false, 48 executable: Boolean = true, 49 beatBytes: Int = 8, 50 burstLen: Int = 16, 51)(implicit p: Parameters) 52 extends AXI4SlaveModule(address, executable, beatBytes, burstLen) 53{ 54 override lazy val module = new AXI4SlaveModuleImp(this){ 55 56 val split = beatBytes / 8 57 val bankByte = memByte / split 58 val offsetBits = log2Up(memByte) 59 60 require(address.length >= 1) 61 val baseAddress = address(0).base 62 63 def index(addr: UInt) = ((addr - baseAddress.U)(offsetBits - 1, 0) >> log2Ceil(beatBytes)).asUInt() 64 65 def inRange(idx: UInt) = idx < (memByte / beatBytes).U 66 67 val wIdx = index(waddr) + writeBeatCnt 68 val rIdx = index(raddr) + readBeatCnt 69 val wen = in.w.fire() && inRange(wIdx) 70 require(beatBytes >= 8) 71 72 val rdata = if (useBlackBox) { 73 val mems = (0 until split).map {_ => Module(new RAMHelper(bankByte))} 74 mems.zipWithIndex map { case (mem, i) => 75 mem.io.clk := clock 76 mem.io.en := !reset.asBool() && ((state === s_rdata) || (state === s_wdata)) 77 mem.io.rIdx := (rIdx << log2Up(split)) + i.U 78 mem.io.wIdx := (wIdx << log2Up(split)) + i.U 79 mem.io.wdata := in.w.bits.data((i + 1) * 64 - 1, i * 64) 80 mem.io.wmask := MaskExpand(in.w.bits.strb((i + 1) * 8 - 1, i * 8)) 81 mem.io.wen := wen 82 } 83 val rdata = mems.map {mem => mem.io.rdata} 84 Cat(rdata.reverse) 85 } else { 86 val mem = Mem(memByte / beatBytes, Vec(beatBytes, UInt(8.W))) 87 88 val wdata = VecInit.tabulate(beatBytes) { i => in.w.bits.data(8 * (i + 1) - 1, 8 * i) } 89 when(wen) { 90 mem.write(wIdx, wdata, in.w.bits.strb.asBools()) 91 } 92 93 Cat(mem.read(rIdx).reverse) 94 } 95 in.r.bits.data := rdata 96 } 97} 98 99class AXI4RAMWrapper 100(snode: AXI4SlaveNode, memByte: Long, useBlackBox: Boolean = false) 101(implicit p: Parameters) 102 extends LazyModule { 103 104 val mnode = AXI4MasterNode(List(snode.in.head._2.master)) 105 106 val portParam = snode.portParams.head 107 val slaveParam = portParam.slaves.head 108 val burstLen = portParam.maxTransfer / portParam.beatBytes 109 val ram = LazyModule(new AXI4RAM( 110 slaveParam.address, memByte, useBlackBox, 111 slaveParam.executable, portParam.beatBytes, burstLen 112 )) 113 ram.node := mnode 114 115 val io_axi4 = InModuleBody{ mnode.makeIOs() } 116 def connectToSoC(soc: HaveAXI4MemPort) = { 117 io_axi4 <> soc.memory 118 } 119 120 lazy val module = new LazyModuleImp(this){} 121} 122