1
0
rocket-chip/rocket/src/main/scala/ptw.scala

151 lines
4.1 KiB
Scala
Raw Normal View History

2014-09-13 03:06:41 +02:00
// See LICENSE for license details.
package rocket
2011-11-09 23:52:17 +01:00
2012-10-08 05:15:54 +02:00
import Chisel._
import uncore._
import Util._
2011-11-09 23:52:17 +01:00
2015-03-14 10:49:07 +01:00
class PTWReq extends CoreBundle {
val addr = UInt(width = vpnBits)
val perm = Bits(width = permBits)
}
class PTWResp extends CoreBundle {
val error = Bool()
val ppn = UInt(width = ppnBits)
val perm = Bits(width = permBits)
2015-03-14 10:49:07 +01:00
val dirty = Bool()
2013-08-12 19:39:11 +02:00
}
class TLBPTWIO extends CoreBundle {
2015-03-14 10:49:07 +01:00
val req = Decoupled(new PTWReq)
2013-08-12 19:39:11 +02:00
val resp = Valid(new PTWResp).flip
2015-03-14 10:49:07 +01:00
val status = new MStatus().asInput
val invalidate = Bool(INPUT)
}
class DatapathPTWIO extends CoreBundle {
val ptbr = UInt(INPUT, paddrBits)
val invalidate = Bool(INPUT)
2015-03-14 10:49:07 +01:00
val status = new MStatus().asInput
2011-11-09 23:52:17 +01:00
}
class PTW(n: Int) extends CoreModule
2011-11-09 23:52:17 +01:00
{
val io = new Bundle {
2013-08-12 19:39:11 +02:00
val requestor = Vec.fill(n){new TLBPTWIO}.flip
val mem = new HellaCacheIO
2013-01-07 22:38:59 +01:00
val dpath = new DatapathPTWIO
}
2011-11-09 23:52:17 +01:00
val levels = 3
val bitsPerLevel = vpnBits/levels
require(vpnBits == levels * bitsPerLevel)
2015-03-14 10:49:07 +01:00
val s_ready :: s_req :: s_wait :: s_set_dirty :: s_wait_dirty :: s_done :: s_error :: Nil = Enum(UInt(), 7)
2013-08-16 00:28:15 +02:00
val state = Reg(init=s_ready)
2013-08-12 19:39:11 +02:00
val count = Reg(UInt(width = log2Up(levels)))
2015-03-14 10:49:07 +01:00
val r_req = Reg(new PTWReq)
2013-08-12 19:39:11 +02:00
val r_req_dest = Reg(Bits())
val r_pte = Reg(Bits())
2011-11-09 23:52:17 +01:00
2015-03-14 10:49:07 +01:00
val vpn_idx = Vec((0 until levels).map(i => (r_req.addr >> (levels-i-1)*bitsPerLevel)(bitsPerLevel-1,0)))(count)
2012-03-18 07:00:51 +01:00
2015-03-14 10:49:07 +01:00
val arb = Module(new RRArbiter(new PTWReq, n))
2012-10-10 06:35:03 +02:00
arb.io.in <> io.requestor.map(_.req)
arb.io.out.ready := state === s_ready
2015-03-14 10:49:07 +01:00
val pte = io.mem.resp.bits.data
2012-10-10 06:35:03 +02:00
when (arb.io.out.fire()) {
2015-03-14 10:49:07 +01:00
r_req := arb.io.out.bits
2012-10-10 06:35:03 +02:00
r_req_dest := arb.io.chosen
2015-03-14 10:49:07 +01:00
r_pte := Cat(io.dpath.ptbr(paddrBits-1,pgIdxBits), pte(pgIdxBits-1,0))
2011-11-10 09:23:29 +01:00
}
2015-03-14 10:49:07 +01:00
val perm_ok = (pte(8,3) & r_req.perm).orR
val is_store = r_req.perm(1) || r_req.perm(4)
val set_dirty_bit = perm_ok && !pte(1) && (!pte(9) || (is_store && !pte(10)))
when (io.mem.resp.valid && state === s_wait && !set_dirty_bit) {
r_pte := pte
2011-11-09 23:52:17 +01:00
}
2015-03-14 10:49:07 +01:00
io.mem.req.valid := state === s_req || state === s_set_dirty
io.mem.req.bits.phys := Bool(true)
2015-03-14 10:49:07 +01:00
io.mem.req.bits.cmd := Mux(state === s_set_dirty, M_XA_OR, M_XRD)
io.mem.req.bits.typ := MT_D
io.mem.req.bits.addr := Cat(r_pte(paddrBits-1,pgIdxBits), vpn_idx).toUInt << log2Up(xLen/8)
io.mem.req.bits.kill := Bool(false)
2015-03-14 10:49:07 +01:00
io.mem.req.bits.data := UInt(1<<9) | Mux(is_store, UInt(1<<10), UInt(0))
2015-03-14 10:49:07 +01:00
val resp_err = state === s_error
val resp_val = state === s_done || resp_err
val r_resp_ppn = io.mem.req.bits.addr >> UInt(pgIdxBits)
2015-03-14 10:49:07 +01:00
val resp_ppn = Vec((0 until levels-1).map(i => Cat(r_resp_ppn >> bitsPerLevel*(levels-i-1), r_req.addr(bitsPerLevel*(levels-i-1)-1,0))) :+ r_resp_ppn)(count)
for (i <- 0 until io.requestor.size) {
2013-08-12 19:39:11 +02:00
val me = r_req_dest === UInt(i)
2012-10-10 06:35:03 +02:00
io.requestor(i).resp.valid := resp_val && me
io.requestor(i).resp.bits.error := resp_err
2013-08-24 06:16:28 +02:00
io.requestor(i).resp.bits.perm := r_pte(8,3)
2015-03-14 10:49:07 +01:00
io.requestor(i).resp.bits.dirty := r_pte(10)
2013-08-12 19:39:11 +02:00
io.requestor(i).resp.bits.ppn := resp_ppn.toUInt
io.requestor(i).invalidate := io.dpath.invalidate
io.requestor(i).status := io.dpath.status
}
2011-11-09 23:52:17 +01:00
// control state machine
switch (state) {
is (s_ready) {
2012-10-10 06:35:03 +02:00
when (arb.io.out.valid) {
state := s_req
}
2013-08-12 19:39:11 +02:00
count := UInt(0)
2011-11-09 23:52:17 +01:00
}
is (s_req) {
when (io.mem.req.ready) {
state := s_wait
2011-11-09 23:52:17 +01:00
}
}
is (s_wait) {
when (io.mem.resp.bits.nack) {
state := s_req
}
when (io.mem.resp.valid) {
2013-08-24 06:16:28 +02:00
state := s_error
2015-03-14 10:49:07 +01:00
when (pte(0)) {
when (set_dirty_bit) {
state := s_set_dirty
}.elsewhen (!pte(1)) {
2013-08-24 06:16:28 +02:00
state := s_done
}.elsewhen (count < levels-1) {
state := s_req
2013-08-24 06:16:28 +02:00
count := count + 1
}
2011-11-09 23:52:17 +01:00
}
}
}
2015-03-14 10:49:07 +01:00
is (s_set_dirty) {
when (io.mem.req.ready) {
state := s_wait_dirty
}
}
is (s_wait_dirty) {
when (io.mem.resp.bits.nack) {
state := s_set_dirty
}
when (io.mem.resp.valid) {
state := s_req
}
}
2011-11-09 23:52:17 +01:00
is (s_done) {
state := s_ready
2011-11-09 23:52:17 +01:00
}
is (s_error) {
state := s_ready
2011-11-09 23:52:17 +01:00
}
}
}