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

205 lines
6.2 KiB
Scala
Raw Normal View History

2011-11-09 23:52:17 +01:00
package Top
{
import Chisel._;
import Node._;
import Constants._;
import scala.math._;
class ioCAM(entries: Int, addr_bits: Int, tag_bits: Int) extends Bundle {
val clear = Bool(INPUT);
val tag = Bits(tag_bits, INPUT);
val hit = Bool(OUTPUT);
val hit_addr = UFix(addr_bits, OUTPUT);
val valid_bits = Bits(entries, OUTPUT);
2011-11-09 23:52:17 +01:00
val write = Bool(INPUT);
val write_tag = Bits(tag_bits, INPUT);
val write_addr = UFix(addr_bits, INPUT);
2011-11-09 23:52:17 +01:00
}
class rocketCAM(entries: Int, tag_bits: Int) extends Component {
val addr_bits = ceil(log(entries)/log(2)).toInt;
val io = new ioCAM(entries, addr_bits, tag_bits);
val cam_tags = Mem(entries, io.write, io.write_addr, io.write_tag);
2011-11-09 23:52:17 +01:00
val vb_array = Reg(resetVal = Bits(0, entries));
when (io.clear) {
2012-02-12 02:20:33 +01:00
vb_array := Bits(0, entries);
}
2012-02-12 02:20:33 +01:00
.elsewhen (io.write) {
vb_array := vb_array.bitSet(io.write_addr, Bool(true));
}
2012-02-12 02:20:33 +01:00
var l_hit = Bool(false)
val mux = (new Mux1H(entries)) { Bits(width = addr_bits) }
for (i <- 0 to entries-1) {
2012-02-12 02:20:33 +01:00
val my_hit = vb_array(UFix(i)).toBool && (cam_tags(UFix(i)) === io.tag)
l_hit = l_hit || my_hit
mux.io.in(i) := Bits(i)
mux.io.sel(i) := my_hit
}
io.valid_bits := vb_array;
io.hit := l_hit;
2012-02-12 02:20:33 +01:00
io.hit_addr := mux.io.out.toUFix;
2011-11-09 23:52:17 +01:00
}
// interface between TLB and PTW
class ioTLB_PTW extends Bundle
{
// requests
val req_val = Bool(OUTPUT);
val req_rdy = Bool(INPUT);
val req_vpn = Bits(VPN_BITS, OUTPUT);
2011-11-09 23:52:17 +01:00
// responses
val resp_val = Bool(INPUT);
val resp_err = Bool(INPUT);
val resp_ppn = Bits(PPN_BITS, INPUT);
val resp_perm = Bits(PERM_BITS, INPUT);
2011-11-09 23:52:17 +01:00
}
// interface between ITLB and fetch stage of pipeline
class ioITLB_CPU(view: List[String] = null) extends Bundle(view)
2011-11-09 23:52:17 +01:00
{
// status bits (from PCR), to check current permission and whether VM is enabled
val status = Bits(17, INPUT);
2011-11-09 23:52:17 +01:00
// invalidate all TLB entries
val invalidate = Bool(INPUT);
2011-11-09 23:52:17 +01:00
// lookup requests
val req_val = Bool(INPUT);
val req_rdy = Bool(OUTPUT);
val req_asid = Bits(ASID_BITS, INPUT);
val req_vpn = UFix(VPN_BITS+1, INPUT);
2011-11-09 23:52:17 +01:00
// lookup responses
val resp_miss = Bool(OUTPUT);
// val resp_val = Bool(OUTPUT);
val resp_ppn = UFix(PPN_BITS, OUTPUT);
val exception = Bool(OUTPUT);
2011-11-09 23:52:17 +01:00
}
class ioITLB extends Bundle
{
val cpu = new ioITLB_CPU();
val ptw = new ioTLB_PTW();
}
class rocketITLB(entries: Int) extends Component
{
val addr_bits = ceil(log10(entries)/log10(2)).toInt;
val io = new ioITLB();
val s_ready :: s_request :: s_wait :: Nil = Enum(3) { UFix() };
val state = Reg(resetVal = s_ready);
2011-11-12 03:48:34 +01:00
val r_cpu_req_val = Reg(resetVal = Bool(false));
2012-01-02 01:09:40 +01:00
val r_cpu_req_vpn = Reg() { Bits() };
val r_cpu_req_asid = Reg() { Bits() };
val r_refill_tag = Reg() { Bits() };
val r_refill_waddr = Reg() { UFix() };
2011-11-09 23:52:17 +01:00
val repl_count = Reg(resetVal = UFix(0, addr_bits));
2011-11-12 03:48:34 +01:00
when (io.cpu.req_val && io.cpu.req_rdy) {
2012-02-12 02:20:33 +01:00
r_cpu_req_vpn := io.cpu.req_vpn;
r_cpu_req_asid := io.cpu.req_asid;
r_cpu_req_val := Bool(true);
2011-11-12 03:48:34 +01:00
}
2012-02-12 02:20:33 +01:00
.otherwise {
r_cpu_req_val := Bool(false);
2011-11-12 03:48:34 +01:00
}
val bad_va = r_cpu_req_vpn(VPN_BITS) != r_cpu_req_vpn(VPN_BITS-1);
2011-11-12 03:48:34 +01:00
val tag_cam = new rocketCAM(entries, ASID_BITS+VPN_BITS);
2011-11-09 23:52:17 +01:00
val tag_ram = Mem(entries, io.ptw.resp_val, r_refill_waddr.toUFix, io.ptw.resp_ppn);
val lookup_tag = Cat(r_cpu_req_asid, r_cpu_req_vpn);
tag_cam.io.clear := io.cpu.invalidate;
2011-11-09 23:52:17 +01:00
tag_cam.io.tag := lookup_tag;
tag_cam.io.write := io.ptw.resp_val || io.ptw.resp_err;
2011-11-09 23:52:17 +01:00
tag_cam.io.write_tag := r_refill_tag;
tag_cam.io.write_addr := r_refill_waddr;
val tag_hit = tag_cam.io.hit || bad_va;
2011-11-12 03:48:34 +01:00
val tag_hit_addr = tag_cam.io.hit_addr;
2011-11-09 23:52:17 +01:00
// extract fields from status register
2011-11-11 02:41:22 +01:00
val status_s = io.cpu.status(SR_S).toBool; // user/supervisor mode
val status_u = !status_s;
val status_vm = io.cpu.status(SR_VM).toBool // virtual memory enable
2011-11-09 23:52:17 +01:00
// extract fields from PT permission bits
val ptw_perm_ux = io.ptw.resp_perm(0);
val ptw_perm_sx = io.ptw.resp_perm(3);
2011-11-09 23:52:17 +01:00
// permission bit arrays
val ux_array = Reg(resetVal = Bits(0, entries)); // user execute permission
val sx_array = Reg(resetVal = Bits(0, entries)); // supervisor execute permission
when (io.ptw.resp_val) {
2012-02-12 02:20:33 +01:00
ux_array := ux_array.bitSet(r_refill_waddr, ptw_perm_ux);
sx_array := sx_array.bitSet(r_refill_waddr, ptw_perm_sx);
}
// when the page table lookup reports an error, set both execute permission
// bits to 0 so the next access will cause an exceptions
when (io.ptw.resp_err) {
2012-02-12 02:20:33 +01:00
ux_array := ux_array.bitSet(r_refill_waddr, Bool(false));
sx_array := sx_array.bitSet(r_refill_waddr, Bool(false));
2011-11-09 23:52:17 +01:00
}
// high if there are any unused entries in the ITLB
val invalid_entry = (tag_cam.io.valid_bits != ~Bits(0,entries));
2011-11-09 23:52:17 +01:00
val ie_enc = new priorityEncoder(entries);
ie_enc.io.in := ~tag_cam.io.valid_bits.toUFix;
2011-11-09 23:52:17 +01:00
val ie_addr = ie_enc.io.out;
val repl_waddr = Mux(invalid_entry, ie_addr, repl_count).toUFix;
val lookup = (state === s_ready) && r_cpu_req_val;
val lookup_hit = lookup && tag_hit;
val lookup_miss = lookup && !tag_hit;
2011-11-11 02:41:22 +01:00
val tlb_hit = status_vm && lookup_hit;
val tlb_miss = status_vm && lookup_miss;
2011-11-09 23:52:17 +01:00
2011-11-11 02:41:22 +01:00
when (tlb_miss) {
2012-02-12 02:20:33 +01:00
r_refill_tag := lookup_tag;
r_refill_waddr := repl_waddr;
2011-11-09 23:52:17 +01:00
when (!invalid_entry) {
2012-02-12 02:20:33 +01:00
repl_count := repl_count + UFix(1);
2011-11-09 23:52:17 +01:00
}
}
val access_fault =
2011-11-11 02:41:22 +01:00
tlb_hit &&
((status_s && !sx_array(tag_hit_addr).toBool) ||
(status_u && !ux_array(tag_hit_addr).toBool) ||
bad_va);
io.cpu.exception := access_fault;
2011-11-12 09:25:06 +01:00
io.cpu.req_rdy := Mux(status_vm, (state === s_ready) && (!r_cpu_req_val || tag_hit), Bool(true));
io.cpu.resp_miss := tlb_miss || (state != s_ready);
2011-11-12 03:48:34 +01:00
io.cpu.resp_ppn := Mux(status_vm, tag_ram(tag_hit_addr), r_cpu_req_vpn(PPN_BITS-1,0)).toUFix;
2011-11-09 23:52:17 +01:00
io.ptw.req_val := (state === s_request);
io.ptw.req_vpn := r_refill_tag(VPN_BITS-1,0);
2011-11-11 02:41:22 +01:00
2011-11-09 23:52:17 +01:00
// control state machine
switch (state) {
is (s_ready) {
2011-11-11 02:41:22 +01:00
when (tlb_miss) {
2012-02-12 02:20:33 +01:00
state := s_request;
2011-11-09 23:52:17 +01:00
}
}
is (s_request) {
when (io.ptw.req_rdy) {
2012-02-12 02:20:33 +01:00
state := s_wait;
2011-11-09 23:52:17 +01:00
}
}
is (s_wait) {
when (io.ptw.resp_val || io.ptw.resp_err) {
2012-02-12 02:20:33 +01:00
state := s_ready;
2011-11-09 23:52:17 +01:00
}
}
}
}
}