source: trunk/modules/vci_cc_vcache_wrapper_v4/caba/source/src/vci_cc_vcache_wrapper_v4.cpp @ 201

Last change on this file since 201 was 201, checked in by alain, 12 years ago

fixing a malicious bug in ICAHE FSM : bad handling of the
speculative access in IDLE state (thanks to Ghassan)

File size: 185.9 KB
Line 
1/* -*- c++ -*-C
2 * File : vci_cc_vcache_wrapper_v4.cpp
3 * Copyright (c) UPMC, Lip6, SoC
4 * Authors : Alain GREINER, Yang GAO
5 *
6 * SOCLIB_LGPL_HEADER_BEGIN
7 *
8 * This file is part of SoCLib, GNU LGPLv2.1.
9 *
10 * SoCLib is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU Lesser General Public License as published
12 * by the Free Software Foundation; version 2.1 of the License.
13 *
14 * SoCLib is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with SoCLib; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 * 02110-1301 USA
23 *
24 * SOCLIB_LGPL_HEADER_END
25 */
26
27#include <cassert>
28#include "arithmetics.h"
29#include "../include/vci_cc_vcache_wrapper_v4.h"
30
31#define DEBUG_DCACHE            1
32#define DEBUG_ICACHE            1
33#define DEBUG_CLEANUP           0
34#define DEBUG_INVAL_ITLB        1
35#define DEBUG_INVAL_DTLB        1
36
37namespace soclib { 
38namespace caba {
39
40namespace {
41const char *icache_fsm_state_str[] = {
42        "ICACHE_IDLE",
43     
44        "ICACHE_XTN_TLB_FLUSH", 
45        "ICACHE_XTN_CACHE_FLUSH", 
46        "ICACHE_XTN_TLB_INVAL", 
47        "ICACHE_XTN_CACHE_INVAL_VA",
48        "ICACHE_XTN_CACHE_INVAL_PA",
49        "ICACHE_XTN_CACHE_INVAL_GO",
50
51        "ICACHE_TLB_WAIT",
52
53        "ICACHE_MISS_VICTIM",
54        "ICACHE_MISS_INVAL",
55        "ICACHE_MISS_WAIT",
56        "ICACHE_MISS_UPDT", 
57
58        "ICACHE_UNC_WAIT", 
59
60        "ICACHE_CC_CHECK", 
61        "ICACHE_CC_INVAL", 
62        "ICACHE_CC_UPDT", 
63       
64    };
65const char *dcache_fsm_state_str[] = {
66        "DCACHE_IDLE",       
67
68        "DCACHE_TLB_MISS",
69        "DCACHE_TLB_PTE1_GET",
70        "DCACHE_TLB_PTE1_SELECT", 
71        "DCACHE_TLB_PTE1_UPDT", 
72        "DCACHE_TLB_PTE2_GET", 
73        "DCACHE_TLB_PTE2_SELECT",
74        "DCACHE_TLB_PTE2_UPDT",   
75        "DCACHE_TLB_SC_UPDT",
76        "DCACHE_TLB_SC_WAIT",
77        "DCACHE_TLB_RETURN",
78
79        "DCACHE_XTN_SWITCH", 
80        "DCACHE_XTN_SYNC", 
81        "DCACHE_XTN_IC_INVAL_VA",
82        "DCACHE_XTN_IC_FLUSH", 
83        "DCACHE_XTN_IC_INVAL_PA",
84        "DCACHE_XTN_IT_INVAL",
85        "DCACHE_XTN_DC_FLUSH", 
86        "DCACHE_XTN_DC_INVAL_VA",
87        "DCACHE_XTN_DC_INVAL_PA",
88        "DCACHE_XTN_DC_INVAL_WAIT",
89        "DCACHE_XTN_DC_INVAL_GO",
90        "DCACHE_XTN_DT_INVAL",
91
92        "DCACHE_WRITE_TLB_DIRTY",
93        "DCACHE_WRITE_CACHE_DIRTY",
94        "DCACHE_WRITE_SC_WAIT", 
95        "DCACHE_WRITE_UNC_WAIT", 
96
97        "DCACHE_MISS_VICTIM",
98        "DCACHE_MISS_INVAL",
99        "DCACHE_MISS_INVAL_WAIT",
100        "DCACHE_MISS_WAIT", 
101        "DCACHE_MISS_UPDT", 
102
103        "DCACHE_UNC_WAIT",   
104
105        "DCACHE_CC_CHECK",
106        "DCACHE_CC_INVAL",
107        "DCACHE_CC_UPDT",
108        "DCACHE_CC_WAIT",
109    };
110const char *cmd_fsm_state_str[] = {
111        "CMD_IDLE",           
112        "CMD_INS_MISS",     
113        "CMD_INS_UNC",     
114        "CMD_DATA_MISS",   
115        "CMD_DATA_UNC",     
116        "CMD_DATA_WRITE", 
117        "CMD_DATA_SC", 
118    };
119const char *rsp_fsm_state_str[] = {
120        "RSP_IDLE",                 
121        "RSP_INS_MISS",   
122        "RSP_INS_UNC",           
123        "RSP_DATA_MISS",             
124        "RSP_DATA_UNC",             
125        "RSP_DATA_WRITE",     
126    };
127const char *cleanup_fsm_state_str[] = {
128        "CLEANUP_DATA_IDLE",           
129        "CLEANUP_DATA_GO",   
130        "CLEANUP_INS_IDLE",     
131        "CLEANUP_INS_GO",     
132    };
133const char *tgt_fsm_state_str[] = {
134        "TGT_IDLE",
135        "TGT_UPDT_WORD",
136        "TGT_UPDT_DATA",
137        "TGT_REQ_BROADCAST",
138        "TGT_REQ_ICACHE",
139        "TGT_REQ_DCACHE",
140        "TGT_RSP_BROADCAST",
141        "TGT_RSP_ICACHE",
142        "TGT_RSP_DCACHE",
143    }; 
144const char *inval_itlb_fsm_state_str[] = {
145        "INVAL_ITLB_IDLE",       
146        "INVAL_ITLB_SCAN", 
147    };
148const char *inval_dtlb_fsm_state_str[] = {
149        "INVAL_DTLB_IDLE",       
150        "INVAL_DTLB_SCAN", 
151    };
152}
153
154#define tmpl(...)  template<typename vci_param, typename iss_t> __VA_ARGS__ VciCcVCacheWrapperV4<vci_param, iss_t>
155
156using soclib::common::uint32_log2;
157
158/////////////////////////////////
159tmpl(/**/)::VciCcVCacheWrapperV4(
160    sc_module_name                      name,
161    int                                 proc_id,
162    const soclib::common::MappingTable  &mtp,
163    const soclib::common::MappingTable  &mtc,
164    const soclib::common::IntTab        &initiator_index_d,
165    const soclib::common::IntTab        &initiator_index_c,
166    const soclib::common::IntTab        &target_index_d,
167    size_t                              itlb_ways,
168    size_t                              itlb_sets,
169    size_t                              dtlb_ways,
170    size_t                              dtlb_sets,
171    size_t                              icache_ways,
172    size_t                              icache_sets,
173    size_t                              icache_words,
174    size_t                              dcache_ways,
175    size_t                              dcache_sets,
176    size_t                              dcache_words,
177    size_t                              wbuf_nlines, 
178    size_t                              wbuf_nwords, 
179    uint32_t                            max_frozen_cycles,
180    uint32_t                            debug_start_cycle,
181    bool                                debug_ok)
182    : soclib::caba::BaseModule(name),
183
184      p_clk("clk"),
185      p_resetn("resetn"),
186      p_vci_ini_d("vci_ini_d"),
187      p_vci_ini_c("vci_ini_c"),
188      p_vci_tgt_c("vci_tgt_d"),
189
190      m_cacheability_table(mtp.getCacheabilityTable()),
191      m_segment(mtc.getSegment(target_index_d)),
192      m_srcid_d(mtp.indexForId(initiator_index_d)),
193      m_srcid_c(mtp.indexForId(initiator_index_c)),
194
195      m_itlb_ways(itlb_ways),
196      m_itlb_sets(itlb_sets),
197
198      m_dtlb_ways(dtlb_ways),
199      m_dtlb_sets(dtlb_sets),
200
201      m_icache_ways(icache_ways),
202      m_icache_sets(icache_sets),
203      m_icache_yzmask((~0)<<(uint32_log2(icache_words) + 2)),
204      m_icache_words(icache_words),
205
206      m_dcache_ways(dcache_ways),
207      m_dcache_sets(dcache_sets),
208      m_dcache_yzmask((~0)<<(uint32_log2(dcache_words) + 2)),
209      m_dcache_words(dcache_words),
210
211      m_proc_id(proc_id),
212
213      m_max_frozen_cycles(max_frozen_cycles),
214
215      m_paddr_nbits(vci_param::N),
216
217      m_debug_start_cycle(debug_start_cycle),
218      m_debug_ok(debug_ok),
219
220      r_mmu_ptpr("r_mmu_ptpr"),
221      r_mmu_mode("r_mmu_mode"),
222      r_mmu_word_lo("r_mmu_word_lo"),
223      r_mmu_word_hi("r_mmu_word_hi"),
224      r_mmu_ibvar("r_mmu_ibvar"),
225      r_mmu_dbvar("r_mmu_dbvar"),
226      r_mmu_ietr("r_mmu_ietr"),
227      r_mmu_detr("r_mmu_detr"),
228
229      r_icache_fsm("r_icache_fsm"),
230      r_icache_fsm_save("r_icache_fsm_save"),
231      r_icache_vci_paddr("r_icache_vci_paddr"),
232      r_icache_vaddr_save("r_icache_vaddr_save"),
233
234      r_icache_miss_way("r_icache_miss_way"),
235      r_icache_miss_set("r_icache_miss_set"),
236      r_icache_miss_word("r_icache_miss_word"),
237      r_icache_miss_inval("r_icache_miss_inval"),
238
239      r_icache_cc_way("r_icache_cc_way"),
240      r_icache_cc_set("r_icache_cc_set"),
241      r_icache_cc_word("r_icache_cc_word"),
242
243      r_icache_flush_count("r_icache_flush_count"),
244
245      r_icache_miss_req("r_icache_miss_req"),
246      r_icache_unc_req("r_icache_unc_req"),
247
248      r_icache_tlb_miss_req("r_icache_tlb_read_req"),
249      r_icache_tlb_rsp_error("r_icache_tlb_rsp_error"),
250
251      r_icache_cleanup_req("r_icache_cleanup_req"),
252      r_icache_cleanup_line("r_icache_cleanup_line"),
253
254      r_dcache_fsm("r_dcache_fsm"),
255      r_dcache_fsm_save("r_dcache_fsm_save"),
256
257      r_dcache_p0_valid("r_dcache_p0_valid"),
258      r_dcache_p0_vaddr("r_dcache_p0_vaddr"),
259      r_dcache_p0_wdata("r_dcache_p0_wdata"),
260      r_dcache_p0_be("r_dcache_p0_be"),
261      r_dcache_p0_paddr("r_dcache_p0_paddr"),
262      r_dcache_p0_cacheable("r_dcache_p0_cacheable"), 
263      r_dcache_p0_tlb_way("r_dcache_p0_tlb_way"),
264      r_dcache_p0_tlb_set("r_dcache_p0_tlb_set"),
265      r_dcache_p0_tlb_nline("r_dcache_p0_tlb_nline"),
266      r_dcache_p0_tlb_dirty("r_dcache_p0_tlb_dirty"),
267      r_dcache_p0_tlb_big("r_dcache_p0_tlb_big"),
268
269      r_dcache_p1_valid("r_dcache_p1_valid"),
270      r_dcache_p1_updt_cache("r_dcache_p1_updt_cache"),
271      r_dcache_p1_set_dirty("r_dcache_p1_set_dirty"),
272      r_dcache_p1_vaddr("r_dcache_p1_vaddr"),
273      r_dcache_p1_wdata("r_dcache_p1_wdata"),
274      r_dcache_p1_be("r_dcache_p1_be"),
275      r_dcache_p1_paddr("r_dcache_p1_paddr"),
276      r_dcache_p1_cache_way("r_dcache_p1_cache_way"),
277      r_dcache_p1_cache_set("r_dcache_p1_cache_set"),
278      r_dcache_p1_cache_word("r_dcache_p1_word_save"),
279      r_dcache_p1_tlb_way("r_dcache_p1_tlb_way"),
280      r_dcache_p1_tlb_set("r_dcache_p1_tlb_set"),
281      r_dcache_p1_tlb_nline("r_dcache_p1_tlb_nline"),
282
283      r_dcache_p2_vaddr("r_dcache_p2_vaddr"),
284      r_dcache_p2_tlb_way("r_dcache_p2_tlb_way"),
285      r_dcache_p2_tlb_set("r_dcache_p2_tlb_set"),
286      r_dcache_p2_set_dirty("r_dcache_p2_set_dirty"),
287      r_dcache_p2_pte_paddr("r_dcache_p2_pte_paddr"),
288      r_dcache_p2_pte_way("r_dcache_p2_pte_way"),
289      r_dcache_p2_pte_set("r_dcache_p2_pte_set"),
290      r_dcache_p2_pte_word("r_dcache_p2_pte_word"),
291      r_dcache_p2_pte_flags("r_dcache_p2_pte_flags"),
292
293      r_dcache_vci_paddr("r_dcache_vci_paddr"),
294      r_dcache_vci_miss_req("r_dcache_vci_miss_req"),
295      r_dcache_vci_unc_req("r_dcache_vci_unc_req"),
296      r_dcache_vci_unc_be("r_dcache_vci_unc_be"),
297      r_dcache_vci_sc_req("r_dcache_vci_sc_req"),
298      r_dcache_vci_sc_old("r_dcache_vci_sc_old"),
299      r_dcache_vci_sc_new("r_dcache_vci_sc_new"),
300
301      r_dcache_xtn_way("r_dcache_xtn_way"),
302      r_dcache_xtn_set("r_dcache_xtn_set"),
303
304      r_dcache_pending_unc_write("r_dcache_pending_unc_write"),
305
306      r_dcache_miss_type("r_dcache_miss_type"),
307      r_dcache_miss_word("r_dcache_miss_word"),
308      r_dcache_miss_way("r_dcache_miss_way"),
309      r_dcache_miss_set("r_dcache_miss_set"),
310      r_dcache_miss_inval("r_dcache_miss_inval"),
311
312      r_dcache_cc_way("r_dcache_cc_way"),
313      r_dcache_cc_set("r_dcache_cc_set"),
314      r_dcache_cc_word("r_dcache_cc_word"),
315
316      r_dcache_flush_count("r_dcache_flush_count"),
317
318      r_dcache_tlb_vaddr("r_dcache_tlb_vaddr"),
319      r_dcache_tlb_ins("r_dcache_tlb_ins"),
320      r_dcache_tlb_pte_flags("r_dcache_tlb_pte_flags"),
321      r_dcache_tlb_pte_ppn("r_dcache_tlb_pte_ppn"),
322      r_dcache_tlb_cache_way("r_dcache_tlb_cache_way"),
323      r_dcache_tlb_cache_set("r_dcache_tlb_cache_set"),
324      r_dcache_tlb_cache_word("r_dcache_tlb_cache_word"),
325      r_dcache_tlb_way("r_dcache_tlb_way"),
326      r_dcache_tlb_set("r_dcache_tlb_set"),
327
328      r_dcache_ll_valid("r_dcache_ll_valid"),
329      r_dcache_ll_data("r_dcache_ll_data"),
330      r_dcache_ll_vaddr("r_dcache_ll_vaddr"),
331
332      r_dcache_itlb_inval_req("r_dcache_itlb_inval_req"),
333      r_dcache_dtlb_inval_req("r_dcache_dtlb_inval_req"),
334      r_dcache_tlb_inval_line("r_dcache_tlb_inval_line"),
335
336      r_dcache_xtn_req("r_dcache_xtn_req"),
337      r_dcache_xtn_opcode("r_dcache_xtn_opcode"),
338
339      r_dcache_cleanup_req("r_dcache_cleanup_req"),
340      r_dcache_cleanup_line("r_dcache_cleanup_line"),
341
342      r_vci_cmd_fsm("r_vci_cmd_fsm"),
343      r_vci_cmd_min("r_vci_cmd_min"),
344      r_vci_cmd_max("r_vci_cmd_max"),
345      r_vci_cmd_cpt("r_vci_cmd_cpt"),
346      r_vci_cmd_imiss_prio("r_vci_cmd_imiss_prio"),
347
348      r_vci_rsp_fsm("r_vci_rsp_fsm"),
349      r_vci_rsp_cpt("r_vci_rsp_cpt"),
350      r_vci_rsp_ins_error("r_vci_rsp_ins_error"),
351      r_vci_rsp_data_error("r_vci_rsp_data_error"),
352      r_vci_rsp_fifo_icache("r_vci_rsp_fifo_icache", 2),        // 2 words depth
353      r_vci_rsp_fifo_dcache("r_vci_rsp_fifo_dcache", 2),        // 2 words depth
354
355      r_cleanup_fsm("r_cleanup_fsm"),
356      r_cleanup_trdid("r_cleanup_trdid"),
357      r_cleanup_buffer(4),                      // up to 4 simultaneous cleanups
358
359      r_tgt_fsm("r_tgt_fsm"),
360      r_tgt_paddr("r_tgt_paddr"),
361      r_tgt_word_count("r_tgt_word_count"),
362      r_tgt_word_min("r_tgt_word_min"),
363      r_tgt_word_max("r_tgt_word_max"),
364      r_tgt_update("r_tgt_update"),
365      r_tgt_update_data("r_tgt_update_data"),
366      r_tgt_srcid("r_tgt_srcid"),
367      r_tgt_pktid("r_tgt_pktid"),
368      r_tgt_trdid("r_tgt_trdid"),
369
370      r_tgt_icache_req("r_tgt_icache_req"),
371      r_tgt_dcache_req("r_tgt_dcache_req"),
372      r_tgt_icache_rsp("r_tgt_icache_rsp"),
373      r_tgt_dcache_rsp("r_tgt_dcache_rsp"),
374
375      r_inval_itlb_fsm("r_inval_itlb_fsm"),         
376      r_inval_itlb_count("r_inval_itlb_count"),         
377
378      r_inval_dtlb_fsm("r_inval_dtlb_fsm"),         
379      r_inval_dtlb_count("r_inval_dtlb_count"),         
380
381      r_iss(this->name(), proc_id),
382      r_wbuf("wbuf", wbuf_nwords, wbuf_nlines, dcache_words ),
383      r_icache("icache", icache_ways, icache_sets, icache_words),
384      r_dcache("dcache", dcache_ways, dcache_sets, dcache_words),
385      r_itlb(itlb_ways,itlb_sets,vci_param::N),
386      r_dtlb(dtlb_ways,dtlb_sets,vci_param::N)
387{
388    assert( ((icache_words*vci_param::B) < (1<<vci_param::K)) and
389             "Need more PLEN bits.");
390
391    assert( (vci_param::T > 2) and ((1<<(vci_param::T-1)) >= (wbuf_nlines)) and
392             "Need more TRDID bits.");
393
394    assert( (icache_words == dcache_words) and
395             "icache_words and dcache_words parameters must be equal");
396
397    r_mmu_params = (uint32_log2(m_dtlb_ways)   << 29)   | (uint32_log2(m_dtlb_sets)   << 25) |
398                   (uint32_log2(m_dcache_ways) << 22)   | (uint32_log2(m_dcache_sets) << 18) |
399                   (uint32_log2(m_itlb_ways)   << 15)   | (uint32_log2(m_itlb_sets)   << 11) |
400                   (uint32_log2(m_icache_ways) << 8)    | (uint32_log2(m_icache_sets) << 4)  |
401                   (uint32_log2(m_icache_words<<2));
402
403    r_mmu_release = (uint32_t)(1 << 16) | 0x1;
404
405    r_tgt_buf         = new uint32_t[dcache_words];
406    r_tgt_be          = new vci_be_t[dcache_words];
407    r_dcache_in_itlb  = new bool[dcache_ways*dcache_sets];           
408    r_dcache_in_dtlb  = new bool[dcache_ways*dcache_sets];         
409
410    SC_METHOD(transition);
411    dont_initialize();
412    sensitive << p_clk.pos();
413 
414    SC_METHOD(genMoore);
415    dont_initialize();
416    sensitive << p_clk.neg();
417
418    typename iss_t::CacheInfo cache_info;
419    cache_info.has_mmu = true;
420    cache_info.icache_line_size = icache_words*sizeof(uint32_t);
421    cache_info.icache_assoc = icache_ways;
422    cache_info.icache_n_lines = icache_sets;
423    cache_info.dcache_line_size = dcache_words*sizeof(uint32_t);
424    cache_info.dcache_assoc = dcache_ways;
425    cache_info.dcache_n_lines = dcache_sets;
426    r_iss.setCacheInfo(cache_info);
427}
428
429/////////////////////////////////////
430tmpl(/**/)::~VciCcVCacheWrapperV4()
431/////////////////////////////////////
432{
433    delete [] r_tgt_be;
434    delete [] r_tgt_buf;
435    delete [] r_dcache_in_itlb;           
436    delete [] r_dcache_in_dtlb;         
437}
438
439////////////////////////
440tmpl(void)::print_cpi()
441////////////////////////
442{
443    std::cout << name() << " CPI = " 
444        << (float)m_cpt_total_cycles/(m_cpt_total_cycles - m_cpt_frz_cycles) << std::endl ;
445}
446
447////////////////////////////////////
448tmpl(void)::print_trace(size_t mode)
449////////////////////////////////////
450{
451    // b0 : write buffer print trace
452    // b1 : write buffer verbose
453    // b2 : dcache print trace
454    // b3 : icache print trace
455
456    typename iss_t::InstructionRequest  ireq;
457    typename iss_t::InstructionResponse irsp;
458    typename iss_t::DataRequest         dreq;
459    typename iss_t::DataResponse        drsp;
460
461    ireq.valid       = m_ireq_valid;
462    ireq.addr        = m_ireq_addr;
463    ireq.mode        = m_ireq_mode;
464
465    irsp.valid       = m_irsp_valid;
466    irsp.instruction = m_irsp_instruction;
467    irsp.error       = m_irsp_error;
468
469    dreq.valid       = m_dreq_valid;
470    dreq.addr        = m_dreq_addr;
471    dreq.mode        = m_dreq_mode;
472    dreq.type        = m_dreq_type;
473    dreq.wdata       = m_dreq_wdata;
474    dreq.be          = m_dreq_be;
475
476    drsp.valid       = m_drsp_valid;
477    drsp.rdata       = m_drsp_rdata;
478    drsp.error       = m_drsp_error;
479
480    std::cout << std::dec << "PROC " << name() << std::endl;
481
482    std::cout << "  " << ireq << std::endl;
483    std::cout << "  " << irsp << std::endl;
484    std::cout << "  " << dreq << std::endl;
485    std::cout << "  " << drsp << std::endl;
486
487    std::cout << "  " << icache_fsm_state_str[r_icache_fsm.read()]
488              << " | " << dcache_fsm_state_str[r_dcache_fsm.read()]
489              << " | " << cmd_fsm_state_str[r_vci_cmd_fsm.read()]
490              << " | " << rsp_fsm_state_str[r_vci_rsp_fsm.read()]
491              << " | " << tgt_fsm_state_str[r_tgt_fsm.read()] << std::endl;
492    std::cout << "  " << cleanup_fsm_state_str[r_cleanup_fsm.read()]
493              << " | " << inval_itlb_fsm_state_str[r_inval_itlb_fsm] 
494              << " | " << inval_dtlb_fsm_state_str[r_inval_dtlb_fsm];
495    if (r_dcache_p0_valid.read() ) std::cout << " | P1_WRITE";
496    if (r_dcache_p1_valid.read() ) std::cout << " | P2_WRITE";
497    std::cout << std::endl;
498
499    if(mode & 0x1)
500    {
501        r_wbuf.printTrace((mode>>1)&1);
502    }
503    if(mode & 0x4)
504    {
505        std::cout << "  Data cache" << std::endl;
506        r_dcache.printTrace();
507    }
508    if(mode & 0x8)
509    {
510        std::cout << "  Instruction cache" << std::endl;
511        r_icache.printTrace();
512    }
513}
514
515//////////////////////////////////////////
516tmpl(void)::cache_monitor( paddr_t addr )
517//////////////////////////////////////////
518{ 
519    size_t      cache_way;
520    size_t      cache_set;
521    size_t      cache_word;
522    uint32_t    cache_rdata;
523    bool        cache_hit = r_dcache.read( addr,
524                                           &cache_rdata,
525                                           &cache_way,
526                                           &cache_set,
527                                           &cache_word );
528    if ( cache_hit != m_debug_previous_hit )
529    {
530        std::cout << "PROC " << name() 
531                  << " cache change at cycle " << std::dec << m_cpt_total_cycles
532                  << " for adresse " << std::hex << addr
533                  << " / HIT = " << cache_hit << std::endl;
534    }
535    m_debug_previous_hit = cache_hit;
536}
537
538
539
540/*
541////////////////////////
542tmpl(void)::print_stats()
543////////////////////////
544{
545    float run_cycles = (float)(m_cpt_total_cycles - m_cpt_frz_cycles);
546    std::cout << name() << std::endl
547        << "- CPI                    = " << (float)m_cpt_total_cycles/run_cycles << std::endl
548        << "- READ RATE              = " << (float)m_cpt_read/run_cycles << std::endl
549        << "- WRITE RATE             = " << (float)m_cpt_write/run_cycles << std::endl
550        << "- IMISS_RATE             = " << (float)m_cpt_ins_miss/m_cpt_ins_read << std::endl
551        << "- DMISS RATE             = " << (float)m_cpt_data_miss/(m_cpt_read-m_cpt_unc_read) << std::endl 
552        << "- INS MISS COST          = " << (float)m_cost_ins_miss_frz/m_cpt_ins_miss << std::endl     
553        << "- DATA MISS COST         = " << (float)m_cost_data_miss_frz/m_cpt_data_miss << std::endl
554        << "- WRITE COST             = " << (float)m_cost_write_frz/m_cpt_write << std::endl       
555        << "- UNC COST               = " << (float)m_cost_unc_read_frz/m_cpt_unc_read << std::endl
556        << "- UNCACHED READ RATE     = " << (float)m_cpt_unc_read/m_cpt_read << std::endl
557        << "- CACHED WRITE RATE      = " << (float)m_cpt_write_cached/m_cpt_write << std::endl
558        << "- INS TLB MISS RATE      = " << (float)m_cpt_ins_tlb_miss/m_cpt_ins_tlb_read << std::endl
559        << "- DATA TLB MISS RATE     = " << (float)m_cpt_data_tlb_miss/m_cpt_data_tlb_read << std::endl
560        << "- ITLB MISS COST         = " << (float)m_cost_ins_tlb_miss_frz/m_cpt_ins_tlb_miss << std::endl
561        << "- DTLB MISS COST         = " << (float)m_cost_data_tlb_miss_frz/m_cpt_data_tlb_miss << std::endl   
562        << "- ITLB UPDATE ACC COST   = " << (float)m_cost_ins_tlb_update_acc_frz/m_cpt_ins_tlb_update_acc << std::endl
563        << "- DTLB UPDATE ACC COST   = " << (float)m_cost_data_tlb_update_acc_frz/m_cpt_data_tlb_update_acc << std::endl
564        << "- DTLB UPDATE DIRTY COST = " << (float)m_cost_data_tlb_update_dirty_frz/m_cpt_data_tlb_update_dirty << std::endl
565        << "- ITLB HIT IN DCACHE RATE= " << (float)m_cpt_ins_tlb_hit_dcache/m_cpt_ins_tlb_miss << std::endl
566        << "- DTLB HIT IN DCACHE RATE= " << (float)m_cpt_data_tlb_hit_dcache/m_cpt_data_tlb_miss << std::endl
567        << "- DCACHE FROZEN BY ITLB  = " << (float)m_cost_ins_tlb_occup_cache_frz/m_cpt_dcache_frz_cycles << std::endl
568        << "- DCACHE FOR TLB %       = " << (float)m_cpt_tlb_occup_dcache/(m_dcache_ways*m_dcache_sets) << std::endl
569        << "- NB CC BROADCAST        = " << m_cpt_cc_broadcast << std::endl
570        << "- NB CC UPDATE DATA      = " << m_cpt_cc_update_data << std::endl
571        << "- NB CC INVAL DATA       = " << m_cpt_cc_inval_data << std::endl
572        << "- NB CC INVAL INS        = " << m_cpt_cc_inval_ins << std::endl
573        << "- CC BROADCAST COST      = " << (float)m_cost_broadcast_frz/m_cpt_cc_broadcast << std::endl
574        << "- CC UPDATE DATA COST    = " << (float)m_cost_updt_data_frz/m_cpt_cc_update_data << std::endl
575        << "- CC INVAL DATA COST     = " << (float)m_cost_inval_data_frz/m_cpt_cc_inval_data << std::endl
576        << "- CC INVAL INS COST      = " << (float)m_cost_inval_ins_frz/m_cpt_cc_inval_ins << std::endl
577        << "- NB CC CLEANUP DATA     = " << m_cpt_cc_cleanup_data << std::endl
578        << "- NB CC CLEANUP INS      = " << m_cpt_cc_cleanup_ins << std::endl
579        << "- IMISS TRANSACTION      = " << (float)m_cost_imiss_transaction/m_cpt_imiss_transaction << std::endl
580        << "- DMISS TRANSACTION      = " << (float)m_cost_dmiss_transaction/m_cpt_dmiss_transaction << std::endl
581        << "- UNC TRANSACTION        = " << (float)m_cost_unc_transaction/m_cpt_unc_transaction << std::endl
582        << "- WRITE TRANSACTION      = " << (float)m_cost_write_transaction/m_cpt_write_transaction << std::endl
583        << "- WRITE LENGTH           = " << (float)m_length_write_transaction/m_cpt_write_transaction << std::endl
584        << "- ITLB MISS TRANSACTION  = " << (float)m_cost_itlbmiss_transaction/m_cpt_itlbmiss_transaction << std::endl
585        << "- DTLB MISS TRANSACTION  = " << (float)m_cost_dtlbmiss_transaction/m_cpt_dtlbmiss_transaction << std::endl;
586}
587
588////////////////////////
589tmpl(void)::clear_stats()
590////////////////////////
591{
592    m_cpt_dcache_data_read  = 0;
593    m_cpt_dcache_data_write = 0;
594    m_cpt_dcache_dir_read   = 0;
595    m_cpt_dcache_dir_write  = 0;
596    m_cpt_icache_data_read  = 0;
597    m_cpt_icache_data_write = 0;
598    m_cpt_icache_dir_read   = 0;
599    m_cpt_icache_dir_write  = 0;
600   
601    m_cpt_frz_cycles        = 0;
602    m_cpt_dcache_frz_cycles = 0;
603    m_cpt_total_cycles      = 0;
604   
605    m_cpt_read         = 0;
606    m_cpt_write        = 0;
607    m_cpt_data_miss    = 0;
608    m_cpt_ins_miss     = 0;
609    m_cpt_unc_read     = 0;
610    m_cpt_write_cached = 0;
611    m_cpt_ins_read     = 0;
612   
613    m_cost_write_frz     = 0;
614    m_cost_data_miss_frz = 0;
615    m_cost_unc_read_frz  = 0;
616    m_cost_ins_miss_frz  = 0;
617   
618    m_cpt_imiss_transaction      = 0;
619    m_cpt_dmiss_transaction      = 0;
620    m_cpt_unc_transaction        = 0;
621    m_cpt_write_transaction      = 0;
622    m_cpt_icache_unc_transaction = 0;   
623   
624    m_cost_imiss_transaction      = 0;
625    m_cost_dmiss_transaction      = 0;
626    m_cost_unc_transaction        = 0;
627    m_cost_write_transaction      = 0;
628    m_cost_icache_unc_transaction = 0;
629    m_length_write_transaction    = 0;
630   
631    m_cpt_ins_tlb_read       = 0;             
632    m_cpt_ins_tlb_miss       = 0;             
633    m_cpt_ins_tlb_update_acc = 0;         
634   
635    m_cpt_data_tlb_read         = 0;           
636    m_cpt_data_tlb_miss         = 0;           
637    m_cpt_data_tlb_update_acc   = 0;       
638    m_cpt_data_tlb_update_dirty = 0;   
639    m_cpt_ins_tlb_hit_dcache    = 0;
640    m_cpt_data_tlb_hit_dcache   = 0;
641    m_cpt_ins_tlb_occup_cache   = 0;
642    m_cpt_data_tlb_occup_cache  = 0;
643   
644    m_cost_ins_tlb_miss_frz          = 0;     
645    m_cost_data_tlb_miss_frz         = 0;     
646    m_cost_ins_tlb_update_acc_frz    = 0;
647    m_cost_data_tlb_update_acc_frz   = 0;
648    m_cost_data_tlb_update_dirty_frz = 0;
649    m_cost_ins_tlb_occup_cache_frz   = 0;
650    m_cost_data_tlb_occup_cache_frz  = 0;
651   
652    m_cpt_itlbmiss_transaction      = 0;   
653    m_cpt_itlb_ll_transaction       = 0; 
654    m_cpt_itlb_sc_transaction       = 0; 
655    m_cpt_dtlbmiss_transaction      = 0; 
656    m_cpt_dtlb_ll_transaction       = 0; 
657    m_cpt_dtlb_sc_transaction       = 0; 
658    m_cpt_dtlb_ll_dirty_transaction = 0; 
659    m_cpt_dtlb_sc_dirty_transaction = 0; 
660   
661    m_cost_itlbmiss_transaction      = 0;   
662    m_cost_itlb_ll_transaction       = 0; 
663    m_cost_itlb_sc_transaction       = 0; 
664    m_cost_dtlbmiss_transaction      = 0;   
665    m_cost_dtlb_ll_transaction       = 0;   
666    m_cost_dtlb_sc_transaction       = 0;   
667    m_cost_dtlb_ll_dirty_transaction = 0;   
668    m_cost_dtlb_sc_dirty_transaction = 0;
669
670    m_cpt_cc_update_data = 0;
671    m_cpt_cc_inval_ins   = 0;
672    m_cpt_cc_inval_data  = 0;
673    m_cpt_cc_broadcast   = 0;
674
675    m_cost_updt_data_frz  = 0;
676    m_cost_inval_ins_frz  = 0;
677    m_cost_inval_data_frz = 0;
678    m_cost_broadcast_frz  = 0;
679
680    m_cpt_cc_cleanup_data = 0;
681    m_cpt_cc_cleanup_ins  = 0;
682}
683
684*/
685
686/////////////////////////
687tmpl(void)::transition()
688/////////////////////////
689{
690    if ( not p_resetn.read() ) 
691    {
692        r_iss.reset();
693        r_wbuf.reset();
694        r_icache.reset();
695        r_dcache.reset();
696        r_itlb.reset();   
697        r_dtlb.reset();   
698
699        r_dcache_fsm      = DCACHE_IDLE;
700        r_icache_fsm      = ICACHE_IDLE;
701        r_vci_cmd_fsm     = CMD_IDLE;
702        r_vci_rsp_fsm     = RSP_IDLE;
703        r_tgt_fsm         = TGT_IDLE;
704        r_inval_itlb_fsm  = INVAL_ITLB_IDLE;         
705        r_inval_dtlb_fsm  = INVAL_DTLB_IDLE;         
706        r_cleanup_fsm     = CLEANUP_DATA_IDLE;
707
708        std::memset(r_dcache_in_itlb, 0, sizeof(*r_dcache_in_itlb)*m_icache_ways*m_icache_sets);
709        std::memset(r_dcache_in_dtlb, 0, sizeof(*r_dcache_in_dtlb)*m_dcache_ways*m_dcache_sets);
710
711       
712        // Response FIFOs and cleanup buffer
713        r_vci_rsp_fifo_icache.init();
714        r_vci_rsp_fifo_dcache.init();
715        r_cleanup_buffer.reset();
716
717        // ICACHE & DCACHE activated
718        r_mmu_mode = 0x3;
719
720        // No request from ICACHE FSM to CMD FSM
721        r_icache_miss_req          = false;
722        r_icache_unc_req           = false;
723
724        // No request from ICACHE_FSM to DCACHE FSM
725        r_icache_tlb_miss_req      = false;     
726 
727        // No request from ICACHE_FSM to CLEANUP FSMs
728        r_icache_cleanup_req       = false;     
729       
730        // No pending write in pipeline
731        r_dcache_p0_valid          = false;
732        r_dcache_p1_valid          = false;
733
734        // No request from DCACHE_FSM to CMD_FSM
735        r_dcache_vci_miss_req      = false;
736        r_dcache_vci_unc_req       = false;
737        r_dcache_vci_sc_req        = false;
738
739        // No uncacheable write pending
740        r_dcache_pending_unc_write = false;
741
742        // No LL reservation
743        r_dcache_ll_valid          = false;
744
745        // No request from DCACHE FSM to INVAL TLB FSMs
746        r_dcache_itlb_inval_req    = false;
747        r_dcache_dtlb_inval_req    = false;
748
749        // No processor XTN request pending
750        r_dcache_xtn_req           = false;
751
752        // No request from DCACHE FSM to CLEANUP FSMs
753        r_dcache_cleanup_req      = false;
754
755        // No request from TGT FSM to ICACHE/DCACHE FSMs
756        r_tgt_icache_req          = false;
757        r_tgt_dcache_req          = false;
758
759        // No signalisation of a coherence request matching a pending miss
760        r_icache_miss_inval       = false;
761        r_dcache_miss_inval       = false;
762
763        // No signalisation  of errors
764        r_vci_rsp_ins_error       = false;
765        r_vci_rsp_data_error      = false;
766
767        // Debug variables
768        m_debug_previous_hit      = false;
769        m_debug_dcache_fsm        = false;
770        m_debug_icache_fsm        = false;
771        m_debug_cleanup_fsm       = false;
772        m_debug_inval_itlb_fsm    = false;
773        m_debug_inval_dtlb_fsm    = false;
774
775/*
776        // activity counters
777        m_cpt_dcache_data_read  = 0;
778        m_cpt_dcache_data_write = 0;
779        m_cpt_dcache_dir_read   = 0;
780        m_cpt_dcache_dir_write  = 0;
781        m_cpt_icache_data_read  = 0;
782        m_cpt_icache_data_write = 0;
783        m_cpt_icache_dir_read   = 0;
784        m_cpt_icache_dir_write  = 0;
785
786        m_cpt_frz_cycles        = 0;
787        m_cpt_dcache_frz_cycles = 0;
788        m_cpt_total_cycles      = 0;
789
790        m_cpt_read              = 0;
791        m_cpt_write             = 0;
792        m_cpt_data_miss         = 0;
793        m_cpt_ins_miss          = 0;
794        m_cpt_unc_read          = 0;
795        m_cpt_write_cached      = 0;
796        m_cpt_ins_read          = 0;
797
798        m_cost_write_frz        = 0;
799        m_cost_data_miss_frz    = 0;
800        m_cost_unc_read_frz     = 0;
801        m_cost_ins_miss_frz     = 0;
802
803        m_cpt_imiss_transaction = 0;
804        m_cpt_dmiss_transaction = 0;
805        m_cpt_unc_transaction   = 0;
806        m_cpt_write_transaction = 0;
807        m_cpt_icache_unc_transaction = 0;       
808
809        m_cost_imiss_transaction      = 0;
810        m_cost_dmiss_transaction      = 0;
811        m_cost_unc_transaction        = 0;
812        m_cost_write_transaction      = 0;
813        m_cost_icache_unc_transaction = 0;
814        m_length_write_transaction    = 0;
815
816        m_cpt_ins_tlb_read       = 0;             
817        m_cpt_ins_tlb_miss       = 0;             
818        m_cpt_ins_tlb_update_acc = 0;         
819
820        m_cpt_data_tlb_read         = 0;           
821        m_cpt_data_tlb_miss         = 0;           
822        m_cpt_data_tlb_update_acc   = 0;       
823        m_cpt_data_tlb_update_dirty = 0;   
824        m_cpt_ins_tlb_hit_dcache    = 0;
825        m_cpt_data_tlb_hit_dcache   = 0;
826        m_cpt_ins_tlb_occup_cache   = 0;
827        m_cpt_data_tlb_occup_cache  = 0;
828
829        m_cost_ins_tlb_miss_frz          = 0;     
830        m_cost_data_tlb_miss_frz         = 0;     
831        m_cost_ins_tlb_update_acc_frz    = 0;
832        m_cost_data_tlb_update_acc_frz   = 0;
833        m_cost_data_tlb_update_dirty_frz = 0;
834        m_cost_ins_tlb_occup_cache_frz   = 0;
835        m_cost_data_tlb_occup_cache_frz  = 0;
836
837        m_cpt_ins_tlb_inval       = 0;           
838        m_cpt_data_tlb_inval      = 0;         
839        m_cost_ins_tlb_inval_frz  = 0;     
840        m_cost_data_tlb_inval_frz = 0;         
841
842        m_cpt_cc_update_data = 0;
843        m_cpt_cc_inval_ins   = 0;
844        m_cpt_cc_inval_data  = 0;
845        m_cpt_cc_broadcast   = 0;
846
847        m_cost_updt_data_frz  = 0;
848        m_cost_inval_ins_frz  = 0;
849        m_cost_inval_data_frz = 0;
850        m_cost_broadcast_frz  = 0;
851
852        m_cpt_cc_cleanup_data = 0;
853        m_cpt_cc_cleanup_ins  = 0;
854
855        m_cpt_itlbmiss_transaction      = 0;   
856        m_cpt_itlb_ll_transaction       = 0; 
857        m_cpt_itlb_sc_transaction       = 0; 
858        m_cpt_dtlbmiss_transaction      = 0; 
859        m_cpt_dtlb_ll_transaction       = 0; 
860        m_cpt_dtlb_sc_transaction       = 0; 
861        m_cpt_dtlb_ll_dirty_transaction = 0; 
862        m_cpt_dtlb_sc_dirty_transaction = 0; 
863 
864        m_cost_itlbmiss_transaction      = 0;   
865        m_cost_itlb_ll_transaction       = 0; 
866        m_cost_itlb_sc_transaction       = 0; 
867        m_cost_dtlbmiss_transaction      = 0;   
868        m_cost_dtlb_ll_transaction       = 0;   
869        m_cost_dtlb_sc_transaction       = 0;   
870        m_cost_dtlb_ll_dirty_transaction = 0;   
871        m_cost_dtlb_sc_dirty_transaction = 0;   
872
873        for (uint32_t i=0; i<32 ; ++i) m_cpt_fsm_icache      [i]   = 0;
874        for (uint32_t i=0; i<32 ; ++i) m_cpt_fsm_dcache      [i]   = 0;
875        for (uint32_t i=0; i<32 ; ++i) m_cpt_fsm_cmd         [i]   = 0;
876        for (uint32_t i=0; i<32 ; ++i) m_cpt_fsm_rsp         [i]   = 0;
877        for (uint32_t i=0; i<32 ; ++i) m_cpt_fsm_tgt         [i]   = 0;
878        for (uint32_t i=0; i<32 ; ++i) m_cpt_fsm_cmd_cleanup [i]   = 0;
879        for (uint32_t i=0; i<32 ; ++i) m_cpt_fsm_rsp_cleanup [i]   = 0;
880
881*/
882        return;
883    }
884
885    // Response FIFOs default values
886    bool       vci_rsp_fifo_icache_get       = false;
887    bool       vci_rsp_fifo_icache_put       = false;
888    uint32_t   vci_rsp_fifo_icache_data      = 0;
889
890    bool       vci_rsp_fifo_dcache_get       = false;
891    bool       vci_rsp_fifo_dcache_put       = false;
892    uint32_t   vci_rsp_fifo_dcache_data      = 0;
893
894#ifdef INSTRUMENTATION
895    m_cpt_fsm_dcache  [r_dcache_fsm.read() ] ++;
896    m_cpt_fsm_icache  [r_icache_fsm.read() ] ++;
897    m_cpt_fsm_cmd     [r_vci_cmd_fsm.read()] ++;
898    m_cpt_fsm_rsp     [r_vci_rsp_fsm.read()] ++;
899    m_cpt_fsm_tgt     [r_tgt_fsm.read()    ] ++;
900    m_cpt_fsm_cleanup [r_cleanup_fsm.read()] ++;
901#endif
902
903    m_cpt_total_cycles++;
904
905    m_debug_cleanup_fsm    = (m_cpt_total_cycles > m_debug_start_cycle) and m_debug_ok;
906    m_debug_icache_fsm     = (m_cpt_total_cycles > m_debug_start_cycle) and m_debug_ok;
907    m_debug_dcache_fsm     = (m_cpt_total_cycles > m_debug_start_cycle) and m_debug_ok;
908    m_debug_inval_itlb_fsm = (m_cpt_total_cycles > m_debug_start_cycle) and m_debug_ok;
909    m_debug_inval_dtlb_fsm = (m_cpt_total_cycles > m_debug_start_cycle) and m_debug_ok;
910
911    /////////////////////////////////////////////////////////////////////
912    // The TGT_FSM controls the following ressources:
913    // - r_tgt_fsm
914    // - r_tgt_buf[nwords]
915    // - r_tgt_be[nwords]
916    // - r_tgt_update
917    // - r_tgt_word_min
918    // - r_tgt_word_max
919    // - r_tgt_word_count
920    // - r_tgt_paddr
921    // - r_tgt_srcid
922    // - r_tgt_trdid
923    // - r_tgt_pktid
924    // - r_tgt_icache_req (set)
925    // - r_tgt_dcache_req (set)
926    //
927    // All VCI commands must be CMD_WRITE.
928    // - If the 2 LSB bits of the VCI address are 11, it is a broadcast request.
929    //   It is a multicast request otherwise.
930    // - For multicast requests, the ADDRESS[2] bit distinguishes DATA/INS
931    //   (0 for data / 1 for instruction), and the ADDRESS[3] bit distinguishes
932    //   INVAL/UPDATE (0 for invalidate / 1 for UPDATE).
933    //
934    // For all types of coherence request, the line index (i.e. the Z & Y fields)
935    // is coded on 34 bits, and is contained in the WDATA and BE fields
936    // of the first VCI flit.
937    // -  for a multicast invalidate or for a broadcast invalidate request
938    //    the VCI packet length is 1 word.
939    // -  for an update request the VCI packet length is (n+2) words.
940    //    The WDATA field of the second VCI word contains the word index.
941    //    The WDATA field of the n following words contains the values.
942    // -  for all transaction types, the VCI response is one single word.
943    // In case of errors in the VCI command packet, the simulation
944    // is stopped with an error message.
945    //
946    // This FSM is NOT pipelined : It consumes a new coherence request
947    // on the VCI port only when the previous request is completed.
948    //
949    // The VCI_TGT FSM stores the external request arguments in the
950    // IDLE, UPDT_WORD & UPDT_DATA states. It sets the r_tgt_icache_req
951    // and/or the r_tgt_dcache_req flip-flops to signal the coherence request
952    // to the ICACHE & DCACHE FSMs in the REQ_ICACHE, REQ_DCACHE & REQ_BROADCAST
953    // states. It waits the completion of the coherence request  by polling the
954    // r_tgt_*cache_req flip-flops in the RSP_ICACHE, RSP_DCACHE & RSP_BROADCAST
955    // states. These flip-flops are reset by the ICACHE and DCACHE FSMs.
956    // These two FSMs signal if a VCI answer must be send by setting
957    // the r_tgt_icache_rsp and/or the r_tgt_dcache_rsp flip_flops.
958    ///////////////////////////////////////////////////////////////////////////////
959
960    switch( r_tgt_fsm.read() ) 
961    {
962    //////////////
963    case TGT_IDLE:
964    {
965        if ( p_vci_tgt_c.cmdval.read() ) 
966        {
967            paddr_t address = p_vci_tgt_c.address.read();
968
969            // command checking
970            if ( p_vci_tgt_c.cmd.read() != vci_param::CMD_WRITE) 
971            {
972                std::cout << "error in component VCI_CC_VCACHE_WRAPPER " << name() << std::endl;
973                std::cout << "the received VCI coherence command is not a write" << std::endl;
974                exit(0);
975            }
976
977            // address checking
978            if ( ( (address & 0x3) != 0x3 ) && ( not m_segment.contains(address)) ) 
979            {
980                std::cout << "error in component VCI_CC_VCACHE_WRAPPER " << name() << std::endl;
981                std::cout << "out of segment VCI coherence command received" << std::endl;
982                exit(0);
983            }
984
985            r_tgt_srcid = p_vci_tgt_c.srcid.read();
986            r_tgt_trdid = p_vci_tgt_c.trdid.read();
987            r_tgt_pktid = p_vci_tgt_c.pktid.read();
988
989            r_tgt_paddr  = (paddr_t)(p_vci_tgt_c.be.read() & 0x3) << 32 |
990                          (paddr_t)p_vci_tgt_c.wdata.read() * m_dcache_words * 4; 
991
992            if ( (address&0x3) == 0x3 ) // broadcast invalidate for data or instruction type
993            {
994                if ( not p_vci_tgt_c.eop.read() ) 
995                {
996                    std::cout << "error in component VCI_CC_VCACHE_WRAPPER " << name() << std::endl;
997                    std::cout << "the BROADCAST INVALIDATE command must be one flit" << std::endl;
998                    exit(0);
999                }
1000                r_tgt_update = false; 
1001                r_tgt_fsm = TGT_REQ_BROADCAST;
1002
1003#ifdef INSTRUMENTATION
1004m_cpt_cc_broadcast++;
1005#endif
1006            }
1007            else                // multi-update or multi-invalidate for data type
1008            {
1009                paddr_t cell = address - m_segment.baseAddress();   
1010
1011                if (cell == 0)                      // invalidate data
1012                {                         
1013                    if ( not p_vci_tgt_c.eop.read() ) 
1014                    {
1015                        std::cout << "error in VCI_CC_VCACHE_WRAPPER " << name() << std::endl;
1016                        std::cout << "the MULTI-INVALIDATE command must be one flit" << std::endl;
1017                        exit(0);
1018                    }
1019                    r_tgt_update = false; 
1020                    r_tgt_fsm    = TGT_REQ_DCACHE;
1021
1022#ifdef INSTRUMENTATION
1023m_cpt_cc_inval_dcache++;
1024#endif
1025                }
1026                else if (cell == 4)                // invalidate instruction
1027                {                               
1028                    if ( not p_vci_tgt_c.eop.read() ) 
1029                    {
1030                        std::cout << "error in VCI_CC_VCACHE_WRAPPER " << name() << std::endl;
1031                        std::cout << "the MULTI-INVALIDATE command must be one flit" << std::endl;
1032                        exit(0);
1033                    }
1034                    r_tgt_update = false; 
1035                    r_tgt_fsm    = TGT_REQ_ICACHE;
1036
1037#ifdef INSTRUMENTATION
1038m_cpt_cc_inval_icache++;
1039#endif
1040                }     
1041                else if (cell == 8)             // update data
1042                {
1043                    if ( p_vci_tgt_c.eop.read() ) 
1044                    {
1045                        std::cout << "error in VCI_CC_VCACHE_WRAPPER " << name() << std::endl;
1046                        std::cout << "the MULTI-UPDATE command must be N+2 flits" << std::endl;
1047                        exit(0);
1048                    }
1049                    r_tgt_update      = true; 
1050                    r_tgt_update_data = true;
1051                    r_tgt_fsm         = TGT_UPDT_WORD;
1052
1053#ifdef INSTRUMENTATION
1054m_cpt_cc_update_dcache++;
1055#endif
1056                }
1057                else                            // update instruction
1058                {
1059                    if ( p_vci_tgt_c.eop.read() ) 
1060                    {
1061                        std::cout << "error in VCI_CC_VCACHE_WRAPPER " << name() << std::endl;
1062                        std::cout << "the MULTI-UPDATE command must be N+2 flits" << std::endl;
1063                        exit(0);
1064                    }
1065                    r_tgt_update      = true; 
1066                    r_tgt_update_data = false;
1067                    r_tgt_fsm         = TGT_UPDT_WORD;
1068
1069#ifdef INSTRUMENTATION
1070m_cpt_cc_update_icache++;
1071#endif
1072                }
1073            } // end if multi     
1074        } // end if cmdval
1075        break;
1076    }
1077    ///////////////////
1078    case TGT_UPDT_WORD:         // first word index acquisition
1079    {
1080        if (p_vci_tgt_c.cmdval.read()) 
1081        {
1082            if ( p_vci_tgt_c.eop.read() ) 
1083            {
1084                std::cout << "error in component VCI_CC_VCACHE_WRAPPER " << name() << std::endl;
1085                std::cout << "the MULTI-UPDATE command must be N+2 flits" << std::endl;
1086                exit(0);
1087            }
1088            for ( size_t i=0 ; i<m_dcache_words ; i++ ) r_tgt_be[i] = false;
1089
1090            r_tgt_word_min   = p_vci_tgt_c.wdata.read(); // first modifid word index
1091            r_tgt_word_count = p_vci_tgt_c.wdata.read(); // initializing word index
1092            r_tgt_fsm = TGT_UPDT_DATA;
1093        }
1094        break;
1095    }
1096    ///////////////////
1097    case TGT_UPDT_DATA:
1098    {
1099        if (p_vci_tgt_c.cmdval.read()) 
1100        {
1101            size_t word = r_tgt_word_count.read();
1102            if (word >= m_dcache_words) 
1103            {
1104                std::cout << "error in component VCI_CC_VCACHE_WRAPPER " << name() << std::endl;
1105                std::cout << "the reveived MULTI-UPDATE command is wrong" << std::endl;
1106                exit(0);
1107            }
1108            r_tgt_buf[word]  = p_vci_tgt_c.wdata.read();
1109            r_tgt_be[word]   = p_vci_tgt_c.be.read();
1110            r_tgt_word_count = word + 1;       
1111
1112            if (p_vci_tgt_c.eop.read())         // last word
1113            {
1114                 r_tgt_word_max = word;
1115                 if ( r_tgt_update_data.read() )        r_tgt_fsm = TGT_REQ_DCACHE;
1116                 else                                   r_tgt_fsm = TGT_REQ_ICACHE;
1117            }
1118        }
1119        break;
1120    }
1121    ///////////////////////
1122    case TGT_REQ_BROADCAST:     // set requests to DCACHE & ICACHE FSMs
1123    {
1124        if ( not r_tgt_icache_req.read() and not r_tgt_dcache_req.read() ) 
1125        {
1126            r_tgt_fsm = TGT_RSP_BROADCAST; 
1127            r_tgt_icache_req = true;
1128            r_tgt_dcache_req = true;
1129        }
1130        break;
1131    }
1132    /////////////////////
1133    case TGT_REQ_ICACHE:        // set request to ICACHE FSM (if no previous request pending)
1134    {
1135        if ( not r_tgt_icache_req.read() ) 
1136        {
1137            r_tgt_fsm = TGT_RSP_ICACHE; 
1138            r_tgt_icache_req = true;
1139        }
1140        break;
1141    }
1142    ////////////////////
1143    case TGT_REQ_DCACHE:        // set request to DCACHE FSM (if no previous request pending)
1144    {
1145        if ( not r_tgt_dcache_req.read() ) 
1146        {
1147            r_tgt_fsm = TGT_RSP_DCACHE; 
1148            r_tgt_dcache_req = true;
1149        }
1150        break;
1151    }
1152    ///////////////////////
1153    case TGT_RSP_BROADCAST:     // waiting acknowledge from both DCACHE & ICACHE FSMs
1154                                // no response when r_tgt_*cache_rsp is false
1155    {
1156        if ( not r_tgt_icache_req.read() and not r_tgt_dcache_req.read() ) // both completed
1157        {
1158            if ( r_tgt_icache_rsp.read() or r_tgt_dcache_rsp.read() )   // at least one response
1159            {
1160                if ( p_vci_tgt_c.rspack.read() )
1161                {
1162                    // reset dcache first if activated
1163                    if (r_tgt_dcache_rsp)   r_tgt_dcache_rsp = false;
1164                    else                    r_tgt_icache_rsp = false;
1165                }
1166            }
1167            else
1168            {
1169                r_tgt_fsm = TGT_IDLE;
1170            }
1171        }
1172        break;
1173    }
1174    ////////////////////
1175    case TGT_RSP_ICACHE:        // waiting acknowledge from ICACHE FSM
1176    {
1177        // no response when r_tgt_icache_rsp is false
1178        if ( not r_tgt_icache_req.read() and p_vci_tgt_c.rspack.read() )
1179        {
1180            r_tgt_fsm        = TGT_IDLE;
1181            r_tgt_icache_rsp = false;
1182        }
1183        break;
1184    }
1185    ////////////////////
1186    case TGT_RSP_DCACHE:
1187    {
1188        // no response when r_tgt_dcache_rsp is false
1189        if ( not r_tgt_dcache_req.read() and p_vci_tgt_c.rspack.read() )
1190        {
1191            r_tgt_fsm        = TGT_IDLE;
1192            r_tgt_dcache_rsp = false;
1193        }
1194        break;
1195    }
1196    } // end switch TGT_FSM
1197
1198    /////////////////////////////////////////////////////////////////////
1199    // Get data and instruction requests from processor
1200    ///////////////////////////////////////////////////////////////////////
1201
1202    typename iss_t::InstructionRequest  ireq = ISS_IREQ_INITIALIZER;
1203    typename iss_t::DataRequest         dreq = ISS_DREQ_INITIALIZER;
1204
1205    r_iss.getRequests(ireq, dreq);
1206
1207    ////////////////////////////////////////////////////////////////////////////////////
1208    //      ICACHE_FSM
1209    //
1210    // There is 9 conditions to exit the IDLE state:
1211    // One condition is a coherence request from TGT FSM :
1212    // - Coherence operation                            => ICACHE_CC_CHEK
1213    // Five configurations corresponding to XTN processor requests sent by DCACHE FSM :
1214    // - Flush TLB                                      => ICACHE_XTN_TLB_FLUSH
1215    // - Flush cache                                    => ICACHE_XTN_CACHE_FLUSH
1216    // - Invalidate a TLB entry                         => ICACHE_XTN_TLB_INVAL
1217    // - Invalidate a cache line                        => ICACHE_XTN_CACHE_INVAL_VA@
1218    // - Invalidate a cache line using physical address => ICACHE_XTN_CACHE_INVAL_PA
1219    // three configurations corresponding to instruction processor requests :
1220    // - tlb miss                                       => ICACHE_TLB_WAIT
1221    // - cacheable read miss                            => ICACHE_MISS_VICTIM
1222    // - uncacheable read miss                          => ICACHE_UNC_REQ
1223    //
1224    // In case of cache miss, the ICACHE FSM request a VCI transaction to CMD FSM
1225    // using the r_icache_tlb_miss_req flip-flop, that reset this flip-flop when the
1226    // transaction starts. Then the ICACHE FSM  goes to the ICACHE_MISS VICTIM
1227    // state to select a slot and request a VCI transaction to the CLEANUP FSM.
1228    // It goes next to the ICACHE_MISS_WAIT state waiting a response from RSP FSM.
1229    // The availability of the missing cache line is signaled by the response fifo,
1230    // and the cache update is done (one word per cycle) in the ICACHE_MISS_UPDT state.
1231    //
1232    // In case of uncacheable address, the ICACHE FSM request an uncached VCI transaction
1233    // to CMD FSM using the r_icache_unc_req flip-flop, that reset this flip-flop
1234    // when the transaction starts. The ICACHE FSM goes to ICACHE_UNC_WAIT to wait
1235    // the response from the RSP FSM, through the response fifo. The missing instruction
1236    // is directly returned to processor in this state.
1237    //
1238    // In case of tlb miss, the ICACHE FSM request to the DCACHE FSM to update the tlb
1239    // using the r_icache_tlb_miss_req flip-flop and the r_icache_tlb_miss_vaddr register,
1240    // and goes to the ICACHE_TLB_WAIT state.
1241    // The tlb update is entirely done by the DCACHE FSM (who becomes the owner of dtlb until
1242    // the update is completed, and reset r_icache_tlb_miss_req to signal the completion.
1243    //
1244    // The DCACHE FSM signals XTN processor requests to ICACHE_FSM
1245    // using the r_dcache_xtn_req flip-flop.
1246    // The request opcode and the address to be invalidated are transmitted
1247    // in the r_dcache_xtn_opcode and r_dcache_p0_wdata registers respectively.
1248    // The r_dcache_xtn_req flip-flop is reset by the ICACHE_FSM when the operation
1249    // is completed.
1250    //
1251    // The r_vci_rsp_ins_error flip-flop is set by the RSP FSM in case of bus error
1252    // in a cache miss or uncacheable read VCI transaction. Nothing is written
1253    // in the response fifo. This flip-flop is reset by the ICACHE-FSM.
1254    ////////////////////////////////////////////////////////////////////////////////////////
1255
1256    // The default value for irsp.valid is false
1257    typename iss_t::InstructionResponse irsp = ISS_IRSP_INITIALIZER;
1258
1259    switch( r_icache_fsm.read() ) 
1260    {
1261    /////////////////
1262    case ICACHE_IDLE:   // In this state, we handle processor requests, XTN requests sent
1263                        // by DCACHE FSM, and coherence requests with a fixed priority:
1264                        //         coherence > XTN > instruction
1265                        // We access the itlb and dcache in parallel with the virtual address
1266                        // for itlb, and with a speculative physical address for icache,
1267                        // computed during the previous cycle.
1268    {
1269        // coherence request from the target FSM
1270        if ( r_tgt_icache_req.read() )
1271        {
1272            r_icache_fsm = ICACHE_CC_CHECK;
1273            r_icache_fsm_save = r_icache_fsm.read();
1274            break;
1275        }
1276
1277        // Decoding processor XTN requests sent by DCACHE FSM 
1278        // These request are not executed in this IDLE state, because
1279        // they require access to icache or itlb, that are already accessed
1280        if ( r_dcache_xtn_req.read() )
1281        {
1282            if ( (int)r_dcache_xtn_opcode.read() == (int)iss_t::XTN_PTPR ) 
1283            {
1284                r_icache_fsm         = ICACHE_XTN_TLB_FLUSH;   
1285                break;
1286            }
1287            if ( (int)r_dcache_xtn_opcode.read() == (int)iss_t::XTN_ICACHE_FLUSH)
1288            {
1289                r_icache_flush_count = 0;
1290                r_icache_fsm         = ICACHE_XTN_CACHE_FLUSH;   
1291                break;
1292            }
1293            if ( (int)r_dcache_xtn_opcode.read() == (int)iss_t::XTN_ITLB_INVAL) 
1294            {
1295                r_icache_fsm         = ICACHE_XTN_TLB_INVAL;   
1296                break;
1297            }
1298            if ( (int)r_dcache_xtn_opcode.read() == (int)iss_t::XTN_ICACHE_INVAL) 
1299            {
1300                r_icache_fsm         = ICACHE_XTN_CACHE_INVAL_VA;   
1301                break;
1302            }
1303            if ( (int)r_dcache_xtn_opcode.read() == (int)iss_t::XTN_MMU_ICACHE_PA_INV) 
1304            {
1305                r_icache_vci_paddr   = (paddr_t)r_mmu_word_hi.read() << 32 | 
1306                                       (paddr_t)r_mmu_word_lo.read();
1307                r_icache_fsm         = ICACHE_XTN_CACHE_INVAL_PA;   
1308                break;
1309            }
1310        } // end if xtn_req
1311
1312        // processor request
1313        if ( ireq.valid )
1314        {
1315            bool        cacheable;
1316            paddr_t     paddr;
1317
1318            // We register processor request
1319            r_icache_vaddr_save = ireq.addr;
1320
1321            // speculative icache access (if cache activated)
1322            // we use the speculative PPN computed during the previous cycle
1323           
1324            uint32_t    cache_inst = 0;
1325            bool        cache_hit  = false;
1326
1327            if ( r_mmu_mode.read() & INS_CACHE_MASK )
1328            {
1329                paddr_t   spc_paddr = (r_icache_vci_paddr.read() & ~PAGE_K_MASK) |
1330                                      ((paddr_t)ireq.addr & PAGE_K_MASK);
1331
1332#ifdef INSTRUMENTATION
1333m_cpt_icache_data_read++;
1334m_cpt_icache_dir_read++;
1335#endif
1336                cache_hit = r_icache.read( spc_paddr,
1337                                           &cache_inst );
1338            }
1339
1340            // systematic itlb access (if tlb activated)
1341            // we use the virtual address
1342
1343            paddr_t     tlb_paddr;
1344            pte_info_t  tlb_flags; 
1345            size_t      tlb_way; 
1346            size_t      tlb_set;
1347            paddr_t     tlb_nline;
1348            bool        tlb_hit   = false;; 
1349
1350            if ( r_mmu_mode.read() & INS_TLB_MASK )
1351            {
1352
1353#ifdef INSTRUMENTATION
1354m_cpt_itlb_read++;
1355#endif
1356                tlb_hit = r_itlb.translate( ireq.addr,
1357                                            &tlb_paddr,
1358                                            &tlb_flags,
1359                                            &tlb_nline, // unused
1360                                            &tlb_way,   // unused
1361                                            &tlb_set ); // unused
1362            }
1363
1364            // We compute cacheability, physical address and check access rights:
1365            // - If MMU activated : cacheability is defined by the C bit in the PTE,
1366            //   the physical address is obtained from the TLB, and the access rights are
1367            //   defined by the U and X bits in the PTE.
1368            // - If MMU not activated : cacheability is defined by the segment table,
1369            //   the physical address is equal to the virtual address (identity mapping)
1370            //   and there is no access rights checking
1371
1372            if ( not (r_mmu_mode.read() & INS_TLB_MASK) )       // tlb not activated:
1373            {
1374                // cacheability
1375                if ( not (r_mmu_mode.read() & INS_CACHE_MASK) ) cacheable = false;
1376                else     cacheable = m_cacheability_table[ireq.addr];
1377
1378                // physical address
1379                paddr = (paddr_t)ireq.addr;
1380            }
1381            else                                                // itlb activated
1382            {
1383                if ( tlb_hit )  // tlb hit
1384                { 
1385                    // cacheability
1386                    if ( not (r_mmu_mode.read() & INS_CACHE_MASK) ) cacheable = false;
1387                    else  cacheable = tlb_flags.c;
1388
1389                    // physical address
1390                    paddr       = tlb_paddr;
1391
1392                    // access rights checking
1393                    if ( not tlb_flags.u && (ireq.mode == iss_t::MODE_USER) )
1394                    {
1395                        r_mmu_ietr        = MMU_READ_PRIVILEGE_VIOLATION;
1396                        r_mmu_ibvar       = ireq.addr;
1397                        irsp.valid        = true;
1398                        irsp.error        = true;
1399                        irsp.instruction  = 0;
1400                        break;
1401                    }
1402                    else if ( not tlb_flags.x )
1403                    {
1404                        r_mmu_ietr        = MMU_READ_EXEC_VIOLATION;
1405                        r_mmu_ibvar       = ireq.addr;
1406                        irsp.valid        = true;
1407                        irsp.error        = true;
1408                        irsp.instruction  = 0;
1409                        break;
1410                    }
1411                }
1412                // in case of TLB miss we send an itlb miss request to DCACHE FSM and break
1413                else
1414                {
1415
1416#ifdef INSTRUMENTATION
1417m_cpt_itlb_miss++;
1418#endif
1419                    r_icache_fsm          = ICACHE_TLB_WAIT;
1420                    r_icache_tlb_miss_req = true;
1421                    break;
1422                } 
1423            } // end if itlb activated
1424
1425            // physical address registration (for next cycle)
1426            r_icache_vci_paddr   = paddr;
1427
1428            // We enter this section only in case of TLB hit:
1429            // Finally, we get the instruction depending on cacheability,
1430            // we send the response to processor, and compute next state
1431            if ( cacheable )    // cacheable read
1432            {
1433                if ( (r_icache_vci_paddr.read() & ~PAGE_K_MASK) 
1434                      != (paddr & ~PAGE_K_MASK) )       // speculative access KO
1435                {
1436
1437#ifdef INSTRUMENTATION
1438m_cpt_icache_spc_miss++;
1439#endif
1440                    // we return an invalid response and stay in IDLE state
1441                    // the cache access will cost one extra cycle.
1442                    break;
1443                }
1444               
1445                if ( not cache_hit )    // cache miss
1446                {
1447                    // in case of icache miss we send a request to CMD FSM, but we are
1448                    // blocked in IDLE state if the previous cleanup is not completed
1449                    if ( not r_icache_cleanup_req.read() )
1450                    {
1451
1452#ifdef INSTRUMENTATION
1453m_cpt_icache_miss++;
1454#endif
1455                        r_icache_fsm      = ICACHE_MISS_VICTIM;
1456                        r_icache_miss_req = true;
1457                    }
1458                    break;
1459                }
1460                else                    // cache hit
1461                {
1462     
1463#ifdef INSTRUMENTATION
1464m_cpt_ins_read++; 
1465#endif
1466                    irsp.valid       = true;
1467                    irsp.instruction = cache_inst;
1468                }
1469            }
1470            else                // non cacheable read
1471            {
1472                r_icache_unc_req  = true;
1473                r_icache_fsm      = ICACHE_UNC_WAIT;
1474            }
1475        }    // end if ireq.valid
1476        break;
1477    }
1478    /////////////////////
1479    case ICACHE_TLB_WAIT:       // Waiting the itlb update by the DCACHE FSM after a tlb miss
1480                                // the itlb is udated by the DCACHE FSM, as well as the
1481                                // r_mmu_ietr and r_mmu_ibvar registers in case of error.
1482                                // the itlb is not accessed by ICACHE FSM until DCACHE FSM
1483                                // reset the r_icache_tlb_miss_req flip-flop
1484                                // external coherence request are accepted in this state.
1485    {
1486        // external coherence request
1487        if ( r_tgt_icache_req.read() )
1488        {
1489            r_icache_fsm = ICACHE_CC_CHECK;
1490            r_icache_fsm_save = r_icache_fsm.read();
1491            break;
1492        }
1493
1494        if ( ireq.valid ) m_cost_ins_tlb_miss_frz++;
1495
1496        // DCACHE FSM signals response by reseting the request flip-flop
1497        if ( not r_icache_tlb_miss_req.read() )
1498        {
1499            if ( r_icache_tlb_rsp_error.read() ) // error reported : tlb not updated
1500            {
1501                r_icache_tlb_rsp_error = false;
1502                irsp.error             = true;
1503                irsp.valid             = true;
1504                r_icache_fsm           = ICACHE_IDLE;
1505            }
1506            else                                // tlb updated : return to IDLE state
1507            {
1508                r_icache_fsm  = ICACHE_IDLE;
1509            }
1510        }
1511        break;
1512    }
1513    //////////////////////////
1514    case ICACHE_XTN_TLB_FLUSH:          // invalidate in one cycle all non global TLB entries
1515    {   
1516        r_itlb.flush();   
1517        r_dcache_xtn_req     = false;
1518        r_icache_fsm         = ICACHE_IDLE;
1519        break;
1520    }
1521    ////////////////////////////
1522    case ICACHE_XTN_CACHE_FLUSH:        // Invalidate sequencially all cache lines using
1523                                        // the r_icache_flush_count register as a slot counter.
1524                                        // We loop in this state until all slots have been visited.
1525                                        // A cleanup request is generated for each valid line
1526                                        // and we are blocked until the previous cleanup is completed
1527    {
1528        if ( not r_icache_cleanup_req.read() )
1529        {
1530            size_t      way = r_icache_flush_count.read()/m_icache_sets;
1531            size_t      set = r_icache_flush_count.read()%m_icache_sets;
1532            paddr_t     nline;
1533            bool        cleanup_req = r_icache.inval( way, 
1534                                                      set, 
1535                                                      &nline );
1536            if ( cleanup_req )
1537            {
1538                r_icache_cleanup_req  = true;
1539                r_icache_cleanup_line = nline;
1540            }
1541            r_icache_flush_count = r_icache_flush_count.read() + 1;
1542        }
1543       
1544        if ( r_icache_flush_count.read() == (m_icache_sets*m_icache_ways - 1) )
1545        {
1546            r_dcache_xtn_req    = false;
1547            r_icache_fsm        = ICACHE_IDLE;
1548        }
1549        break;
1550    }
1551    //////////////////////////
1552    case ICACHE_XTN_TLB_INVAL:          // invalidate one TLB entry selected by the virtual address
1553                                        // stored in the r_dcache_p0_wdata register
1554    {
1555        r_itlb.inval(r_dcache_p0_wdata.read());
1556        r_dcache_xtn_req     = false;
1557        r_icache_fsm         = ICACHE_IDLE;
1558        break;
1559    }
1560    ///////////////////////////////
1561    case ICACHE_XTN_CACHE_INVAL_VA:     // Selective cache line invalidate with virtual address
1562                                        // requires 3 cycles (in case of hit on itlb and icache).
1563                                        // In this state, we access TLB to translate virtual address
1564                                        // stored in the r_dcache_p0_wdata register.
1565    {
1566        paddr_t         paddr;                     
1567        bool            hit;
1568
1569        // read physical address in TLB when MMU activated
1570        if ( r_mmu_mode.read() & INS_TLB_MASK )         // itlb activated
1571        {
1572
1573#ifdef INSTRUMENTATION
1574m_cpt_itlb_read++;
1575#endif
1576            hit = r_itlb.translate(r_dcache_p0_wdata.read(), 
1577                                   &paddr); 
1578        } 
1579        else                                            // itlb not activated
1580        {
1581            paddr       = (paddr_t)r_dcache_p0_wdata.read();
1582            hit         = true;
1583        }
1584
1585        if ( hit )              // continue the selective inval process
1586        {
1587            r_icache_vci_paddr    = paddr;               
1588            r_icache_fsm          = ICACHE_XTN_CACHE_INVAL_PA;
1589        }
1590        else                    // miss : send a request to DCACHE FSM
1591        {
1592
1593#ifdef INSTRUMENTATION
1594m_cpt_itlb_miss++;
1595#endif
1596            r_icache_tlb_miss_req = true;
1597            r_icache_fsm          = ICACHE_TLB_WAIT;
1598        }
1599        break;
1600    }
1601    ///////////////////////////////
1602    case ICACHE_XTN_CACHE_INVAL_PA:     // selective invalidate cache line with physical address
1603                                        // require 2 cycles. In this state, we read dcache,
1604                                        // with address stored in r_icache_vci_paddr register.
1605    {
1606        uint32_t        data;
1607        size_t          way;
1608        size_t          set;
1609        size_t          word;
1610        bool            hit = r_icache.read(r_icache_vci_paddr.read(),
1611                                            &data,
1612                                            &way,
1613                                            &set,
1614                                            &word);
1615        if ( hit )      // inval to be done
1616        {
1617                r_icache_miss_way = way;
1618                r_icache_miss_set = set;
1619                r_icache_fsm      = ICACHE_XTN_CACHE_INVAL_GO;
1620        }
1621        else            // miss : acknowlege the XTN request and return
1622        {
1623            r_dcache_xtn_req = false; 
1624            r_icache_fsm     = ICACHE_IDLE;
1625        }
1626        break;
1627    }
1628    ///////////////////////////////
1629    case ICACHE_XTN_CACHE_INVAL_GO:     // In this state, we invalidate the cache line & cleanup.
1630                                        // We are blocked if the previous cleanup is not completed
1631    {
1632        paddr_t nline;
1633
1634        if ( not r_icache_cleanup_req.read() )
1635        {
1636            r_icache.inval( r_icache_miss_way.read(),
1637                            r_icache_miss_set.read(),
1638                            &nline );
1639 
1640            // request cleanup
1641            r_icache_cleanup_req  = true;
1642            r_icache_cleanup_line = nline;
1643            // acknowledge the XTN request and return
1644            r_dcache_xtn_req      = false; 
1645            r_icache_fsm          = ICACHE_IDLE;
1646        }
1647        break;
1648    }
1649
1650    ////////////////////////
1651    case ICACHE_MISS_VICTIM:               // Selects a victim line
1652                                           // Set the r_icache_cleanup_req flip-flop
1653                                           // when the selected slot is not empty
1654    {
1655        if ( ireq.valid ) m_cost_ins_miss_frz++;
1656
1657        bool    valid;
1658        size_t  way;
1659        size_t  set;
1660        paddr_t victim;
1661
1662        valid = r_icache.victim_select(r_icache_vci_paddr.read(),
1663                                       &victim, 
1664                                       &way, 
1665                                       &set);
1666        r_icache_miss_way     = way;
1667        r_icache_miss_set     = set;
1668
1669        if ( valid )
1670        {
1671            r_icache_cleanup_req  = true;
1672            r_icache_cleanup_line = victim;
1673            r_icache_fsm          = ICACHE_MISS_INVAL;
1674        }
1675        else
1676        {
1677            r_icache_fsm          = ICACHE_MISS_WAIT;
1678        }
1679        break;
1680    }
1681    ///////////////////////
1682    case ICACHE_MISS_INVAL:     // invalidate the victim line
1683    {
1684        paddr_t nline;
1685
1686        r_icache.inval( r_icache_miss_way.read(),
1687                        r_icache_miss_set.read(),
1688                        &nline );       // unused
1689
1690        r_icache_fsm = ICACHE_MISS_WAIT;
1691        break;
1692    }
1693    //////////////////////
1694    case ICACHE_MISS_WAIT:      // waiting a response to a miss request from VCI_RSP FSM
1695    {
1696        if ( ireq.valid ) m_cost_ins_miss_frz++;
1697
1698        // external coherence request
1699        if ( r_tgt_icache_req.read() )     
1700        {
1701            r_icache_fsm = ICACHE_CC_CHECK;
1702            r_icache_fsm_save = r_icache_fsm.read();
1703            break;
1704        }
1705
1706        if ( r_vci_rsp_ins_error.read() ) // bus error
1707        {
1708            r_mmu_ietr = MMU_READ_DATA_ILLEGAL_ACCESS; 
1709            r_mmu_ibvar  = r_icache_vaddr_save.read();
1710            irsp.valid           = true;
1711            irsp.error           = true;
1712            r_vci_rsp_ins_error  = false;
1713            r_icache_fsm = ICACHE_IDLE;
1714        }
1715        else if ( r_vci_rsp_fifo_icache.rok() ) // response available
1716        {
1717            r_icache_miss_word = 0;
1718            r_icache_fsm       = ICACHE_MISS_UPDT; 
1719        }       
1720        break;
1721    }
1722    //////////////////////
1723    case ICACHE_MISS_UPDT:      // update the cache (one word per cycle)
1724    {
1725        if ( ireq.valid ) m_cost_ins_miss_frz++;
1726
1727        if ( r_vci_rsp_fifo_icache.rok() )      // response available
1728        {
1729            if ( r_icache_miss_inval )  // Matching coherence request
1730                                        // We pop the response FIFO, without updating the cache
1731                                        // We send a cleanup for the missing line at the last word
1732                                        // Blocked if the previous cleanup is not completed
1733            {
1734                if ( r_icache_miss_word.read() < m_icache_words-1 )     // not the last word
1735                {
1736                    vci_rsp_fifo_icache_get = true;
1737                    r_icache_miss_word = r_icache_miss_word.read() + 1;
1738                }
1739                else                                                    // last word
1740                {
1741                    if ( not r_icache_cleanup_req.read() )      // no pending cleanup
1742                    {
1743                        vci_rsp_fifo_icache_get = true;
1744                        r_icache_cleanup_req    = true;
1745                        r_icache_cleanup_line   = r_icache_vci_paddr.read() >> (uint32_log2(m_icache_words<<2));
1746                        r_icache_miss_inval     = false;
1747                        r_icache_fsm            = ICACHE_IDLE;
1748                    }
1749                }
1750            }
1751            else                        // No matching coherence request
1752                                        // We pop the FIFO and update the cache
1753                                        // We update the directory at the last word
1754            {
1755
1756#ifdef INSTRUMENTATION
1757m_cpt_icache_data_write++;
1758#endif
1759                r_icache.write( r_icache_miss_way.read(),
1760                                r_icache_miss_set.read(),
1761                                r_icache_miss_word.read(),
1762                                r_vci_rsp_fifo_icache.read() );
1763                vci_rsp_fifo_icache_get = true;
1764                r_icache_miss_word = r_icache_miss_word.read() + 1;
1765                if ( r_icache_miss_word.read() == m_icache_words-1 )  // last word
1766                {
1767
1768#ifdef INSTRUMENTATION
1769m_cpt_icache_dir_write++;
1770#endif
1771                    r_icache.victim_update_tag( r_icache_vci_paddr.read(),
1772                                                r_icache_miss_way.read(),
1773                                                r_icache_miss_set.read() );
1774                    r_icache_fsm = ICACHE_IDLE;
1775                }
1776            }
1777        }
1778        break;
1779    }
1780    ////////////////////
1781    case ICACHE_UNC_WAIT:       // waiting a response to an uncacheable read from VCI_RSP FSM
1782                                //
1783    {
1784        // external coherence request
1785        if ( r_tgt_icache_req.read() ) 
1786        {
1787            r_icache_fsm = ICACHE_CC_CHECK;
1788            r_icache_fsm_save = r_icache_fsm.read();
1789            break;
1790        }
1791
1792        if ( r_vci_rsp_ins_error.read() ) // bus error
1793        {
1794            r_mmu_ietr          = MMU_READ_DATA_ILLEGAL_ACCESS;   
1795            r_mmu_ibvar         = ireq.addr;
1796            r_vci_rsp_ins_error = false;
1797            irsp.valid          = true;
1798            irsp.error          = true;
1799            r_icache_fsm        = ICACHE_IDLE;
1800        }
1801        else if (r_vci_rsp_fifo_icache.rok() ) // instruction available
1802        {
1803            vci_rsp_fifo_icache_get = true;
1804            r_icache_fsm            = ICACHE_IDLE;
1805            if ( ireq.valid and (ireq.addr == r_icache_vaddr_save.read()) )  // request not modified
1806            {
1807                irsp.valid       = true;
1808                irsp.instruction = r_vci_rsp_fifo_icache.read();
1809            }
1810        }       
1811        break;
1812    }
1813    /////////////////////
1814    case ICACHE_CC_CHECK:       // This state is the entry point of a sub-fsm
1815                                // handling coherence requests.
1816                                // the return state is defined in r_icache_fsm_save.
1817    {
1818        paddr_t  paddr = r_tgt_paddr.read();
1819        paddr_t  mask  = ~((m_icache_words<<2)-1);
1820
1821        if( (r_icache_fsm_save.read() == ICACHE_MISS_WAIT) and
1822                ((r_icache_vci_paddr.read() & mask) == (paddr & mask)))         // matching a pending miss
1823        {
1824            r_icache_miss_inval = true;                         // signaling the matching
1825            r_tgt_icache_req    = false;                        // coherence request completed
1826            r_tgt_icache_rsp    = r_tgt_update.read();          // response required if update
1827            r_icache_fsm        = r_icache_fsm_save.read();
1828        }
1829        else                                                            // no match
1830        {
1831
1832#ifdef INSTRUMENTATION
1833m_cpt_icache_dir_read++;
1834#endif
1835            uint32_t    inst;
1836            size_t      way;
1837            size_t      set;
1838            size_t      word;
1839            bool        hit = r_icache.read(paddr, 
1840                                            &inst,
1841                                            &way, 
1842                                            &set, 
1843                                            &word);
1844            r_icache_cc_way = way;
1845            r_icache_cc_set = set;
1846
1847            if ( hit and r_tgt_update.read() )           // hit update
1848            {
1849                r_icache_fsm         = ICACHE_CC_UPDT;
1850                r_icache_cc_word     = r_tgt_word_min.read();
1851            }
1852            else if ( hit and not r_tgt_update.read() )  // hit inval
1853            {
1854                r_icache_fsm           = ICACHE_CC_INVAL;
1855            }
1856            else                                         // miss can happen
1857            {
1858                r_tgt_icache_req = false;
1859                r_tgt_icache_rsp = r_tgt_update.read();
1860                r_icache_fsm     = r_icache_fsm_save.read();
1861            }
1862        }
1863        break;
1864    }
1865
1866    /////////////////////
1867    case ICACHE_CC_INVAL:       // invalidate a cache line
1868    {                       
1869        paddr_t nline;
1870        r_icache.inval( r_icache_cc_way.read(),
1871                        r_icache_cc_set.read(), 
1872                        &nline );
1873
1874        r_tgt_icache_req = false;
1875        r_tgt_icache_rsp = true;
1876        r_icache_fsm     = r_icache_fsm_save.read();
1877        break;
1878    }
1879    ////////////////////
1880    case ICACHE_CC_UPDT:        // write one word per cycle (from word_min to word_max)
1881    {
1882        size_t  word  = r_icache_cc_word.read();
1883        size_t  way   = r_icache_cc_way.read();
1884        size_t  set   = r_icache_cc_set.read();
1885
1886        r_icache.write( way,
1887                        set,
1888                        word,
1889                        r_tgt_buf[word],
1890                        r_tgt_be[word] );
1891
1892        r_icache_cc_word = word+1;
1893
1894        if ( word == r_tgt_word_max.read() )    // last word
1895        {
1896            r_tgt_icache_req = false;
1897            r_tgt_icache_rsp = true;
1898            r_icache_fsm     = r_icache_fsm_save.read();
1899        }
1900        break;
1901    }
1902
1903    } // end switch r_icache_fsm
1904
1905    // save the IREQ and IRSP fields for the print_trace() function
1906    m_ireq_valid        = ireq.valid;
1907    m_ireq_addr         = ireq.addr;
1908    m_ireq_mode         = ireq.mode;
1909   
1910    m_irsp_valid        = irsp.valid;
1911    m_irsp_instruction  = irsp.instruction;
1912    m_irsp_error        = irsp.error;
1913
1914    ////////////////////////////////////////////////////////////////////////////////////
1915    //      INVAL ITLB FSM
1916    // This FSM works in parallel with the ICACHE FSM.
1917    // When the r_dcache_itlb_inval_req flip-flop is activated by the DCACHE FSM
1918    // it scans sequencially all entries in the ITLB, and invalidates the
1919    // entries matching the evicted line.
1920    // It signals the completion of invalidation by reseting r_dcache_itlb_inval_req.
1921    ////////////////////////////////////////////////////////////////////////////////////
1922
1923    switch(r_inval_itlb_fsm) 
1924    {
1925    /////////////////////
1926    case INVAL_ITLB_IDLE:
1927    {
1928        if ( r_dcache_itlb_inval_req.read() )
1929        {
1930            r_itlb.reset_bypass(r_dcache_tlb_inval_line.read());
1931            r_inval_itlb_count = 0;
1932            r_inval_itlb_fsm   = INVAL_ITLB_SCAN;   
1933
1934#if DEBUG_INVAL_ITLB
1935if ( m_debug_inval_itlb_fsm )
1936{
1937    std::cout << "  <PROC.INVAL_ITLB_IDLE> Invalidate request for line " 
1938              << std::hex << r_dcache_tlb_inval_line.read() << std::endl;
1939    r_itlb.print();
1940}
1941#endif
1942        }   
1943        break;
1944    }
1945    /////////////////////
1946    case INVAL_ITLB_SCAN:
1947    {
1948        paddr_t line = r_dcache_tlb_inval_line.read();          // nline
1949        size_t  way  = r_inval_itlb_count.read()/m_itlb_sets;   // way
1950        size_t  set  = r_inval_itlb_count.read()%m_itlb_sets;   // set
1951
1952        bool ok = r_itlb.inval( line,
1953                                way,
1954                                set );
1955
1956#if DEBUG_INVAL_ITLB
1957if ( m_debug_inval_itlb_fsm )
1958{
1959    std::cout << "  <PROC.INVAL_ITLB_SCAN>" << std::hex
1960              << " line = " << line << std::dec
1961              << " / set = " << set
1962              << " / way = " << way;
1963    if ( ok ) std::cout << " / HIT" << std::endl;
1964    else      std::cout << " / MISS" << std::endl;
1965}
1966#endif
1967
1968        r_inval_itlb_count = r_inval_itlb_count.read() + 1;
1969        if ( r_inval_itlb_count.read() == (m_itlb_sets*m_itlb_ways - 1) ) 
1970        {
1971            r_inval_itlb_fsm        = INVAL_ITLB_IDLE;
1972            r_dcache_itlb_inval_req = false;
1973        }
1974        break;
1975    }       
1976    } // end switch r_inval_itlb_fsm
1977
1978    ////////////////////////////////////////////////////////////////////////////////////
1979    //      DCACHE FSM
1980    //
1981    // Both the Cacheability Table, and the MMU cacheable bit are used to define
1982    // the cacheability, depending on the MMU mode.
1983    //
1984    // 1/ Coherence requests :
1985    //    There is a coherence request when the tgt_dcache_req flip-flop is set,
1986    //    requesting a line invalidation or a line update.
1987    //    Coherence requests are taken into account in IDLE, UNC_WAIT, MISS_WAIT states.
1988    //    The actions associated to the pre-empted state are not executed, the DCACHE FSM
1989    //    goes to the CC_CHECK state to execute the requested action, and returns to the
1990    //    pre-empted state.
1991    //
1992    // 2/ processor requests :
1993    //    Processor READ, WRITE, LL or SC requests are taken in IDLE state only.
1994    //    The IDLE state implements a three stages pipe-line to handle write bursts:
1995    //    - The physical address is computed by dtlb in stage P0.
1996    //    - The registration in wbuf and the dcache hit are computed in stage P1.
1997    //    - The dcache update is done in stage P2. 
1998    //    A write operation can require a fourth stage if the dirty bit must be updated,
1999    //    or if the TLBs must be cleared, but these "long write" operation requires 
2000    //    to exit the IDLE stage
2001    //    If there is no write in the pipe, dcache and dtlb are accessed in parallel,
2002    //    (virtual address for itlb, and speculative physical address computed during
2003    //    previous cycle for dcache) in order to return the data in one cycle for a read.
2004    //    We just pay an extra cycle when the speculative access is illegal.
2005    //
2006    // 3/ Atomic instructions LL/SC
2007    //    The LL/SC address can be cacheable or non cacheable.
2008    //    The reservation registers (r_dcache_ll_valid, r_dcache_ll_vaddr and
2009    //    r_dcache_ll_data are stored in the L1 cache controller, and not in the
2010    //    memory controller.
2011    //    - LL requests from the processor are transmitted as standard VCI
2012    //      READ transactions (one word / one line, depending on the cacheability).
2013    //    - SC requests from the processor are systematically transmitted to the
2014    //      memory cache as COMPARE&swap requests (both the data value stored in the
2015    //      r_dcache_ll_data register and the new value).
2016    //
2017    // 4/ Non cacheable access:
2018    //    This component implement a strong order between non cacheable access
2019    //    (read or write) : A new non cacheable VCI transaction starts only when
2020    //    the previous non cacheable transaction is completed. Both cacheable and
2021    //    non cacheable transactions use the write buffer, but the DCACHE FSM registers
2022    //    a non cacheable write transaction posted in the write buffer by setting the
2023    //    r_dcache_pending_unc_write flip_flop. All other non cacheable requests
2024    //    are stalled until this flip-flop is reset by the VCI_RSP_FSM (when the
2025    //    pending non cacheable write transaction completes).
2026    //
2027    // 5/ Error handling: 
2028    //    When the MMU is not activated, Read Bus Errors are synchronous events,
2029    //    but Write Bus Errors are asynchronous events (processor is not frozen).
2030    //    - If a Read Bus Error is detected, the VCI_RSP FSM sets the
2031    //      r_vci_rsp_data_error flip-flop, without writing any data in the
2032    //      r_vci_rsp_fifo_dcache FIFO, and the synchronous error is signaled
2033    //      by the DCACHE FSM.
2034    //    - If a Write Bus Error is detected, the VCI_RSP FSM  signals
2035    //      the asynchronous error using the setWriteBerr() method.
2036    //    When the MMU is activated bus error are rare events, as the MMU
2037    //    checks the physical address before the VCI transaction starts.
2038    ////////////////////////////////////////////////////////////////////////////////////////
2039
2040    // The default value for drsp.valid is false
2041    typename iss_t::DataResponse  drsp = ISS_DRSP_INITIALIZER;
2042
2043    switch ( r_dcache_fsm.read() ) 
2044    {
2045    case DCACHE_IDLE:   // There is 8 conditions to exit the IDLE state :
2046                        // 1) Long write request (DCACHE FSM)   => DCACHE_WRITE_***
2047                        // 2) Coherence request (TGT FSM)       => DCACHE_CC_CHECK
2048                        // 3) ITLB miss request (ICACHE FSM)    => DCACHE_TLB_MISS
2049                        // 4) XTN request (processor)           => DCACHE_XTN_*
2050                        // 5) DTLB miss (processor)             => DCACHE_TLB_MISS
2051                        // 6) Cacheable read miss (processor)   => DCACHE_MISS_VICTIM
2052                        // 7) Uncacheable read (processor)      => DCACHE_UNC_REQ
2053                        // 8) SC access (processor)             => DCACHE_SC
2054                        // There is 4 configurations to access the cache,
2055                        // depending on the pipe-line state, defined
2056                        // by the r_dcache_p0_valid (V0) flip-flop : P1 stage activated
2057                        // and    r_dcache_p1_valid (V1) flip-flop : P2 stage activated
2058                        //  V0 / V1 / Data      / Directory / comment                   
2059                        //  0  / 0  / read(A0)  / read(A0)  / read speculative access 
2060                        //  0  / 1  / write(A2) / nop       / read request delayed
2061                        //  1  / 0  / nop       / read(A1)  / read request delayed
2062                        //  1  / 1  / write(A2) / read(A1)  / read request delayed
2063    { 
2064        ////////////////////////////////////////////////////////////////////////////////
2065        // Handling P2 pipe-line stage
2066        // Inputs are r_dcache_p1_* registers.
2067        // Three actions are executed in this P2 stage:
2068        // - If r_dcache_p1_updt_cache is true, we update the local copy in dcache.
2069        // - If the modified cache line has copies in itlb (resp. dtlb), and if the
2070        //   INVAL_ITLB (resp. INVAL_DTLB) FSM is idle, we launch the TLB invalidate
2071        //   operation. This operation is NOT blocking for the processor: the DCACHE FSM
2072        //   doesn't wait the TLB invalidate completion to handle processor requests.
2073        //   If the INVAL_ITLB (resp INVAL_DTLB) FSM is already processintg a previous
2074        //   invalidation request, the DCACHE FSM is frosen until completion of the
2075        //   previous  TLB invalidate operation.
2076        // - If the PTE dirty bit must be updated, we start a "long write", that is
2077        //   blocking for the processor, because we switch to the DCACHE_WRITE_SET_DIRTY
2078        //   state, and the number of cycles can be large...
2079
2080        bool long_write_set_dirty = false;
2081        bool tlb_inval_frozen     = false;
2082
2083        if ( r_dcache_p1_valid.read() )         // P2 stage activated
2084        {
2085            bool     cache_updt = r_dcache_p1_updt_cache.read();
2086            size_t   cache_way  = r_dcache_p1_cache_way.read();
2087            size_t   cache_set  = r_dcache_p1_cache_set.read();
2088            size_t   cache_word = r_dcache_p1_cache_word.read();
2089            uint32_t wdata      = r_dcache_p1_wdata.read();
2090            vci_be_t be         = r_dcache_p1_be.read();
2091
2092            // The PTE address is used when the PTE dirty bit must be set.
2093            // It is the concatenation of the nline value (from dtlb)
2094            // and the word index (from virtual address)
2095            paddr_t  pte_paddr = (paddr_t)(r_dcache_p1_tlb_nline.read()*(m_dcache_words<<2)) 
2096                                 | (paddr_t)(r_dcache_p1_vaddr.read()%(m_dcache_words<<2));
2097           
2098            // The line index is used when a TLB inval is required
2099            paddr_t  inval_line = r_dcache_p1_paddr.read()>>(uint32_log2(m_dcache_words<<2)); 
2100
2101            // checking dcache update
2102            if ( cache_updt )   
2103            {
2104                r_dcache.write( cache_way,
2105                                cache_set,
2106                                cache_word,
2107                                wdata,
2108                                be );
2109#ifdef INSTRUMENTATION
2110m_cpt_dcache_data_write++; 
2111#endif
2112
2113                // Checking copies in TLBs
2114                bool itlb_inval = ( (r_mmu_mode.read() & INS_TLB_MASK) and
2115                                    r_dcache_in_itlb[cache_way*m_dcache_sets+cache_set] );
2116                bool dtlb_inval = ( (r_mmu_mode.read() & DATA_TLB_MASK) and
2117                                    r_dcache_in_dtlb[cache_way*m_dcache_sets+cache_set] );
2118
2119                if ( (dtlb_inval and r_dcache_dtlb_inval_req.read() ) or
2120                     (itlb_inval and r_dcache_itlb_inval_req.read() ) ) // at least one FSM not idle
2121                {
2122                    tlb_inval_frozen = true;
2123                }
2124                else                                                    // requested FSM idle
2125                {
2126                    r_dcache_tlb_inval_line = inval_line;
2127                    r_dcache_itlb_inval_req = itlb_inval;
2128                    r_dcache_dtlb_inval_req = dtlb_inval;
2129                    r_dcache_in_itlb[cache_way*m_dcache_sets+cache_set] = false;
2130                    r_dcache_in_dtlb[cache_way*m_dcache_sets+cache_set] = false;
2131                }
2132            } // end dcache update
2133
2134            // checking dirty bit update
2135            if ( r_dcache_p1_set_dirty.read() ) 
2136            {
2137                long_write_set_dirty = true;
2138                r_dcache_p2_vaddr     = r_dcache_p1_vaddr.read();
2139                r_dcache_p2_set_dirty = r_dcache_p1_set_dirty.read();
2140                r_dcache_p2_tlb_way   = r_dcache_p1_tlb_way.read();     
2141                r_dcache_p2_tlb_set   = r_dcache_p1_tlb_set.read();     
2142                r_dcache_p2_pte_paddr = pte_paddr;
2143            }
2144
2145#if DEBUG_DCACHE
2146if ( m_debug_dcache_fsm )
2147{
2148    if ( cache_updt ) 
2149        std::cout << "  <PROC.DCACHE_IDLE> P2 stage: cache update" << std::dec
2150                  << " / way = " << cache_way
2151                  << " / set = " << cache_set
2152                  << " / word = " << cache_word << std::hex
2153                  << " / wdata = " << wdata
2154                  << " / be = " << be << std::endl;
2155    if ( long_write_set_dirty ) 
2156        std::cout << "  <PROC.DCACHE_IDLE> P2 stage: dirty bit update required"
2157                  << " / pte_paddr = " << std::hex << pte_paddr << std::endl;
2158}
2159#endif
2160        } // end P2 stage
2161
2162        ///////////////////////////////////////////////////////////////////////////
2163        // Handling P1 pipe-line stage
2164        // Inputs are r_dcache_p0_* registers.
2165        // - We must write into wbuf and test the hit in dcache.
2166        // If the write request is not cacheable, and there is a pending
2167        // non cacheable write, or if the write buffer is full, we break:
2168        // The P0 and P1 pipe-line stages are frozen until the write
2169        // request registration is possible, but the P2 stage is not frozen.
2170        // - The r_dcache_p1_valid bit activating the P2 pipe-line stage
2171        // must be computed at all cycles. The P2 stage must be activated
2172        // if there is local copy in dcache, or if the PTE dirty bit must be set.
2173
2174        if ( r_dcache_p0_valid.read() and not tlb_inval_frozen )  // P1 stage activated
2175        {
2176            // write not cacheable, and previous non cacheable write registered
2177            if ( not r_dcache_p0_cacheable.read() and r_dcache_pending_unc_write.read() ) 
2178            {
2179                r_dcache_p1_valid = false;
2180                break;
2181            }
2182
2183            // try a registration into write buffer
2184            bool wok = r_wbuf.write( r_dcache_p0_paddr.read(),
2185                                     r_dcache_p0_be.read(),
2186                                     r_dcache_p0_wdata.read(),
2187                                     r_dcache_p0_cacheable.read() );
2188#ifdef INSTRUMENTATION
2189m_cpt_wbuf_write++;
2190#endif
2191            // write buffer full
2192            if ( not wok ) 
2193            {
2194                r_dcache_p1_valid = false;
2195                break; 
2196            }
2197            // update the write_buffer state extension
2198            r_dcache_pending_unc_write = not r_dcache_p0_cacheable.read();
2199
2200            // read directory to detect local copy
2201            size_t  cache_way;
2202            size_t  cache_set;
2203            size_t  cache_word;
2204            bool    local_copy;
2205            if ( r_mmu_mode.read() & DATA_CACHE_MASK)   // cache activated
2206            {
2207                local_copy = r_dcache.hit( r_dcache_p0_paddr.read(),
2208                                           &cache_way,
2209                                           &cache_set,
2210                                           &cache_word );
2211#ifdef INSTRUMENTATION
2212m_cpt_dcache_dir_read++; 
2213#endif
2214            }
2215            else
2216            {
2217                local_copy = false;
2218            }
2219
2220            // dirty bit update requested
2221            bool dirty_req = (r_mmu_mode.read() & DATA_TLB_MASK) and not r_dcache_p0_tlb_dirty.read();
2222
2223            // if there is a local copy or a dirty bit update requested 
2224            if ( local_copy or dirty_req )
2225            {
2226                r_dcache_p1_valid       = true;
2227                r_dcache_p1_set_dirty   = dirty_req;
2228                r_dcache_p1_updt_cache  = local_copy;
2229                r_dcache_p1_vaddr       = r_dcache_p0_vaddr.read();
2230                r_dcache_p1_wdata       = r_dcache_p0_wdata.read();
2231                r_dcache_p1_be          = r_dcache_p0_be.read();
2232                r_dcache_p1_paddr       = r_dcache_p0_paddr.read();
2233                r_dcache_p1_tlb_way     = r_dcache_p0_tlb_way;
2234                r_dcache_p1_tlb_set     = r_dcache_p0_tlb_set;
2235                r_dcache_p1_tlb_nline   = r_dcache_p0_tlb_nline;
2236                r_dcache_p1_cache_way   = cache_way;
2237                r_dcache_p1_cache_set   = cache_set;
2238                r_dcache_p1_cache_word  = cache_word;
2239            }
2240            else
2241            {
2242                r_dcache_p1_valid       = false;
2243            }
2244        }
2245        else                            // P1 stage not activated
2246        {
2247            r_dcache_p1_valid = false; 
2248        } // end P1 stage
2249
2250        /////////////////////////////////////////////////////////////////////////////
2251        // handling P0 write pipe-line stage
2252        // This stage is controlling the DCACHE FSM state register:
2253        // - the FSM is frozen if a TLB invalidate operation must be delayed,
2254        // - the long write requests have the highest priority,
2255        // - then the external coherence requests,
2256        // - then the itlb miss requests,
2257        // - and finally the processor requests.
2258        // A processor read request generate a dcache access using speculative PPN
2259        // only if the write pipe-line is empty. There is an unconditionnal access
2260        // to the dtlb, using virtual address from processor.
2261        // The r_dcache_p0_valid value must be computed at all cycles.
2262
2263        bool p0_valid = false;  // default value
2264
2265        // TLB inval delayed
2266        if ( tlb_inval_frozen )
2267        {
2268            break;
2269        }
2270
2271        // long write request
2272        else if ( long_write_set_dirty )
2273        {
2274            r_dcache_fsm = DCACHE_WRITE_TLB_DIRTY;
2275        }
2276
2277        // external coherence request
2278        else if ( r_tgt_dcache_req.read() )   
2279        {
2280            r_dcache_fsm = DCACHE_CC_CHECK;
2281            r_dcache_fsm_save = DCACHE_IDLE;
2282        }       
2283
2284        // itlb miss request
2285        else if ( r_icache_tlb_miss_req.read() )
2286        {
2287            r_dcache_tlb_ins    = true;
2288            r_dcache_tlb_vaddr  = r_icache_vaddr_save.read();
2289            r_dcache_fsm        = DCACHE_TLB_MISS;
2290        }
2291
2292        // processor request
2293        else if (dreq.valid )
2294        {
2295            // dcache access using speculative PPN only if pipe-line empty
2296            paddr_t     cache_paddr;
2297            size_t      cache_way;
2298            size_t      cache_set;
2299            size_t      cache_word;
2300            uint32_t    cache_rdata;
2301            bool        cache_hit;
2302
2303            if ( (r_mmu_mode.read() & DATA_CACHE_MASK) and      // cache activated
2304                 not r_dcache_p0_valid.read() and
2305                 not r_dcache_p1_valid.read() )                 // pipe-line empty
2306            {
2307                cache_paddr = (r_dcache_p0_paddr.read() & ~PAGE_K_MASK) | 
2308                              ((paddr_t)dreq.addr & PAGE_K_MASK);
2309
2310                cache_hit = r_dcache.read( cache_paddr,
2311                                           &cache_rdata,
2312                                           &cache_way,
2313                                           &cache_set,
2314                                           &cache_word );
2315#ifdef INSTRUMENTATION
2316m_cpt_dcache_dir_read++;
2317m_cpt_dcache_data_read++;
2318#endif
2319            }
2320            else
2321            {
2322                cache_hit = false;
2323            } // end dcache access   
2324
2325            // systematic dtlb access using virtual address
2326
2327            paddr_t     tlb_paddr;
2328            pte_info_t  tlb_flags; 
2329            size_t      tlb_way; 
2330            size_t      tlb_set; 
2331            paddr_t     tlb_nline; 
2332            bool        tlb_hit;       
2333
2334            if ( r_mmu_mode.read() & DATA_TLB_MASK )    // TLB activated
2335            {
2336                tlb_hit = r_dtlb.translate( dreq.addr,
2337                                            &tlb_paddr,
2338                                            &tlb_flags,
2339                                            &tlb_nline,
2340                                            &tlb_way,   
2341                                            &tlb_set ); 
2342#ifdef INSTRUMENTATION
2343m_cpt_dtlb_read++;
2344#endif
2345                // register dtlb outputs
2346                r_dcache_p0_tlb_nline = tlb_nline;
2347                r_dcache_p0_tlb_way   = tlb_way;
2348                r_dcache_p0_tlb_set   = tlb_set;
2349                r_dcache_p0_tlb_dirty = tlb_flags.d;
2350                r_dcache_p0_tlb_big   = tlb_flags.b;
2351            }
2352            else
2353            {
2354                tlb_hit = false;
2355            } // end dtlb access
2356
2357            // register the processor request
2358            r_dcache_p0_vaddr = dreq.addr;
2359            r_dcache_p0_be    = dreq.be;
2360            r_dcache_p0_wdata = dreq.wdata;
2361
2362            // Handling READ XTN requests from processor
2363            // They are executed in this DCACHE_IDLE state.
2364            // The processor must not be in user mode
2365            if (dreq.type == iss_t::XTN_READ) 
2366            {
2367                int xtn_opcode = (int)dreq.addr/4;
2368
2369                // checking processor mode:
2370                if (dreq.mode  == iss_t::MODE_USER)
2371                {
2372                    r_mmu_detr = MMU_READ_PRIVILEGE_VIOLATION; 
2373                    r_mmu_dbvar  = dreq.addr;
2374                    drsp.valid            = true;
2375                    drsp.error            = true;
2376                    r_dcache_fsm          = DCACHE_IDLE;
2377                }
2378                else 
2379                {
2380                    switch( xtn_opcode ) 
2381                    {
2382                    case iss_t::XTN_INS_ERROR_TYPE:
2383                        drsp.rdata = r_mmu_ietr.read();
2384                        drsp.valid = true;
2385                        break;
2386
2387                    case iss_t::XTN_DATA_ERROR_TYPE:
2388                        drsp.rdata = r_mmu_detr.read();
2389                        drsp.valid = true;
2390                        break;
2391
2392                    case iss_t::XTN_INS_BAD_VADDR:
2393                        drsp.rdata = r_mmu_ibvar.read();       
2394                        drsp.valid = true;
2395                        break;
2396
2397                    case iss_t::XTN_DATA_BAD_VADDR:
2398                        drsp.rdata = r_mmu_dbvar.read();       
2399                        drsp.valid = true;
2400                        break;
2401
2402                    case iss_t::XTN_PTPR:
2403                        drsp.rdata = r_mmu_ptpr.read();
2404                        drsp.valid = true;
2405                        break;
2406
2407                    case iss_t::XTN_TLB_MODE:
2408                        drsp.rdata = r_mmu_mode.read();
2409                        drsp.valid = true;
2410                        break;
2411
2412                    case iss_t::XTN_MMU_PARAMS:
2413                        drsp.rdata = r_mmu_params.read();
2414                        drsp.valid = true;
2415                        break;
2416
2417                    case iss_t::XTN_MMU_RELEASE:
2418                        drsp.rdata = r_mmu_release.read();
2419                        drsp.valid = true;
2420                        break;
2421
2422                    case iss_t::XTN_MMU_WORD_LO:
2423                        drsp.rdata = r_mmu_word_lo.read();
2424                        drsp.valid = true;
2425                        break;
2426
2427                    case iss_t::XTN_MMU_WORD_HI:
2428                        drsp.rdata = r_mmu_word_hi.read();
2429                        drsp.valid = true;
2430                        break;
2431
2432                    default:
2433                        r_mmu_detr = MMU_READ_UNDEFINED_XTN; 
2434                        r_mmu_dbvar  = dreq.addr;
2435                        drsp.valid = true;
2436                        drsp.error = true;
2437                        break;
2438                    } // end switch xtn_opcode
2439                } // end else
2440            } // end if XTN_READ
2441
2442            // Handling WRITE XTN requests from processor.
2443            // They are not executed in this DCACHE_IDLE state,
2444            // if they require access to the caches or the TLBs
2445            // that are already accessed for speculative read.
2446            // Caches can be invalidated or flushed in user mode,
2447            // and the sync instruction can be executed in user mode
2448            else if (dreq.type == iss_t::XTN_WRITE) 
2449            {
2450                int xtn_opcode      = (int)dreq.addr/4;
2451                r_dcache_xtn_opcode = xtn_opcode;
2452
2453                // checking processor mode:
2454                if ( (dreq.mode  == iss_t::MODE_USER) &&
2455                     (xtn_opcode != iss_t:: XTN_SYNC) &&
2456                     (xtn_opcode != iss_t::XTN_DCACHE_INVAL) &&
2457                     (xtn_opcode != iss_t::XTN_DCACHE_FLUSH) &&
2458                     (xtn_opcode != iss_t::XTN_ICACHE_INVAL) &&
2459                     (xtn_opcode != iss_t::XTN_ICACHE_FLUSH) )
2460                {
2461                    r_mmu_detr = MMU_WRITE_PRIVILEGE_VIOLATION; 
2462                    r_mmu_dbvar  = dreq.addr;
2463                    drsp.valid          = true;
2464                    drsp.error          = true;
2465                    r_dcache_fsm        = DCACHE_IDLE;
2466                }
2467                else
2468                {
2469                    switch( xtn_opcode ) 
2470                    {     
2471                    case iss_t::XTN_PTPR:                       // itlb & dtlb must be flushed
2472                        r_mmu_ptpr       = dreq.wdata;
2473                        r_dcache_xtn_req = true;
2474                        r_dcache_fsm     = DCACHE_XTN_SWITCH;
2475                        break;
2476
2477                    case iss_t::XTN_TLB_MODE:                   // no cache or tlb access
2478                        r_mmu_mode = dreq.wdata;
2479                        drsp.valid = true;
2480                        r_dcache_fsm = DCACHE_IDLE;
2481                        break;
2482
2483                    case iss_t::XTN_DTLB_INVAL:                 // dtlb access
2484                        r_dcache_fsm = DCACHE_XTN_DT_INVAL; 
2485                        break;
2486
2487                    case iss_t::XTN_ITLB_INVAL:                 // itlb access
2488                        r_dcache_xtn_req = true;
2489                        r_dcache_fsm = DCACHE_XTN_IT_INVAL; 
2490                        break;
2491
2492                    case iss_t::XTN_DCACHE_INVAL:               // dcache, dtlb & itlb access
2493                        r_dcache_fsm = DCACHE_XTN_DC_INVAL_VA;
2494                        break;
2495
2496                    case iss_t::XTN_MMU_DCACHE_PA_INV:          // dcache, dtlb & itlb access
2497                        r_dcache_fsm   = DCACHE_XTN_DC_INVAL_PA;
2498                        r_dcache_p0_paddr = (paddr_t)r_mmu_word_hi.read() << 32 | 
2499                                         (paddr_t)r_mmu_word_lo.read();
2500                        break;
2501
2502                    case iss_t::XTN_DCACHE_FLUSH:              // itlb and dtlb must be reset 
2503                        r_dcache_flush_count = 0;
2504                        r_dcache_fsm         = DCACHE_XTN_DC_FLUSH; 
2505                        break;
2506
2507                    case iss_t::XTN_ICACHE_INVAL:               // icache and itlb access
2508                        r_dcache_xtn_req = true;
2509                        r_dcache_fsm     = DCACHE_XTN_IC_INVAL_VA; 
2510                        break;
2511
2512                    case iss_t::XTN_MMU_ICACHE_PA_INV:          // icache access
2513                        r_dcache_xtn_req = true;
2514                        r_dcache_fsm     = DCACHE_XTN_IC_INVAL_PA; 
2515                        break;
2516
2517                    case iss_t::XTN_ICACHE_FLUSH:               // icache access
2518                        r_dcache_xtn_req = true; 
2519                        r_dcache_fsm     = DCACHE_XTN_IC_FLUSH;
2520                        break;
2521
2522                    case iss_t::XTN_SYNC:                       // wait until write buffer empty
2523                        r_dcache_fsm     = DCACHE_XTN_SYNC;
2524                        break;
2525
2526                    case iss_t::XTN_MMU_WORD_LO:                // no cache or tlb access
2527                        r_mmu_word_lo = dreq.wdata;
2528                        drsp.valid    = true;
2529                        r_dcache_fsm  = DCACHE_IDLE;
2530                        break;
2531
2532                    case iss_t::XTN_MMU_WORD_HI:                // no cache or tlb access
2533                        r_mmu_word_hi = dreq.wdata;
2534                        drsp.valid    = true;
2535                        r_dcache_fsm  = DCACHE_IDLE;
2536                        break;
2537
2538                    case iss_t::XTN_ICACHE_PREFETCH:            // not implemented : no action
2539                    case iss_t::XTN_DCACHE_PREFETCH:            // not implemented : no action
2540                        drsp.valid   = true;
2541                        r_dcache_fsm = DCACHE_IDLE;
2542                        break;
2543       
2544                    default:
2545                        r_mmu_detr = MMU_WRITE_UNDEFINED_XTN; 
2546                        r_mmu_dbvar  = dreq.addr;
2547                        drsp.valid = true;
2548                        drsp.error = true;
2549                        r_dcache_fsm = DCACHE_IDLE;
2550                        break;
2551                    } // end switch xtn_opcode
2552                } // end else
2553            } // end if XTN_WRITE
2554
2555            // Handling read/write processor requests.
2556            // The dtlb and dcache can be activated or not.
2557            // We compute the physical address, the cacheability, and check processor request.
2558            // - If DTLB not activated : cacheability is defined by the segment table,
2559            //   the physical address is equal to the virtual address (identity mapping)
2560            // - If DTLB activated : cacheability is defined by the C bit in the PTE,
2561            //   the physical address is obtained from the TLB, and the U & W bits
2562            //   of the PTE are checked.
2563            // The processor request is decoded only if the TLB is not activated or if
2564            // the virtual address hits in tLB and access rights are OK.
2565            // We call the TLB_MISS sub-fsm in case of dtlb miss.
2566            else
2567            {
2568                bool    valid_req = false;
2569                bool    cacheable = false;
2570                paddr_t paddr     = 0;
2571
2572                if ( not (r_mmu_mode.read() & DATA_TLB_MASK) )          // dtlb not activated
2573                {
2574                    valid_req     = true;
2575
2576                    // cacheability
2577                    if ( not (r_mmu_mode.read() & DATA_CACHE_MASK) ) cacheable = false;
2578                    else cacheable = m_cacheability_table[dreq.addr];
2579
2580                    // physical address
2581                    paddr       = (paddr_t)dreq.addr;
2582                }
2583                else                                                    // dtlb activated
2584                {
2585                    if ( tlb_hit )                                      // tlb hit
2586                    {
2587                        // cacheability
2588                        if ( not (r_mmu_mode.read() & DATA_CACHE_MASK) ) cacheable = false;
2589                        else cacheable = tlb_flags.c;
2590
2591                        // access rights checking
2592                        if ( not tlb_flags.u and (dreq.mode == iss_t::MODE_USER)) 
2593                        {
2594                            if ( (dreq.type == iss_t::DATA_READ) or (dreq.type == iss_t::DATA_LL) )
2595                                r_mmu_detr = MMU_READ_PRIVILEGE_VIOLATION;
2596                            else 
2597                                r_mmu_detr = MMU_WRITE_PRIVILEGE_VIOLATION;
2598
2599                            r_mmu_dbvar  = dreq.addr;
2600                            drsp.valid   = true;
2601                            drsp.error   = true;
2602                            drsp.rdata   = 0;
2603                        }
2604                        else if ( not tlb_flags.w and
2605                                  ((dreq.type == iss_t::DATA_WRITE) or
2606                                   (dreq.type == iss_t::DATA_SC)) ) 
2607                        {
2608                            r_mmu_detr   = MMU_WRITE_ACCES_VIOLATION; 
2609                            r_mmu_dbvar  = dreq.addr;
2610                            drsp.valid   = true;
2611                            drsp.error   = true;
2612                            drsp.rdata   = 0;
2613                        }
2614                        else
2615                        {
2616                            valid_req    = true;
2617                        }
2618
2619                        // physical address
2620                        paddr       = tlb_paddr;
2621                    }
2622                    else                                                // tlb miss
2623                    {
2624                        r_dcache_tlb_vaddr   = dreq.addr;
2625                        r_dcache_tlb_ins     = false; 
2626                        r_dcache_fsm         = DCACHE_TLB_MISS;
2627                    }
2628                }    // end DTLB activated
2629
2630                if ( valid_req )        // processor request is valid
2631                {
2632                    // physical address and cacheability registration
2633                    r_dcache_p0_paddr          = paddr;
2634                    r_dcache_p0_cacheable      = cacheable;
2635
2636                    // READ or LL request
2637                    // The read requests are taken only if the write pipe-line is empty.
2638                    // If dcache hit, dtlb hit, and speculative PPN OK, data in one cycle.
2639                    // If speculative access is KO we just pay one extra cycle.
2640                    // If dcache miss, we go to DCACHE_MISS_VICTIM state.
2641                    // If uncacheable, we go to DCACHE_UNC_WAIT state.
2642                    if ( ((dreq.type == iss_t::DATA_READ) or (dreq.type == iss_t::DATA_LL)) and
2643                         not r_dcache_p0_valid.read() and not r_dcache_p1_valid.read() )
2644                    { 
2645                        if ( cacheable )                        // cacheable read
2646                        {
2647                            // if the speculative access is illegal, we pay an extra cycle
2648                            if ( (r_dcache_p0_paddr.read() & ~PAGE_K_MASK) 
2649                                 != (paddr & ~PAGE_K_MASK))
2650                            {
2651#ifdef INSTRUMENTATION
2652m_cpt_dcache_spec_miss++;
2653#endif
2654                            }
2655                            // if cache miss, try to get the missing line
2656                            else if ( not cache_hit )
2657                            {
2658#ifdef INSTRUMENTATION
2659m_cpt_dcache_miss++;
2660#endif
2661                                // blocked in IDLE state if previous cleanup not completed
2662                                if ( not r_dcache_cleanup_req.read() )
2663                                {
2664                                    r_dcache_vci_paddr    = paddr;
2665                                    r_dcache_vci_miss_req = true;
2666                                    r_dcache_miss_type    = PROC_MISS;
2667                                    r_dcache_fsm          = DCACHE_MISS_VICTIM;
2668                                }
2669                            }
2670                            // if cache hit return the data
2671                            else                   
2672                            {
2673#ifdef INSTRUMENTATION
2674m_cpt_data_read++;
2675#endif
2676                                drsp.valid   = true;
2677                                drsp.rdata   = cache_rdata;
2678                            }
2679                        }
2680                        else                                    // uncacheable read
2681                        {
2682                            r_dcache_vci_paddr    = paddr;
2683                            r_dcache_vci_unc_be   = dreq.be;
2684                            r_dcache_vci_unc_req  = true;
2685                            r_dcache_fsm          = DCACHE_UNC_WAIT;
2686                        }
2687
2688                        // makes reservation in case of LL
2689                        if ( dreq.type == iss_t::DATA_LL )
2690                        {
2691                            r_dcache_ll_valid = true;
2692                            r_dcache_ll_data  = cache_rdata;
2693                            r_dcache_ll_vaddr = dreq.addr;
2694                        }
2695                    } // end READ or LL
2696
2697                    // WRITE request:
2698                    // The write request arguments have been registered.
2699                    // The physical address has been computed and registered.
2700                    // We acknowledge the processor request and activate the P1 pipeline stage.
2701                    else if ( dreq.type == iss_t::DATA_WRITE )
2702                    {
2703
2704#ifdef INSTRUMENTATION
2705m_cpt_data_write++;
2706#endif
2707                        p0_valid   = true;
2708                        drsp.valid = true;
2709                        drsp.rdata = 0;
2710                    } // end WRITE
2711 
2712                    // SC request:
2713                    // - if a valid LL reservation (with the same address) is registered,
2714                    // we request a SC transaction to CMD FSM and go to the DCACHE_UNC_WAIT state
2715                    // that will directly return the response to the processor, and invalidate
2716                    // the LL reservation. We don't check a possible write hit in dcache,
2717                    // as the cache update is done by the coherence transaction...
2718                    // - if there is no registerd LL, we just stay in IDLE state, invalidate
2719                    // the LL reservation, and return 1 (atomic access failed)
2720                    else if ( dreq.type == iss_t::DATA_SC )
2721                    {
2722#ifdef INSTRUMENTATION
2723m_cpt_data_sc++;
2724#endif
2725                        // test if valid registered LL
2726                        if ( r_dcache_ll_valid.read() and (r_dcache_ll_vaddr.read() == dreq.addr))
2727                        { 
2728                            r_dcache_vci_paddr      = paddr;
2729                            r_dcache_vci_sc_req     = true;
2730                            r_dcache_vci_sc_old     = r_dcache_ll_data.read();
2731                            r_dcache_vci_sc_new     = dreq.wdata;
2732                            r_dcache_fsm            = DCACHE_UNC_WAIT;
2733                        }
2734                        else                                    // no registered LL
2735                        {
2736                            drsp.valid        = true;
2737                            drsp.rdata        = 1;
2738                            r_dcache_ll_valid = false;
2739                        }
2740                    } // end SC
2741                } // end valid_req
2742            }  // end if read/write request     
2743        } // end P0 pipe stage
2744
2745        r_dcache_p0_valid = p0_valid;
2746        break;
2747    } 
2748    /////////////////////
2749    case DCACHE_TLB_MISS: // This is the entry point for the sub-fsm handling tlb miss.
2750                          // - Input arguments are r_dcache_tlb_vaddr & r_dcache_tlb_ins
2751                          // - It try to find the missing TLB entry in dcache,
2752                          //   and activates the cache miss procedure in case of miss.
2753                          // - It bypass the first level page table access if possible.
2754                          // - It uses atomic access to update the R/L access bits
2755                          //   in the page table if required.
2756                          // - It directly updates the itlb or dtlb, and writes into the
2757                          //   r_mmu_ins_* or r_mmu_data* error reporting registers.
2758    {
2759        uint32_t        ptba = 0;
2760        bool            bypass;
2761        paddr_t         paddr;
2762
2763        // evaluate bypass in order to skip first level page table access
2764        if ( r_dcache_tlb_ins.read() )                          // itlb miss
2765        {
2766            bypass = r_itlb.get_bypass(r_dcache_tlb_vaddr.read(), &ptba);
2767        }
2768        else                                                    // dtlb miss
2769        {
2770            bypass = r_dtlb.get_bypass(r_dcache_tlb_vaddr.read(), &ptba);
2771        }
2772
2773        if ( not bypass )     // Try to read the PTE1/PTD1 in dcache
2774        {
2775            paddr = (paddr_t)r_mmu_ptpr.read() << (INDEX1_NBITS+2) |
2776                    (paddr_t)((r_dcache_tlb_vaddr.read() >> PAGE_M_NBITS) << 2);
2777            r_dcache_tlb_paddr = paddr;
2778            r_dcache_fsm       = DCACHE_TLB_PTE1_GET;
2779        }
2780        else                  // Try to read directly the PTE2 in dcache
2781        {
2782            paddr = (paddr_t)ptba << PAGE_K_NBITS |
2783                    (paddr_t)(r_dcache_tlb_vaddr.read()&PTD_ID2_MASK)>>(PAGE_K_NBITS-3);
2784            r_dcache_tlb_paddr = paddr;
2785            r_dcache_fsm       = DCACHE_TLB_PTE2_GET;
2786        }
2787
2788#if DEBUG_DCACHE
2789if ( m_debug_dcache_fsm )
2790{
2791    if ( r_dcache_tlb_ins.read() ) 
2792        std::cout << "  <PROC.DCACHE_TLB_MISS> ITLB miss request:";
2793    else                           
2794        std::cout << "  <PROC.DCACHE_TLB_MISS> DTLB miss request:";
2795    std::cout << " vaddr = " << std::hex << r_dcache_tlb_vaddr.read()
2796              << " / bypass = " << bypass
2797              << " / PTE address = " << paddr << std::endl;
2798}
2799#endif
2800 
2801        break;
2802    }
2803    ///////////////////////// 
2804    case DCACHE_TLB_PTE1_GET:   // try to read a PT1 entry in dcache
2805    {
2806        uint32_t        entry;
2807        size_t          way;
2808        size_t          set;
2809        size_t          word;
2810
2811        bool     hit = r_dcache.read( r_dcache_tlb_paddr.read(),
2812                                      &entry,
2813                                      &way,
2814                                      &set,
2815                                      &word );
2816#ifdef INSTRUMENTATION
2817m_cpt_dcache_data_read++;
2818m_cpt_dcache_dir_read++;
2819#endif
2820        if ( hit )      // request hit in dcache
2821        {
2822            if ( not (entry & PTE_V_MASK) )     // unmapped
2823            {
2824                if ( r_dcache_tlb_ins.read() ) 
2825                {
2826                    r_mmu_ietr             = MMU_READ_PT1_UNMAPPED;
2827                    r_mmu_ibvar            = r_dcache_tlb_vaddr.read();
2828                    r_icache_tlb_miss_req  = false;
2829                    r_icache_tlb_rsp_error = true;
2830                }
2831                else
2832                {
2833                    r_mmu_detr             = MMU_READ_PT1_UNMAPPED;
2834                    r_mmu_dbvar            = r_dcache_tlb_vaddr.read();
2835                    drsp.valid             = true;
2836                    drsp.error             = true;
2837                }
2838                r_dcache_fsm          = DCACHE_IDLE;
2839
2840#if DEBUG_DCACHE
2841if ( m_debug_dcache_fsm )
2842{
2843    std::cout << "  <PROC.DCACHE_TLB_PTE1_GET> HIT in dcache, but unmapped:"
2844              << std::dec << " way = " << way
2845              << std::dec << " / set = " << set
2846              << std::dec << " / word = " << word
2847              << std::hex << " / PTE1 = " << entry << std::endl;
2848}
2849#endif
2850 
2851            }
2852            else if( entry & PTE_T_MASK )       //  PTD : access PT2
2853            {
2854                // register bypass
2855                if ( r_dcache_tlb_ins.read() )          // itlb
2856                {
2857                    r_itlb.set_bypass(r_dcache_tlb_vaddr.read(),
2858                                      entry & ((1 << (m_paddr_nbits-PAGE_K_NBITS)) - 1), 
2859                                      r_dcache_tlb_paddr.read() >> (uint32_log2(m_icache_words<<2))); 
2860                }
2861                else                                    // dtlb
2862                {
2863                    r_dtlb.set_bypass(r_dcache_tlb_vaddr.read(),
2864                                      entry & ((1 << (m_paddr_nbits-PAGE_K_NBITS)) - 1),
2865                                      r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words)+2));
2866                }
2867                r_dcache_tlb_paddr = (paddr_t)(entry & ((1<<(m_paddr_nbits-PAGE_K_NBITS))-1)) << PAGE_K_NBITS |
2868                                     (paddr_t)(((r_dcache_tlb_vaddr.read() & PTD_ID2_MASK) >> PAGE_K_NBITS) << 3);
2869                r_dcache_fsm       = DCACHE_TLB_PTE2_GET;
2870
2871#if DEBUG_DCACHE
2872if ( m_debug_dcache_fsm )
2873{
2874    std::cout << "  <PROC.DCACHE_TLB_PTE1_GET> HIT in dcache "
2875              << std::dec << " way = " << way
2876              << std::dec << " / set = " << set
2877              << std::dec << " / word = " << word
2878              << std::hex << " / PTD = " << entry << std::endl;
2879}
2880#endif
2881            }
2882            else                        //  PTE1 :  update the TLB
2883            {
2884                if ( r_dcache_tlb_ins.read() ) 
2885                    r_dcache_in_itlb[m_icache_sets*way+set] = true;
2886                else                           
2887                    r_dcache_in_dtlb[m_dcache_sets*way+set] = true;
2888                r_dcache_tlb_pte_flags  = entry;
2889                r_dcache_tlb_cache_way  = way;
2890                r_dcache_tlb_cache_set  = set;
2891                r_dcache_tlb_cache_word = word;
2892                r_dcache_fsm            = DCACHE_TLB_PTE1_SELECT;
2893
2894#if DEBUG_DCACHE
2895if ( m_debug_dcache_fsm )
2896{
2897    std::cout << "  <PROC.DCACHE_TLB_PTE1_GET> HIT in dcache:"
2898              << std::dec << " way = " << way
2899              << std::dec << " / set = " << set
2900              << std::dec << " / word = " << word
2901              << std::hex << " / PTE1 = " << entry << std::endl;
2902}
2903#endif
2904            }
2905        }
2906        else            // we must load the missing cache line in dcache
2907        {
2908            r_dcache_vci_paddr     = r_dcache_tlb_paddr.read(); 
2909            r_dcache_miss_type     = PTE1_MISS;
2910            r_dcache_fsm           = DCACHE_MISS_VICTIM;         
2911            r_dcache_vci_miss_req  = true;             
2912
2913#if DEBUG_DCACHE
2914if ( m_debug_dcache_fsm )
2915{
2916    std::cout << "  <PROC.DCACHE_TLB_PTE1_GET> MISS in dcache:"
2917              << " PTE1 address = " << std::hex << r_dcache_tlb_paddr.read() << std::endl;
2918}
2919#endif
2920        }
2921        break;
2922    }
2923    ////////////////////////////
2924    case DCACHE_TLB_PTE1_SELECT:        // select a slot for PTE1
2925    {
2926        size_t  way;
2927        size_t  set;
2928
2929        if ( r_dcache_tlb_ins.read() )
2930        {
2931            r_itlb.select( r_dcache_tlb_vaddr.read(),
2932                           true,  // PTE1
2933                           &way,
2934                           &set );
2935#ifdef INSTRUMENTATION
2936m_cpt_itlb_read++;
2937#endif
2938        }
2939        else
2940        {
2941            r_dtlb.select( r_dcache_tlb_vaddr.read(),
2942                           true,  // PTE1
2943                           &way,
2944                           &set );
2945#ifdef INSTRUMENTATION
2946m_cpt_dtlb_read++;
2947#endif
2948        }
2949        r_dcache_tlb_way = way;
2950        r_dcache_tlb_set = set;
2951        r_dcache_fsm     = DCACHE_TLB_PTE1_UPDT;
2952
2953#if DEBUG_DCACHE
2954if ( m_debug_dcache_fsm )
2955{
2956    if ( r_dcache_tlb_ins.read() ) 
2957        std::cout << "  <PROC.DCACHE_TLB_PTE1_SELECT> Select a slot in ITLB:";
2958    else                           
2959        std::cout << "  <PROC.DCACHE_TLB_PTE1_SELECT> Select a slot in DTLB:";
2960        std::cout << " way = " << std::dec << way
2961                  << " / set = " << set << std::endl;
2962}
2963#endif
2964        break;
2965    }
2966    //////////////////////////
2967    case DCACHE_TLB_PTE1_UPDT:  // write a new PTE1 in tlb after testing the L/R bit
2968                                // if L/R bit already set, exit the sub-fsm
2969                                // if not, the page table must be updated
2970    {
2971        paddr_t   nline = r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words)+2);   
2972        uint32_t  pte   = r_dcache_tlb_pte_flags.read();
2973        bool      updt  = false;
2974
2975        //  test the access bits L/R, depending on the physical address locality
2976        //  we must use the 10 MSB bits of the 19 bits PPN1 to obtain the target index
2977        //  we must use the 10 MSB bits of the SRCID to obtain the local index
2978        //  set the r_dcache_vci_sc_old and r_dcache_vci_sc_new registers if SC required
2979
2980        uint32_t target = (pte >> 9) & 0x3FF;
2981        uint32_t local  = m_srcid_d >> 4;
2982
2983        if ( local == target )                                          // local_address
2984        {
2985            if ( not ((pte & PTE_L_MASK) == PTE_L_MASK) ) // we must set the L bit
2986            {
2987                updt            = true;
2988                r_dcache_vci_sc_old = r_dcache_tlb_pte_flags.read();
2989                r_dcache_vci_sc_new = r_dcache_tlb_pte_flags.read() | PTE_L_MASK;
2990            }
2991        }
2992        else                                                            // remote address
2993        {
2994            if ( not ((pte & PTE_R_MASK) == PTE_R_MASK) ) // we must set the R bit
2995            {
2996                updt                = true;
2997                r_dcache_vci_sc_old = r_dcache_tlb_pte_flags.read();
2998                r_dcache_vci_sc_new = r_dcache_tlb_pte_flags.read() | PTE_R_MASK;
2999            }
3000        }
3001
3002        // update TLB
3003        if ( r_dcache_tlb_ins.read() ) 
3004        {
3005            r_itlb.write( pte,
3006                          r_dcache_tlb_vaddr.read(),   
3007                          r_dcache_tlb_way.read(), 
3008                          r_dcache_tlb_set.read(),
3009                          nline );
3010#ifdef INSTRUMENTATION
3011m_cpt_itlb_write++;
3012#endif
3013        }
3014        else
3015        {
3016            r_dtlb.write( pte,
3017                          r_dcache_tlb_vaddr.read(),   
3018                          r_dcache_tlb_way.read(), 
3019                          r_dcache_tlb_set.read(),
3020                          nline );
3021#ifdef INSTRUMENTATION
3022m_cpt_dtlb_write++;
3023#endif
3024        }
3025        // next state
3026        if ( updt ) r_dcache_fsm = DCACHE_TLB_SC_UPDT;  // dcache and page table update
3027        else        r_dcache_fsm = DCACHE_TLB_RETURN;   // exit sub-fsm
3028
3029#if DEBUG_DCACHE
3030if ( m_debug_dcache_fsm )
3031{
3032    if ( r_dcache_tlb_ins.read() ) 
3033    {
3034        std::cout << "  <PROC.DCACHE_TLB_PTE1_UPDT> write PTE1 in ITLB:";
3035        std::cout << " way = " << std::dec << r_dcache_tlb_way.read()
3036                  << " / set = " << r_dcache_tlb_set.read() << std::endl;
3037        r_itlb.print();
3038    }
3039    else                           
3040    {
3041        std::cout << "  <PROC.DCACHE_TLB_PTE1_UPDT> write PTE1 in DTLB:";
3042        std::cout << " way = " << std::dec << r_dcache_tlb_way.read()
3043                  << " / set = " << r_dcache_tlb_set.read() << std::endl;
3044        r_dtlb.print();
3045    }
3046   
3047}
3048#endif
3049        break;
3050    }
3051    /////////////////////////
3052    case DCACHE_TLB_PTE2_GET:   // Try to get a PTE2 (64 bits) in the dcache
3053    {
3054        uint32_t        pte_flags;
3055        uint32_t        pte_ppn;
3056        size_t          way;
3057        size_t          set;
3058        size_t          word; 
3059 
3060        bool     hit = r_dcache.read( r_dcache_tlb_paddr.read(),
3061                                      &pte_flags,
3062                                      &pte_ppn,
3063                                      &way,
3064                                      &set,
3065                                      &word );
3066#ifdef INSTRUMENTATION
3067m_cpt_dcache_data_read++;
3068m_cpt_dcache_dir_read++;
3069#endif
3070        if ( hit )      // request hits in dcache
3071        {
3072            if ( not (pte_flags & PTE_V_MASK) ) // unmapped
3073            {
3074                if ( r_dcache_tlb_ins.read() ) 
3075                {
3076                    r_mmu_ietr             = MMU_READ_PT2_UNMAPPED;
3077                    r_mmu_ibvar            = r_dcache_tlb_vaddr.read();
3078                    r_icache_tlb_miss_req  = false;
3079                    r_icache_tlb_rsp_error = true;
3080                }
3081                else
3082                {
3083                    r_mmu_detr             = MMU_READ_PT2_UNMAPPED;
3084                    r_mmu_dbvar            = r_dcache_tlb_vaddr.read();
3085                    drsp.valid             = true;
3086                    drsp.error             = true;
3087                }
3088                r_dcache_fsm          = DCACHE_IDLE;
3089
3090#if DEBUG_DCACHE
3091if ( m_debug_dcache_fsm )
3092{
3093    std::cout << "  <PROC.DCACHE_TLB_PTE2_GET> HIT in dcache, but PTE is unmapped"
3094              << " PTE_FLAGS = " << std::hex << pte_flags
3095              << " PTE_PPN = " << std::hex << pte_ppn << std::endl;
3096}
3097#endif
3098            }
3099            else                                // mapped : update the TLB
3100            {
3101                if ( r_dcache_tlb_ins.read() ) r_dcache_in_itlb[m_icache_sets*way+set] = true;
3102                else                           r_dcache_in_dtlb[m_dcache_sets*way+set] = true;
3103                r_dcache_tlb_pte_flags  = pte_flags;
3104                r_dcache_tlb_pte_ppn    = pte_ppn;
3105                r_dcache_tlb_cache_way  = way;
3106                r_dcache_tlb_cache_set  = set;
3107                r_dcache_tlb_cache_word = word;
3108                r_dcache_fsm            = DCACHE_TLB_PTE2_SELECT;
3109
3110#if DEBUG_DCACHE
3111if ( m_debug_dcache_fsm )
3112{
3113    std::cout << "  <PROC.DCACHE_TLB_PTE2_GET> HIT in dcache:"
3114              << " PTE_FLAGS = " << std::hex << pte_flags
3115              << " PTE_PPN = " << std::hex << pte_ppn << std::endl;
3116}
3117#endif
3118             }
3119        }
3120        else            // we must load the missing cache line in dcache
3121        {
3122            r_dcache_vci_paddr    = r_dcache_tlb_paddr.read();
3123            r_dcache_miss_type    = PTE2_MISS;
3124            r_dcache_fsm          = DCACHE_MISS_VICTIM; 
3125            r_dcache_vci_miss_req = true;
3126
3127#if DEBUG_DCACHE
3128if ( m_debug_dcache_fsm )
3129{
3130    std::cout << "  <PROC.DCACHE_TLB_PTE2_GET> MISS in dcache:"
3131              << " PTE address = " << std::hex << r_dcache_tlb_paddr.read() << std::endl;
3132}
3133#endif
3134        }
3135        break;
3136    }
3137    ////////////////////////////
3138    case DCACHE_TLB_PTE2_SELECT:    // select a slot for PTE2
3139    {
3140        size_t way;
3141        size_t set;
3142
3143        if ( r_dcache_tlb_ins.read() )
3144        {
3145            r_itlb.select( r_dcache_tlb_vaddr.read(),
3146                           false,       // PTE2
3147                           &way,
3148                           &set );
3149#ifdef INSTRUMENTATION
3150m_cpt_itlb_read++;
3151#endif
3152        }
3153        else
3154        {
3155            r_dtlb.select( r_dcache_tlb_vaddr.read(),
3156                           false,       // PTE2
3157                           &way,
3158                           &set );
3159#ifdef INSTRUMENTATION
3160m_cpt_dtlb_read++;
3161#endif
3162        }
3163        r_dcache_tlb_way = way;
3164        r_dcache_tlb_set = set;
3165        r_dcache_fsm     = DCACHE_TLB_PTE2_UPDT;
3166        break;
3167    }
3168    //////////////////////////
3169    case DCACHE_TLB_PTE2_UPDT:          // write a new PTE2 in tlb after testing the L/R bit
3170                                        // if L/R bit already set exit the sub-fsm
3171                                        // if not, the page table must be updated by an atomic access
3172    {
3173        paddr_t         nline     = r_dcache_p0_paddr.read() >> (uint32_log2(m_dcache_words)+2);   
3174        uint32_t        pte_flags = r_dcache_tlb_pte_flags.read();
3175        uint32_t        pte_ppn   = r_dcache_tlb_pte_ppn.read();
3176        bool            updt      = false;                         // page table update required
3177
3178        //  test the access bit L/R, depending on the physical address locality
3179        //  we must use the 10 MSB bits of the 28 bits PPN2 to obtain the target cluster index
3180        //  we must use the 10 MSB bits of the SRCID to obtain the local cluster index
3181        //  set the r_dcache_vci_sc_old and r_dcache_vci_sc_new registers if SC required.
3182
3183        uint32_t target = (pte_ppn >> 18) & 0x3FF;
3184        uint32_t local  = m_srcid_d >> 4;
3185
3186        if ( local == target )                                          // local address
3187        {
3188            if ( not ((pte_flags & PTE_L_MASK) == PTE_L_MASK) ) // we must set the L bit
3189            {
3190                updt                   = true;
3191                r_dcache_vci_sc_old        = r_dcache_tlb_pte_flags.read();
3192                r_dcache_vci_sc_new        = r_dcache_tlb_pte_flags.read() | PTE_L_MASK;
3193            }
3194        }
3195        else                                                             // remote address
3196        {
3197            if ( not ((pte_flags & PTE_R_MASK) == PTE_R_MASK) ) // we must set the R bit
3198            {
3199                updt                   = true;
3200                r_dcache_vci_sc_old        = r_dcache_tlb_pte_flags.read();
3201                r_dcache_vci_sc_new        = r_dcache_tlb_pte_flags.read() | PTE_R_MASK;
3202            }
3203        }
3204       
3205        // update TLB for a PTE2
3206        if ( r_dcache_tlb_ins.read() ) 
3207        {
3208            r_itlb.write( pte_flags,
3209                          pte_ppn,
3210                          r_dcache_tlb_vaddr.read(),   
3211                          r_dcache_tlb_way.read(), 
3212                          r_dcache_tlb_set.read(),
3213                          nline );
3214#ifdef INSTRUMENTATION
3215m_cpt_itlb_write++;
3216#endif
3217        }
3218        else
3219        {
3220            r_dtlb.write( pte_flags,
3221                          pte_ppn,
3222                          r_dcache_tlb_vaddr.read(),   
3223                          r_dcache_tlb_way.read(), 
3224                          r_dcache_tlb_set.read(),
3225                          nline );
3226#ifdef INSTRUMENTATION
3227m_cpt_dtlb_write++;
3228#endif
3229        }
3230
3231#if DEBUG_DCACHE
3232if ( m_debug_dcache_fsm )
3233{
3234    if ( r_dcache_tlb_ins.read() ) 
3235    {
3236        std::cout << "  <PROC.DCACHE_TLB_PTE2_UPDT> write PTE2 in ITLB:";
3237        std::cout << " way = " << std::dec << r_dcache_tlb_way.read()
3238                  << " / set = " << r_dcache_tlb_set.read() << std::endl;
3239        r_itlb.print();
3240    }
3241    else                           
3242    {
3243        std::cout << "  <PROC.DCACHE_TLB_PTE2_UPDT> write PTE2 in DTLB:";
3244        std::cout << " way = " << std::dec << r_dcache_tlb_way.read()
3245                  << " / set = " << r_dcache_tlb_set.read() << std::endl;
3246        r_dtlb.print();
3247    }
3248}
3249#endif
3250        // next state
3251        if ( updt ) r_dcache_fsm = DCACHE_TLB_SC_UPDT;  // dcache and page table update
3252        else        r_dcache_fsm = DCACHE_TLB_RETURN;   // exit sub-fsm
3253        break;
3254    }
3255    ////////////////////////
3256    case DCACHE_TLB_SC_UPDT:            // update the dcache after a tlb miss (L/R bit),
3257                                        // request a SC transaction to CMD FSM
3258    {
3259        r_dcache.write(r_dcache_tlb_cache_way.read(),
3260                       r_dcache_tlb_cache_set.read(),
3261                       r_dcache_tlb_cache_word.read(),
3262                       r_dcache_tlb_pte_flags.read());
3263#ifdef INSTRUMENTATION
3264m_cpt_dcache_data_write++;
3265#endif
3266        // r_dcache_vci_sc_old & r_dcache_vci_sc_new registers are already set
3267        r_dcache_vci_sc_req  = true;
3268        r_dcache_fsm         = DCACHE_TLB_SC_WAIT;
3269        break;
3270    }
3271    ////////////////////////
3272    case DCACHE_TLB_SC_WAIT:                // wait response to SC transaction from RSP FSM
3273                                        // we consume the response, and exit the sub-fsm.
3274                                        // we don't analyse the response, because
3275                                        // we don't care if the L/R bit update is not done
3276                                        // we must take the coherence requests because
3277                                        // there is a risk of dead-lock
3278
3279    {
3280        // external coherence request
3281        if ( r_tgt_dcache_req )
3282        {
3283            r_dcache_fsm = DCACHE_CC_CHECK;
3284            r_dcache_fsm_save = r_dcache_fsm;
3285            break;
3286        }
3287
3288        if ( not r_dcache_vci_sc_req.read() )   // response available
3289        {
3290            if ( r_vci_rsp_data_error.read() )          r_vci_rsp_data_error = false;
3291            else if ( r_vci_rsp_fifo_dcache.rok() )     vci_rsp_fifo_dcache_get = true;
3292            else
3293            {
3294                assert( false and "rsp_fifo should not be empty in DCACHE_TLB_SC_WAIT state" );
3295            }
3296            r_dcache_fsm     = DCACHE_TLB_RETURN;
3297        }
3298        break;
3299    }
3300    ///////////////////////
3301    case DCACHE_TLB_RETURN:             // return to caller state depending on the tlb miss type
3302    {
3303        if ( r_dcache_tlb_ins.read() ) r_icache_tlb_miss_req = false;
3304        r_dcache_fsm = DCACHE_IDLE;
3305        break;
3306    }
3307    ///////////////////////
3308    case DCACHE_XTN_SWITCH:             // Both itlb and dtlb must be flushed
3309    {
3310        if ( not r_dcache_xtn_req.read() )
3311        {
3312            r_dtlb.flush();
3313            r_dcache_fsm = DCACHE_IDLE;
3314            drsp.valid = true;
3315        }
3316        break;
3317    }
3318    /////////////////////
3319    case DCACHE_XTN_SYNC:               // waiting until write buffer empty
3320                                        // The coherence request must be taken
3321                                        // as there is a risk of dead-lock
3322    {
3323        // external coherence request
3324        if ( r_tgt_dcache_req.read() )   
3325        {
3326            r_dcache_fsm = DCACHE_CC_CHECK;
3327            r_dcache_fsm_save = DCACHE_XTN_SYNC;
3328        }       
3329
3330        if ( r_wbuf.empty() )
3331        {
3332            drsp.valid   = true;
3333            r_dcache_fsm = DCACHE_IDLE;
3334        }
3335        break;
3336    }
3337    ////////////////////////
3338    case DCACHE_XTN_IC_FLUSH:           // Waiting completion of an XTN request to the ICACHE FSM
3339    case DCACHE_XTN_IC_INVAL_VA:        // Caution : the itlb miss requests must be taken
3340    case DCACHE_XTN_IC_INVAL_PA:        // because the XTN_ICACHE_INVAL request to icache
3341    case DCACHE_XTN_IT_INVAL:           // can generate an itlb miss...
3342    {
3343        // external coherence request
3344        if ( r_tgt_dcache_req )   
3345        {
3346            r_dcache_fsm = DCACHE_CC_CHECK;
3347            r_dcache_fsm_save = r_dcache_fsm;
3348            break;
3349        } 
3350
3351        // itlb miss request
3352        if ( r_icache_tlb_miss_req.read() )
3353        {
3354            r_dcache_tlb_ins    = true;
3355            r_dcache_tlb_vaddr  = r_icache_vaddr_save.read();
3356            r_dcache_fsm        = DCACHE_TLB_MISS;
3357            break;
3358        }
3359
3360        // test if XTN request to icache completed
3361        if ( not r_dcache_xtn_req.read() ) 
3362        {
3363            r_dcache_fsm = DCACHE_IDLE;
3364            drsp.valid = true;
3365        }
3366        break;
3367    }
3368    /////////////////////////
3369    case DCACHE_XTN_DC_FLUSH:   // Invalidate sequencially all cache lines, using
3370                                // the r_dcache_flush counter as a slot counter.
3371                                // We loop in this state until all slots have been visited.
3372                                // A cleanup request is generated for each valid line
3373                                // and we are blocked until the previous cleanup is completed
3374                                // Finally, both the itlb and dtlb are reset, because
3375                                // all TLB entries (including global entries) must be invalidated.
3376    {
3377        if ( not r_dcache_cleanup_req )
3378        {
3379            paddr_t     nline;
3380            size_t      way = r_dcache_flush_count.read()/m_icache_sets;
3381            size_t      set = r_dcache_flush_count.read()%m_icache_sets;
3382
3383            bool        cleanup_req = r_dcache.inval( way,
3384                                                      set,
3385                                                      &nline );
3386            if ( cleanup_req ) 
3387            {
3388                r_dcache_cleanup_req  = true;
3389                r_dcache_cleanup_line = nline;
3390            }
3391
3392            r_dcache_flush_count = r_dcache_flush_count.read() + 1;
3393
3394            if ( r_dcache_flush_count.read() == (m_dcache_sets*m_dcache_ways - 1) )     // last slot
3395            {
3396                r_dtlb.reset();      // global entries are invalidated
3397                r_itlb.reset();      // global entries are invalidated
3398                for (size_t line = 0; line < m_dcache_ways*m_dcache_sets; line++)
3399                {
3400                    r_dcache_in_itlb[line] = false;
3401                    r_dcache_in_dtlb[line] = false;
3402                }
3403                r_dcache_fsm = DCACHE_IDLE;
3404                drsp.valid = true;
3405            }
3406        }
3407        break;
3408    }
3409    /////////////////////////
3410    case DCACHE_XTN_DT_INVAL:   // handling processor XTN_DTLB_INVAL request
3411    {
3412        r_dtlb.inval(r_dcache_p0_wdata.read());
3413        r_dcache_fsm        = DCACHE_IDLE;
3414        drsp.valid          = true;
3415        break;
3416    }
3417    ////////////////////////////
3418    case DCACHE_XTN_DC_INVAL_VA:  // selective cache line invalidate with virtual address
3419                                  // requires 3 cycles: access tlb, read cache, inval cache
3420                                  // we compute the physical address in this state
3421    {
3422        paddr_t paddr;
3423        bool    hit;
3424
3425        if ( r_mmu_mode.read() & DATA_TLB_MASK )        // dtlb activated
3426        {
3427#ifdef INSTRUMENTATION
3428m_cpt_dtlb_read++;
3429#endif
3430            hit = r_dtlb.translate( r_dcache_p0_wdata.read(),
3431                                    &paddr ); 
3432        }
3433        else                                            // dtlb not activated
3434        {
3435            paddr = (paddr_t)r_dcache_p0_wdata.read();
3436            hit   = true;
3437        }
3438
3439        if ( hit )              // tlb hit
3440        {
3441            r_dcache_p0_paddr = paddr;
3442            r_dcache_fsm      = DCACHE_XTN_DC_INVAL_PA;
3443        }
3444        else                    // tlb miss
3445        {
3446#ifdef INSTRUMENTATION
3447m_cpt_dtlb_miss++;
3448#endif
3449            r_dcache_tlb_ins    = false;                // dtlb
3450            r_dcache_tlb_vaddr  = r_dcache_p0_wdata.read();
3451            r_dcache_fsm        = DCACHE_TLB_MISS; 
3452        } 
3453        break;
3454    }
3455    ////////////////////////////
3456    case DCACHE_XTN_DC_INVAL_PA:  // selective cache line invalidate with physical address
3457                                  // requires 2 cycles: read cache / inval cache
3458                                  // In this state we read dcache.
3459    {
3460        uint32_t        data;
3461        size_t          way;
3462        size_t          set;
3463        size_t          word;
3464        bool            hit = r_dcache.read( r_dcache_p0_paddr.read(),
3465                                             &data,
3466                                             &way,
3467                                             &set,
3468                                             &word );
3469#ifdef INSTRUMENTATION
3470m_cpt_dcache_data_read++;
3471m_cpt_dcache_dir_read++;
3472#endif
3473        if ( hit )      // inval to be done
3474        {
3475            r_dcache_xtn_way = way;
3476            r_dcache_xtn_set = set;
3477            r_dcache_fsm      = DCACHE_XTN_DC_INVAL_GO;
3478        }
3479        else            // miss : nothing to do
3480        {
3481            r_dcache_fsm      = DCACHE_IDLE;
3482            drsp.valid        = true;
3483        }
3484        break;
3485    }
3486    ////////////////////////////
3487    case DCACHE_XTN_DC_INVAL_GO:  // In this state, we invalidate the cache line & cleanup
3488                                  // Blocked if previous cleanup not completed
3489             
3490    {
3491        if ( not r_dcache_cleanup_req.read() )
3492        {
3493            paddr_t     nline;
3494            size_t      way       = r_dcache_xtn_way.read();
3495            size_t      set       = r_dcache_xtn_set.read();
3496            bool        inval_tlb = false;
3497   
3498            r_icache.inval( way,
3499                            set,
3500                            &nline );
3501
3502            // request cleanup
3503            r_dcache_cleanup_req  = true;
3504            r_dcache_cleanup_line = nline;
3505           
3506            // possible itlb & dtlb invalidate requests
3507            r_dcache_tlb_inval_line = nline;
3508
3509            if ( (r_mmu_mode.read() & DATA_TLB_MASK) and
3510                 r_dcache_in_dtlb[way*m_dcache_sets+set] ) 
3511            {
3512                r_dcache_dtlb_inval_req = true;
3513                r_dcache_in_dtlb[way*m_dcache_sets+set] = false;
3514                inval_tlb = true;
3515            }
3516            if ( (r_mmu_mode.read() & INS_TLB_MASK) and
3517                 r_dcache_in_itlb[m_dcache_sets*way+set] )
3518            {   
3519                r_dcache_itlb_inval_req = true;
3520                r_dcache_in_itlb[way*m_dcache_sets+set] = false;
3521                inval_tlb = true;
3522            }
3523
3524            // no valid response until itlb & dtlb invalidated
3525            if (inval_tlb ) 
3526            {
3527                r_dcache_fsm = DCACHE_XTN_DC_INVAL_WAIT;
3528            }
3529            else
3530            {
3531                r_dcache_fsm = DCACHE_IDLE;
3532                drsp.valid = true;
3533            }
3534        }
3535        break;
3536    }
3537    //////////////////////////////
3538    case DCACHE_XTN_DC_INVAL_WAIT:      // waiting completion of itlb and dtlb invalidate
3539    {
3540        if ( not (r_dcache_itlb_inval_req.read() or r_dcache_dtlb_inval_req.read()) ) 
3541        {
3542            r_dcache_fsm = DCACHE_IDLE;
3543            drsp.valid = true;
3544        } 
3545        break;
3546    }
3547    ////////////////////////
3548    case DCACHE_MISS_VICTIM:            // Selects a victim line
3549                                        // Set the r_dcache_cleanup_req flip-flop
3550                                        // when the selected slot is not empty
3551    {
3552        bool      valid;
3553        size_t    way;
3554        size_t    set;
3555        paddr_t   victim;
3556
3557        valid = r_dcache.victim_select( r_dcache_vci_paddr.read(),
3558                                        &victim,
3559                                        &way,
3560                                        &set );
3561        r_dcache_miss_way = way;
3562        r_dcache_miss_set = set;
3563
3564        if ( valid )
3565        {
3566            r_dcache_cleanup_req  = true;
3567            r_dcache_cleanup_line = victim;
3568            r_dcache_fsm          = DCACHE_MISS_INVAL;
3569        }
3570        else
3571        {
3572            r_dcache_fsm          = DCACHE_MISS_WAIT;
3573        }
3574
3575#if DEBUG_DCACHE
3576if ( m_debug_dcache_fsm )
3577{
3578    std::cout << "  <PROC.DCACHE_MISS_VICTIM> Select a slot:"
3579              << " / way = "   << way
3580              << " / set = "   << set
3581              << " / valid = "  << valid
3582              << " / line = " << std::hex << victim << std::endl; 
3583}
3584#endif
3585        break;
3586    }
3587    ///////////////////////
3588    case DCACHE_MISS_INVAL:             // invalidate the victim line
3589                                        // and possibly request itlb or dtlb invalidate
3590    {
3591        paddr_t nline;
3592        size_t  way = r_dcache_miss_way.read();
3593        size_t  set = r_dcache_miss_set.read();
3594
3595        r_dcache.inval( way, 
3596                        set,
3597                        &nline );
3598
3599        // if itlb & dtlb invalidate are required
3600        // the miss response is not handled before invalidate completed
3601        if ( (r_mmu_mode.read() & DATA_TLB_MASK) and
3602             ( r_dcache_in_itlb[way*m_dcache_sets+set] or
3603               r_dcache_in_dtlb[m_dcache_sets*way+set] ) )
3604        {       
3605            r_dcache_tlb_inval_line = r_dcache_vci_paddr.read() >> (uint32_log2(m_dcache_words)+2);
3606            r_dcache_itlb_inval_req  = r_dcache_in_itlb[way*m_dcache_sets+set];
3607            r_dcache_in_itlb[way*m_dcache_sets+set] = false;
3608            r_dcache_dtlb_inval_req  = r_dcache_in_dtlb[way*m_dcache_sets+set];
3609            r_dcache_in_dtlb[way*m_dcache_sets+set] = false;
3610            r_dcache_fsm = DCACHE_MISS_INVAL_WAIT;
3611        }
3612        else
3613        {
3614            r_dcache_fsm = DCACHE_MISS_WAIT;
3615        }
3616        break;
3617    }
3618    ////////////////////////////
3619    case DCACHE_MISS_INVAL_WAIT:  // waiting completion of itlb / dtlb invalidate
3620    {
3621        if ( (not r_dcache_itlb_inval_req.read()) or (not r_dcache_dtlb_inval_req.read()) )
3622        {
3623            r_dcache_fsm = DCACHE_MISS_WAIT;
3624        }
3625        break;
3626    }
3627    //////////////////////
3628    case DCACHE_MISS_WAIT:      // waiting the response to a miss request from VCI_RSP FSM
3629                                // This state is in charge of error signaling
3630                                // There is 5 types of error depending on the requester
3631    {
3632        // external coherence request
3633        if ( r_tgt_dcache_req ) 
3634        {
3635            r_dcache_fsm = DCACHE_CC_CHECK;
3636            r_dcache_fsm_save = r_dcache_fsm;
3637            break;
3638        }
3639
3640        if ( r_vci_rsp_data_error.read() )                      // bus error
3641        {
3642            switch ( r_dcache_miss_type.read() )
3643            {
3644                case PROC_MISS: 
3645                {
3646                    r_mmu_detr            = MMU_READ_DATA_ILLEGAL_ACCESS; 
3647                    r_mmu_dbvar           = r_dcache_p0_vaddr.read();
3648                    drsp.valid            = true;
3649                    drsp.error            = true;
3650                    r_dcache_fsm          = DCACHE_IDLE;
3651                    break;
3652                }
3653                case PTE1_MISS:
3654                {
3655                    if ( r_dcache_tlb_ins.read() )
3656                    {
3657                        r_mmu_ietr              = MMU_READ_PT1_ILLEGAL_ACCESS;
3658                        r_mmu_ibvar             = r_dcache_tlb_vaddr.read();
3659                        r_icache_tlb_miss_req   = false;
3660                        r_icache_tlb_rsp_error  = true;
3661                    }
3662                    else
3663                    {
3664                        r_mmu_detr              = MMU_READ_PT1_ILLEGAL_ACCESS;
3665                        r_mmu_dbvar             = r_dcache_tlb_vaddr.read();
3666                        drsp.valid              = true;
3667                        drsp.error              = true;
3668                    }
3669                    r_dcache_fsm                = DCACHE_IDLE;
3670                    break;
3671                }
3672                case PTE2_MISS: 
3673                {
3674                    if ( r_dcache_tlb_ins.read() )
3675                    {
3676                        r_mmu_ietr              = MMU_READ_PT2_ILLEGAL_ACCESS;
3677                        r_mmu_ibvar             = r_dcache_tlb_vaddr.read();
3678                        r_icache_tlb_miss_req   = false;
3679                        r_icache_tlb_rsp_error  = true;
3680                    }
3681                    else
3682                    {
3683                        r_mmu_detr              = MMU_READ_PT2_ILLEGAL_ACCESS;
3684                        r_mmu_dbvar             = r_dcache_tlb_vaddr.read();
3685                        drsp.valid              = true;
3686                        drsp.error              = true;
3687                    }
3688                    r_dcache_fsm                = DCACHE_IDLE;
3689                    break;
3690                }
3691            } // end switch type
3692            r_vci_rsp_data_error = false;
3693        }
3694        else if ( r_vci_rsp_fifo_dcache.rok() )         // valid response available
3695        {
3696            r_dcache_miss_word = 0;
3697            r_dcache_fsm       = DCACHE_MISS_UPDT;
3698        }       
3699        break;
3700    }
3701    //////////////////////
3702    case DCACHE_MISS_UPDT:      // update the dcache (one word per cycle)
3703                                // returns the response depending on the miss type
3704    {
3705        if ( r_vci_rsp_fifo_dcache.rok() )      // one word available
3706        {
3707            if ( r_dcache_miss_inval.read() )   // Matching coherence request
3708                                                // pop the FIFO, without cache update
3709                                                // send a cleanup for the missing line
3710                                                // if the previous cleanup is completed
3711            {
3712                if ( r_dcache_miss_word.read() < (m_dcache_words - 1) )     // not the last
3713                {
3714                    vci_rsp_fifo_dcache_get = true;
3715                    r_dcache_miss_word = r_dcache_miss_word.read() + 1;
3716                }
3717                else                                                    // last word
3718                {
3719                    if ( not r_dcache_cleanup_req.read() )      // no pending cleanup
3720                    {
3721                        vci_rsp_fifo_dcache_get = true;
3722                        r_dcache_cleanup_req    = true;
3723                        r_dcache_cleanup_line   = r_dcache_vci_paddr.read() >> 
3724                                                     (uint32_log2(m_dcache_words)+2);
3725                        r_dcache_miss_inval     = false;
3726                        r_dcache_fsm            = DCACHE_IDLE;
3727                    }
3728                }
3729            }
3730            else                                // No matching coherence request
3731                                                // pop the FIFO and update the cache
3732                                                // update the directory at the last word
3733                                                // send a response to ICACHE FSM
3734                                                // in case of itlb miss
3735            {
3736
3737#ifdef INSTRUMENTATION
3738m_cpt_dcache_data_write++;
3739#endif
3740                r_dcache.write( r_dcache_miss_way.read(),
3741                                r_dcache_miss_set.read(),
3742                                r_dcache_miss_word.read(),
3743                                r_vci_rsp_fifo_dcache.read());
3744
3745                vci_rsp_fifo_dcache_get = true;
3746                r_dcache_miss_word = r_dcache_miss_word.read() + 1;
3747               
3748                // if last word, update directory, set in_itlb & in_dtlb bits
3749                if ( r_dcache_miss_word.read() == (m_dcache_words - 1) ) 
3750                {
3751
3752#ifdef INSTRUMENTATION
3753m_cpt_dcache_dir_write++;
3754#endif
3755                    r_dcache.victim_update_tag( r_dcache_vci_paddr.read(),
3756                                                r_dcache_miss_way.read(),
3757                                                r_dcache_miss_set.read() );
3758                   
3759                    if      (r_dcache_miss_type.read()==PTE1_MISS) r_dcache_fsm = DCACHE_TLB_PTE1_GET; 
3760                    else if (r_dcache_miss_type.read()==PTE2_MISS) r_dcache_fsm = DCACHE_TLB_PTE2_GET;
3761                    else                                           r_dcache_fsm = DCACHE_IDLE;
3762                }
3763            }
3764
3765#if DEBUG_DCACHE
3766if ( m_debug_dcache_fsm )
3767{
3768    if ( r_dcache_miss_inval.read() )
3769    {
3770        if ( r_dcache_miss_word.read() < m_dcache_words-1 ) 
3771        {
3772            std::cout << "  <PROC.DCACHE_MISS_UPDT> Matching coherence request:"
3773                      << "  pop the FIFO, don't update the cache" << std::endl;
3774        }
3775        else
3776        {
3777            std::cout << "  <PROC.DCACHE_MISS_UPDT> Matching coherence request:"
3778                      << " last word : send a cleanup request " << std::endl;
3779        }
3780    }
3781    else
3782    {
3783        std::cout << "  <PROC.DCACHE_MISS_UPDT> Write one word:"
3784                  << " address = " << r_dcache_vci_paddr.read() 
3785                  << " / data = "  << r_vci_rsp_fifo_dcache.read()
3786                  << " / way = "   << r_dcache_miss_way.read() 
3787                  << " / set = "   << r_dcache_miss_set.read()
3788                  << " / word = "  << r_dcache_miss_word.read() << std::endl; 
3789    }
3790}
3791#endif
3792 
3793        } // end if rok
3794        break;
3795    }
3796    /////////////////////
3797    case DCACHE_UNC_WAIT:
3798    {
3799        // external coherence request
3800        if ( r_tgt_dcache_req.read() ) 
3801        {
3802            r_dcache_fsm = DCACHE_CC_CHECK;
3803            r_dcache_fsm_save = r_dcache_fsm;
3804            break;
3805        }
3806
3807        if ( r_vci_rsp_data_error.read() )      // bus error
3808        {
3809            r_mmu_detr           = MMU_READ_DATA_ILLEGAL_ACCESS; 
3810            r_mmu_dbvar          = dreq.addr;
3811            r_vci_rsp_data_error = false;
3812            drsp.error           = true;
3813            drsp.valid           = true;
3814            r_dcache_fsm         = DCACHE_IDLE;
3815            break;
3816        }
3817        else if ( r_vci_rsp_fifo_dcache.rok() )     // data available
3818        {
3819            vci_rsp_fifo_dcache_get = true;     
3820            r_dcache_fsm            = DCACHE_IDLE;
3821            // we acknowledge the processor request if it has not been modified
3822            if ( dreq.valid and (dreq.addr == r_dcache_p0_vaddr.read()) )
3823            {
3824                drsp.valid          = true;
3825                drsp.rdata          = r_vci_rsp_fifo_dcache.read();
3826            }
3827        }       
3828        break;
3829    }
3830    ////////////////////////////
3831    case DCACHE_WRITE_TLB_DIRTY:        // set PTE dirty bit in dtlb
3832    {
3833        // set dirty bit in dtlb
3834        r_dtlb.set_dirty( r_dcache_p2_tlb_way.read(),
3835                          r_dcache_p2_tlb_set.read() );
3836
3837        // get PTE in dcache
3838        uint32_t pte_flags = 0;
3839        size_t   way;
3840        size_t   set;
3841        size_t   word;
3842        bool     hit = r_dcache.read( r_dcache_p2_pte_paddr.read(),
3843                                      &pte_flags,
3844                                      &way,
3845                                      &set,
3846                                      &word );
3847#ifdef INSTRUMENTATION
3848m_cpt_dcache_data_read++;
3849m_cpt_dcache_dir_read++;
3850#endif;
3851
3852#if DEBUG_DCACHE
3853if ( m_debug_dcache_fsm )
3854{
3855    std::cout << "  <PROC.DCACHE_WRITE_TLB_DIRTY> Set PTE dirty bit in dtlb:"
3856              << " paddr = " << r_dcache_p2_pte_paddr.read() 
3857              << " / tlb_way = " << r_dcache_p2_tlb_way.read()
3858              << " / tlb_set = " << r_dcache_p2_tlb_set.read() << std::endl;
3859}
3860#endif
3861        assert( hit and "error in DCACHE_WRITE_TLB_DIRTY: the PTE should be in dcache" );
3862
3863        r_dcache_p2_pte_way   = way;                    // register pte way in dcache
3864        r_dcache_p2_pte_set   = set;                    // register pte set in dcache;
3865        r_dcache_p2_pte_word  = word;                   // register pte word in dcache;
3866        r_dcache_p2_pte_flags = pte_flags;              // register pte value
3867        r_dcache_fsm          = DCACHE_WRITE_CACHE_DIRTY;
3868        break;
3869    }
3870    //////////////////////////////
3871    case DCACHE_WRITE_CACHE_DIRTY:      // set PTE dirty bit in dcache
3872                                        // request SC tranansaction to CMD FSM
3873    {
3874        // set PTE dirty bit in dcache
3875        r_dcache.write( r_dcache_p2_pte_way.read(),
3876                        r_dcache_p2_pte_set.read(),
3877                        r_dcache_p2_pte_word.read(),
3878                        r_dcache_p2_pte_flags.read() | PTE_D_MASK,
3879                        0xF );
3880
3881#ifdef INSTRUMENTATION
3882m_cpt_dcache_data_write++;
3883#endif
3884       
3885#if DEBUG_DCACHE
3886if ( m_debug_dcache_fsm )
3887{
3888    std::cout << "  <PROC.DCACHE_WRITE_CACHE_DIRTY> Set PTE dirty bit in dcache:"
3889              << " / way = " << r_dcache_p2_pte_way.read()
3890              << " / set = " << r_dcache_p2_pte_set.read() 
3891              << " / word = " << r_dcache_p2_pte_word.read() << std::endl;
3892}
3893#endif
3894        // request sc transaction to CMD_FSM
3895        r_dcache_vci_sc_req = true;
3896        r_dcache_vci_sc_old = r_dcache_p2_pte_flags.read();
3897        r_dcache_vci_sc_new = r_dcache_p2_pte_flags.read() | PTE_D_MASK;
3898        r_dcache_fsm        = DCACHE_WRITE_SC_WAIT;   
3899        break;
3900    }
3901    //////////////////////////
3902    case DCACHE_WRITE_SC_WAIT:          // wait completion of SC
3903                                        // if atomic, write completed : return to IDLE state
3904                                        // else, makes an uncacheable read to retry the SC
3905    {
3906        // external coherence request
3907        if ( r_tgt_dcache_req ) 
3908        {
3909            r_dcache_fsm = DCACHE_CC_CHECK;
3910            r_dcache_fsm_save = r_dcache_fsm;
3911            break;
3912        }
3913
3914        if ( r_vci_rsp_data_error.read() )      // bus error
3915        {
3916            r_mmu_detr   = MMU_WRITE_PT2_ILLEGAL_ACCESS; 
3917            r_mmu_dbvar  = r_dcache_p2_vaddr;
3918            drsp.valid   = true;
3919            drsp.error   = true;
3920            r_dcache_fsm = DCACHE_IDLE;
3921            break;
3922        }
3923        else if ( r_vci_rsp_fifo_dcache.rok() ) // response available
3924        {
3925            if ( r_vci_rsp_fifo_dcache.read() == 0 )            // atomic
3926            {
3927                drsp.valid   = true;            // acknowledge the initial write
3928                r_dcache_fsm = DCACHE_IDLE;
3929            }
3930            else                                               
3931            {
3932                r_dcache_vci_paddr   = r_dcache_p2_pte_paddr;
3933                r_dcache_vci_unc_req = true;
3934                r_dcache_vci_unc_be  = 0xF;
3935                r_dcache_fsm         = DCACHE_WRITE_UNC_WAIT;
3936            }
3937        }
3938        break;
3939    }
3940    ///////////////////////////
3941    case DCACHE_WRITE_UNC_WAIT:         // wait completion of uncacheable read
3942                                        // in case of success we retry a SC request to
3943                                        // set the dirty bit in the PTE
3944    {
3945        // external coherence request
3946        if ( r_tgt_dcache_req ) 
3947        {
3948            r_dcache_fsm = DCACHE_CC_CHECK;
3949            r_dcache_fsm_save = r_dcache_fsm;
3950            break;
3951        }
3952
3953        if ( r_vci_rsp_data_error.read() )      // bus error
3954        {
3955            r_mmu_detr   = MMU_READ_PT2_ILLEGAL_ACCESS; 
3956            r_mmu_dbvar  = r_dcache_p2_vaddr;
3957            drsp.valid   = true;
3958            drsp.error   = true;
3959            r_dcache_fsm = DCACHE_IDLE;
3960            break;
3961        }
3962        if ( r_vci_rsp_fifo_dcache.rok() )      // PTE available
3963        {
3964            r_dcache_vci_sc_req = true;
3965            r_dcache_vci_sc_old = r_vci_rsp_fifo_dcache.read();
3966            r_dcache_vci_sc_new = r_vci_rsp_fifo_dcache.read() | PTE_D_MASK;
3967            r_dcache_fsm        = DCACHE_WRITE_SC_WAIT;   
3968        }
3969        break;
3970    }
3971    /////////////////////
3972    case DCACHE_CC_CHECK:   // This state is the entry point for the sub-FSM
3973                            // handling coherence requests.
3974                            // If there is a matching pending miss on the modified cache
3975                            // line this is signaled in the r_dcache_miss inval flip-flop.
3976                            // If the updated (or invalidated) cache line has copies in TLBs
3977                            // these TLB copies are invalidated.
3978                            // The return state is defined in r_dcache_fsm_save
3979    {
3980        paddr_t  paddr = r_tgt_paddr.read();
3981        paddr_t  mask = ~((m_dcache_words<<2)-1);
3982
3983
3984        if( (r_dcache_fsm_save == DCACHE_MISS_WAIT) and
3985            ((r_dcache_vci_paddr.read() & mask) == (paddr & mask)) ) // matching pending miss
3986        {
3987            r_dcache_miss_inval = true;                 // signaling the match
3988            r_tgt_dcache_req    = false;                // coherence request completed
3989            r_tgt_dcache_rsp    = r_tgt_update.read();  // response required if update
3990            r_dcache_fsm        = r_dcache_fsm_save;
3991
3992#if DEBUG_DCACHE
3993if ( m_debug_dcache_fsm )
3994{
3995    std::cout << "  <PROC.DCACHE_CC_CHECK> Coherence request matching a pending miss:"
3996              << " address = " << std::hex << paddr << std::endl;
3997}
3998#endif
3999 
4000        }
4001        else                                                            // no match
4002        {
4003            uint32_t    rdata;
4004            size_t      way;
4005            size_t      set;
4006            size_t      word;
4007
4008            bool        hit = r_dcache.read(paddr,
4009                                            &rdata,     // unused
4010                                            &way, 
4011                                            &set,
4012                                            &word);     // unused
4013#ifdef INSTRUMENTATION
4014m_cpt_dcache_data_read++;
4015m_cpt_dcache_dir_read++;
4016#endif
4017            r_dcache_cc_way = way;
4018            r_dcache_cc_set = set;
4019
4020            if ( hit and r_tgt_update.read() )          // hit update
4021            {
4022                r_dcache_fsm     = DCACHE_CC_UPDT;
4023                r_dcache_cc_word = r_tgt_word_min.read();
4024            }
4025            else if ( hit and not r_tgt_update.read() ) // hit inval
4026            {
4027                r_dcache_fsm     = DCACHE_CC_INVAL;
4028            }
4029            else                                        // miss can happen
4030            {
4031                r_tgt_dcache_req = false;
4032                r_tgt_dcache_rsp = r_tgt_update.read();
4033                r_dcache_fsm     = r_dcache_fsm_save.read();
4034            }
4035
4036#if DEBUG_DCACHE
4037if ( m_debug_dcache_fsm )
4038{
4039   
4040    std::cout << "  <PROC.DCACHE_CC_CHECK> Coherence request received :"
4041              << " address = " << std::hex << paddr << std::dec;
4042    if ( hit ) 
4043    {
4044        std::cout << " / HIT" << " / way = " << way << " / set = " << set << std::endl;
4045    }
4046    else
4047    {
4048        std::cout << " / MISS" << std::endl;
4049    }
4050}
4051#endif
4052 
4053        }
4054        break;
4055    }
4056    /////////////////////
4057    case DCACHE_CC_INVAL:       // invalidate one cache line
4058                                // and test possible copies in TLBs
4059    {
4060        paddr_t nline;
4061        size_t  way       = r_dcache_cc_way.read();
4062        size_t  set       = r_dcache_cc_set.read();
4063        bool    inval_tlb = false;
4064
4065        r_dcache.inval( way, 
4066                        set,
4067                        &nline );
4068           
4069        // possible itlb & dtlb invalidate requests
4070        r_dcache_tlb_inval_line = nline;
4071
4072        if ( (r_mmu_mode.read() & DATA_TLB_MASK) and
4073             r_dcache_in_dtlb[way*m_dcache_sets+set] ) 
4074        {
4075            r_dcache_dtlb_inval_req = true;
4076            r_dcache_in_dtlb[way*m_dcache_sets+set] = false;
4077            inval_tlb = true;
4078        }
4079        if ( (r_mmu_mode.read() & INS_TLB_MASK) and
4080            r_dcache_in_itlb[m_dcache_sets*way+set] )
4081        {       
4082            r_dcache_itlb_inval_req = true;
4083            r_dcache_in_itlb[way*m_dcache_sets+set] = false;
4084            inval_tlb = true;
4085        }
4086
4087        // no valid response until itlb & dtlb invalidated
4088        if (inval_tlb ) 
4089        {
4090            r_dcache_fsm = DCACHE_CC_WAIT;
4091        }
4092        else
4093        {
4094            r_tgt_dcache_rsp = true;
4095            r_tgt_dcache_req = false;
4096            r_dcache_fsm     = r_dcache_fsm_save.read();
4097        }
4098
4099#if DEBUG_DCACHE
4100if ( m_debug_dcache_fsm )
4101{
4102    std::cout << "  <PROC.DCACHE_CC_INVAL> Invalidate cache line :" << std::dec
4103              << " way = " << way
4104              << " / set = " << set << std::endl;
4105}
4106#endif
4107 
4108        break;
4109    }
4110    ///////////////////
4111    case DCACHE_CC_UPDT:        // write one word per cycle (from word_min to word_max)
4112                                // and test possible copies in TLBs
4113    {
4114        size_t  word  = r_dcache_cc_word.read();
4115        size_t  way   = r_dcache_cc_way.read();
4116        size_t  set   = r_dcache_cc_set.read();
4117
4118        r_dcache.write( way,
4119                        set,
4120                        word,
4121                        r_tgt_buf[word],
4122                        r_tgt_be[word] );
4123#ifdef INSTRUMENTATION
4124m_cpt_dcache_data_write++;
4125#endif
4126        r_dcache_cc_word = word + 1;
4127
4128        if ( word == r_tgt_word_max.read() )    // last word
4129        {
4130            // invalidate copies in TLBs
4131            if ( (r_mmu_mode.read() & DATA_TLB_MASK) and
4132                 ( r_dcache_in_itlb[way*m_dcache_sets+set] or
4133                   r_dcache_in_dtlb[m_dcache_sets*way+set] ) )
4134            {
4135                r_dcache_tlb_inval_line = r_tgt_paddr.read() >> (uint32_log2(m_dcache_words)+2);
4136                r_dcache_itlb_inval_req = r_dcache_in_itlb[m_dcache_sets*way+set];
4137                r_dcache_in_itlb[way*m_dcache_sets+set] = false;
4138                r_dcache_dtlb_inval_req = r_dcache_in_dtlb[m_dcache_sets*way+set]; 
4139                r_dcache_in_dtlb[way*m_dcache_sets+set] = false;
4140                r_dcache_fsm     = DCACHE_CC_WAIT;
4141            }
4142            else
4143            {
4144                r_tgt_dcache_rsp = true;
4145                r_tgt_dcache_req = false;
4146                r_dcache_fsm     = r_dcache_fsm_save.read();
4147            }
4148        }
4149
4150#if DEBUG_DCACHE
4151if ( m_debug_dcache_fsm )
4152{
4153    std::cout << "  <PROC.DCACHE_CC_UPDT> Update one word :" << std::dec
4154              << " way = " << way
4155              << " / set = " << set
4156              << " / word = " << word
4157              << " / value = " << std::hex << r_tgt_buf[word] << std::endl;
4158}
4159#endif
4160 
4161        break;
4162    }
4163    ////////////////////
4164    case DCACHE_CC_WAIT:        // wait completion of TLB invalidate
4165    {
4166        if ( not r_dcache_itlb_inval_req.read() and not r_dcache_dtlb_inval_req.read() )
4167        {
4168            r_tgt_dcache_rsp = true;
4169            r_tgt_dcache_req = false;
4170            r_dcache_fsm     = r_dcache_fsm_save.read();
4171        }
4172    }   
4173    } // end switch r_dcache_fsm
4174
4175
4176    //////////////////// save DREQ and DRSP fields for print_trace() ////////////////
4177    m_dreq_valid = dreq.valid;
4178    m_dreq_addr  = dreq.addr;
4179    m_dreq_mode  = dreq.mode;
4180    m_dreq_type  = dreq.type;
4181    m_dreq_wdata = dreq.wdata;
4182    m_dreq_be    = dreq.be;
4183   
4184    m_drsp_valid = drsp.valid;
4185    m_drsp_rdata = drsp.rdata;
4186    m_drsp_error = drsp.error;
4187
4188    ///////////////// wbuf update //////////////////////////////////////////////////////
4189    r_wbuf.update();
4190
4191    ////////////////////////////////////////////////////////////////////////////////////
4192    //      INVAL DTLB FSM
4193    // This FSM works in parallel with the DCACHE FSM.
4194    // When the r_dcache_dtlb_inval_req flip-flop is activated by the DCACHE FSM
4195    // it scans sequencially all entries in the DTLB, and invalidates the
4196    // entries matching the evicted line.
4197    // It signals the completion of invalidation by reseting r_dcache_itlb_inval_req.
4198    ////////////////////////////////////////////////////////////////////////////////////
4199
4200    switch(r_inval_dtlb_fsm) 
4201    {
4202    /////////////////////
4203    case INVAL_DTLB_IDLE:
4204    {
4205        if ( r_dcache_dtlb_inval_req.read() ) 
4206        {
4207            r_dtlb.reset_bypass(r_dcache_tlb_inval_line.read());
4208            r_inval_dtlb_count = 0;
4209            r_inval_dtlb_fsm   = INVAL_DTLB_SCAN;   
4210
4211#if DEBUG_INVAL_DTLB
4212if ( m_debug_inval_dtlb_fsm )
4213{
4214    std::cout << "  <PROC.INVAL_DTLB_IDLE> Invalidate request for line " 
4215              << std::hex << r_dcache_tlb_inval_line.read() << std::endl;
4216    r_dtlb.print();
4217}
4218#endif
4219        }   
4220        break;
4221    }
4222    /////////////////////
4223    case INVAL_DTLB_SCAN:
4224    {
4225        paddr_t line = r_dcache_tlb_inval_line.read();          // nline
4226        size_t  way  = r_inval_dtlb_count.read()/m_itlb_sets;   // way
4227        size_t  set  = r_inval_dtlb_count.read()%m_itlb_sets;   // set
4228
4229        bool ok = r_dtlb.inval( line,
4230                                way,
4231                                set );
4232
4233#if DEBUG_INVAL_DTLB
4234if ( m_debug_inval_dtlb_fsm )
4235{
4236    std::cout << "  <PROC.INVAL_DTLB_SCAN>" << std::hex
4237              << " line = " << line << std::dec
4238              << " / set = " << set
4239              << " / way = " << way;
4240    if ( ok ) std::cout << " / HIT" << std::endl;
4241    else      std::cout << " / MISS" << std::endl;
4242}
4243#endif
4244                   
4245        r_inval_dtlb_count = r_inval_dtlb_count.read() + 1;
4246        if ( r_inval_dtlb_count.read() == (m_dtlb_sets*m_dtlb_ways - 1) )
4247        {
4248            r_inval_dtlb_fsm        = INVAL_DTLB_IDLE;
4249            r_dcache_dtlb_inval_req = false;
4250        }
4251        break;
4252    }
4253    } // end switch r_inval_dtlb_fsm
4254
4255    /////////// test processor frozen /////////////////////////////////////////////
4256    // The simulation exit if the number of consecutive frozen cycles
4257    // is larger than the m_max_frozen_cycles (constructor parameter)
4258    if ( (ireq.valid and not irsp.valid) or (dreq.valid and not drsp.valid) )       
4259    {
4260        m_cpt_frz_cycles++;             // used for instrumentation
4261        m_cpt_stop_simulation++;        // used for debug
4262        if ( m_cpt_stop_simulation > m_max_frozen_cycles )
4263        {
4264            std::cout << std::dec << "ERROR in CC_VCACHE_WRAPPER " << name() << std::endl
4265                      << " stop at cycle " << m_cpt_total_cycles << std::endl
4266                      << " frozen since cycle " << m_cpt_total_cycles - m_max_frozen_cycles
4267                      << std::endl;
4268            exit(1);
4269        }
4270    }
4271    else
4272    {
4273        m_cpt_stop_simulation = 0;
4274    }
4275
4276    /////////// execute one iss cycle /////////////////////////////////
4277    {
4278    uint32_t it = 0;
4279    for (size_t i=0; i<(size_t)iss_t::n_irq; i++) if(p_irq[i].read()) it |= (1<<i);
4280    r_iss.executeNCycles(1, irsp, drsp, it);
4281    }
4282
4283    ////////////////////////////////////////////////////////////////////////////
4284    // The VCI_CMD FSM controls the following ressources:
4285    // - r_vci_cmd_fsm
4286    // - r_vci_cmd_min
4287    // - r_vci_cmd_max
4288    // - r_vci_cmd_cpt
4289    // - r_vci_cmd_imiss_prio
4290    // - wbuf (reset)
4291    // - r_icache_miss_req (reset)
4292    // - r_icache_unc_req (reset)
4293    // - r_dcache_vci_miss_req (reset)
4294    // - r_dcache_vci_unc_req (reset)
4295    // - r_dcache_vci_sc_req (reset)
4296    //
4297    // This FSM handles requests from both the DCACHE FSM & the ICACHE FSM.
4298    // There is 6 request types, with the following priorities :
4299    // 1 - Data Read Miss         : r_dcache_vci_miss_req and miss in the write buffer
4300    // 2 - Data Read Uncachable   : r_dcache_vci_unc_req 
4301    // 3 - Instruction Miss       : r_icache_miss_req and miss in the write buffer
4302    // 4 - Instruction Uncachable : r_icache_unc_req
4303    // 5 - Data Write             : r_wbuf.rok()     
4304    // 6 - Data Store Conditionnal: r_dcache_vci_sc_req
4305    //
4306    // As we want to support several simultaneous VCI transactions, the VCI_CMD_FSM
4307    // and the VCI_RSP_FSM are fully desynchronized.
4308    //
4309    // VCI formats:
4310    // According to the VCI advanced specification, all read requests packets
4311    // (data Uncached, Miss data, instruction Uncached, Miss instruction)
4312    // are one word packets.
4313    // For write burst packets, all words are in the same cache line,
4314    // and addresses must be contiguous (the BE field is 0 in case of "holes").
4315    // The sc command packet implements actually a compare-and-swap mechanism
4316    // and the packet contains two flits.
4317    ////////////////////////////////////////////////////////////////////////////////////
4318
4319    switch ( r_vci_cmd_fsm.read() ) 
4320    {
4321        //////////////
4322        case CMD_IDLE:
4323        {
4324            // r_dcache_vci_miss_req and r_icache_miss_req require both a write_buffer access
4325            // to check a possible pending write on the same cache line.
4326            // As there is only one possible access per cycle to write buffer, we implement
4327            // a round-robin priority for this access, using the r_vci_cmd_imiss_prio flip-flop.
4328
4329            size_t      wbuf_min;
4330            size_t      wbuf_max;
4331
4332            bool dcache_miss_req = r_dcache_vci_miss_req.read()
4333                 and ( not r_icache_miss_req.read() or not r_vci_cmd_imiss_prio.read() );
4334            bool icache_miss_req = r_icache_miss_req.read()
4335                 and ( not r_dcache_vci_miss_req.read() or r_vci_cmd_imiss_prio.read() );
4336
4337            // 1 - Data Read Miss
4338            if ( dcache_miss_req and r_wbuf.miss(r_dcache_vci_paddr.read()) )
4339            {
4340                r_vci_cmd_fsm         = CMD_DATA_MISS;
4341                r_dcache_vci_miss_req = false;
4342                r_vci_cmd_imiss_prio  = true;
4343//                m_cpt_dmiss_transaction++;
4344            }
4345            // 2 - Data Read Uncachable
4346            else if ( r_dcache_vci_unc_req.read() )
4347            {
4348                r_vci_cmd_fsm        = CMD_DATA_UNC;
4349                r_dcache_vci_unc_req = false;
4350//                m_cpt_dunc_transaction++;
4351            }
4352            // 3 - Instruction Miss
4353            else if ( icache_miss_req and r_wbuf.miss(r_icache_vci_paddr.read()) )
4354            {
4355                r_vci_cmd_fsm        = CMD_INS_MISS;
4356                r_icache_miss_req    = false;
4357                r_vci_cmd_imiss_prio = false;
4358//                m_cpt_imiss_transaction++;
4359            }
4360            // 4 - Instruction Uncachable
4361            else if ( r_icache_unc_req.read() )
4362            {
4363                r_vci_cmd_fsm    = CMD_INS_UNC;
4364                r_icache_unc_req = false;
4365//                m_cpt_iunc_transaction++;
4366            }
4367            // 5 - Data Write
4368            else if ( r_wbuf.rok(&wbuf_min, &wbuf_max) )
4369            {
4370                r_vci_cmd_fsm       = CMD_DATA_WRITE;
4371                r_vci_cmd_cpt       = wbuf_min;
4372                r_vci_cmd_min       = wbuf_min;
4373                r_vci_cmd_max       = wbuf_max;
4374//                m_cpt_write_transaction++;
4375//                m_length_write_transaction += (wbuf_max-wbuf_min+1);
4376            }
4377            // 6 - Data Store Conditionnal
4378            else if ( r_dcache_vci_sc_req.read() )
4379            {
4380                r_vci_cmd_fsm       = CMD_DATA_SC;
4381                r_dcache_vci_sc_req     = false;
4382                r_vci_cmd_cpt       = 0;
4383//                m_cpt_sc_transaction++;
4384            }
4385            break;
4386        }
4387        ////////////////////
4388        case CMD_DATA_WRITE:
4389        {
4390            if ( p_vci_ini_d.cmdack.read() )
4391            {
4392//                m_conso_wbuf_read++;
4393                r_vci_cmd_cpt = r_vci_cmd_cpt + 1;
4394                if (r_vci_cmd_cpt == r_vci_cmd_max) // last flit sent
4395                {
4396                    r_vci_cmd_fsm = CMD_IDLE ;
4397                    r_wbuf.sent() ;
4398                }
4399            }
4400            break;
4401        }
4402        /////////////////
4403        case CMD_DATA_SC:
4404        {
4405            // The SC VCI command contains two flits
4406            if ( p_vci_ini_d.cmdack.read() )
4407            {
4408               r_vci_cmd_cpt = r_vci_cmd_cpt + 1;
4409               if (r_vci_cmd_cpt == 1) r_vci_cmd_fsm = CMD_IDLE ;
4410            }
4411            break;
4412        }
4413        //////////////////
4414        case CMD_INS_MISS:
4415        case CMD_INS_UNC:
4416        case CMD_DATA_MISS:
4417        case CMD_DATA_UNC:
4418        {
4419            // all read VCI commands contain one single flit
4420            if ( p_vci_ini_d.cmdack.read() )  r_vci_cmd_fsm = CMD_IDLE;
4421            break;
4422        }
4423
4424    } // end  switch r_vci_cmd_fsm
4425
4426    //////////////////////////////////////////////////////////////////////////
4427    // The VCI_RSP FSM controls the following ressources:
4428    // - r_vci_rsp_fsm:
4429    // - r_vci_rsp_fifo_icache (push)
4430    // - r_vci_rsp_fifo_dcache (push)
4431    // - r_vci_rsp_data_error (set)
4432    // - r_vci_rsp_ins_error (set)
4433    // - r_vci_rsp_cpt
4434    //
4435    // As the VCI_RSP and VCI_CMD are fully desynchronized to support several
4436    // simultaneous VCI transactions, this FSM uses the VCI TRDID field
4437    // to identify the transactions.
4438    //
4439    // VCI vormat:
4440    // This component checks the response packet length and accepts only
4441    // single word packets for write response packets.
4442    //
4443    // Error handling:
4444    // This FSM analyzes the VCI error code and signals directly the Write Bus Error.
4445    // In case of Read Data Error, the VCI_RSP FSM sets the r_vci_rsp_data_error
4446    // flip_flop and the error is signaled by the DCACHE FSM. 
4447    // In case of Instruction Error, the VCI_RSP FSM sets the r_vci_rsp_ins_error
4448    // flip_flop and the error is signaled by the ICACHE FSM. 
4449    // In case of Cleanup Error, the simulation stops with an error message...
4450    //////////////////////////////////////////////////////////////////////////
4451
4452    switch ( r_vci_rsp_fsm.read() ) 
4453    {
4454    //////////////
4455    case RSP_IDLE:
4456    {
4457        if ( p_vci_ini_d.rspval.read() )
4458        {
4459            r_vci_rsp_cpt = 0;
4460
4461            if ( (p_vci_ini_d.rtrdid.read() >> (vci_param::T-1)) != 0 ) // Write transaction
4462            {
4463                r_vci_rsp_fsm = RSP_DATA_WRITE;
4464            }
4465            else if ( p_vci_ini_d.rtrdid.read() == TYPE_INS_MISS )
4466            {
4467                r_vci_rsp_fsm = RSP_INS_MISS;
4468            }
4469            else if ( p_vci_ini_d.rtrdid.read() == TYPE_INS_UNC )
4470            {
4471                r_vci_rsp_fsm = RSP_INS_UNC;
4472            }
4473            else if ( p_vci_ini_d.rtrdid.read() == TYPE_DATA_MISS )
4474            {
4475                r_vci_rsp_fsm = RSP_DATA_MISS;
4476            }
4477            else if ( p_vci_ini_d.rtrdid.read() == TYPE_DATA_UNC )
4478            {
4479                r_vci_rsp_fsm = RSP_DATA_UNC;
4480            }
4481            else
4482            {
4483                assert(false and "Unexpected VCI response");
4484            }
4485        }
4486        break;
4487    }
4488        //////////////////
4489        case RSP_INS_MISS:
4490        {
4491            if ( p_vci_ini_d.rspval.read() )
4492            {
4493                if ( (p_vci_ini_d.rerror.read()&0x1) != 0 )  // error reported
4494                {
4495                    r_vci_rsp_ins_error = true;
4496                    if ( p_vci_ini_d.reop.read() ) r_vci_rsp_fsm = RSP_IDLE;
4497                }
4498                else                                        // no error reported
4499                {
4500                    if ( r_vci_rsp_fifo_icache.wok() )
4501                    {
4502                        assert( (r_vci_rsp_cpt.read() < m_icache_words) and
4503                        "The VCI response packet for instruction miss is too long" );
4504
4505                        r_vci_rsp_cpt                 = r_vci_rsp_cpt.read() + 1;
4506                        vci_rsp_fifo_icache_put       = true,
4507                        vci_rsp_fifo_icache_data      = p_vci_ini_d.rdata.read();
4508                        if ( p_vci_ini_d.reop.read() )
4509                        {
4510                            assert( (r_vci_rsp_cpt.read() == m_icache_words - 1) and
4511                            "The VCI response packet for instruction miss is too short");
4512
4513                            r_vci_rsp_fsm    = RSP_IDLE;
4514                        }
4515                    }
4516                }
4517            }
4518            break;
4519        }
4520        /////////////////
4521        case RSP_INS_UNC:
4522        {
4523            if (p_vci_ini_d.rspval.read() )
4524            {
4525                assert( p_vci_ini_d.reop.read() and
4526                "illegal VCI response packet for uncachable instruction");
4527
4528                if ( (p_vci_ini_d.rerror.read()&0x1) != 0 )  // error reported
4529                {
4530                    r_vci_rsp_ins_error = true;
4531                    r_vci_rsp_fsm = RSP_IDLE;
4532                }
4533                else                                         // no error reported
4534                {
4535                    if ( r_vci_rsp_fifo_icache.wok())
4536                    {
4537                        vci_rsp_fifo_icache_put       = true;
4538                        vci_rsp_fifo_icache_data      = p_vci_ini_d.rdata.read();
4539                        r_vci_rsp_fsm = RSP_IDLE;
4540                    }
4541                }
4542            }
4543            break;
4544        }
4545        ///////////////////
4546        case RSP_DATA_MISS:
4547        {
4548            if ( p_vci_ini_d.rspval.read() )
4549            {
4550                if ( (p_vci_ini_d.rerror.read()&0x1) != 0 )  // error reported
4551                {
4552                    r_vci_rsp_data_error = true;
4553                    if ( p_vci_ini_d.reop.read() ) r_vci_rsp_fsm = RSP_IDLE;
4554                }
4555                else                                        // no error reported
4556                {
4557                    if ( r_vci_rsp_fifo_dcache.wok() )
4558                    {
4559                        assert( (r_vci_rsp_cpt.read() < m_dcache_words) and
4560                        "The VCI response packet for data miss is too long");
4561
4562                        r_vci_rsp_cpt                 = r_vci_rsp_cpt.read() + 1;
4563                        vci_rsp_fifo_dcache_put       = true,
4564                        vci_rsp_fifo_dcache_data      = p_vci_ini_d.rdata.read();
4565                        if ( p_vci_ini_d.reop.read() )
4566                        {
4567                            assert( (r_vci_rsp_cpt.read() == m_dcache_words - 1) and
4568                            "The VCI response packet for data miss is too short");
4569
4570                            r_vci_rsp_fsm     = RSP_IDLE;
4571                        }
4572                    }
4573                }
4574            }
4575            break;
4576        }
4577        //////////////////
4578        case RSP_DATA_UNC:
4579        {
4580            if (p_vci_ini_d.rspval.read() )
4581            {
4582                assert( p_vci_ini_d.reop.read() and
4583                "illegal VCI response packet for uncachable read data");
4584
4585                if ( (p_vci_ini_d.rerror.read()&0x1) != 0 )  // error reported
4586                {
4587                    r_vci_rsp_data_error = true;
4588                    r_vci_rsp_fsm = RSP_IDLE;
4589                }
4590                else                                         // no error reported
4591                {
4592                    if ( r_vci_rsp_fifo_dcache.wok())
4593                    {
4594                        vci_rsp_fifo_dcache_put       = true;
4595                        vci_rsp_fifo_dcache_data      = p_vci_ini_d.rdata.read();
4596                        r_vci_rsp_fsm = RSP_IDLE;
4597                    }
4598                }
4599            }
4600            break;
4601        }
4602        ////////////////////
4603        case RSP_DATA_WRITE:
4604        {
4605            if (p_vci_ini_d.rspval.read())
4606            {
4607                assert( p_vci_ini_d.reop.read() and
4608                "a VCI response packet must contain one flit for a write transaction");
4609
4610                r_vci_rsp_fsm = RSP_IDLE;
4611                uint32_t   wbuf_index = p_vci_ini_d.rtrdid.read() - (1<<(vci_param::T-1));
4612                bool       cacheable  = r_wbuf.completed(wbuf_index);
4613                if ( not cacheable ) r_dcache_pending_unc_write = false;
4614                if ( (p_vci_ini_d.rerror.read()&0x1) != 0 ) r_iss.setWriteBerr();
4615            }
4616            break;
4617        }
4618    } // end switch r_vci_rsp_fsm
4619
4620    ////////////////////////////////////////////////////////////////////////////////
4621    // The CLEANUP FSM send the cleanup commands on the coherence network,
4622    // and supports simultaneous cleanup transactions, but two simultaneous
4623    // transactions mut address different cache lines.
4624    // Therefore, the line number is registered in an associative
4625    // registration buffer (Content Adressable Memory) by the CLEANUP FSM,
4626    // and the corresponding slot (identified by the VCI TRDID field) is cleared
4627    // when the cleanup transaction response is received.
4628    // It handles cleanup requests from both the DCACHE FSM & ICACHE FSM
4629    // with a round robin priority, and can support up to 4 simultaneous
4630    // cleanup transactions (4 slots in the registration buffer).
4631    // The r_dcache_cleanup_req (or r_icache_cleanup_req) flip-flops are reset
4632    // when the command has been sent.
4633    // The VCI TRDID field is used to distinguish data/instruction cleanups:
4634    // - if data cleanup        : TRDID = 2*index + 0
4635    // - if instruction cleanup : TRDID = 2*index + 1
4636    ////////////////////////////////////////////////////////////////////////////
4637
4638    switch ( r_cleanup_fsm.read() ) 
4639    {
4640        ///////////////////////
4641        case CLEANUP_DATA_IDLE:     // dcache has highest priority
4642        {
4643            size_t  index = 0;
4644            bool    ok;
4645            if ( r_dcache_cleanup_req.read() )      // dcache request
4646            {
4647                ok = r_cleanup_buffer.register_value( r_dcache_cleanup_line.read(), 
4648                                                      &index );   
4649                if ( ok )   // successful registration
4650                {
4651                    r_cleanup_fsm   = CLEANUP_DATA_GO; 
4652                    r_cleanup_trdid = index<<1;
4653                }
4654            }
4655            else if ( r_icache_cleanup_req.read() ) // icache request
4656            {
4657                ok = r_cleanup_buffer.register_value( r_icache_cleanup_line.read(), 
4658                                                      &index );   
4659                if ( ok )   // successful registration
4660                {
4661                    r_cleanup_fsm   = CLEANUP_INS_GO; 
4662                    r_cleanup_trdid = (index<<1) + 1;
4663                }
4664            }
4665            break;
4666        }
4667        //////////////////////
4668        case CLEANUP_INS_IDLE:     // icache has highest priority
4669        {
4670            size_t  index = 0;
4671            bool    ok;
4672            if ( r_icache_cleanup_req.read() )      // icache request
4673            {
4674                ok = r_cleanup_buffer.register_value( r_icache_cleanup_line.read(),
4675                                                      &index );   
4676                if ( ok )   // successful registration
4677                {
4678                    r_cleanup_fsm   = CLEANUP_INS_GO;
4679                    r_cleanup_trdid = (index<<1) + 1;
4680                }
4681            }
4682            else if ( r_dcache_cleanup_req.read() ) // dcache request
4683            {
4684                ok = r_cleanup_buffer.register_value( r_dcache_cleanup_line.read(),
4685                                                      &index );   
4686                if ( ok )   // successful registration
4687                {
4688                    r_cleanup_fsm   = CLEANUP_DATA_GO;
4689                    r_cleanup_trdid = index<<1;
4690                }
4691            }
4692            break;
4693        }
4694        /////////////////////
4695        case CLEANUP_DATA_GO:
4696        {
4697            if ( p_vci_ini_c.cmdack.read() )
4698            {
4699                r_dcache_cleanup_req = false;
4700                r_cleanup_fsm        = CLEANUP_INS_IDLE;
4701
4702#if DEBUG_CLEANUP
4703if ( m_debug_cleanup_fsm )
4704{
4705    std::cout << "  <PROC.CLEANUP_DATA_GO> Cleanup request for icache:" << std::hex
4706              << " address = " << (r_dcache_cleanup_line.read()*m_dcache_words*4)
4707              << " / trdid = " << r_cleanup_trdid.read() << std::endl;
4708}
4709#endif
4710            }
4711        }
4712        ////////////////////////
4713        case CLEANUP_INS_GO:
4714        {
4715            if ( p_vci_ini_c.cmdack.read() )
4716            {
4717                r_icache_cleanup_req = false;
4718                r_cleanup_fsm        = CLEANUP_DATA_IDLE;
4719
4720#if DEBUG_CLEANUP
4721if ( m_debug_cleanup_fsm )
4722{
4723    std::cout << "  <PROC.CLEANUP_INS_GO> Cleanup request for dcache:" << std::hex
4724              << " address = " << (r_icache_cleanup_line.read()*m_icache_words*4)
4725              << " / trdid = " << r_cleanup_trdid.read() << std::endl;
4726}
4727#endif
4728            }
4729        }
4730    } // end switch CLEANUP FSM
4731
4732    //////////////// Handling  cleanup responses //////////////////
4733    if ( p_vci_ini_c.rspval.read() )    // valid response
4734    {
4735        r_cleanup_buffer.cancel_index( p_vci_ini_c.rtrdid.read() >> 1);
4736    }
4737
4738    ///////////////// Response FIFOs update  //////////////////////
4739    r_vci_rsp_fifo_icache.update(vci_rsp_fifo_icache_get,
4740                                 vci_rsp_fifo_icache_put,
4741                                 vci_rsp_fifo_icache_data);
4742
4743    r_vci_rsp_fifo_dcache.update(vci_rsp_fifo_dcache_get,
4744                                 vci_rsp_fifo_dcache_put,
4745                                 vci_rsp_fifo_dcache_data);
4746} // end transition()
4747
4748///////////////////////
4749tmpl(void)::genMoore()
4750///////////////////////
4751{
4752    ////////////////////////////////////////////////////////////////
4753    // VCI initiator command on the coherence network (cleanup)
4754    // it depends on the CLEANUP FSM state
4755
4756    paddr_t  address;
4757
4758    if ( r_cleanup_fsm.read() == CLEANUP_DATA_GO )
4759        address = r_dcache_cleanup_line.read()*m_dcache_words*4;
4760    else if ( r_cleanup_fsm.read() == CLEANUP_INS_GO )
4761        address = r_icache_cleanup_line.read()*m_icache_words*4;
4762    else
4763        address = 0;
4764
4765    p_vci_ini_c.cmdval  = ((r_cleanup_fsm.read() == CLEANUP_DATA_GO) or
4766                           (r_cleanup_fsm.read() == CLEANUP_INS_GO) );
4767    p_vci_ini_c.address = address;
4768    p_vci_ini_c.wdata   = 0;
4769    p_vci_ini_c.be      = 0xF;
4770    p_vci_ini_c.plen    = 4;
4771    p_vci_ini_c.cmd     = vci_param::CMD_WRITE;
4772    p_vci_ini_c.trdid   = r_cleanup_trdid.read();
4773    p_vci_ini_c.pktid   = 0;
4774    p_vci_ini_c.srcid   = m_srcid_c;
4775    p_vci_ini_c.cons    = false;
4776    p_vci_ini_c.wrap    = false;
4777    p_vci_ini_c.contig  = false;
4778    p_vci_ini_c.clen    = 0;
4779    p_vci_ini_c.cfixed  = false;
4780    p_vci_ini_c.eop     = true;
4781
4782    /////////////////////////////////////////////////////////////////
4783    // VCI initiator response on the coherence network (cleanup)
4784    // We always consume the response, and we don't use it.
4785
4786    p_vci_ini_c.rspack  = true;
4787
4788    /////////////////////////////////////////////////////////////////
4789    // VCI initiator command on the direct network
4790    // it depends on the CMD FSM state
4791
4792    p_vci_ini_d.pktid  = 0;
4793    p_vci_ini_d.srcid  = m_srcid_d;
4794    p_vci_ini_d.cons   = (r_vci_cmd_fsm.read() == CMD_DATA_SC);
4795    p_vci_ini_d.contig = not (r_vci_cmd_fsm.read() == CMD_DATA_SC);
4796    p_vci_ini_d.wrap   = false;
4797    p_vci_ini_d.clen   = 0;
4798    p_vci_ini_d.cfixed = false;
4799
4800    switch ( r_vci_cmd_fsm.read() ) {
4801
4802    case CMD_IDLE:
4803        p_vci_ini_d.cmdval  = false;
4804        p_vci_ini_d.address = 0;
4805        p_vci_ini_d.wdata   = 0;
4806        p_vci_ini_d.be      = 0;
4807        p_vci_ini_d.trdid   = 0;
4808        p_vci_ini_d.plen    = 0;
4809        p_vci_ini_d.cmd     = vci_param::CMD_NOP;
4810        p_vci_ini_d.eop     = false;
4811        break;
4812
4813    case CMD_INS_MISS:
4814        p_vci_ini_d.cmdval  = true;
4815        p_vci_ini_d.address = r_icache_vci_paddr.read() & m_icache_yzmask;
4816        p_vci_ini_d.wdata   = 0;
4817        p_vci_ini_d.be      = 0xF;
4818        p_vci_ini_d.trdid   = TYPE_INS_MISS;
4819        p_vci_ini_d.plen    = m_icache_words<<2;
4820        p_vci_ini_d.cmd     = vci_param::CMD_READ;
4821        p_vci_ini_d.eop     = true;
4822        break;
4823
4824    case CMD_INS_UNC:
4825        p_vci_ini_d.cmdval  = true;
4826        p_vci_ini_d.address = r_icache_vci_paddr.read() & ~0x3;
4827        p_vci_ini_d.wdata   = 0;
4828        p_vci_ini_d.be      = 0xF;
4829        p_vci_ini_d.trdid   = TYPE_INS_UNC;
4830        p_vci_ini_d.plen    = 4;
4831        p_vci_ini_d.cmd     = vci_param::CMD_READ;
4832        p_vci_ini_d.eop     = true;
4833        break;
4834
4835    case CMD_DATA_MISS:
4836        p_vci_ini_d.cmdval  = true;
4837        p_vci_ini_d.address = r_dcache_vci_paddr.read() & m_dcache_yzmask;
4838        p_vci_ini_d.wdata   = 0;
4839        p_vci_ini_d.be      = 0xF;
4840        p_vci_ini_d.trdid   = TYPE_DATA_MISS;
4841        p_vci_ini_d.plen    = m_dcache_words << 2;
4842        p_vci_ini_d.cmd     = vci_param::CMD_READ;
4843        p_vci_ini_d.eop     = true;
4844        break;
4845
4846    case CMD_DATA_UNC:
4847        p_vci_ini_d.cmdval  = true;
4848        p_vci_ini_d.address = r_dcache_vci_paddr.read() & ~0x3;
4849        p_vci_ini_d.wdata   = 0;
4850        p_vci_ini_d.be      = r_dcache_vci_unc_be.read();
4851        p_vci_ini_d.trdid   = TYPE_DATA_UNC;
4852        p_vci_ini_d.plen    = 4;
4853        p_vci_ini_d.cmd     = vci_param::CMD_READ;
4854        p_vci_ini_d.eop     = true;
4855        break;
4856
4857    case CMD_DATA_WRITE:
4858        p_vci_ini_d.cmdval  = true;
4859        p_vci_ini_d.address = r_wbuf.getAddress(r_vci_cmd_cpt.read()) & ~0x3;
4860        p_vci_ini_d.wdata   = r_wbuf.getData(r_vci_cmd_cpt.read());
4861        p_vci_ini_d.be      = r_wbuf.getBe(r_vci_cmd_cpt.read());
4862        p_vci_ini_d.trdid   = r_wbuf.getIndex() + (1<<(vci_param::T-1));
4863        p_vci_ini_d.plen    = (r_vci_cmd_max.read() - r_vci_cmd_min.read() + 1) << 2;
4864        p_vci_ini_d.cmd     = vci_param::CMD_WRITE;
4865        p_vci_ini_d.eop     = (r_vci_cmd_cpt.read() == r_vci_cmd_max.read());
4866        break;
4867
4868    case CMD_DATA_SC:
4869        p_vci_ini_d.cmdval  = true;
4870        p_vci_ini_d.address = r_dcache_vci_paddr.read() & ~0x3;
4871        if ( r_vci_cmd_cpt.read() == 0 ) p_vci_ini_d.wdata = r_dcache_vci_sc_old.read();
4872        else                             p_vci_ini_d.wdata = r_dcache_vci_sc_new.read();
4873        p_vci_ini_d.be      = 0xF;
4874        p_vci_ini_d.trdid   = TYPE_DATA_UNC; 
4875        p_vci_ini_d.plen    = 8;
4876        p_vci_ini_d.cmd     = vci_param::CMD_STORE_COND;
4877        p_vci_ini_d.eop     = (r_vci_cmd_cpt.read() == 1);
4878        break;     
4879    } // end switch r_vci_cmd_fsm
4880
4881    //////////////////////////////////////////////////////////
4882    // VCI initiator response on the direct network
4883    // it depends on the VCI RSP state
4884
4885    switch (r_vci_rsp_fsm.read() )
4886    {
4887        case RSP_DATA_WRITE : p_vci_ini_d.rspack = true; break;
4888        case RSP_INS_MISS   : p_vci_ini_d.rspack = r_vci_rsp_fifo_icache.wok(); break;
4889        case RSP_INS_UNC    : p_vci_ini_d.rspack = r_vci_rsp_fifo_icache.wok(); break;
4890        case RSP_DATA_MISS  : p_vci_ini_d.rspack = r_vci_rsp_fifo_dcache.wok(); break;
4891        case RSP_DATA_UNC   : p_vci_ini_d.rspack = r_vci_rsp_fifo_dcache.wok(); break;
4892        case RSP_IDLE       : p_vci_ini_d.rspack = false; break;
4893    } // end switch r_vci_rsp_fsm
4894
4895    ////////////////////////////////////////////////////////////////
4896    // VCI target command and response on the coherence network
4897    switch ( r_tgt_fsm.read() ) 
4898    {
4899    case TGT_IDLE:
4900    case TGT_UPDT_WORD:
4901    case TGT_UPDT_DATA:
4902        p_vci_tgt_c.cmdack  = true;
4903        p_vci_tgt_c.rspval  = false;
4904        break;
4905
4906    case TGT_RSP_BROADCAST:
4907        p_vci_tgt_c.cmdack  = false;
4908        p_vci_tgt_c.rspval  = not r_tgt_icache_req.read() and not r_tgt_dcache_req.read()
4909                              and ( r_tgt_icache_rsp.read() or r_tgt_dcache_rsp.read() );
4910        p_vci_tgt_c.rsrcid  = r_tgt_srcid.read();
4911        p_vci_tgt_c.rpktid  = r_tgt_pktid.read();
4912        p_vci_tgt_c.rtrdid  = r_tgt_trdid.read();
4913        p_vci_tgt_c.rdata   = 0;
4914        p_vci_tgt_c.rerror  = 0;
4915        p_vci_tgt_c.reop    = true;
4916        break;
4917
4918    case TGT_RSP_ICACHE:
4919        p_vci_tgt_c.cmdack  = false;
4920        p_vci_tgt_c.rspval  = not r_tgt_icache_req.read() and r_tgt_icache_rsp.read();
4921        p_vci_tgt_c.rsrcid  = r_tgt_srcid.read();
4922        p_vci_tgt_c.rpktid  = r_tgt_pktid.read();
4923        p_vci_tgt_c.rtrdid  = r_tgt_trdid.read();
4924        p_vci_tgt_c.rdata   = 0;
4925        p_vci_tgt_c.rerror  = 0;
4926        p_vci_tgt_c.reop    = true;
4927        break;
4928
4929    case TGT_RSP_DCACHE:
4930        p_vci_tgt_c.cmdack  = false;
4931        p_vci_tgt_c.rspval  = not r_tgt_dcache_req.read() and r_tgt_dcache_rsp.read();
4932        p_vci_tgt_c.rsrcid  = r_tgt_srcid.read();
4933        p_vci_tgt_c.rpktid  = r_tgt_pktid.read();
4934        p_vci_tgt_c.rtrdid  = r_tgt_trdid.read();
4935        p_vci_tgt_c.rdata   = 0;
4936        p_vci_tgt_c.rerror  = 0;
4937        p_vci_tgt_c.reop    = true;
4938        break;
4939
4940    case TGT_REQ_BROADCAST:
4941    case TGT_REQ_ICACHE:
4942    case TGT_REQ_DCACHE:
4943        p_vci_tgt_c.cmdack  = false;
4944        p_vci_tgt_c.rspval  = false;
4945        break;
4946
4947    } // end switch TGT_FSM
4948} // end genMoore
4949
4950}}
4951
4952// Local Variables:
4953// tab-width: 4
4954// c-basic-offset: 4
4955// c-file-offsets:((innamespace . 0)(inline-open . 0))
4956// indent-tabs-mode: nil
4957// End:
4958
4959// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
4960
4961
4962
4963
4964
4965
4966
4967
4968
4969
Note: See TracBrowser for help on using the repository browser.