source: trunk/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp @ 892

Last change on this file since 892 was 892, checked in by cfuguet, 9 years ago

trunk: introduce debug messages in cc_vcache for processor write reqs

File size: 243.7 KB
Line 
1/* -*- c++ -*-
2 * File : vci_cc_vcache_wrapper.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 * Maintainers: cesar.fuguet-tortolero@lip6.fr
27 *              alexandre.joannou@lip6.fr
28 */
29
30#include <cassert>
31#include <signal.h>
32
33#include "arithmetics.h"
34#include "../include/vci_cc_vcache_wrapper.h"
35
36#define DEBUG_DCACHE    1
37#define DEBUG_ICACHE    1
38#define DEBUG_CMD       0
39
40namespace soclib {
41namespace caba {
42
43namespace {
44const char * icache_fsm_state_str[] = {
45        "ICACHE_IDLE",
46
47        "ICACHE_XTN_TLB_FLUSH",
48        "ICACHE_XTN_CACHE_FLUSH",
49        "ICACHE_XTN_CACHE_FLUSH_GO",
50        "ICACHE_XTN_TLB_INVAL",
51        "ICACHE_XTN_CACHE_INVAL_VA",
52        "ICACHE_XTN_CACHE_INVAL_PA",
53        "ICACHE_XTN_CACHE_INVAL_GO",
54
55        "ICACHE_TLB_WAIT",
56
57        "ICACHE_MISS_SELECT",
58        "ICACHE_MISS_CLEAN",
59        "ICACHE_MISS_WAIT",
60        "ICACHE_MISS_DATA_UPDT",
61        "ICACHE_MISS_DIR_UPDT",
62
63        "ICACHE_UNC_WAIT",
64
65        "ICACHE_CC_CHECK",
66        "ICACHE_CC_UPDT",
67        "ICACHE_CC_INVAL",
68    };
69
70const char * dcache_fsm_state_str[] = {
71        "DCACHE_IDLE",
72
73        "DCACHE_TLB_MISS",
74        "DCACHE_TLB_PTE1_GET",
75        "DCACHE_TLB_PTE1_SELECT",
76        "DCACHE_TLB_PTE1_UPDT",
77        "DCACHE_TLB_PTE2_GET",
78        "DCACHE_TLB_PTE2_SELECT",
79        "DCACHE_TLB_PTE2_UPDT",
80        "DCACHE_TLB_LR_UPDT",
81        "DCACHE_TLB_LR_WAIT",
82        "DCACHE_TLB_RETURN",
83
84        "DCACHE_XTN_SWITCH",
85        "DCACHE_XTN_SYNC",
86        "DCACHE_XTN_IC_INVAL_VA",
87        "DCACHE_XTN_IC_FLUSH",
88        "DCACHE_XTN_IC_INVAL_PA",
89        "DCACHE_XTN_IC_PADDR_EXT",
90        "DCACHE_XTN_IT_INVAL",
91        "DCACHE_XTN_DC_FLUSH",
92        "DCACHE_XTN_DC_FLUSH_GO",
93        "DCACHE_XTN_DC_INVAL_VA",
94        "DCACHE_XTN_DC_INVAL_PA",
95        "DCACHE_XTN_DC_INVAL_END",
96        "DCACHE_XTN_DC_INVAL_GO",
97        "DCACHE_XTN_DT_INVAL",
98
99        "DCACHE_DIRTY_GET_PTE",
100        "DCACHE_DIRTY_WAIT",
101
102        "DCACHE_MISS_SELECT",
103        "DCACHE_MISS_CLEAN",
104        "DCACHE_MISS_WAIT",
105        "DCACHE_MISS_DATA_UPDT",
106        "DCACHE_MISS_DIR_UPDT",
107
108        "DCACHE_UNC_WAIT",
109        "DCACHE_LL_WAIT",
110        "DCACHE_SC_WAIT",
111
112        "DCACHE_CC_CHECK",
113        "DCACHE_CC_UPDT",
114        "DCACHE_CC_INVAL",
115
116        "DCACHE_INVAL_TLB_SCAN",
117    };
118
119const char * cmd_fsm_state_str[] = {
120        "CMD_IDLE",
121        "CMD_INS_MISS",
122        "CMD_INS_UNC",
123        "CMD_DATA_MISS",
124        "CMD_DATA_UNC_READ",
125        "CMD_DATA_UNC_WRITE",
126        "CMD_DATA_WRITE",
127        "CMD_DATA_LL",
128        "CMD_DATA_SC",
129        "CMD_DATA_CAS",
130    };
131
132const char * vci_pktid_type_str[] = {
133        "TYPE_DATA_UNC",
134        "TYPE_READ_DATA_MISS",
135        "TYPE_READ_INS_UNC",
136        "TYPE_READ_INS_MISS",
137        "TYPE_WRITE",
138        "TYPE_CAS",
139        "TYPE_LL",
140        "TYPE_SC",
141    };
142
143const char * vci_cmd_type_str[] = {
144        "NOP or STORE_COND",
145        "READ",
146        "WRITE",
147        "LOCKED_READ"
148    };
149
150const char * rsp_fsm_state_str[] = {
151        "RSP_IDLE",
152        "RSP_INS_MISS",
153        "RSP_INS_UNC",
154        "RSP_DATA_MISS",
155        "RSP_DATA_UNC",
156        "RSP_DATA_LL",
157        "RSP_DATA_WRITE",
158    };
159
160const char * cc_receive_fsm_state_str[] = {
161        "CC_RECEIVE_IDLE",
162        "CC_RECEIVE_BRDCAST_HEADER",
163        "CC_RECEIVE_BRDCAST_NLINE",
164        "CC_RECEIVE_INS_INVAL_HEADER",
165        "CC_RECEIVE_INS_INVAL_NLINE",
166        "CC_RECEIVE_INS_UPDT_HEADER",
167        "CC_RECEIVE_INS_UPDT_NLINE",
168        "CC_RECEIVE_INS_UPDT_DATA",
169        "CC_RECEIVE_DATA_INVAL_HEADER",
170        "CC_RECEIVE_DATA_INVAL_NLINE",
171        "CC_RECEIVE_DATA_UPDT_HEADER",
172        "CC_RECEIVE_DATA_UPDT_NLINE",
173        "CC_RECEIVE_DATA_UPDT_DATA",
174    };
175
176const char * cc_send_fsm_state_str[] = {
177        "CC_SEND_IDLE",
178        "CC_SEND_CLEANUP_1",
179        "CC_SEND_CLEANUP_2",
180        "CC_SEND_MULTI_ACK",
181    };
182}
183
184#define tmpl(...) \
185   template<typename vci_param, \
186            size_t   dspin_in_width, \
187            size_t   dspin_out_width, \
188            typename iss_t> __VA_ARGS__ \
189   VciCcVCacheWrapper<vci_param, dspin_in_width, dspin_out_width, iss_t>
190
191using namespace soclib::common;
192
193/////////////////////////////////
194tmpl(/**/)::VciCcVCacheWrapper(
195    sc_module_name name,
196    const int proc_id,
197    const MappingTable &mtd,
198    const IntTab &srcid,
199    const size_t cc_global_id,
200    const size_t itlb_ways,
201    const size_t itlb_sets,
202    const size_t dtlb_ways,
203    const size_t dtlb_sets,
204    const size_t icache_ways,
205    const size_t icache_sets,
206    const size_t icache_words,
207    const size_t dcache_ways,
208    const size_t dcache_sets,
209    const size_t dcache_words,
210    const size_t wbuf_nlines,
211    const size_t wbuf_nwords,
212    const size_t x_width,
213    const size_t y_width,
214    const uint32_t max_frozen_cycles,
215    const uint32_t debug_start_cycle,
216    const bool debug_ok)
217    : soclib::caba::BaseModule(name),
218
219      p_clk("p_clk"),
220      p_resetn("p_resetn"),
221      p_vci("p_vci"),
222      p_dspin_m2p("p_dspin_m2p"),
223      p_dspin_p2m("p_dspin_p2m"),
224      p_dspin_clack("p_dspin_clack"),
225
226      m_cacheability_table( mtd.getCacheabilityTable()),
227      m_srcid(mtd.indexForId(srcid)),
228      m_cc_global_id(cc_global_id),
229      m_nline_width(vci_param::N - (uint32_log2(dcache_words)) - 2),
230      m_itlb_ways(itlb_ways),
231      m_itlb_sets(itlb_sets),
232      m_dtlb_ways(dtlb_ways),
233      m_dtlb_sets(dtlb_sets),
234      m_icache_ways(icache_ways),
235      m_icache_sets(icache_sets),
236      m_icache_yzmask((~0) << (uint32_log2(icache_words) + 2)),
237      m_icache_words(icache_words),
238      m_dcache_ways(dcache_ways),
239      m_dcache_sets(dcache_sets),
240      m_dcache_yzmask((~0) << (uint32_log2(dcache_words) + 2)),
241      m_dcache_words(dcache_words),
242      m_x_width(x_width),
243      m_y_width(y_width),
244      m_proc_id(proc_id),
245      m_max_frozen_cycles(max_frozen_cycles),
246      m_paddr_nbits(vci_param::N),
247      m_debug_start_cycle(debug_start_cycle),
248      m_debug_ok(debug_ok),
249      m_dcache_paddr_ext_reset(0),
250      m_icache_paddr_ext_reset(0),
251
252      r_mmu_ptpr("r_mmu_ptpr"),
253      r_mmu_mode("r_mmu_mode"),
254      r_mmu_word_lo("r_mmu_word_lo"),
255      r_mmu_word_hi("r_mmu_word_hi"),
256      r_mmu_ibvar("r_mmu_ibvar"),
257      r_mmu_dbvar("r_mmu_dbvar"),
258      r_mmu_ietr("r_mmu_ietr"),
259      r_mmu_detr("r_mmu_detr"),
260
261      r_icache_fsm("r_icache_fsm"),
262      r_icache_fsm_save("r_icache_fsm_save"),
263      r_icache_vci_paddr("r_icache_vci_paddr"),
264      r_icache_vaddr_save("r_icache_vaddr_save"),
265
266      r_icache_miss_way("r_icache_miss_way"),
267      r_icache_miss_set("r_icache_miss_set"),
268      r_icache_miss_word("r_icache_miss_word"),
269      r_icache_miss_inval("r_icache_miss_inval"),
270      r_icache_miss_clack("r_icache_miss_clack"),
271
272      r_icache_cc_way("r_icache_cc_way"),
273      r_icache_cc_set("r_icache_cc_set"),
274      r_icache_cc_word("r_icache_cc_word"),
275      r_icache_cc_need_write("r_icache_cc_need_write"),
276
277      r_icache_flush_count("r_icache_flush_count"),
278
279      r_icache_miss_req("r_icache_miss_req"),
280      r_icache_unc_req("r_icache_unc_req"),
281
282      r_icache_tlb_miss_req("r_icache_tlb_read_req"),
283      r_icache_tlb_rsp_error("r_icache_tlb_rsp_error"),
284
285      r_icache_cleanup_victim_req("r_icache_cleanup_victim_req"),
286      r_icache_cleanup_victim_nline("r_icache_cleanup_victim_nline"),
287
288      r_icache_cc_send_req("r_icache_cc_send_req"),
289      r_icache_cc_send_type("r_icache_cc_send_type"),
290      r_icache_cc_send_nline("r_icache_cc_send_nline"),
291      r_icache_cc_send_way("r_icache_cc_send_way"),
292      r_icache_cc_send_updt_tab_idx("r_icache_cc_send_updt_tab_idx"),
293
294      r_dcache_fsm("r_dcache_fsm"),
295      r_dcache_fsm_cc_save("r_dcache_fsm_cc_save"),
296      r_dcache_fsm_scan_save("r_dcache_fsm_scan_save"),
297
298      r_dcache_wbuf_req("r_dcache_wbuf_req"),
299      r_dcache_updt_req("r_dcache_updt_req"),
300      r_dcache_save_vaddr("r_dcache_save_vaddr"),
301      r_dcache_save_wdata("r_dcache_save_wdata"),
302      r_dcache_save_be("r_dcache_save_be"),
303      r_dcache_save_paddr("r_dcache_save_paddr"),
304      r_dcache_save_cache_way("r_dcache_save_cache_way"),
305      r_dcache_save_cache_set("r_dcache_save_cache_set"),
306      r_dcache_save_cache_word("r_dcache_save_cache_word"),
307
308      r_dcache_dirty_paddr("r_dcache_dirty_paddr"),
309      r_dcache_dirty_way("r_dcache_dirty_way"),
310      r_dcache_dirty_set("r_dcache_dirty_set"),
311
312      r_dcache_vci_paddr("r_dcache_vci_paddr"),
313      r_dcache_vci_wdata("r_dcache_vci_wdata"),
314      r_dcache_vci_miss_req("r_dcache_vci_miss_req"),
315      r_dcache_vci_unc_req("r_dcache_vci_unc_req"),
316      r_dcache_vci_unc_be("r_dcache_vci_unc_be"),
317      r_dcache_vci_unc_write("r_dcache_vci_unc_write"),
318      r_dcache_vci_cas_req("r_dcache_vci_cas_req"),
319      r_dcache_vci_cas_old("r_dcache_vci_cas_old"),
320      r_dcache_vci_cas_new("r_dcache_vci_cas_new"),
321      r_dcache_vci_ll_req("r_dcache_vci_ll_req"),
322      r_dcache_vci_sc_req("r_dcache_vci_sc_req"),
323      r_dcache_vci_sc_data("r_dcache_vci_sc_data"),
324
325      r_dcache_xtn_way("r_dcache_xtn_way"),
326      r_dcache_xtn_set("r_dcache_xtn_set"),
327
328      r_dcache_miss_type("r_dcache_miss_type"),
329      r_dcache_miss_word("r_dcache_miss_word"),
330      r_dcache_miss_way("r_dcache_miss_way"),
331      r_dcache_miss_set("r_dcache_miss_set"),
332      r_dcache_miss_inval("r_dcache_miss_inval"),
333
334      r_dcache_cc_way("r_dcache_cc_way"),
335      r_dcache_cc_set("r_dcache_cc_set"),
336      r_dcache_cc_word("r_dcache_cc_word"),
337      r_dcache_cc_need_write("r_dcache_cc_need_write"),
338
339      r_dcache_flush_count("r_dcache_flush_count"),
340
341      r_dcache_ll_rsp_count("r_dcache_ll_rsp_count"),
342
343      r_dcache_tlb_vaddr("r_dcache_tlb_vaddr"),
344      r_dcache_tlb_ins("r_dcache_tlb_ins"),
345      r_dcache_tlb_pte_flags("r_dcache_tlb_pte_flags"),
346      r_dcache_tlb_pte_ppn("r_dcache_tlb_pte_ppn"),
347      r_dcache_tlb_cache_way("r_dcache_tlb_cache_way"),
348      r_dcache_tlb_cache_set("r_dcache_tlb_cache_set"),
349      r_dcache_tlb_cache_word("r_dcache_tlb_cache_word"),
350      r_dcache_tlb_way("r_dcache_tlb_way"),
351      r_dcache_tlb_set("r_dcache_tlb_set"),
352
353      r_dcache_tlb_inval_line("r_dcache_tlb_inval_line"),
354      r_dcache_tlb_inval_set("r_dcache_tlb_inval_set"),
355
356      r_dcache_xtn_req("r_dcache_xtn_req"),
357      r_dcache_xtn_opcode("r_dcache_xtn_opcode"),
358
359      r_dcache_cleanup_victim_req("r_dcache_cleanup_victim_req"),
360      r_dcache_cleanup_victim_nline("r_dcache_cleanup_victim_nline"),
361
362      r_dcache_cc_send_req("r_dcache_cc_send_req"),
363      r_dcache_cc_send_type("r_dcache_cc_send_type"),
364      r_dcache_cc_send_nline("r_dcache_cc_send_nline"),
365      r_dcache_cc_send_way("r_dcache_cc_send_way"),
366      r_dcache_cc_send_updt_tab_idx("r_dcache_cc_send_updt_tab_idx"),
367
368      r_vci_cmd_fsm("r_vci_cmd_fsm"),
369      r_vci_cmd_min("r_vci_cmd_min"),
370      r_vci_cmd_max("r_vci_cmd_max"),
371      r_vci_cmd_cpt("r_vci_cmd_cpt"),
372      r_vci_cmd_imiss_prio("r_vci_cmd_imiss_prio"),
373
374      r_vci_rsp_fsm("r_vci_rsp_fsm"),
375      r_vci_rsp_cpt("r_vci_rsp_cpt"),
376      r_vci_rsp_ins_error("r_vci_rsp_ins_error"),
377      r_vci_rsp_data_error("r_vci_rsp_data_error"),
378      r_vci_rsp_fifo_icache("r_vci_rsp_fifo_icache", 2), // 2 words depth
379      r_vci_rsp_fifo_dcache("r_vci_rsp_fifo_dcache", 2), // 2 words depth
380
381      r_cc_send_fsm("r_cc_send_fsm"),
382      r_cc_send_last_client("r_cc_send_last_client"),
383
384      r_cc_receive_fsm("r_cc_receive_fsm"),
385      r_cc_receive_data_ins("r_cc_receive_data_ins"),
386      r_cc_receive_word_idx("r_cc_receive_word_idx"),
387      r_cc_receive_updt_fifo_be("r_cc_receive_updt_fifo_be", 2), // 2 words depth
388      r_cc_receive_updt_fifo_data("r_cc_receive_updt_fifo_data", 2), // 2 words depth
389      r_cc_receive_updt_fifo_eop("r_cc_receive_updt_fifo_eop", 2), // 2 words depth
390
391      r_cc_receive_icache_req("r_cc_receive_icache_req"),
392      r_cc_receive_icache_type("r_cc_receive_icache_type"),
393      r_cc_receive_icache_way("r_cc_receive_icache_way"),
394      r_cc_receive_icache_set("r_cc_receive_icache_set"),
395      r_cc_receive_icache_updt_tab_idx("r_cc_receive_icache_updt_tab_idx"),
396      r_cc_receive_icache_nline("r_cc_receive_icache_nline"),
397
398      r_cc_receive_dcache_req("r_cc_receive_dcache_req"),
399      r_cc_receive_dcache_type("r_cc_receive_dcache_type"),
400      r_cc_receive_dcache_way("r_cc_receive_dcache_way"),
401      r_cc_receive_dcache_set("r_cc_receive_dcache_set"),
402      r_cc_receive_dcache_updt_tab_idx("r_cc_receive_dcache_updt_tab_idx"),
403      r_cc_receive_dcache_nline("r_cc_receive_dcache_nline"),
404
405      r_iss(this->name(), proc_id),
406      r_wbuf("wbuf", wbuf_nwords, wbuf_nlines, dcache_words ),
407      r_icache("icache", icache_ways, icache_sets, icache_words),
408      r_dcache("dcache", dcache_ways, dcache_sets, dcache_words),
409      r_itlb("itlb", proc_id, itlb_ways,itlb_sets,vci_param::N),
410      r_dtlb("dtlb", proc_id, dtlb_ways,dtlb_sets,vci_param::N)
411{
412    std::cout << "  - Building VciCcVcacheWrapper : " << name << std::endl;
413
414    assert(((icache_words*vci_param::B) < (1 << vci_param::K)) and
415             "Need more PLEN bits.");
416
417    assert((vci_param::T > 2) and ((1 << (vci_param::T - 1)) >= (wbuf_nlines)) and
418             "Need more TRDID bits.");
419
420    assert((icache_words == dcache_words) and
421             "icache_words and dcache_words parameters must be equal");
422
423    assert((itlb_sets == dtlb_sets) and
424             "itlb_sets and dtlb_sets parameters must be etqual");
425
426    assert((itlb_ways == dtlb_ways) and
427             "itlb_ways and dtlb_ways parameters must be etqual");
428
429    r_mmu_params = (uint32_log2(m_dtlb_ways)   << 29) | (uint32_log2(m_dtlb_sets)   << 25) |
430                   (uint32_log2(m_dcache_ways) << 22) | (uint32_log2(m_dcache_sets) << 18) |
431                   (uint32_log2(m_itlb_ways)   << 15) | (uint32_log2(m_itlb_sets)   << 11) |
432                   (uint32_log2(m_icache_ways) << 8)  | (uint32_log2(m_icache_sets) << 4)  |
433                   (uint32_log2(m_icache_words << 2));
434
435    r_mmu_release = (uint32_t) (1 << 16) | 0x1;
436
437    r_dcache_in_tlb       = new bool[dcache_ways * dcache_sets];
438    r_dcache_contains_ptd = new bool[dcache_ways * dcache_sets];
439
440    SC_METHOD(transition);
441    dont_initialize();
442    sensitive << p_clk.pos();
443
444    SC_METHOD(genMoore);
445    dont_initialize();
446    sensitive << p_clk.neg();
447
448    typename iss_t::CacheInfo cache_info;
449    cache_info.has_mmu = true;
450    cache_info.icache_line_size = icache_words * sizeof(uint32_t);
451    cache_info.icache_assoc = icache_ways;
452    cache_info.icache_n_lines = icache_sets;
453    cache_info.dcache_line_size = dcache_words * sizeof(uint32_t);
454    cache_info.dcache_assoc = dcache_ways;
455    cache_info.dcache_n_lines = dcache_sets;
456    r_iss.setCacheInfo(cache_info);
457}
458
459/////////////////////////////////////
460tmpl(/**/)::~VciCcVCacheWrapper()
461/////////////////////////////////////
462{
463    delete [] r_dcache_in_tlb;
464    delete [] r_dcache_contains_ptd;
465}
466
467////////////////////////
468tmpl(void)::print_cpi()
469////////////////////////
470{
471    std::cout << name() << " CPI = "
472        << (float)m_cpt_total_cycles/(m_cpt_total_cycles - m_cpt_frz_cycles) << std::endl ;
473}
474
475////////////////////////////////////
476tmpl(void)::print_trace(size_t mode)
477////////////////////////////////////
478{
479    // b0 : write buffer trace
480    // b1 : dump processor registers
481    // b2 : dcache trace
482    // b3 : icache trace
483    // b4 : dtlb trace
484    // b5 : itlb trace
485    // b6 : SR (ISS register 32)
486
487    std::cout << std::dec << "PROC " << name() << std::endl;
488
489    std::cout << "  " << m_ireq << std::endl;
490    std::cout << "  " << m_irsp << std::endl;
491    std::cout << "  " << m_dreq << std::endl;
492    std::cout << "  " << m_drsp << std::endl;
493
494    std::cout << "  " << icache_fsm_state_str[r_icache_fsm.read()]
495              << " | " << dcache_fsm_state_str[r_dcache_fsm.read()]
496              << " | " << cmd_fsm_state_str[r_vci_cmd_fsm.read()]
497              << " | " << rsp_fsm_state_str[r_vci_rsp_fsm.read()]
498              << " | " << cc_receive_fsm_state_str[r_cc_receive_fsm.read()]
499              << " | " << cc_send_fsm_state_str[r_cc_send_fsm.read()]
500              << " | MMU = " << r_mmu_mode.read();
501
502    if (r_dcache_updt_req.read()) std::cout << " | P1_UPDT";
503    if (r_dcache_wbuf_req.read()) std::cout << " | P1_WBUF";
504    std::cout << std::endl;
505
506    if (mode & 0x01)
507    {
508        if (r_icache_miss_req.read())     std::cout << "  IMISS_REQ" << std::endl;
509        if (r_icache_unc_req.read())      std::cout << "  IUNC_REQ" << std::endl;
510        if (r_dcache_vci_miss_req.read()) std::cout << "  DMISS_REQ" << std::endl;
511        if (r_dcache_vci_unc_req.read())  std::cout << "  DUNC_REQ" << std::endl;
512
513        r_wbuf.printTrace((mode >> 1) & 1);
514    }
515    if (mode & 0x02)
516    {
517        r_iss.dump();
518    }
519    if (mode & 0x04)
520    {
521        std::cout << "  Data Cache" << std::endl;
522        r_dcache.printTrace();
523    }
524    if (mode & 0x08)
525    {
526        std::cout << "  Instruction Cache" << std::endl;
527        r_icache.printTrace();
528    }
529    if (mode & 0x10)
530    {
531        std::cout << "  Data TLB" << std::endl;
532        r_dtlb.printTrace();
533    }
534    if (mode & 0x20)
535    {
536        std::cout << "  Instruction TLB" << std::endl;
537        r_itlb.printTrace();
538    }
539    if (mode & 0x40)
540    {
541        uint32_t status = r_iss.debugGetRegisterValue(32);
542        std::cout << name();
543        if (status != m_previous_status ) std::cout << " NEW ";
544        std::cout << " status = " << std::hex << status << " " << std::endl;
545        m_previous_status = status;
546    }
547}
548
549//////////////////////////////////////////
550tmpl(void)::cache_monitor(paddr_t addr)
551//////////////////////////////////////////
552{
553    bool cache_hit;
554    size_t cache_way = 0;
555    size_t cache_set = 0;
556    size_t cache_word = 0;
557    uint32_t cache_rdata = 0;
558
559    cache_hit = r_dcache.read_neutral(addr,
560                                      &cache_rdata,
561                                      &cache_way,
562                                      &cache_set,
563                                      &cache_word);
564
565    if (cache_hit != m_debug_previous_d_hit)
566    {
567        std::cout << "Monitor PROC " << name()
568                  << " DCACHE at cycle " << std::dec << m_cpt_total_cycles
569                  << " / HIT = " << cache_hit
570                  << " / PADDR = " << std::hex << addr
571                  << " / DATA = " << cache_rdata
572                  << " / WAY = " << cache_way << std::endl;
573        m_debug_previous_d_hit = cache_hit;
574    }
575
576    cache_hit = r_icache.read_neutral(addr,
577                                      &cache_rdata,
578                                      &cache_way,
579                                      &cache_set,
580                                      &cache_word);
581
582    if (cache_hit != m_debug_previous_i_hit)
583    {
584        std::cout << "Monitor PROC " << name()
585                  << " ICACHE at cycle " << std::dec << m_cpt_total_cycles
586                  << " / HIT = " << cache_hit
587                  << " / PADDR = " << std::hex << addr
588                  << " / DATA = " << cache_rdata
589                  << " / WAY = " << cache_way << std::endl;
590        m_debug_previous_i_hit = cache_hit;
591    }
592}
593
594/*
595////////////////////////
596tmpl(void)::print_stats()
597////////////////////////
598{
599    float run_cycles = (float)(m_cpt_total_cycles - m_cpt_frz_cycles);
600    std::cout << name() << std::endl
601        << "- CPI                    = " << (float)m_cpt_total_cycles/run_cycles << std::endl
602        << "- READ RATE              = " << (float)m_cpt_read/run_cycles << std::endl
603        << "- WRITE RATE             = " << (float)m_cpt_write/run_cycles << std::endl
604        << "- IMISS_RATE             = " << (float)m_cpt_ins_miss/m_cpt_ins_read << std::endl
605        << "- DMISS RATE             = " << (float)m_cpt_data_miss/(m_cpt_read-m_cpt_unc_read) << std::endl
606        << "- INS MISS COST          = " << (float)m_cost_ins_miss_frz/m_cpt_ins_miss << std::endl
607        << "- DATA MISS COST         = " << (float)m_cost_data_miss_frz/m_cpt_data_miss << std::endl
608        << "- WRITE COST             = " << (float)m_cost_write_frz/m_cpt_write << std::endl
609        << "- UNC COST               = " << (float)m_cost_unc_read_frz/m_cpt_unc_read << std::endl
610        << "- UNCACHED READ RATE     = " << (float)m_cpt_unc_read/m_cpt_read << std::endl
611        << "- CACHED WRITE RATE      = " << (float)m_cpt_write_cached/m_cpt_write << std::endl
612        << "- INS TLB MISS RATE      = " << (float)m_cpt_ins_tlb_miss/m_cpt_ins_tlb_read << std::endl
613        << "- DATA TLB MISS RATE     = " << (float)m_cpt_data_tlb_miss/m_cpt_data_tlb_read << std::endl
614        << "- ITLB MISS COST         = " << (float)m_cost_ins_tlb_miss_frz/m_cpt_ins_tlb_miss << std::endl
615        << "- DTLB MISS COST         = " << (float)m_cost_data_tlb_miss_frz/m_cpt_data_tlb_miss << std::endl
616        << "- ITLB UPDATE ACC COST   = " << (float)m_cost_ins_tlb_update_acc_frz/m_cpt_ins_tlb_update_acc << std::endl
617        << "- DTLB UPDATE ACC COST   = " << (float)m_cost_data_tlb_update_acc_frz/m_cpt_data_tlb_update_acc << std::endl
618        << "- DTLB UPDATE DIRTY COST = " << (float)m_cost_data_tlb_update_dirty_frz/m_cpt_data_tlb_update_dirty << std::endl
619        << "- ITLB HIT IN DCACHE RATE= " << (float)m_cpt_ins_tlb_hit_dcache/m_cpt_ins_tlb_miss << std::endl
620        << "- DTLB HIT IN DCACHE RATE= " << (float)m_cpt_data_tlb_hit_dcache/m_cpt_data_tlb_miss << std::endl
621        << "- DCACHE FROZEN BY ITLB  = " << (float)m_cost_ins_tlb_occup_cache_frz/m_cpt_dcache_frz_cycles << std::endl
622        << "- DCACHE FOR TLB %       = " << (float)m_cpt_tlb_occup_dcache/(m_dcache_ways*m_dcache_sets) << std::endl
623        << "- NB CC BROADCAST        = " << m_cpt_cc_broadcast << std::endl
624        << "- NB CC UPDATE DATA      = " << m_cpt_cc_update_data << std::endl
625        << "- NB CC INVAL DATA       = " << m_cpt_cc_inval_data << std::endl
626        << "- NB CC INVAL INS        = " << m_cpt_cc_inval_ins << std::endl
627        << "- CC BROADCAST COST      = " << (float)m_cost_broadcast_frz/m_cpt_cc_broadcast << std::endl
628        << "- CC UPDATE DATA COST    = " << (float)m_cost_updt_data_frz/m_cpt_cc_update_data << std::endl
629        << "- CC INVAL DATA COST     = " << (float)m_cost_inval_data_frz/m_cpt_cc_inval_data << std::endl
630        << "- CC INVAL INS COST      = " << (float)m_cost_inval_ins_frz/m_cpt_cc_inval_ins << std::endl
631        << "- NB CC CLEANUP DATA     = " << m_cpt_cc_cleanup_data << std::endl
632        << "- NB CC CLEANUP INS      = " << m_cpt_cc_cleanup_ins << std::endl
633        << "- IMISS TRANSACTION      = " << (float)m_cost_imiss_transaction/m_cpt_imiss_transaction << std::endl
634        << "- DMISS TRANSACTION      = " << (float)m_cost_dmiss_transaction/m_cpt_dmiss_transaction << std::endl
635        << "- UNC TRANSACTION        = " << (float)m_cost_unc_transaction/m_cpt_unc_transaction << std::endl
636        << "- WRITE TRANSACTION      = " << (float)m_cost_write_transaction/m_cpt_write_transaction << std::endl
637        << "- WRITE LENGTH           = " << (float)m_length_write_transaction/m_cpt_write_transaction << std::endl
638        << "- ITLB MISS TRANSACTION  = " << (float)m_cost_itlbmiss_transaction/m_cpt_itlbmiss_transaction << std::endl
639        << "- DTLB MISS TRANSACTION  = " << (float)m_cost_dtlbmiss_transaction/m_cpt_dtlbmiss_transaction << std::endl;
640}
641
642////////////////////////
643tmpl(void)::clear_stats()
644////////////////////////
645{
646    m_cpt_dcache_data_read  = 0;
647    m_cpt_dcache_data_write = 0;
648    m_cpt_dcache_dir_read   = 0;
649    m_cpt_dcache_dir_write  = 0;
650    m_cpt_icache_data_read  = 0;
651    m_cpt_icache_data_write = 0;
652    m_cpt_icache_dir_read   = 0;
653    m_cpt_icache_dir_write  = 0;
654
655    m_cpt_frz_cycles        = 0;
656    m_cpt_dcache_frz_cycles = 0;
657    m_cpt_total_cycles      = 0;
658
659    m_cpt_read         = 0;
660    m_cpt_write        = 0;
661    m_cpt_data_miss    = 0;
662    m_cpt_ins_miss     = 0;
663    m_cpt_unc_read     = 0;
664    m_cpt_write_cached = 0;
665    m_cpt_ins_read     = 0;
666
667    m_cost_write_frz     = 0;
668    m_cost_data_miss_frz = 0;
669    m_cost_unc_read_frz  = 0;
670    m_cost_ins_miss_frz  = 0;
671
672    m_cpt_imiss_transaction      = 0;
673    m_cpt_dmiss_transaction      = 0;
674    m_cpt_unc_transaction        = 0;
675    m_cpt_write_transaction      = 0;
676    m_cpt_icache_unc_transaction = 0;
677
678    m_cost_imiss_transaction      = 0;
679    m_cost_dmiss_transaction      = 0;
680    m_cost_unc_transaction        = 0;
681    m_cost_write_transaction      = 0;
682    m_cost_icache_unc_transaction = 0;
683    m_length_write_transaction    = 0;
684
685    m_cpt_ins_tlb_read       = 0;
686    m_cpt_ins_tlb_miss       = 0;
687    m_cpt_ins_tlb_update_acc = 0;
688
689    m_cpt_data_tlb_read         = 0;
690    m_cpt_data_tlb_miss         = 0;
691    m_cpt_data_tlb_update_acc   = 0;
692    m_cpt_data_tlb_update_dirty = 0;
693    m_cpt_ins_tlb_hit_dcache    = 0;
694    m_cpt_data_tlb_hit_dcache   = 0;
695    m_cpt_ins_tlb_occup_cache   = 0;
696    m_cpt_data_tlb_occup_cache  = 0;
697
698    m_cost_ins_tlb_miss_frz          = 0;
699    m_cost_data_tlb_miss_frz         = 0;
700    m_cost_ins_tlb_update_acc_frz    = 0;
701    m_cost_data_tlb_update_acc_frz   = 0;
702    m_cost_data_tlb_update_dirty_frz = 0;
703    m_cost_ins_tlb_occup_cache_frz   = 0;
704    m_cost_data_tlb_occup_cache_frz  = 0;
705
706    m_cpt_itlbmiss_transaction      = 0;
707    m_cpt_itlb_ll_transaction       = 0;
708    m_cpt_itlb_sc_transaction       = 0;
709    m_cpt_dtlbmiss_transaction      = 0;
710    m_cpt_dtlb_ll_transaction       = 0;
711    m_cpt_dtlb_sc_transaction       = 0;
712    m_cpt_dtlb_ll_dirty_transaction = 0;
713    m_cpt_dtlb_sc_dirty_transaction = 0;
714
715    m_cost_itlbmiss_transaction      = 0;
716    m_cost_itlb_ll_transaction       = 0;
717    m_cost_itlb_sc_transaction       = 0;
718    m_cost_dtlbmiss_transaction      = 0;
719    m_cost_dtlb_ll_transaction       = 0;
720    m_cost_dtlb_sc_transaction       = 0;
721    m_cost_dtlb_ll_dirty_transaction = 0;
722    m_cost_dtlb_sc_dirty_transaction = 0;
723
724    m_cpt_cc_update_data = 0;
725    m_cpt_cc_inval_ins   = 0;
726    m_cpt_cc_inval_data  = 0;
727    m_cpt_cc_broadcast   = 0;
728
729    m_cost_updt_data_frz  = 0;
730    m_cost_inval_ins_frz  = 0;
731    m_cost_inval_data_frz = 0;
732    m_cost_broadcast_frz  = 0;
733
734    m_cpt_cc_cleanup_data = 0;
735    m_cpt_cc_cleanup_ins  = 0;
736}
737
738*/
739
740/////////////////////////
741tmpl(void)::transition()
742/////////////////////////
743{
744    if (not p_resetn.read())
745    {
746        r_iss.reset();
747        r_wbuf.reset();
748        r_icache.reset();
749        r_dcache.reset();
750        r_itlb.reset();
751        r_dtlb.reset();
752
753        r_dcache_fsm     = DCACHE_IDLE;
754        r_icache_fsm     = ICACHE_IDLE;
755        r_vci_cmd_fsm    = CMD_IDLE;
756        r_vci_rsp_fsm    = RSP_IDLE;
757        r_cc_receive_fsm = CC_RECEIVE_IDLE;
758        r_cc_send_fsm    = CC_SEND_IDLE;
759
760        // reset data physical address extension
761        r_dcache_paddr_ext = m_dcache_paddr_ext_reset;
762
763        // reset inst physical address extension
764        r_icache_paddr_ext = m_icache_paddr_ext_reset;
765
766        // reset dcache directory extension
767        for (size_t i = 0; i< m_dcache_ways * m_dcache_sets; i++)
768        {
769            r_dcache_in_tlb[i] = false;
770            r_dcache_contains_ptd[i] = false;
771        }
772
773        // Response FIFOs and cleanup buffer
774        r_vci_rsp_fifo_icache.init();
775        r_vci_rsp_fifo_dcache.init();
776
777        // ICACHE & DCACHE activated
778        // ITLB & DTLB desactivated
779        r_mmu_mode = 0x3;
780
781        // No request from ICACHE FSM to CMD FSM
782        r_icache_miss_req          = false;
783        r_icache_unc_req           = false;
784
785        // No request from ICACHE_FSM to DCACHE FSM
786        r_icache_tlb_miss_req      = false;
787
788        // No request from ICACHE_FSM to CC_SEND FSM
789        r_icache_cc_send_req       = false;
790        r_icache_cleanup_victim_req = false;
791
792        r_icache_clack_req         = false;
793
794        // No pending write in pipeline
795        r_dcache_wbuf_req          = false;
796        r_dcache_updt_req          = false;
797
798        // No request from DCACHE_FSM to CMD_FSM
799        r_dcache_vci_miss_req      = false;
800        r_dcache_vci_unc_req       = false;
801        r_dcache_vci_cas_req       = false;
802        r_dcache_vci_ll_req        = false;
803        r_dcache_vci_sc_req        = false;
804
805        // No processor XTN request pending
806        r_dcache_xtn_req           = false;
807
808        // No request from DCACHE FSM to CC_SEND FSM
809        r_dcache_cc_send_req        = false;
810        r_dcache_cleanup_victim_req = false;
811
812        r_dcache_clack_req         = false;
813
814        // No request from CC_RECEIVE FSM to ICACHE/DCACHE FSMs
815        r_cc_receive_icache_req    = false;
816        r_cc_receive_dcache_req    = false;
817
818        // last cc_send client was dcache
819        r_cc_send_last_client      = false;
820
821        // No pending cleanup after a replacement
822        r_icache_miss_clack        = false;
823        r_dcache_miss_clack        = false;
824
825        // No signalisation of a coherence request matching a pending miss
826        r_icache_miss_inval        = false;
827        r_dcache_miss_inval        = false;
828
829        r_dspin_clack_req          = false;
830
831        // No signalisation  of errors
832        r_vci_rsp_ins_error        = false;
833        r_vci_rsp_data_error       = false;
834
835        // Debug variables
836        m_debug_previous_i_hit     = false;
837        m_debug_previous_d_hit     = false;
838        m_debug_icache_fsm         = false;
839        m_debug_dcache_fsm         = false;
840        m_debug_cmd_fsm            = false;
841
842        // activity counters
843        m_cpt_dcache_data_read  = 0;
844        m_cpt_dcache_data_write = 0;
845        m_cpt_dcache_dir_read   = 0;
846        m_cpt_dcache_dir_write  = 0;
847        m_cpt_icache_data_read  = 0;
848        m_cpt_icache_data_write = 0;
849        m_cpt_icache_dir_read   = 0;
850        m_cpt_icache_dir_write  = 0;
851
852        m_cpt_frz_cycles        = 0;
853        m_cpt_total_cycles      = 0;
854        m_cpt_stop_simulation   = 0;
855
856        m_cpt_data_miss         = 0;
857        m_cpt_ins_miss          = 0;
858        m_cpt_unc_read          = 0;
859        m_cpt_write_cached      = 0;
860        m_cpt_ins_read          = 0;
861
862        m_cost_write_frz        = 0;
863        m_cost_data_miss_frz    = 0;
864        m_cost_unc_read_frz     = 0;
865        m_cost_ins_miss_frz     = 0;
866
867        m_cpt_imiss_transaction = 0;
868        m_cpt_dmiss_transaction = 0;
869        m_cpt_unc_transaction   = 0;
870        m_cpt_write_transaction = 0;
871        m_cpt_icache_unc_transaction = 0;
872
873        m_cost_imiss_transaction      = 0;
874        m_cost_dmiss_transaction      = 0;
875        m_cost_unc_transaction        = 0;
876        m_cost_write_transaction      = 0;
877        m_cost_icache_unc_transaction = 0;
878        m_length_write_transaction    = 0;
879
880        m_cpt_ins_tlb_read       = 0;
881        m_cpt_ins_tlb_miss       = 0;
882        m_cpt_ins_tlb_update_acc = 0;
883
884        m_cpt_data_tlb_read         = 0;
885        m_cpt_data_tlb_miss         = 0;
886        m_cpt_data_tlb_update_acc   = 0;
887        m_cpt_data_tlb_update_dirty = 0;
888        m_cpt_ins_tlb_hit_dcache    = 0;
889        m_cpt_data_tlb_hit_dcache   = 0;
890        m_cpt_ins_tlb_occup_cache   = 0;
891        m_cpt_data_tlb_occup_cache  = 0;
892
893        m_cost_ins_tlb_miss_frz          = 0;
894        m_cost_data_tlb_miss_frz         = 0;
895        m_cost_ins_tlb_update_acc_frz    = 0;
896        m_cost_data_tlb_update_acc_frz   = 0;
897        m_cost_data_tlb_update_dirty_frz = 0;
898        m_cost_ins_tlb_occup_cache_frz   = 0;
899        m_cost_data_tlb_occup_cache_frz  = 0;
900
901        m_cpt_ins_tlb_inval       = 0;
902        m_cpt_data_tlb_inval      = 0;
903        m_cost_ins_tlb_inval_frz  = 0;
904        m_cost_data_tlb_inval_frz = 0;
905
906        m_cpt_cc_broadcast   = 0;
907
908        m_cost_updt_data_frz  = 0;
909        m_cost_inval_ins_frz  = 0;
910        m_cost_inval_data_frz = 0;
911        m_cost_broadcast_frz  = 0;
912
913        m_cpt_cc_cleanup_data = 0;
914        m_cpt_cc_cleanup_ins  = 0;
915
916        m_cpt_itlbmiss_transaction      = 0;
917        m_cpt_itlb_ll_transaction       = 0;
918        m_cpt_itlb_sc_transaction       = 0;
919        m_cpt_dtlbmiss_transaction      = 0;
920        m_cpt_dtlb_ll_transaction       = 0;
921        m_cpt_dtlb_sc_transaction       = 0;
922        m_cpt_dtlb_ll_dirty_transaction = 0;
923        m_cpt_dtlb_sc_dirty_transaction = 0;
924
925        m_cost_itlbmiss_transaction      = 0;
926        m_cost_itlb_ll_transaction       = 0;
927        m_cost_itlb_sc_transaction       = 0;
928        m_cost_dtlbmiss_transaction      = 0;
929        m_cost_dtlb_ll_transaction       = 0;
930        m_cost_dtlb_sc_transaction       = 0;
931        m_cost_dtlb_ll_dirty_transaction = 0;
932        m_cost_dtlb_sc_dirty_transaction = 0;
933/*
934        m_cpt_dcache_frz_cycles = 0;
935        m_cpt_read = 0;
936        m_cpt_write = 0;
937        m_cpt_cc_update_data = 0;
938        m_cpt_cc_inval_ins   = 0;
939        m_cpt_cc_inval_data  = 0;
940*/
941
942        for (uint32_t i = 0; i < 32; ++i) m_cpt_fsm_icache[i] = 0;
943        for (uint32_t i = 0; i < 32; ++i) m_cpt_fsm_dcache[i] = 0;
944        for (uint32_t i = 0; i < 32; ++i) m_cpt_fsm_cmd[i] = 0;
945        for (uint32_t i = 0; i < 32; ++i) m_cpt_fsm_rsp[i] = 0;
946
947        // init the llsc reservation buffer
948        r_dcache_llsc_valid = false;
949        m_monitor_ok = false;
950
951        return;
952    }
953
954    // Response FIFOs default values
955    bool     vci_rsp_fifo_icache_get  = false;
956    bool     vci_rsp_fifo_icache_put  = false;
957    uint32_t vci_rsp_fifo_icache_data = 0;
958
959    bool     vci_rsp_fifo_dcache_get  = false;
960    bool     vci_rsp_fifo_dcache_put  = false;
961    uint32_t vci_rsp_fifo_dcache_data = 0;
962
963    // updt fifo
964    bool     cc_receive_updt_fifo_get  = false;
965    bool     cc_receive_updt_fifo_put  = false;
966    uint32_t cc_receive_updt_fifo_be   = 0;
967    uint32_t cc_receive_updt_fifo_data = 0;
968    bool     cc_receive_updt_fifo_eop  = false;
969
970#ifdef INSTRUMENTATION
971    m_cpt_fsm_dcache [r_dcache_fsm.read() ] ++;
972    m_cpt_fsm_icache [r_icache_fsm.read() ] ++;
973    m_cpt_fsm_cmd    [r_vci_cmd_fsm.read()] ++;
974    m_cpt_fsm_rsp    [r_vci_rsp_fsm.read()] ++;
975    m_cpt_fsm_tgt    [r_tgt_fsm.read()    ] ++;
976    m_cpt_fsm_cleanup[r_cleanup_cmd_fsm.read()] ++;
977#endif
978
979    m_cpt_total_cycles++;
980
981    m_debug_icache_fsm = m_debug_icache_fsm ||
982        ((m_cpt_total_cycles > m_debug_start_cycle) and m_debug_ok);
983    m_debug_dcache_fsm = m_debug_dcache_fsm ||
984        ((m_cpt_total_cycles > m_debug_start_cycle) and m_debug_ok);
985    m_debug_cmd_fsm = m_debug_cmd_fsm ||
986        ((m_cpt_total_cycles > m_debug_start_cycle) and m_debug_ok);
987
988    /////////////////////////////////////////////////////////////////////
989    // Get data and instruction requests from processor
990    ///////////////////////////////////////////////////////////////////////
991
992    r_iss.getRequests(m_ireq, m_dreq);
993
994    ////////////////////////////////////////////////////////////////////////////////////
995    //      ICACHE_FSM
996    //
997    // 1/ Coherence operations
998    //    They are handled as interrupts generated by the CC_RECEIVE FSM.
999    //    - There is a coherence request when r_tgt_icache_req is set.
1000    //    They are taken in IDLE, MISS_WAIT, MISS_DIR_UPDT, UNC_WAIT, states.
1001    //    - There is a cleanup ack request when r_cleanup_icache_req is set.
1002    //    They are taken in IDLE, MISS_SELECT, MISS_CLEAN, MISS_WAIT,
1003    //    MISS_DATA_UPDT, MISS_DIR_UPDT and UNC_WAIT states.
1004    //    - For both types of requests, actions associated to the pre-empted state
1005    //    are not executed. The DCACHE FSM goes to the proper sub-FSM (CC_CHECK
1006    //    or CC_CLACK) to execute the requested coherence operation, and returns
1007    //    to the pre-empted state.
1008    //
1009    // 2/ Processor requests
1010    //    They are taken in IDLE state only. In case of cache miss, or uncacheable
1011    //    instruction, the ICACHE FSM request a VCI transaction to CMD FSM,
1012    //    using the r_icache_miss_req or r_icache_unc_req flip-flops. These
1013    //    flip-flops are reset when the transaction starts.
1014    //    - In case of miss the ICACHE FSM  goes to the ICACHE_MISS_SELECT state
1015    //    to select a slot and possibly request a cleanup transaction to the CC_SEND FSM.
1016    //    It goes next to the ICACHE_MISS_WAIT state waiting a response from RSP FSM,
1017    //    The availability of the missing cache line is signaled by the response fifo,
1018    //    and the cache update is done (one word per cycle) in the ICACHE_MISS_DATA_UPDT
1019    //    and ICACHE_MISS_DIR_UPDT states.
1020    //    - In case of uncacheable instruction, the ICACHE FSM goes to ICACHE_UNC_WAIT
1021    //    to wait the response from the RSP FSM, through the response fifo.
1022    //    The missing instruction is directly returned to processor in this state.
1023    //
1024    // 3/ TLB miss
1025    //    In case of tlb miss, the ICACHE FSM request to the DCACHE FSM to update the
1026    //    ITLB using the r_icache_tlb_miss_req flip-flop and the r_icache_tlb_miss_vaddr
1027    //    register, and goes to the ICACHE_TLB_WAIT state.
1028    //    The tlb update is entirely done by the DCACHE FSM (who becomes the owner
1029    //    of ITLB until the update is completed, and reset r_icache_tlb_miss_req
1030    //    to signal the completion.
1031    //
1032    // 4/ XTN requests
1033    //    The DCACHE FSM signals XTN processor requests to ICACHE_FSM
1034    //    using the r_dcache_xtn_req flip-flop.
1035    //    The request opcode and the address to be invalidated are transmitted
1036    //    in the r_dcache_xtn_opcode and r_dcache_save_wdata registers respectively.
1037    //    The r_dcache_xtn_req flip-flop is reset by the ICACHE_FSM when the operation
1038    //    is completed.
1039    //
1040    // 5/ Error Handling
1041    //    The r_vci_rsp_ins_error flip-flop is set by the RSP FSM in case of bus error
1042    //    in a cache miss or uncacheable read VCI transaction. Nothing is written
1043    //    in the response fifo. This flip-flop is reset by the ICACHE-FSM.
1044    ////////////////////////////////////////////////////////////////////////////////////////
1045
1046    // default value for m_irsp
1047    m_irsp.valid = false;
1048    m_irsp.error = false;
1049    m_irsp.instruction = 0;
1050
1051    switch (r_icache_fsm.read())
1052    {
1053    /////////////////
1054    case ICACHE_IDLE:   // In this state, we handle processor requests, XTN requests,
1055                        // and coherence requests with a fixed priority:
1056                        // 1/ Coherence requests                        => ICACHE_CC_CHECK
1057                        // 2/ XTN processor requests (from DCACHE FSM)  => ICACHE_XTN_*
1058                        // 3/ tlb miss                                  => ICACHE_TLB_WAIT
1059                        // 4/ cacheable read miss                       => ICACHE_MISS_SELECT
1060                        // 5/ uncacheable read miss                     => ICACHE_UNC_REQ
1061    {
1062        // coherence clack interrupt
1063        if (r_icache_clack_req.read())
1064        {
1065            r_icache_fsm = ICACHE_CC_CHECK;
1066            r_icache_fsm_save = r_icache_fsm.read();
1067            break;
1068        }
1069
1070        // coherence interrupt
1071        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
1072        {
1073            r_icache_fsm = ICACHE_CC_CHECK;
1074            r_icache_fsm_save = r_icache_fsm.read();
1075            break;
1076        }
1077
1078        // XTN requests sent by DCACHE FSM
1079        // These request are not executed in this IDLE state (except XTN_INST_PADDR_EXT),
1080        // because they require access to icache or itlb, that are already accessed
1081        if (r_dcache_xtn_req.read())
1082        {
1083            if ((int) r_dcache_xtn_opcode.read() == (int) iss_t::XTN_PTPR )
1084            {
1085                r_icache_fsm = ICACHE_XTN_TLB_FLUSH;
1086            }
1087            else if ((int) r_dcache_xtn_opcode.read() == (int) iss_t::XTN_ICACHE_FLUSH)
1088            {
1089                r_icache_flush_count = 0;
1090                r_icache_fsm = ICACHE_XTN_CACHE_FLUSH;
1091            }
1092            else if ((int) r_dcache_xtn_opcode.read() == (int) iss_t::XTN_ITLB_INVAL)
1093            {
1094                r_icache_fsm = ICACHE_XTN_TLB_INVAL;
1095            }
1096            else if ((int) r_dcache_xtn_opcode.read() == (int) iss_t::XTN_ICACHE_INVAL)
1097            {
1098                r_icache_fsm = ICACHE_XTN_CACHE_INVAL_VA;
1099            }
1100            else if ((int) r_dcache_xtn_opcode.read() == (int) iss_t::XTN_MMU_ICACHE_PA_INV)
1101            {
1102                if (sizeof(paddr_t) <= 32)
1103                {
1104                    assert(r_mmu_word_hi.read() == 0 &&
1105                    "illegal XTN request in ICACHE: high bits should be 0 for 32bit paddr");
1106                    r_icache_vci_paddr = (paddr_t) r_mmu_word_lo.read();
1107                }
1108                else
1109                {
1110                    r_icache_vci_paddr = (paddr_t) r_mmu_word_hi.read() << 32 |
1111                                         (paddr_t) r_mmu_word_lo.read();
1112                }
1113                r_icache_fsm = ICACHE_XTN_CACHE_INVAL_PA;
1114            }
1115            else if ((int) r_dcache_xtn_opcode.read() == (int) iss_t::XTN_INST_PADDR_EXT)
1116            {
1117                r_icache_paddr_ext = r_dcache_save_wdata.read();
1118                r_dcache_xtn_req   = false;
1119            }
1120            else
1121            {
1122               assert(false and
1123               "undefined XTN request received by ICACHE FSM");
1124            }
1125            break;
1126        } // end if xtn_req
1127
1128        // processor request
1129        if (m_ireq.valid )
1130        {
1131            bool       cacheable;
1132            paddr_t    paddr;
1133            bool       tlb_hit = false;
1134            pte_info_t tlb_flags;
1135            size_t     tlb_way;
1136            size_t     tlb_set;
1137            paddr_t    tlb_nline;
1138            uint32_t   cache_inst = 0;
1139            size_t     cache_way;
1140            size_t     cache_set;
1141            size_t     cache_word;
1142            int        cache_state = CACHE_SLOT_STATE_EMPTY;
1143
1144            // We register processor request
1145            r_icache_vaddr_save = m_ireq.addr;
1146            paddr = (paddr_t) m_ireq.addr;
1147
1148            // sytematic itlb access (if activated)
1149            if (r_mmu_mode.read() & INS_TLB_MASK)
1150            {
1151
1152#ifdef INSTRUMENTATION
1153                m_cpt_itlb_read++;
1154#endif
1155                tlb_hit = r_itlb.translate(m_ireq.addr,
1156                                           &paddr,
1157                                           &tlb_flags,
1158                                           &tlb_nline, // unused
1159                                           &tlb_way,   // unused
1160                                           &tlb_set);  // unused
1161            }
1162            else if (vci_param::N > 32)
1163            {
1164                paddr = paddr | ((paddr_t) r_icache_paddr_ext.read() << 32);
1165            }
1166
1167            // systematic icache access (if activated)
1168            if (r_mmu_mode.read() & INS_CACHE_MASK)
1169            {
1170
1171
1172#ifdef INSTRUMENTATION
1173                m_cpt_icache_data_read++;
1174                m_cpt_icache_dir_read++;
1175#endif
1176                r_icache.read(paddr,
1177                              &cache_inst,
1178                              &cache_way,
1179                              &cache_set,
1180                              &cache_word,
1181                              &cache_state);
1182            }
1183
1184            // We compute cacheability and check access rights:
1185            // - If MMU activated : cacheability is defined by the C bit in the PTE,
1186            //   and the access rights are defined by the U and X bits in the PTE.
1187            // - If MMU not activated : cacheability is defined by the segment table,
1188            //   and there is no access rights checking
1189
1190            if (not (r_mmu_mode.read() & INS_TLB_MASK)) // tlb not activated:
1191            {
1192                // cacheability
1193                if   (not (r_mmu_mode.read() & INS_CACHE_MASK)) cacheable = false;
1194                else cacheable = m_cacheability_table[(uint64_t) m_ireq.addr];
1195            }
1196            else // itlb activated
1197            {
1198                if (tlb_hit) // ITLB hit
1199                {
1200                    // cacheability
1201                    if (not (r_mmu_mode.read() & INS_CACHE_MASK)) cacheable = false;
1202                    else  cacheable = tlb_flags.c;
1203
1204                    // access rights checking
1205                    if (not tlb_flags.u && (m_ireq.mode == iss_t::MODE_USER))
1206                    {
1207
1208#if DEBUG_ICACHE
1209if ( m_debug_icache_fsm )
1210std::cout << "  <PROC " << name() << " ICACHE_IDLE> MMU Privilege Violation"
1211          << " : PADDR = " << std::hex << paddr << std::endl;
1212#endif
1213                        r_mmu_ietr          = MMU_READ_PRIVILEGE_VIOLATION;
1214                        r_mmu_ibvar         = m_ireq.addr;
1215                        m_irsp.valid        = true;
1216                        m_irsp.error        = true;
1217                        m_irsp.instruction  = 0;
1218                        break;
1219                    }
1220                    else if (not tlb_flags.x)
1221                    {
1222
1223#if DEBUG_ICACHE
1224if ( m_debug_icache_fsm )
1225std::cout << "  <PROC " << name() << " ICACHE_IDLE> MMU Executable Violation"
1226          << " : PADDR = " << std::hex << paddr << std::endl;
1227#endif
1228                        r_mmu_ietr          = MMU_READ_EXEC_VIOLATION;
1229                        r_mmu_ibvar         = m_ireq.addr;
1230                        m_irsp.valid        = true;
1231                        m_irsp.error        = true;
1232                        m_irsp.instruction  = 0;
1233                        break;
1234                    }
1235                }
1236                else // ITLB miss
1237                {
1238
1239#ifdef INSTRUMENTATION
1240                    m_cpt_itlb_miss++;
1241#endif
1242                    r_icache_fsm          = ICACHE_TLB_WAIT;
1243                    r_icache_tlb_miss_req = true;
1244                    break;
1245                }
1246            } // end if itlb activated
1247
1248            // physical address registration
1249            r_icache_vci_paddr = paddr;
1250
1251            // Finally, we send the response to processor, and compute next state
1252            if (cacheable)
1253            {
1254                if (cache_state == CACHE_SLOT_STATE_EMPTY) // cache miss
1255                {
1256
1257#ifdef INSTRUMENTATION
1258                    m_cpt_icache_miss++;
1259#endif
1260                    // we request a VCI transaction
1261                    r_icache_fsm = ICACHE_MISS_SELECT;
1262#if DEBUG_ICACHE
1263                    if (m_debug_icache_fsm)
1264                        std::cout << "  <PROC " << name() << " ICACHE_IDLE> READ MISS in icache"
1265                            << " : PADDR = " << std::hex << paddr << std::endl;
1266#endif
1267                   r_icache_miss_req = true;
1268                }
1269                else if (cache_state == CACHE_SLOT_STATE_ZOMBI ) // pending cleanup
1270                {
1271                    // stalled until cleanup is acknowledged
1272                    r_icache_fsm = ICACHE_IDLE;
1273                }
1274                else // cache hit
1275                {
1276
1277#ifdef INSTRUMENTATION
1278                    m_cpt_ins_read++;
1279#endif
1280                    // return instruction to processor
1281                    m_irsp.valid       = true;
1282                    m_irsp.instruction = cache_inst;
1283                    r_icache_fsm       = ICACHE_IDLE;
1284#if DEBUG_ICACHE
1285                    if (m_debug_icache_fsm)
1286                        std::cout << "  <PROC " << name() << " ICACHE_IDLE> READ HIT in icache"
1287                            << " : PADDR = " << std::hex << paddr
1288                            << " / INST  = " << cache_inst << std::endl;
1289#endif
1290                }
1291            }
1292            else // non cacheable read
1293            {
1294                r_icache_unc_req = true;
1295                r_icache_fsm     = ICACHE_UNC_WAIT;
1296
1297#if DEBUG_ICACHE
1298                if (m_debug_icache_fsm)
1299                {
1300                    std::cout << "  <PROC " << name()
1301                        << " ICACHE_IDLE> READ UNCACHEABLE in icache"
1302                        << " : PADDR = " << std::hex << paddr << std::endl;
1303                }
1304#endif
1305            }
1306        }    // end if m_ireq.valid
1307        break;
1308    }
1309    /////////////////////
1310    case ICACHE_TLB_WAIT:   // Waiting the itlb update by the DCACHE FSM after a tlb miss
1311                            // the itlb is udated by the DCACHE FSM, as well as the
1312                            // r_mmu_ietr and r_mmu_ibvar registers in case of error.
1313                            // the itlb is not accessed by ICACHE FSM until DCACHE FSM
1314                            // reset the r_icache_tlb_miss_req flip-flop
1315                            // external coherence request are accepted in this state.
1316    {
1317        // coherence clack interrupt
1318        if (r_icache_clack_req.read())
1319        {
1320            r_icache_fsm = ICACHE_CC_CHECK;
1321            r_icache_fsm_save = r_icache_fsm.read();
1322            break;
1323        }
1324
1325        // coherence interrupt
1326        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
1327        {
1328            r_icache_fsm = ICACHE_CC_CHECK;
1329            r_icache_fsm_save = r_icache_fsm.read();
1330            break;
1331        }
1332
1333        if (m_ireq.valid) m_cost_ins_tlb_miss_frz++;
1334
1335        // DCACHE FSM signals response by reseting the request flip-flop
1336        if (not r_icache_tlb_miss_req.read())
1337        {
1338            if (r_icache_tlb_rsp_error.read()) // error reported : tlb not updated
1339            {
1340                r_icache_tlb_rsp_error = false;
1341                m_irsp.error = true;
1342                m_irsp.valid = true;
1343                r_icache_fsm = ICACHE_IDLE;
1344            }
1345            else // tlb updated : return to IDLE state
1346            {
1347                r_icache_fsm  = ICACHE_IDLE;
1348            }
1349        }
1350        break;
1351    }
1352    //////////////////////////
1353    case ICACHE_XTN_TLB_FLUSH:  // invalidate in one cycle all non global TLB entries
1354    {
1355        r_itlb.flush();
1356        r_dcache_xtn_req = false;
1357        r_icache_fsm     = ICACHE_IDLE;
1358        break;
1359    }
1360    ////////////////////////////
1361    case ICACHE_XTN_CACHE_FLUSH:    // Invalidate sequencially all cache lines, using
1362                                    // r_icache_flush_count as a slot counter,
1363                                    // looping in this state until all slots are visited.
1364                                    // It can require two cycles per slot:
1365                                    // We test here the slot state, and make the actual inval
1366                                    // (if line is valid) in ICACHE_XTN_CACHE_FLUSH_GO state.
1367                                    // A cleanup request is generated for each valid line
1368    {
1369        // coherence clack interrupt
1370        if (r_icache_clack_req.read())
1371        {
1372            r_icache_fsm = ICACHE_CC_CHECK;
1373            r_icache_fsm_save = r_icache_fsm.read();
1374            break;
1375        }
1376
1377        // coherence request (from CC_RECEIVE FSM)
1378        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
1379        {
1380            r_icache_fsm = ICACHE_CC_CHECK;
1381            r_icache_fsm_save = r_icache_fsm.read();
1382            break;
1383        }
1384
1385        if (not r_icache_cc_send_req.read()) // blocked until previous cc_send request is sent
1386        {
1387            int state;
1388            paddr_t tag;
1389            size_t way = r_icache_flush_count.read() / m_icache_sets;
1390            size_t set = r_icache_flush_count.read() % m_icache_sets;
1391
1392#ifdef INSTRUMENTATION
1393            m_cpt_icache_dir_read++;
1394#endif
1395            r_icache.read_dir(way,
1396                              set,
1397                              &tag,
1398                              &state);
1399
1400            if (state == CACHE_SLOT_STATE_VALID)    // inval required
1401            {
1402                // request cleanup
1403                r_icache_cc_send_req   = true;
1404                r_icache_cc_send_nline = tag * m_icache_sets + set;
1405                r_icache_cc_send_way   = way;
1406                r_icache_cc_send_type  = CC_TYPE_CLEANUP;
1407
1408                // goes to ICACHE_XTN_CACHE_FLUSH_GO to make inval
1409                r_icache_miss_way = way;
1410                r_icache_miss_set = set;
1411                r_icache_fsm      = ICACHE_XTN_CACHE_FLUSH_GO;
1412            }
1413            else if (r_icache_flush_count.read() ==
1414                      (m_icache_sets*m_icache_ways - 1))  // last slot
1415            {
1416                r_dcache_xtn_req = false;
1417                m_drsp.valid = true;
1418                r_icache_fsm = ICACHE_IDLE;
1419            }
1420
1421            // saturation counter, to have the same last slot condition
1422            // in ICACHE_XTN_CACHE_FLUSH and ICACHE_XTN_CACHE_FLUSH_GO states
1423            if (r_icache_flush_count.read() < (m_icache_sets * m_icache_ways - 1))
1424            {
1425                r_icache_flush_count = r_icache_flush_count.read() + 1;
1426            }
1427        }
1428        break;
1429    }
1430    ///////////////////////////////
1431    case ICACHE_XTN_CACHE_FLUSH_GO:   // Switch slot state to ZOMBI for an XTN flush
1432    {
1433        size_t way = r_icache_miss_way.read();
1434        size_t set = r_icache_miss_set.read();
1435
1436#ifdef INSTRUMENTATION
1437        m_cpt_icache_dir_write++;
1438#endif
1439
1440        r_icache.write_dir(way,
1441                           set,
1442                           CACHE_SLOT_STATE_ZOMBI);
1443
1444        if (r_icache_flush_count.read() ==
1445                      (m_icache_sets*m_icache_ways - 1))  // last slot
1446        {
1447            r_dcache_xtn_req = false;
1448            m_drsp.valid = true;
1449            r_icache_fsm = ICACHE_IDLE;
1450        }
1451        else
1452        {
1453            r_icache_fsm = ICACHE_XTN_CACHE_FLUSH;
1454        }
1455        break;
1456    }
1457
1458    //////////////////////////
1459    case ICACHE_XTN_TLB_INVAL: // invalidate one TLB entry selected by the virtual address
1460                               // stored in the r_dcache_save_wdata register
1461    {
1462        r_itlb.inval(r_dcache_save_wdata.read());
1463        r_dcache_xtn_req = false;
1464        r_icache_fsm     = ICACHE_IDLE;
1465        break;
1466    }
1467    ///////////////////////////////
1468    case ICACHE_XTN_CACHE_INVAL_VA: // Selective cache line invalidate with virtual address
1469                                    // requires 3 cycles (in case of hit on itlb and icache).
1470                                    // In this state, access TLB to translate virtual address
1471                                    // stored in the r_dcache_save_wdata register.
1472    {
1473        paddr_t paddr;
1474        bool    hit;
1475
1476        // read physical address in TLB when MMU activated
1477        if (r_mmu_mode.read() & INS_TLB_MASK) // itlb activated
1478        {
1479
1480#ifdef INSTRUMENTATION
1481            m_cpt_itlb_read++;
1482#endif
1483            hit = r_itlb.translate(r_dcache_save_wdata.read(), &paddr);
1484        }
1485        else // itlb not activated
1486        {
1487            paddr = (paddr_t) r_dcache_save_wdata.read();
1488            hit   = true;
1489        }
1490
1491        if (hit) // continue the selective inval process
1492        {
1493            r_icache_vci_paddr = paddr;
1494            r_icache_fsm       = ICACHE_XTN_CACHE_INVAL_PA;
1495        }
1496        else // miss : send a request to DCACHE FSM
1497        {
1498
1499#ifdef INSTRUMENTATION
1500            m_cpt_itlb_miss++;
1501#endif
1502            r_icache_tlb_miss_req = true;
1503            r_icache_vaddr_save   = r_dcache_save_wdata.read();
1504            r_icache_fsm          = ICACHE_TLB_WAIT;
1505        }
1506        break;
1507    }
1508    ///////////////////////////////
1509    case ICACHE_XTN_CACHE_INVAL_PA: // selective invalidate cache line with physical address
1510                                    // require 2 cycles. In this state, we read directory
1511                                    // with address stored in r_icache_vci_paddr register.
1512    {
1513        int    state;
1514        size_t way;
1515        size_t set;
1516        size_t word;
1517
1518#ifdef INSTRUMENTATION
1519        m_cpt_icache_dir_read++;
1520#endif
1521        r_icache.read_dir(r_icache_vci_paddr.read(),
1522                          &state,
1523                          &way,
1524                          &set,
1525                          &word);
1526
1527        if (state == CACHE_SLOT_STATE_VALID) // inval to be done
1528        {
1529            r_icache_miss_way = way;
1530            r_icache_miss_set = set;
1531            r_icache_fsm      = ICACHE_XTN_CACHE_INVAL_GO;
1532        }
1533        else // miss : acknowlege the XTN request and return
1534        {
1535            r_dcache_xtn_req = false;
1536            r_icache_fsm     = ICACHE_IDLE;
1537        }
1538        break;
1539    }
1540    ///////////////////////////////
1541    case ICACHE_XTN_CACHE_INVAL_GO:  // Switch slot to ZOMBI state for an XTN inval
1542    {
1543        if (not r_icache_cc_send_req.read())  // blocked until previous cc_send request not sent
1544        {
1545
1546#ifdef INSTRUMENTATION
1547            m_cpt_icache_dir_write++;
1548#endif
1549            r_icache.write_dir(r_icache_miss_way.read(),
1550                               r_icache_miss_set.read(),
1551                               CACHE_SLOT_STATE_ZOMBI);
1552
1553            // request cleanup
1554            r_icache_cc_send_req   = true;
1555            r_icache_cc_send_nline = r_icache_vci_paddr.read() / (m_icache_words << 2);
1556            r_icache_cc_send_way   = r_icache_miss_way.read();
1557            r_icache_cc_send_type  = CC_TYPE_CLEANUP;
1558
1559            // acknowledge the XTN request and return
1560            r_dcache_xtn_req = false;
1561            r_icache_fsm     = ICACHE_IDLE;
1562        }
1563        break;
1564    }
1565    ////////////////////////
1566    case ICACHE_MISS_SELECT:       // Try to select a slot in associative set,
1567                                   // Waiting in this state if no slot available.
1568                                   // If a victim slot has been choosen and the r_icache_cc_send_req is false,
1569                                   // we send the cleanup request in this state.
1570                                   // If not, a r_icache_cleanup_victim_req flip-flop is
1571                                   // utilized for saving this cleanup request, and it will be sent later
1572                                   // in state ICACHE_MISS_WAIT or ICACHE_MISS_UPDT_DIR.
1573                                   // The r_icache_miss_clack flip-flop is set
1574                                   // when a cleanup is required
1575    {
1576        if (m_ireq.valid) m_cost_ins_miss_frz++;
1577
1578        // coherence clack interrupt
1579        if (r_icache_clack_req.read())
1580        {
1581            r_icache_fsm = ICACHE_CC_CHECK;
1582            r_icache_fsm_save = r_icache_fsm.read();
1583            break;
1584        }
1585
1586        // coherence interrupt
1587        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
1588        {
1589            r_icache_fsm = ICACHE_CC_CHECK;
1590            r_icache_fsm_save = r_icache_fsm.read();
1591            break;
1592        }
1593
1594
1595        bool found;
1596        bool cleanup;
1597        size_t way;
1598        size_t set;
1599        paddr_t victim;
1600
1601#ifdef INSTRUMENTATION
1602        m_cpt_icache_dir_read++;
1603#endif
1604        r_icache.read_select(r_icache_vci_paddr.read(),
1605                             &victim,
1606                             &way,
1607                             &set,
1608                             &found,
1609                             &cleanup);
1610        if (not found)
1611        {
1612            break;
1613        }
1614        else
1615        {
1616            r_icache_miss_way = way;
1617            r_icache_miss_set = set;
1618
1619            if (cleanup)
1620            {
1621                if (not r_icache_cc_send_req.read())
1622                {
1623                    r_icache_cc_send_req   = true;
1624                    r_icache_cc_send_nline = victim;
1625                    r_icache_cc_send_way   = way;
1626                    r_icache_cc_send_type  = CC_TYPE_CLEANUP;
1627                }
1628                else
1629                {
1630                    r_icache_cleanup_victim_req   = true;
1631                    r_icache_cleanup_victim_nline = victim;
1632                }
1633
1634                r_icache_miss_clack = true;
1635                r_icache_fsm        = ICACHE_MISS_CLEAN;
1636            }
1637            else
1638            {
1639                r_icache_fsm = ICACHE_MISS_WAIT;
1640            }
1641
1642#if DEBUG_ICACHE
1643            if (m_debug_icache_fsm)
1644            {
1645                std::cout << "  <PROC " << name()
1646                    << " ICACHE_MISS_SELECT> Select a slot:" << std::dec
1647                    << " / WAY = " << way
1648                    << " / SET = " << set;
1649                if (cleanup) std::cout << " / VICTIM = " << std::hex << victim << std::endl;
1650                else         std::cout << std::endl;
1651            }
1652#endif
1653        }
1654        break;
1655    }
1656    ///////////////////////
1657    case ICACHE_MISS_CLEAN:   // switch the slot to zombi state
1658    {
1659        if (m_ireq.valid) m_cost_ins_miss_frz++;
1660
1661#ifdef INSTRUMENTATION
1662        m_cpt_icache_dir_write++;
1663#endif
1664        r_icache.write_dir(r_icache_miss_way.read(),
1665                           r_icache_miss_set.read(),
1666                           CACHE_SLOT_STATE_ZOMBI);
1667#if DEBUG_ICACHE
1668        if (m_debug_icache_fsm)
1669        {
1670            std::cout << "  <PROC " << name()
1671                << " ICACHE_MISS_CLEAN> Switch to ZOMBI state" << std::dec
1672                << " / WAY = " << r_icache_miss_way.read()
1673                << " / SET = " << r_icache_miss_set.read() << std::endl;
1674        }
1675#endif
1676
1677        r_icache_fsm = ICACHE_MISS_WAIT;
1678        break;
1679    }
1680    //////////////////////
1681    case ICACHE_MISS_WAIT: // waiting response from VCI_RSP FSM
1682    {
1683        if (m_ireq.valid) m_cost_ins_miss_frz++;
1684
1685        // send cleanup victim request
1686        if (r_icache_cleanup_victim_req.read() and not r_icache_cc_send_req.read())
1687        {
1688            r_icache_cc_send_req        = true;
1689            r_icache_cc_send_nline      = r_icache_cleanup_victim_nline;
1690            r_icache_cc_send_way        = r_icache_miss_way;
1691            r_icache_cc_send_type       = CC_TYPE_CLEANUP;
1692            r_icache_cleanup_victim_req = false;
1693        }
1694
1695        // coherence clack interrupt
1696        if (r_icache_clack_req.read())
1697        {
1698            r_icache_fsm = ICACHE_CC_CHECK;
1699            r_icache_fsm_save = r_icache_fsm.read();
1700            break;
1701        }
1702
1703        // coherence interrupt
1704        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() and not r_icache_cleanup_victim_req.read())
1705        {
1706            r_icache_fsm = ICACHE_CC_CHECK;
1707            r_icache_fsm_save = r_icache_fsm.read();
1708            break;
1709        }
1710
1711        if (r_vci_rsp_ins_error.read()) // bus error
1712        {
1713            r_mmu_ietr          = MMU_READ_DATA_ILLEGAL_ACCESS;
1714            r_mmu_ibvar         = r_icache_vaddr_save.read();
1715            m_irsp.valid        = true;
1716            m_irsp.error        = true;
1717            r_vci_rsp_ins_error = false;
1718            r_icache_fsm        = ICACHE_IDLE;
1719        }
1720        else if (r_vci_rsp_fifo_icache.rok()) // response available
1721        {
1722            r_icache_miss_word = 0;
1723            r_icache_fsm       = ICACHE_MISS_DATA_UPDT;
1724        }
1725        break;
1726    }
1727    ///////////////////////////
1728    case ICACHE_MISS_DATA_UPDT:  // update the cache (one word per cycle)
1729    {
1730        if (m_ireq.valid) m_cost_ins_miss_frz++;
1731
1732        if (r_vci_rsp_fifo_icache.rok()) // response available
1733        {
1734
1735#ifdef INSTRUMENTATION
1736            m_cpt_icache_data_write++;
1737#endif
1738            r_icache.write(r_icache_miss_way.read(),
1739                           r_icache_miss_set.read(),
1740                           r_icache_miss_word.read(),
1741                           r_vci_rsp_fifo_icache.read());
1742#if DEBUG_ICACHE
1743            if (m_debug_icache_fsm)
1744            {
1745                std::cout << "  <PROC " << name()
1746                    << " ICACHE_MISS_DATA_UPDT> Write one word:"
1747                    << " WDATA = " << std::hex << r_vci_rsp_fifo_icache.read()
1748                    << " WAY = " << r_icache_miss_way.read()
1749                    << " SET = " << r_icache_miss_set.read()
1750                    << " WORD = " << r_icache_miss_word.read() << std::endl;
1751            }
1752#endif
1753            vci_rsp_fifo_icache_get = true;
1754            r_icache_miss_word = r_icache_miss_word.read() + 1;
1755
1756            if (r_icache_miss_word.read() == m_icache_words - 1) // last word
1757            {
1758                r_icache_fsm = ICACHE_MISS_DIR_UPDT;
1759            }
1760        }
1761        break;
1762    }
1763    //////////////////////////
1764    case ICACHE_MISS_DIR_UPDT:  // Stalled if a victim line has been evicted,
1765                                // and the cleanup ack has not been received,
1766                                // as indicated by r_icache_miss_clack.
1767                                // - If no matching coherence request (r_icache_miss_inval)
1768                                //   switch directory slot to VALID state.
1769                                // - If matching coherence request, switch directory slot
1770                                //   to ZOMBI state, and send a cleanup request.
1771    {
1772        if (m_ireq.valid ) m_cost_ins_miss_frz++;
1773
1774        // send cleanup victim request
1775        if (r_icache_cleanup_victim_req.read() and not r_icache_cc_send_req.read())
1776        {
1777            r_icache_cc_send_req        = true;
1778            r_icache_cc_send_nline      = r_icache_cleanup_victim_nline;
1779            r_icache_cc_send_way        = r_icache_miss_way;
1780            r_icache_cc_send_type       = CC_TYPE_CLEANUP;
1781            r_icache_cleanup_victim_req = false;
1782        }
1783
1784        // coherence clack interrupt
1785        if (r_icache_clack_req.read())
1786        {
1787            r_icache_fsm = ICACHE_CC_CHECK;
1788            r_icache_fsm_save = r_icache_fsm.read();
1789            break;
1790        }
1791
1792        // coherence interrupt
1793        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() and not r_icache_cleanup_victim_req.read())
1794        {
1795            r_icache_fsm = ICACHE_CC_CHECK;
1796            r_icache_fsm_save = r_icache_fsm.read();
1797            break;
1798        }
1799
1800        if (not r_icache_miss_clack.read()) // waiting cleanup acknowledge for victim line
1801        {
1802            if (r_icache_miss_inval) // Switch slot to ZOMBI state, and new cleanup
1803            {
1804                if (not r_icache_cc_send_req.read())
1805                {
1806                    r_icache_miss_inval    = false;
1807                    // request cleanup
1808                    r_icache_cc_send_req   = true;
1809                    r_icache_cc_send_nline = r_icache_vci_paddr.read() / (m_icache_words << 2);
1810                    r_icache_cc_send_way   = r_icache_miss_way.read();
1811                    r_icache_cc_send_type  = CC_TYPE_CLEANUP;
1812
1813#ifdef INSTRUMENTATION
1814                    m_cpt_icache_dir_write++;
1815#endif
1816                    r_icache.write_dir(r_icache_vci_paddr.read(),
1817                                       r_icache_miss_way.read(),
1818                                       r_icache_miss_set.read(),
1819                                       CACHE_SLOT_STATE_ZOMBI);
1820#if DEBUG_ICACHE
1821                    if (m_debug_icache_fsm)
1822                    {
1823                        std::cout << "  <PROC " << name()
1824                            << " ICACHE_MISS_DIR_UPDT> Switch cache slot to ZOMBI state"
1825                            << " PADDR = " << std::hex << r_icache_vci_paddr.read()
1826                            << " WAY = " << std::dec << r_icache_miss_way.read()
1827                            << " SET = " << r_icache_miss_set.read() << std::endl;
1828                    }
1829#endif
1830                }
1831                else
1832                    break;
1833            }
1834            else // Switch slot to VALID state
1835            {
1836
1837#ifdef INSTRUMENTATION
1838                m_cpt_icache_dir_write++;
1839#endif
1840                r_icache.write_dir(r_icache_vci_paddr.read(),
1841                                   r_icache_miss_way.read(),
1842                                   r_icache_miss_set.read(),
1843                                   CACHE_SLOT_STATE_VALID);
1844#if DEBUG_ICACHE
1845                if (m_debug_icache_fsm)
1846                {
1847                    std::cout << "  <PROC " << name()
1848                        << " ICACHE_MISS_DIR_UPDT> Switch cache slot to VALID state"
1849                        << " PADDR = " << std::hex << r_icache_vci_paddr.read()
1850                        << " WAY = " << std::dec << r_icache_miss_way.read()
1851                        << " SET = " << r_icache_miss_set.read() << std::endl;
1852                }
1853#endif
1854            }
1855
1856            r_icache_fsm = ICACHE_IDLE;
1857        }
1858        break;
1859    }
1860    ////////////////////
1861    case ICACHE_UNC_WAIT: // waiting a response to an uncacheable read from VCI_RSP FSM
1862    {
1863        // coherence clack interrupt
1864        if (r_icache_clack_req.read())
1865        {
1866            r_icache_fsm      = ICACHE_CC_CHECK;
1867            r_icache_fsm_save = r_icache_fsm.read();
1868            break;
1869        }
1870
1871        // coherence interrupt
1872        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
1873        {
1874            r_icache_fsm      = ICACHE_CC_CHECK;
1875            r_icache_fsm_save = r_icache_fsm.read();
1876            break;
1877        }
1878
1879        if (r_vci_rsp_ins_error.read()) // bus error
1880        {
1881            r_mmu_ietr          = MMU_READ_DATA_ILLEGAL_ACCESS;
1882            r_mmu_ibvar         = m_ireq.addr;
1883            r_vci_rsp_ins_error = false;
1884            m_irsp.valid        = true;
1885            m_irsp.error        = true;
1886            r_icache_fsm        = ICACHE_IDLE;
1887        }
1888        else if (r_vci_rsp_fifo_icache.rok()) // instruction available
1889        {
1890            vci_rsp_fifo_icache_get = true;
1891            r_icache_fsm            = ICACHE_IDLE;
1892            if (m_ireq.valid and
1893                (m_ireq.addr == r_icache_vaddr_save.read())) // request unmodified
1894            {
1895                m_irsp.valid       = true;
1896                m_irsp.instruction = r_vci_rsp_fifo_icache.read();
1897            }
1898        }
1899        break;
1900    }
1901    /////////////////////
1902    case ICACHE_CC_CHECK:   // This state is the entry point of a sub-fsm
1903                            // handling coherence requests.
1904                            // if there is a matching pending miss, it is
1905                            // signaled in the r_icache_miss_inval flip-flop.
1906                            // The return state is defined in r_icache_fsm_save.
1907    {
1908        paddr_t paddr = r_cc_receive_icache_nline.read() * m_icache_words * 4;
1909        paddr_t mask  = ~((m_icache_words << 2) - 1);
1910
1911        // CLACK handler
1912        // We switch the directory slot to EMPTY state
1913        // and reset r_icache_miss_clack if the cleanup ack
1914        // is matching a pending miss.
1915        if (r_icache_clack_req.read())
1916        {
1917
1918            if (m_ireq.valid) m_cost_ins_miss_frz++;
1919
1920#ifdef INSTRUMENTATION
1921            m_cpt_icache_dir_write++;
1922#endif
1923            r_icache.write_dir(0,
1924                               r_icache_clack_way.read(),
1925                               r_icache_clack_set.read(),
1926                               CACHE_SLOT_STATE_EMPTY);
1927
1928            if ((r_icache_miss_set.read() == r_icache_clack_set.read()) and
1929                 (r_icache_miss_way.read() == r_icache_clack_way.read()))
1930            {
1931                r_icache_miss_clack = false;
1932            }
1933
1934            r_icache_clack_req = false;
1935
1936            // return to cc_save state
1937            r_icache_fsm = r_icache_fsm_save.read();
1938
1939#if DEBUG_ICACHE
1940            if (m_debug_icache_fsm)
1941            {
1942                std::cout << "  <PROC " << name()
1943                    << " ICACHE_CC_CHECK>  CC_TYPE_CLACK slot returns to empty state"
1944                    << " set = " << r_icache_clack_set.read()
1945                    << " / way = " << r_icache_clack_way.read() << std::endl;
1946            }
1947#endif
1948
1949            break;
1950        }
1951
1952        assert(not r_icache_cc_send_req.read() and "CC_SEND must be available in ICACHE_CC_CHECK");
1953
1954        // Match between MISS address and CC address
1955        if (r_cc_receive_icache_req.read() and
1956          ((r_icache_fsm_save.read() == ICACHE_MISS_SELECT)  or
1957           (r_icache_fsm_save.read() == ICACHE_MISS_WAIT)  or
1958           (r_icache_fsm_save.read() == ICACHE_MISS_DIR_UPDT)) and
1959          ((r_icache_vci_paddr.read() & mask) == (paddr & mask))) // matching
1960        {
1961            // signaling the matching
1962            r_icache_miss_inval = true;
1963
1964            // in case of update, go to CC_UPDT
1965            // JUST TO POP THE FIFO
1966            if (r_cc_receive_icache_type.read() == CC_TYPE_UPDT)
1967            {
1968                r_icache_fsm = ICACHE_CC_UPDT;
1969                r_icache_cc_word = r_cc_receive_word_idx.read();
1970
1971                // just pop the fifo , don't write in icache
1972                r_icache_cc_need_write = false;
1973            }
1974            // the request is dealt with
1975            else
1976            {
1977                r_cc_receive_icache_req = false;
1978                r_icache_fsm = r_icache_fsm_save.read();
1979            }
1980#if DEBUG_ICACHE
1981            if (m_debug_icache_fsm)
1982            {
1983                std::cout << "  <PROC " << name()
1984                    << " ICACHE_CC_CHECK> Coherence request matching a pending miss:"
1985                    << " PADDR = " << std::hex << paddr << std::endl;
1986            }
1987#endif
1988        }
1989
1990        // CC request handler
1991
1992        int    state = 0;
1993        size_t way = 0;
1994        size_t set = 0;
1995        size_t word = 0;
1996
1997#ifdef INSTRUMENTATION
1998        m_cpt_icache_dir_read++;
1999#endif
2000        r_icache.read_dir(paddr,
2001                          &state,
2002                          &way,
2003                          &set,
2004                          &word);
2005
2006        r_icache_cc_way = way;
2007        r_icache_cc_set = set;
2008
2009        if (state == CACHE_SLOT_STATE_VALID)            // hit
2010        {
2011            // need to update the cache state
2012            if (r_cc_receive_icache_type.read() == CC_TYPE_UPDT)  // hit update
2013            {
2014                r_icache_cc_need_write = true;
2015                r_icache_fsm = ICACHE_CC_UPDT;
2016                r_icache_cc_word = r_cc_receive_word_idx.read();
2017            }
2018            else if (r_cc_receive_icache_type.read() == CC_TYPE_INVAL) // hit inval
2019            {
2020                r_icache_fsm = ICACHE_CC_INVAL;
2021            }
2022        }
2023        else                                      // miss
2024        {
2025            // multicast acknowledgement required in case of update
2026            if (r_cc_receive_icache_type.read() == CC_TYPE_UPDT)
2027            {
2028                r_icache_fsm = ICACHE_CC_UPDT;
2029                r_icache_cc_word = r_cc_receive_word_idx.read();
2030
2031                // just pop the fifo , don't write in icache
2032                r_icache_cc_need_write = false;
2033            }
2034            else // No response needed
2035            {
2036                r_cc_receive_icache_req = false;
2037                r_icache_fsm = r_icache_fsm_save.read();
2038            }
2039        }
2040        break;
2041    }
2042    /////////////////////
2043    case ICACHE_CC_INVAL:  // hit inval : switch slot to ZOMBI state
2044    {
2045        assert (not r_icache_cc_send_req.read() &&
2046                "ERROR in ICACHE_CC_INVAL: the r_icache_cc_send_req "
2047                "must not be set");
2048
2049#ifdef INSTRUMENTATION
2050        m_cpt_icache_dir_read++;
2051#endif
2052
2053        // Switch slot state to ZOMBI and send CLEANUP command
2054        r_icache.write_dir(r_icache_cc_way.read(),
2055                           r_icache_cc_set.read(),
2056                           CACHE_SLOT_STATE_ZOMBI);
2057
2058        // coherence request completed
2059        r_icache_cc_send_req   = true;
2060        r_icache_cc_send_nline = r_cc_receive_icache_nline.read();
2061        r_icache_cc_send_way   = r_icache_cc_way.read();
2062        r_icache_cc_send_type  = CC_TYPE_CLEANUP;
2063
2064        r_icache_fsm = r_icache_fsm_save.read();
2065
2066#if DEBUG_ICACHE
2067        if (m_debug_icache_fsm)
2068        {
2069            std::cout << "  <PROC " << name()
2070                << " ICACHE_CC_INVAL> slot returns to ZOMBI state"
2071                << " set = " << r_icache_cc_set.read()
2072                << " / way = " << r_icache_cc_way.read() << std::endl;
2073        }
2074#endif
2075
2076        break;
2077    }
2078    ////////////////////
2079    case ICACHE_CC_UPDT: // hit update : write one word per cycle
2080    {
2081        assert (not r_icache_cc_send_req.read() &&
2082                "ERROR in ICACHE_CC_UPDT: the r_icache_cc_send_req "
2083                "must not be set");
2084
2085        if (not r_cc_receive_updt_fifo_be.rok()) break;
2086
2087
2088        size_t word = r_icache_cc_word.read();
2089        size_t way  = r_icache_cc_way.read();
2090        size_t set  = r_icache_cc_set.read();
2091
2092        if (r_icache_cc_need_write.read())
2093        {
2094            r_icache.write(way,
2095                           set,
2096                           word,
2097                           r_cc_receive_updt_fifo_data.read(),
2098                           r_cc_receive_updt_fifo_be.read());
2099
2100            r_icache_cc_word = word + 1;
2101
2102#ifdef INSTRUMENTATION
2103            m_cpt_icache_data_write++;
2104#endif
2105
2106#if DEBUG_ICACHE
2107            if (m_debug_icache_fsm)
2108            {
2109                std::cout << "  <PROC " << name()
2110                    << " ICACHE_CC_UPDT> Write one word "
2111                    << " set = " << r_icache_cc_set.read()
2112                    << " / way = " << r_icache_cc_way.read()
2113                    << " / word = " << r_icache_cc_word.read() << std::endl;
2114            }
2115#endif
2116        }
2117
2118        if (r_cc_receive_updt_fifo_eop.read()) // last word
2119        {
2120            // no need to write in the cache anymore
2121            r_icache_cc_need_write = false;
2122
2123            // coherence request completed
2124            r_cc_receive_icache_req = false;
2125
2126            // request multicast acknowledgement
2127            r_icache_cc_send_req          = true;
2128            r_icache_cc_send_nline        = r_cc_receive_icache_nline.read();
2129            r_icache_cc_send_updt_tab_idx = r_cc_receive_icache_updt_tab_idx.read();
2130            r_icache_cc_send_type         = CC_TYPE_MULTI_ACK;
2131
2132            r_icache_fsm = r_icache_fsm_save.read();
2133        }
2134        //consume fifo if not eop
2135        cc_receive_updt_fifo_get = true;
2136
2137        break;
2138    }
2139
2140    } // end switch r_icache_fsm
2141
2142    ////////////////////////////////////////////////////////////////////////////////////
2143    //      DCACHE FSM
2144    //
2145    // 1/ Coherence operations
2146    //    They are handled as interrupts generated by the CC_RECEIVE FSM.
2147    //    - There is a coherence request when r_tgt_dcache_req is set.
2148    //    They are taken in IDLE, MISS_WAIT, MISS_DIR_UPDT, UNC_WAIT, LL_WAIT
2149    //    and SC_WAIT states.
2150    //    - There is a cleanup acknowledge request when r_cleanup_dcache_req is set.
2151    //    They are taken in IDLE, MISS_SELECT, MISS_CLEAN, MISS_WAIT, MISS_DATA_UPDT,
2152    //    MISS_DIR_UPDT, UNC_WAIT, LL_WAIT, SC_WAIT states.
2153    //    - For both types of requests, actions associated to the pre-empted state
2154    //    are not executed. The DCACHE FSM goes to the proper sub-FSM (CC_CHECK
2155    //    or CC_CLACK) to execute the requested coherence operation, and returns
2156    //    to the pre-empted state.
2157    //
2158    // 2/ TLB miss
2159    //    The page tables are generally cacheable.
2160    //    In case of miss in itlb or dtlb, the tlb miss is handled by a dedicated
2161    //    sub-fsm (DCACHE_TLB_MISS state), that handle possible miss in DCACHE,
2162    //    this sub-fsm implement the table-walk...
2163    //
2164    // 3/ processor requests
2165    //    Processor requests are taken in IDLE state only.
2166    //    The IDLE state implements a two stages pipe-line to handle write bursts:
2167    //    - Both DTLB and DCACHE are accessed in stage P0 (if processor request valid).
2168    //    - The registration in wbuf and the dcache update is done in stage P1
2169    //      (if the processor request is a write).
2170    //    The two r_dcache_wbuf_req and r_dcache_updt_req flip-flops define
2171    //    the operations that must be done in P1 stage, and the access type
2172    //    (read or write) to the DATA part of DCACHE depends on r_dcache_updt_req.
2173    //    READ requests are delayed if a cache update is requested.
2174    //    WRITE or SC requests can require a PTE Dirty bit update (in memory),
2175    //    that is done (before handling the processor request) by a dedicated sub-fsm.
2176    //    If a PTE is modified, both the itlb and dtlb are selectively, but sequencially
2177    //    cleared by a dedicated sub_fsm (DCACHE_INVAL_TLB_SCAN state).
2178    //
2179    // 4/ Atomic instructions LL/SC
2180    //    The LL/SC address are non cacheable (systematic access to memory).
2181    //    The llsc buffer contains a registration for an active LL/SC operation
2182    //    (with an address, a registration key, an aging counter and a valid bit).
2183    //    - LL requests from the processor are transmitted as a one flit VCI command
2184    //      (CMD_LOCKED_READ as CMD, and TYPE_LL as PKTID value). PLEN must
2185    //      be 8 as the response is 2 flits long (data and registration key)
2186    //    - SC requests from the processor are systematically transmitted to the
2187    //      memory cache as 2 flits VCI command (CMD_STORE_COND as CMD, and TYPE_SC
2188    //      as PKTID value).  The first flit contains the registration key, the second
2189    //      flit contains the data to write in case of success.
2190    //      The cache is not updated, as this is done in case of success by the
2191    //      coherence transaction.
2192    //
2193    // 5/ Non cacheable access:
2194    //    This component implement a strong order between non cacheable access
2195    //    (read or write) : A new non cacheable VCI transaction starts only when
2196    //    the previous non cacheable transaction is completed. After send the VCI
2197    //    transaction, the DCACHE FSM wait for the respone in the DCACHE_UNC_WAIT state.
2198    //    So the processor is blocked until the respone arrives in CACHE L1.
2199    //
2200    // 6/ Error handling:
2201    //    When the MMU is not activated, Read Bus Errors are synchronous events,
2202    //    Some Write Bus Errors are synchronous events when the request is a non cacheable access
2203    //    but some Write Bus Errors are asynchronous events when the request is cacheable access
2204    //    (processor is not frozen).
2205    //    - If a Read Bus Error or a Non Cacheable Write Bus Error is detected, the VCI_RSP FSM sets the
2206    //      r_vci_rsp_data_error flip-flop, without writing any data in the
2207    //      r_vci_rsp_fifo_dcache FIFO, and the synchronous error is signaled
2208    //      by the DCACHE FSM.
2209    //    - If a Cacheable Write Bus Error is detected, the VCI_RSP_FSM signals
2210    //    the asynchronous error using the setWriteBerr() method.
2211    //    When the MMU is activated bus error are rare events, as the MMU
2212    //    checks the physical address before the VCI transaction starts.
2213    ////////////////////////////////////////////////////////////////////////////////////////
2214
2215    // default value for m_drsp
2216    m_drsp.valid = false;
2217    m_drsp.error = false;
2218    m_drsp.rdata = 0;
2219
2220    switch (r_dcache_fsm.read())
2221    {
2222    case DCACHE_IDLE: // There are 10 conditions to exit the IDLE state :
2223                      // 1) ITLB/DTLB inval request (update)  => DCACHE_INVAL_TLB_SCAN
2224                      // 2) Coherence request (TGT FSM)       => DCACHE_CC_CHECK
2225                      // 3) ITLB miss request (ICACHE FSM)    => DCACHE_TLB_MISS
2226                      // 4) XTN request (processor)           => DCACHE_XTN_*
2227                      // 5) DTLB miss (processor)             => DCACHE_TLB_MISS
2228                      // 6) Dirty bit update (processor)      => DCACHE_DIRTY_GET_PTE
2229                      // 7) Cacheable read miss (processor)   => DCACHE_MISS_SELECT
2230                      // 8) Uncacheable read/write (processor)=> DCACHE_UNC_WAIT
2231                      // 9) LL access (processor)             => DCACHE_LL_WAIT
2232                      // 10) SC access (processor)            => DCACHE_SC_WAIT
2233                      //
2234                      // There is a fixed priority to handle requests to DCACHE:
2235                      //    1/ the ITLB/DTLB invalidate requests
2236                      //    2/ the coherence requests,
2237                      //    3/ the processor requests (including DTLB miss),
2238                      //    4/ the ITLB miss requests,
2239                      // The address space processor request are handled as follows:
2240                      // - WRITE request is blocked if the Dirty bit mus be set.
2241                      // If DTLB hit, the P1 stage is activated (writes WBUF, and
2242                      // updates DCACHE if DCACHE hit) & processor request acknowledged.
2243                      // - READ request generate a simultaneouss access to  DCACHE.DATA
2244                      // and DCACHE.DIR, but is delayed if DCACHE update required.
2245                      //
2246                      // There is 4 configurations defining the access type to
2247                      // DTLB, DCACHE.DATA, and DCACHE.DIR, depending on the
2248                      // dreq.valid (dreq) and r_dcache_updt_req (updt) signals:
2249                      //    dreq / updt / DTLB  / DCACHE.DIR / DCACHE.DATA /
2250                      //     0   /  0   / NOP   / NOP        / NOP         /
2251                      //     0   /  1   / NOP   / NOP        / WRITE       /
2252                      //     1   /  0   / READ  / READ       / NOP         /
2253                      //     1   /  1   / READ  / READ       / WRITE       /
2254                      // Those two registers are set at each cycle from the 3 signals
2255                      // updt_request, wbuf_request, wbuf_write_miss.
2256    {
2257        paddr_t paddr;
2258        pte_info_t tlb_flags;
2259        size_t   tlb_way;
2260        size_t   tlb_set;
2261        paddr_t  tlb_nline = 0;
2262        size_t   cache_way;
2263        size_t   cache_set;
2264        size_t   cache_word;
2265        uint32_t cache_rdata = 0;
2266        bool     tlb_hit = false;
2267        int      cache_state = CACHE_SLOT_STATE_EMPTY;
2268
2269        bool tlb_inval_required = false; // request TLB inval after cache update
2270        bool wbuf_write_miss = false;    // miss a WBUF write request
2271        bool updt_request = false;       // request DCACHE update in P1 stage
2272        bool wbuf_request = false;       // request WBUF write in P1 stage
2273
2274        // physical address computation : systematic DTLB access if activated
2275        paddr = (paddr_t) m_dreq.addr;
2276        if (m_dreq.valid)
2277        {
2278            if (r_mmu_mode.read() & DATA_TLB_MASK)  // DTLB activated
2279            {
2280                tlb_hit = r_dtlb.translate(m_dreq.addr,
2281                                           &paddr,
2282                                           &tlb_flags,
2283                                           &tlb_nline,
2284                                           &tlb_way,
2285                                           &tlb_set);
2286#ifdef INSTRUMENTATION
2287                m_cpt_dtlb_read++;
2288#endif
2289            }
2290            else // identity mapping
2291            {
2292                // we take into account the paddr extension
2293                if (vci_param::N > 32)
2294                    paddr = paddr | ((paddr_t) (r_dcache_paddr_ext.read()) << 32);
2295            }
2296        } // end physical address computation
2297
2298        // systematic DCACHE access depending on r_dcache_updt_req (if activated)
2299        if (r_mmu_mode.read() & DATA_CACHE_MASK)
2300        {
2301
2302            if (m_dreq.valid and r_dcache_updt_req.read()) // read DIR and write DATA
2303            {
2304                r_dcache.read_dir(paddr,
2305                                  &cache_state,
2306                                  &cache_way,
2307                                  &cache_set,
2308                                  &cache_word);
2309
2310                r_dcache.write(r_dcache_save_cache_way.read(),
2311                               r_dcache_save_cache_set.read(),
2312                               r_dcache_save_cache_word.read(),
2313                               r_dcache_save_wdata.read(),
2314                               r_dcache_save_be.read());
2315#ifdef INSTRUMENTATION
2316                m_cpt_dcache_dir_read++;
2317                m_cpt_dcache_data_write++;
2318#endif
2319            }
2320            else if (m_dreq.valid and not r_dcache_updt_req.read()) // read DIR and DATA
2321            {
2322                r_dcache.read(paddr,
2323                              &cache_rdata,
2324                              &cache_way,
2325                              &cache_set,
2326                              &cache_word,
2327                              &cache_state);
2328
2329#ifdef INSTRUMENTATION
2330                m_cpt_dcache_dir_read++;
2331                m_cpt_dcache_data_read++;
2332#endif
2333            }
2334            else if (not m_dreq.valid and r_dcache_updt_req.read()) // write DATA
2335            {
2336                r_dcache.write(r_dcache_save_cache_way.read(),
2337                               r_dcache_save_cache_set.read(),
2338                               r_dcache_save_cache_word.read(),
2339                               r_dcache_save_wdata.read(),
2340                               r_dcache_save_be.read());
2341#ifdef INSTRUMENTATION
2342                m_cpt_dcache_data_write++;
2343#endif
2344            }
2345        } // end dcache access
2346
2347        // DCACHE update in P1 stage can require ITLB / DTLB inval or flush
2348        if (r_dcache_updt_req.read())
2349        {
2350            size_t way = r_dcache_save_cache_way.read();
2351            size_t set = r_dcache_save_cache_set.read();
2352
2353            if (r_dcache_in_tlb[way * m_dcache_sets + set])
2354            {
2355                tlb_inval_required      = true;
2356                r_dcache_tlb_inval_set  = 0;
2357                r_dcache_tlb_inval_line = r_dcache_save_paddr.read() >>
2358                                           (uint32_log2(m_dcache_words << 2));
2359                r_dcache_in_tlb[way * m_dcache_sets + set] = false;
2360            }
2361            else if (r_dcache_contains_ptd[way * m_dcache_sets + set])
2362            {
2363                r_itlb.reset();
2364                r_dtlb.reset();
2365                r_dcache_contains_ptd[way * m_dcache_sets + set] = false;
2366            }
2367
2368#if DEBUG_DCACHE
2369            if (m_debug_dcache_fsm)
2370                std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
2371                    << " Cache update in P1 stage" << std::dec
2372                    << " / WAY = " << r_dcache_save_cache_way.read()
2373                    << " / SET = " << r_dcache_save_cache_set.read()
2374                    << " / WORD = " << r_dcache_save_cache_word.read() << std::hex
2375                    << " / WDATA = " << r_dcache_save_wdata.read()
2376                    << " / BE = " << r_dcache_save_be.read() << std::endl;
2377#endif
2378        } // end test TLB inval
2379
2380        // Try WBUF update in P1 stage
2381        // Miss if the write request is non cacheable, and there is a pending
2382        // non cacheable write, or if the write buffer is full.
2383        if (r_dcache_wbuf_req.read())
2384        {
2385            bool wok = r_wbuf.write(r_dcache_save_paddr.read(),
2386                                    r_dcache_save_be.read(),
2387                                    r_dcache_save_wdata.read(),
2388                                    true);
2389#ifdef INSTRUMENTATION
2390            m_cpt_wbuf_write++;
2391#endif
2392            if (not wok ) // miss if write buffer full
2393            {
2394                wbuf_write_miss = true;
2395            }
2396        } // end WBUF update
2397
2398        // Computing the response to processor,
2399        // and the next value for r_dcache_fsm
2400
2401        // itlb/dtlb invalidation self-request
2402        if (tlb_inval_required)
2403        {
2404            r_dcache_fsm_scan_save = r_dcache_fsm.read();
2405            r_dcache_fsm           = DCACHE_INVAL_TLB_SCAN;
2406        }
2407
2408        // coherence clack request (from DSPIN CLACK)
2409        else if (r_dcache_clack_req.read())
2410        {
2411            r_dcache_fsm = DCACHE_CC_CHECK;
2412            r_dcache_fsm_cc_save = r_dcache_fsm.read();
2413        }
2414        // coherence request (from CC_RECEIVE FSM)
2415        else if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
2416        {
2417            r_dcache_fsm = DCACHE_CC_CHECK;
2418            r_dcache_fsm_cc_save = r_dcache_fsm.read();
2419        }
2420
2421        // processor request (READ, WRITE, LL, SC, XTN_READ, XTN_WRITE)
2422        // we don't take the processor request, and registers
2423        // are frozen in case of wbuf_write_miss
2424        else if (m_dreq.valid and not wbuf_write_miss)
2425        {
2426            // register processor request and DCACHE response
2427            r_dcache_save_vaddr      = m_dreq.addr;
2428            r_dcache_save_be         = m_dreq.be;
2429            r_dcache_save_wdata      = m_dreq.wdata;
2430            r_dcache_save_paddr      = paddr;
2431            r_dcache_save_cache_way  = cache_way;
2432            r_dcache_save_cache_set  = cache_set;
2433            r_dcache_save_cache_word = cache_word;
2434
2435            // READ XTN requests from processor
2436            // They are executed in this DCACHE_IDLE state.
2437            // The processor must not be in user mode
2438            if (m_dreq.type == iss_t::XTN_READ)
2439            {
2440                int xtn_opcode = (int) m_dreq.addr / 4;
2441
2442                // checking processor mode:
2443                if (m_dreq.mode  == iss_t::MODE_USER)
2444                {
2445                    r_mmu_detr   = MMU_READ_PRIVILEGE_VIOLATION;
2446                    r_mmu_dbvar  = m_dreq.addr;
2447                    m_drsp.valid = true;
2448                    m_drsp.error = true;
2449                    m_drsp.rdata = 0;
2450                    r_dcache_fsm = DCACHE_IDLE;
2451                }
2452                else
2453                {
2454                    switch (xtn_opcode)
2455                    {
2456                    case iss_t::XTN_INS_ERROR_TYPE:
2457                        m_drsp.rdata = r_mmu_ietr.read();
2458                        m_drsp.valid = true;
2459                        m_drsp.error = false;
2460                        break;
2461
2462                    case iss_t::XTN_DATA_ERROR_TYPE:
2463                        m_drsp.rdata = r_mmu_detr.read();
2464                        m_drsp.valid = true;
2465                        m_drsp.error = false;
2466                        break;
2467
2468                    case iss_t::XTN_INS_BAD_VADDR:
2469                        m_drsp.rdata = r_mmu_ibvar.read();
2470                        m_drsp.valid = true;
2471                        m_drsp.error = false;
2472                        break;
2473
2474                    case iss_t::XTN_DATA_BAD_VADDR:
2475                        m_drsp.rdata = r_mmu_dbvar.read();
2476                        m_drsp.valid = true;
2477                        m_drsp.error = false;
2478                        break;
2479
2480                    case iss_t::XTN_PTPR:
2481                        m_drsp.rdata = r_mmu_ptpr.read();
2482                        m_drsp.valid = true;
2483                        m_drsp.error = false;
2484                        break;
2485
2486                    case iss_t::XTN_TLB_MODE:
2487                        m_drsp.rdata = r_mmu_mode.read();
2488                        m_drsp.valid = true;
2489                        m_drsp.error = false;
2490                        break;
2491
2492                    case iss_t::XTN_MMU_PARAMS:
2493                        m_drsp.rdata = r_mmu_params;
2494                        m_drsp.valid = true;
2495                        m_drsp.error = false;
2496                        break;
2497
2498                    case iss_t::XTN_MMU_RELEASE:
2499                        m_drsp.rdata = r_mmu_release;
2500                        m_drsp.valid = true;
2501                        m_drsp.error = false;
2502                        break;
2503
2504                    case iss_t::XTN_MMU_WORD_LO:
2505                        m_drsp.rdata = r_mmu_word_lo.read();
2506                        m_drsp.valid = true;
2507                        m_drsp.error = false;
2508                        break;
2509
2510                    case iss_t::XTN_MMU_WORD_HI:
2511                        m_drsp.rdata = r_mmu_word_hi.read();
2512                        m_drsp.valid = true;
2513                        m_drsp.error = false;
2514                        break;
2515
2516                    case iss_t::XTN_DATA_PADDR_EXT:
2517                        m_drsp.rdata = r_dcache_paddr_ext.read();
2518                        m_drsp.valid = true;
2519                        m_drsp.error = false;
2520                        break;
2521
2522                    case iss_t::XTN_INST_PADDR_EXT:
2523                        m_drsp.rdata = r_icache_paddr_ext.read();
2524                        m_drsp.valid = true;
2525                        m_drsp.error = false;
2526                        break;
2527
2528                    default:
2529                        r_mmu_detr   = MMU_READ_UNDEFINED_XTN;
2530                        r_mmu_dbvar  = m_dreq.addr;
2531                        m_drsp.valid = true;
2532                        m_drsp.error = true;
2533                        m_drsp.rdata = 0;
2534                        break;
2535                    } // end switch xtn_opcode
2536                } // end else
2537            } // end if XTN_READ
2538
2539            // Handling WRITE XTN requests from processor.
2540            // They are not executed in this DCACHE_IDLE state
2541            // if they require access to the caches or the TLBs
2542            // that are already accessed.
2543            // Caches can be invalidated or flushed in user mode,
2544            // and the sync instruction can be executed in user mode
2545            else if (m_dreq.type == iss_t::XTN_WRITE)
2546            {
2547                int xtn_opcode = (int)m_dreq.addr / 4;
2548                r_dcache_xtn_opcode = xtn_opcode;
2549
2550                // checking processor mode:
2551                if ((m_dreq.mode  == iss_t::MODE_USER) &&
2552                     (xtn_opcode != iss_t::XTN_SYNC) &&
2553                     (xtn_opcode != iss_t::XTN_DCACHE_INVAL) &&
2554                     (xtn_opcode != iss_t::XTN_DCACHE_FLUSH) &&
2555                     (xtn_opcode != iss_t::XTN_ICACHE_INVAL) &&
2556                     (xtn_opcode != iss_t::XTN_ICACHE_FLUSH))
2557                {
2558                    r_mmu_detr   = MMU_WRITE_PRIVILEGE_VIOLATION;
2559                    r_mmu_dbvar  = m_dreq.addr;
2560                    m_drsp.valid = true;
2561                    m_drsp.error = true;
2562                    m_drsp.rdata = 0;
2563                    r_dcache_fsm = DCACHE_IDLE;
2564                }
2565                else
2566                {
2567                    switch (xtn_opcode)
2568                    {
2569                    case iss_t::XTN_PTPR: // itlb & dtlb must be flushed
2570                        r_dcache_xtn_req = true;
2571                        r_dcache_fsm     = DCACHE_XTN_SWITCH;
2572                        break;
2573
2574                    case iss_t::XTN_TLB_MODE: // no cache or tlb access
2575                        r_mmu_mode   = m_dreq.wdata;
2576                        m_drsp.valid = true;
2577                        r_dcache_fsm = DCACHE_IDLE;
2578                        break;
2579
2580                    case iss_t::XTN_DTLB_INVAL: // dtlb access
2581                        r_dcache_fsm = DCACHE_XTN_DT_INVAL;
2582                        break;
2583
2584                    case iss_t::XTN_ITLB_INVAL: // itlb access
2585                        r_dcache_xtn_req = true;
2586                        r_dcache_fsm     = DCACHE_XTN_IT_INVAL;
2587                        break;
2588
2589                    case iss_t::XTN_DCACHE_INVAL:  // dcache, dtlb & itlb access
2590                        r_dcache_fsm = DCACHE_XTN_DC_INVAL_VA;
2591                        break;
2592
2593                    case iss_t::XTN_MMU_DCACHE_PA_INV: // dcache, dtlb & itlb access
2594                        r_dcache_fsm = DCACHE_XTN_DC_INVAL_PA;
2595                        if (sizeof(paddr_t) <= 32)
2596                        {
2597                            assert(r_mmu_word_hi.read() == 0 &&
2598                            "high bits should be 0 for 32bit paddr");
2599                            r_dcache_save_paddr = (paddr_t)r_mmu_word_lo.read();
2600                        }
2601                        else
2602                        {
2603                            r_dcache_save_paddr = (paddr_t)r_mmu_word_hi.read() << 32 |
2604                                                  (paddr_t)r_mmu_word_lo.read();
2605                        }
2606                        break;
2607
2608                    case iss_t::XTN_DCACHE_FLUSH: // itlb and dtlb must be reset
2609                        r_dcache_flush_count = 0;
2610                        r_dcache_fsm         = DCACHE_XTN_DC_FLUSH;
2611                        break;
2612
2613                    case iss_t::XTN_ICACHE_INVAL: // icache and itlb access
2614                        r_dcache_xtn_req = true;
2615                        r_dcache_fsm     = DCACHE_XTN_IC_INVAL_VA;
2616                        break;
2617
2618                    case iss_t::XTN_MMU_ICACHE_PA_INV: // icache access
2619                        r_dcache_xtn_req = true;
2620                        r_dcache_fsm     = DCACHE_XTN_IC_INVAL_PA;
2621                        break;
2622
2623                    case iss_t::XTN_ICACHE_FLUSH:   // icache access
2624                        r_dcache_xtn_req = true;
2625                        r_dcache_fsm     = DCACHE_XTN_IC_FLUSH;
2626                        break;
2627
2628                    case iss_t::XTN_SYNC:           // wait until write buffer empty
2629                        r_dcache_fsm = DCACHE_XTN_SYNC;
2630                        break;
2631
2632                    case iss_t::XTN_MMU_WORD_LO:    // no cache or tlb access
2633                        r_mmu_word_lo = m_dreq.wdata;
2634                        m_drsp.valid  = true;
2635                        r_dcache_fsm  = DCACHE_IDLE;
2636                        break;
2637
2638                    case iss_t::XTN_MMU_WORD_HI:    // no cache or tlb access
2639                        r_mmu_word_hi = m_dreq.wdata;
2640                        m_drsp.valid  = true;
2641                        r_dcache_fsm  = DCACHE_IDLE;
2642                        break;
2643
2644                    case iss_t::XTN_MMU_LL_RESET:   // no cache or tlb access
2645                        r_dcache_llsc_valid = false;
2646                        m_drsp.valid        = true;
2647                        r_dcache_fsm        = DCACHE_IDLE;
2648                    break;
2649
2650                    case iss_t::XTN_DATA_PADDR_EXT:  // no cache or tlb access
2651                        r_dcache_paddr_ext = m_dreq.wdata;
2652                        m_drsp.valid       = true;
2653                        r_dcache_fsm       = DCACHE_IDLE;
2654                    break;
2655
2656                    case iss_t::XTN_INST_PADDR_EXT:  // no cache or tlb access
2657                        r_dcache_xtn_req = true;
2658                        r_dcache_fsm     = DCACHE_XTN_IC_PADDR_EXT;
2659                    break;
2660
2661                    case iss_t::XTN_ICACHE_PREFETCH: // not implemented : no action
2662                    case iss_t::XTN_DCACHE_PREFETCH: // not implemented : no action
2663                        m_drsp.valid = true;
2664                        r_dcache_fsm = DCACHE_IDLE;
2665                    break;
2666
2667                    case iss_t::XTN_DEBUG_MASK:     // debug mask
2668                        m_debug_dcache_fsm = ((m_dreq.wdata & 0x1) != 0);
2669                        m_debug_icache_fsm = ((m_dreq.wdata & 0x2) != 0);
2670                        m_debug_cmd_fsm = ((m_dreq.wdata & 0x4) != 0);
2671                        m_drsp.valid = true;
2672                        r_dcache_fsm = DCACHE_IDLE;
2673                        break;
2674
2675                    default:
2676                        r_mmu_detr   = MMU_WRITE_UNDEFINED_XTN;
2677                        r_mmu_dbvar  = m_dreq.addr;
2678                        m_drsp.valid = true;
2679                        m_drsp.error = true;
2680                        r_dcache_fsm = DCACHE_IDLE;
2681                        break;
2682                    } // end switch xtn_opcode
2683                } // end else
2684            } // end if XTN_WRITE
2685
2686            // Handling processor requests to address space (READ/WRITE/LL/SC)
2687            // The dtlb and dcache can be activated or not.
2688            // We compute the cacheability, and check processor request validity:
2689            // - If DTLB not activated : cacheability is defined by the segment table,
2690            //   and there is no access rights checking.
2691            // - If DTLB activated : cacheability is defined by the C bit in the PTE,
2692            //   and the U & W bits of the PTE are checked, as well as the DTLB hit.
2693            //   Jumps to the TLB_MISS sub-fsm in case of dtlb miss.
2694            else
2695            {
2696                bool valid_req;
2697                bool cacheable;
2698
2699                if (not (r_mmu_mode.read() & DATA_TLB_MASK)) // dtlb not activated
2700                {
2701                    valid_req = true;
2702
2703                    if (not (r_mmu_mode.read() & DATA_CACHE_MASK)) cacheable = false;
2704                    else cacheable = m_cacheability_table[(uint64_t)m_dreq.addr];
2705                }
2706                else // dtlb activated
2707                {
2708                    if (tlb_hit) // tlb hit
2709                    {
2710                        // cacheability
2711                        if (not (r_mmu_mode.read() & DATA_CACHE_MASK)) cacheable = false;
2712                        else cacheable = tlb_flags.c;
2713
2714                        // access rights checking
2715                        if (not tlb_flags.u and (m_dreq.mode == iss_t::MODE_USER))
2716                        {
2717                            if ((m_dreq.type == iss_t::DATA_READ) or
2718                                 (m_dreq.type == iss_t::DATA_LL))
2719                            {
2720                                r_mmu_detr = MMU_READ_PRIVILEGE_VIOLATION;
2721                            }
2722                            else
2723                            {
2724                                r_mmu_detr = MMU_WRITE_PRIVILEGE_VIOLATION;
2725                            }
2726                            valid_req    = false;
2727                            r_mmu_dbvar  = m_dreq.addr;
2728                            m_drsp.valid = true;
2729                            m_drsp.error = true;
2730                            m_drsp.rdata = 0;
2731#if DEBUG_DCACHE
2732                            if (m_debug_dcache_fsm)
2733                                std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
2734                                    << " HIT in dtlb, but privilege violation" << std::endl;
2735#endif
2736                        }
2737                        else if (not tlb_flags.w and
2738                                  ((m_dreq.type == iss_t::DATA_WRITE) or
2739                                   (m_dreq.type == iss_t::DATA_SC)))
2740                        {
2741                            r_mmu_detr   = MMU_WRITE_ACCES_VIOLATION;
2742                            valid_req    = false;
2743                            r_mmu_dbvar  = m_dreq.addr;
2744                            m_drsp.valid = true;
2745                            m_drsp.error = true;
2746                            m_drsp.rdata = 0;
2747#if DEBUG_DCACHE
2748                            if (m_debug_dcache_fsm)
2749                                std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
2750                                    << " HIT in dtlb, but writable violation" << std::endl;
2751#endif
2752                        }
2753                        else
2754                        {
2755                            valid_req = true;
2756                        }
2757                    }
2758                    else // tlb miss
2759                    {
2760                        valid_req          = false;
2761                        r_dcache_tlb_vaddr = m_dreq.addr;
2762                        r_dcache_tlb_ins   = false;
2763                        r_dcache_fsm       = DCACHE_TLB_MISS;
2764                    }
2765                }    // end DTLB activated
2766
2767                if (valid_req) // processor request is valid (after MMU check)
2768                {
2769                    // READ request
2770                    // The read requests are taken only if there is no cache update.
2771                    // We request a VCI transaction to CMD FSM if miss or uncachable
2772
2773                    if (((m_dreq.type == iss_t::DATA_READ))
2774                          and not r_dcache_updt_req.read())
2775                    {
2776                        if (cacheable) // cacheable read
2777                        {
2778                            if (cache_state == CACHE_SLOT_STATE_EMPTY)   // cache miss
2779                            {
2780#ifdef INSTRUMENTATION
2781                                m_cpt_dcache_miss++;
2782#endif
2783                                // request a VCI DMISS transaction
2784                                r_dcache_vci_paddr    = paddr;
2785                                r_dcache_vci_miss_req = true;
2786                                r_dcache_miss_type    = PROC_MISS;
2787                                r_dcache_fsm          = DCACHE_MISS_SELECT;
2788#if DEBUG_DCACHE
2789                                if (m_debug_dcache_fsm)
2790                                    std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
2791                                        << " READ MISS in dcache"
2792                                        << " / PADDR = " << std::hex << paddr << std::endl;
2793#endif
2794                            }
2795                            else if (cache_state == CACHE_SLOT_STATE_ZOMBI) // pending cleanup
2796                            {
2797                                // stalled until cleanup is acknowledged
2798                                r_dcache_fsm   = DCACHE_IDLE;
2799#if DEBUG_DCACHE
2800                                if (m_debug_dcache_fsm)
2801                                    std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
2802                                        << " Pending cleanup, stalled until cleanup acknowledge"
2803                                        << " / PADDR = " << std::hex << paddr << std::endl;
2804#endif
2805                            }
2806                            else                                      // cache hit
2807                            {
2808#ifdef INSTRUMENTATION
2809                                m_cpt_data_read++;
2810#endif
2811                                // returns data to processor
2812                                m_drsp.valid = true;
2813                                m_drsp.error = false;
2814                                m_drsp.rdata = cache_rdata;
2815#if DEBUG_DCACHE
2816                                if (m_debug_dcache_fsm)
2817                                    std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
2818                                        << " READ HIT in dcache"
2819                                        << " : PADDR = " << std::hex << paddr
2820                                        << " / DATA  = " << std::hex << cache_rdata << std::endl;
2821#endif
2822                            }
2823                        }
2824                        else // uncacheable read
2825                        {
2826                            r_dcache_vci_paddr     = paddr;
2827                            r_dcache_vci_unc_be    = m_dreq.be;
2828                            r_dcache_vci_unc_write = false;
2829                            r_dcache_vci_unc_req   = true;
2830                            r_dcache_fsm           = DCACHE_UNC_WAIT;
2831#if DEBUG_DCACHE
2832                            if (m_debug_dcache_fsm)
2833                                std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
2834                                    << " READ UNCACHEABLE in dcache"
2835                                    << " / PADDR = " << std::hex << paddr << std::endl;
2836#endif
2837                        }
2838                    } // end READ
2839
2840                    // LL request (non cachable)
2841                    // We request a VCI LL transaction to CMD FSM and register
2842                    // the LL/SC operation in llsc buffer.
2843                    else if (m_dreq.type == iss_t::DATA_LL)
2844                    {
2845                        // register paddr in LLSC buffer
2846                        r_dcache_llsc_paddr = paddr;
2847                        r_dcache_llsc_count = LLSC_TIMEOUT;
2848                        r_dcache_llsc_valid = true;
2849
2850                        // request an LL VCI transaction and go to DCACHE_LL_WAIT state
2851                        r_dcache_vci_ll_req   = true;
2852                        r_dcache_vci_paddr    = paddr;
2853                        r_dcache_ll_rsp_count = 0;
2854                        r_dcache_fsm          = DCACHE_LL_WAIT;
2855
2856                    }// end LL
2857
2858                    // WRITE request:
2859                    // If the TLB is activated and the PTE Dirty bit is not set, we stall
2860                    // the processor and set the Dirty bit before handling the write request,
2861                    // going to the DCACHE_DIRTY_GT_PTE state.
2862                    // If we don't need to set the Dirty bit, we can acknowledge
2863                    // the processor request, as the write arguments (including the
2864                    // physical address) are registered in r_dcache_save registers,
2865                    // and the write will be done in the P1 pipeline stage.
2866                    else if (m_dreq.type == iss_t::DATA_WRITE)
2867                    {
2868                        if ((r_mmu_mode.read() & DATA_TLB_MASK)
2869                              and not tlb_flags.d) // Dirty bit must be set
2870                        {
2871                            // The PTE physical address is obtained from the nline value (dtlb),
2872                            // and from the virtual address (word index)
2873                            if (tlb_flags.b ) // PTE1
2874                            {
2875                                r_dcache_dirty_paddr = (paddr_t)(tlb_nline * (m_dcache_words << 2)) |
2876                                                       (paddr_t)((m_dreq.addr >> 19) & 0x3c);
2877                            }
2878                            else // PTE2
2879                            {
2880                                r_dcache_dirty_paddr = (paddr_t) (tlb_nline * (m_dcache_words << 2)) |
2881                                                       (paddr_t) ((m_dreq.addr >> 9) & 0x38);
2882                            }
2883                            r_dcache_fsm = DCACHE_DIRTY_GET_PTE;
2884                        }
2885                        else // Write request accepted
2886                        {
2887#ifdef INSTRUMENTATION
2888                            m_cpt_data_write++;
2889#endif
2890                            // cleaning llsc buffer if address matching
2891                            if (paddr == r_dcache_llsc_paddr.read())
2892                                r_dcache_llsc_valid = false;
2893
2894                            if (not cacheable) // uncacheable write
2895                            {
2896                                r_dcache_vci_paddr     = paddr;
2897                                r_dcache_vci_wdata     = m_dreq.wdata;
2898                                r_dcache_vci_unc_write = true;
2899                                r_dcache_vci_unc_be    = m_dreq.be;
2900                                r_dcache_vci_unc_req   = true;
2901                                r_dcache_fsm           = DCACHE_UNC_WAIT;
2902
2903#if DEBUG_DCACHE
2904                                if (m_debug_dcache_fsm)
2905                                {
2906                                    std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
2907                                        << " Request WRITE UNCACHEABLE" << std::hex
2908                                        << " / VADDR = " << m_dreq.addr
2909                                        << " / PADDR = " << paddr
2910                                        << std::dec << std::endl;
2911                                }
2912#endif
2913                            }
2914                            else
2915                            {
2916                                // response to processor
2917                                m_drsp.valid = true;
2918                                // activating P1 stage
2919                                wbuf_request = true;
2920                                updt_request = (cache_state == CACHE_SLOT_STATE_VALID);
2921
2922#if DEBUG_DCACHE
2923                                if (m_debug_dcache_fsm)
2924                                {
2925                                    std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
2926                                        << " Request WBUF WRITE" << std::hex
2927                                        << " / VADDR = " << m_dreq.addr
2928                                        << " / PADDR = " << paddr
2929                                        << std::dec << std::endl;
2930                                }
2931#endif
2932                            }
2933                        }
2934                    } // end WRITE
2935
2936                    // SC request:
2937                    // If the TLB is activated and the PTE Dirty bit is not set, we stall
2938                    // the processor and set the Dirty bit before handling the write request,
2939                    // going to the DCACHE_DIRTY_GT_PTE state.
2940                    // If we don't need to set the Dirty bit, we test the llsc buffer:
2941                    // If failure, we send a negative response to processor.
2942                    // If success, we request a SC transaction to CMD FSM and go
2943                    // to DCACHE_SC_WAIT state.
2944                    // We don't check a possible write hit in dcache, as the cache update
2945                    // is done by the coherence transaction induced by the SC...
2946                    else if (m_dreq.type == iss_t::DATA_SC)
2947                    {
2948                        if ((r_mmu_mode.read() & DATA_TLB_MASK)
2949                              and not tlb_flags.d) // Dirty bit must be set
2950                        {
2951                            // The PTE physical address is obtained from the nline value (dtlb),
2952                            // and the word index (virtual address)
2953                            if (tlb_flags.b) // PTE1
2954                            {
2955                                r_dcache_dirty_paddr = (paddr_t) (tlb_nline * (m_dcache_words << 2)) |
2956                                                       (paddr_t) ((m_dreq.addr >> 19) & 0x3c);
2957                            }
2958                            else // PTE2
2959                            {
2960                                r_dcache_dirty_paddr = (paddr_t) (tlb_nline * (m_dcache_words << 2)) |
2961                                                       (paddr_t) ((m_dreq.addr >> 9) & 0x38);
2962                            }
2963                            r_dcache_fsm = DCACHE_DIRTY_GET_PTE;
2964                            m_drsp.valid = false;
2965                            m_drsp.error = false;
2966                            m_drsp.rdata = 0;
2967                        }
2968                        else // SC request accepted
2969                        {
2970#ifdef INSTRUMENTATION
2971                            m_cpt_data_sc++;
2972#endif
2973                            // checking local success
2974                            if (r_dcache_llsc_valid.read() and
2975                                (r_dcache_llsc_paddr.read() == paddr)) // local success
2976                            {
2977                                // request an SC CMD and go to DCACHE_SC_WAIT state
2978                                r_dcache_vci_paddr   = paddr;
2979                                r_dcache_vci_sc_req  = true;
2980                                r_dcache_vci_sc_data = m_dreq.wdata;
2981                                r_dcache_fsm         = DCACHE_SC_WAIT;
2982                            }
2983                            else // local fail
2984                            {
2985                                m_drsp.valid = true;
2986                                m_drsp.error = false;
2987                                m_drsp.rdata = 0x1;
2988                            }
2989                        }
2990                    } // end SC
2991                } // end valid_req
2992            }  // end if read/write/ll/sc request
2993        } // end processor request
2994
2995        // itlb miss request
2996        else if (r_icache_tlb_miss_req.read() and not wbuf_write_miss)
2997        {
2998            r_dcache_tlb_ins    = true;
2999            r_dcache_tlb_vaddr  = r_icache_vaddr_save.read();
3000            r_dcache_fsm        = DCACHE_TLB_MISS;
3001        }
3002
3003        // Computing requests for P1 stage : r_dcache_wbuf_req & r_dcache_updt_req
3004        r_dcache_updt_req = updt_request;
3005        r_dcache_wbuf_req = wbuf_request or
3006                            (r_dcache_wbuf_req.read() and wbuf_write_miss);
3007        break;
3008    }
3009    /////////////////////
3010    case DCACHE_TLB_MISS: // This is the entry point for the sub-fsm handling all tlb miss.
3011                          // Input arguments are:
3012                          // - r_dcache_tlb_vaddr
3013                          // - r_dcache_tlb_ins (true when itlb miss)
3014                          // The sub-fsm access the dcache to find the missing TLB entry,
3015                          // and activates the cache miss procedure in case of miss.
3016                          // It bypass the first level page table access if possible.
3017                          // It uses atomic access to update the R/L access bits
3018                          // in the page table if required.
3019                          // It directly updates the itlb or dtlb, and writes into the
3020                          // r_mmu_ins_* or r_mmu_data* error reporting registers.
3021    {
3022        uint32_t ptba = 0;
3023        bool     bypass;
3024        paddr_t  pte_paddr;
3025
3026        // evaluate bypass in order to skip first level page table access
3027        if (r_dcache_tlb_ins.read()) // itlb miss
3028        {
3029            bypass = r_itlb.get_bypass(r_dcache_tlb_vaddr.read(), &ptba);
3030        }
3031        else // dtlb miss
3032        {
3033            bypass = r_dtlb.get_bypass(r_dcache_tlb_vaddr.read(), &ptba);
3034        }
3035
3036        if (not bypass) // Try to read PTE1/PTD1 in dcache
3037        {
3038            pte_paddr = (((paddr_t) r_mmu_ptpr.read()) << (INDEX1_NBITS + 2)) |
3039                       ((((paddr_t) r_dcache_tlb_vaddr.read()) >> PAGE_M_NBITS) << 2);
3040            r_dcache_tlb_paddr = pte_paddr;
3041            r_dcache_fsm       = DCACHE_TLB_PTE1_GET;
3042        }
3043        else // Try to read PTE2 in dcache
3044        {
3045            pte_paddr = (paddr_t) ptba << PAGE_K_NBITS |
3046                        (paddr_t) (r_dcache_tlb_vaddr.read() & PTD_ID2_MASK) >> (PAGE_K_NBITS - 3);
3047            r_dcache_tlb_paddr = pte_paddr;
3048            r_dcache_fsm       = DCACHE_TLB_PTE2_GET;
3049        }
3050
3051#if DEBUG_DCACHE
3052        if (m_debug_dcache_fsm)
3053        {
3054            if (r_dcache_tlb_ins.read())
3055                std::cout << "  <PROC " << name() << " DCACHE_TLB_MISS> ITLB miss";
3056            else
3057                std::cout << "  <PROC " << name() << " DCACHE_TLB_MISS> DTLB miss";
3058            std::cout << " / VADDR = " << std::hex << r_dcache_tlb_vaddr.read()
3059                << " / ptpr  = " << (((paddr_t)r_mmu_ptpr.read()) << (INDEX1_NBITS+2))
3060                << " / BYPASS = " << bypass
3061                << " / PTE_ADR = " << pte_paddr << std::endl;
3062        }
3063#endif
3064
3065        break;
3066    }
3067    /////////////////////////
3068    case DCACHE_TLB_PTE1_GET: // try to read a PT1 entry in dcache
3069    {
3070        // coherence clack request (from DSPIN CLACK)
3071        if (r_dcache_clack_req.read())
3072        {
3073            r_dcache_fsm = DCACHE_CC_CHECK;
3074            r_dcache_fsm_cc_save = r_dcache_fsm.read();
3075            break;
3076        }
3077
3078        // coherence request (from CC_RECEIVE FSM)
3079        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
3080        {
3081            r_dcache_fsm = DCACHE_CC_CHECK;
3082            r_dcache_fsm_cc_save = r_dcache_fsm.read();
3083            break;
3084        }
3085
3086        uint32_t entry;
3087        size_t way;
3088        size_t set;
3089        size_t word;
3090        int    cache_state;
3091        r_dcache.read(r_dcache_tlb_paddr.read(),
3092                      &entry,
3093                      &way,
3094                      &set,
3095                      &word,
3096                      &cache_state);
3097#ifdef INSTRUMENTATION
3098        m_cpt_dcache_data_read++;
3099        m_cpt_dcache_dir_read++;
3100#endif
3101        if (cache_state == CACHE_SLOT_STATE_VALID)   // hit in dcache
3102        {
3103            if (not (entry & PTE_V_MASK)) // unmapped
3104            {
3105                if (r_dcache_tlb_ins.read())
3106                {
3107                    r_mmu_ietr             = MMU_READ_PT1_UNMAPPED;
3108                    r_mmu_ibvar            = r_dcache_tlb_vaddr.read();
3109                    r_icache_tlb_miss_req  = false;
3110                    r_icache_tlb_rsp_error = true;
3111                }
3112                else
3113                {
3114                    r_mmu_detr   = MMU_READ_PT1_UNMAPPED;
3115                    r_mmu_dbvar  = r_dcache_tlb_vaddr.read();
3116                    m_drsp.valid = true;
3117                    m_drsp.error = true;
3118                }
3119                r_dcache_fsm = DCACHE_IDLE;
3120
3121#if DEBUG_DCACHE
3122                if (m_debug_dcache_fsm)
3123                {
3124                    std::cout << "  <PROC " << name()
3125                        << " DCACHE_TLB_PTE1_GET> HIT in dcache, but unmapped"
3126                        << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
3127                        << std::dec << " / way = " << way
3128                        << std::dec << " / set = " << set
3129                        << std::dec << " / word = " << word
3130                        << std::hex << " / PTE1 = " << entry << std::endl;
3131                }
3132#endif
3133
3134            }
3135            else if (entry & PTE_T_MASK) //  PTD : me must access PT2
3136            {
3137                // mark the cache line ac containing a PTD
3138                r_dcache_contains_ptd[m_dcache_sets * way + set] = true;
3139
3140                // register bypass
3141                if (r_dcache_tlb_ins.read()) // itlb
3142                {
3143                    r_itlb.set_bypass(r_dcache_tlb_vaddr.read(),
3144                                      entry & ((1 << (m_paddr_nbits-PAGE_K_NBITS)) - 1),
3145                                      r_dcache_tlb_paddr.read() / (m_icache_words << 2));
3146                }
3147                else // dtlb
3148                {
3149                    r_dtlb.set_bypass(r_dcache_tlb_vaddr.read(),
3150                                      entry & ((1 << (m_paddr_nbits-PAGE_K_NBITS)) - 1),
3151                                      r_dcache_tlb_paddr.read() / (m_dcache_words << 2));
3152                }
3153                r_dcache_tlb_paddr =
3154                    (paddr_t)(entry & ((1 << (m_paddr_nbits - PAGE_K_NBITS)) - 1)) << PAGE_K_NBITS |
3155                    (paddr_t)(((r_dcache_tlb_vaddr.read() & PTD_ID2_MASK) >> PAGE_K_NBITS) << 3);
3156                r_dcache_fsm = DCACHE_TLB_PTE2_GET;
3157
3158#if DEBUG_DCACHE
3159                if (m_debug_dcache_fsm)
3160                {
3161                    std::cout << "  <PROC " << name()
3162                        << " DCACHE_TLB_PTE1_GET> HIT in dcache"
3163                        << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
3164                        << std::dec << " / way = " << way
3165                        << std::dec << " / set = " << set
3166                        << std::dec << " / word = " << word
3167                        << std::hex << " / PTD = " << entry << std::endl;
3168                }
3169#endif
3170            }
3171            else //  PTE1 :  we must update the TLB
3172            {
3173                r_dcache_in_tlb[m_icache_sets * way + set] = true;
3174                r_dcache_tlb_pte_flags  = entry;
3175                r_dcache_tlb_cache_way  = way;
3176                r_dcache_tlb_cache_set  = set;
3177                r_dcache_tlb_cache_word = word;
3178                r_dcache_fsm            = DCACHE_TLB_PTE1_SELECT;
3179
3180#if DEBUG_DCACHE
3181                if (m_debug_dcache_fsm)
3182                {
3183                    std::cout << "  <PROC " << name()
3184                        << " DCACHE_TLB_PTE1_GET> HIT in dcache"
3185                        << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
3186                        << std::dec << " / way = " << way
3187                        << std::dec << " / set = " << set
3188                        << std::dec << " / word = " << word
3189                        << std::hex << " / PTE1 = " << entry << std::endl;
3190                }
3191#endif
3192            }
3193        }
3194        else if (cache_state == CACHE_SLOT_STATE_ZOMBI) // pending cleanup
3195        {
3196            // stalled until cleanup is acknowledged
3197            r_dcache_fsm = DCACHE_TLB_PTE1_GET;
3198        }
3199        else // we must load the missing cache line in dcache
3200        {
3201            r_dcache_vci_miss_req = true;
3202            r_dcache_vci_paddr    = r_dcache_tlb_paddr.read();
3203            r_dcache_save_paddr   = r_dcache_tlb_paddr.read();
3204            r_dcache_miss_type    = PTE1_MISS;
3205            r_dcache_fsm          = DCACHE_MISS_SELECT;
3206
3207#if DEBUG_DCACHE
3208            if (m_debug_dcache_fsm)
3209            {
3210                std::cout << "  <PROC " << name()
3211                    << " DCACHE_TLB_PTE1_GET> MISS in dcache:"
3212                    << " PTE1 address = " << std::hex << r_dcache_tlb_paddr.read() << std::endl;
3213            }
3214#endif
3215        }
3216        break;
3217    }
3218    ////////////////////////////
3219    case DCACHE_TLB_PTE1_SELECT: // select a slot for PTE1
3220    {
3221        size_t way;
3222        size_t set;
3223
3224        if (r_dcache_tlb_ins.read())
3225        {
3226            r_itlb.select(r_dcache_tlb_vaddr.read(),
3227                          true,  // PTE1
3228                          &way,
3229                          &set);
3230#ifdef INSTRUMENTATION
3231            m_cpt_itlb_read++;
3232#endif
3233        }
3234        else
3235        {
3236            r_dtlb.select(r_dcache_tlb_vaddr.read(),
3237                          true,  // PTE1
3238                          &way,
3239                          &set);
3240#ifdef INSTRUMENTATION
3241            m_cpt_dtlb_read++;
3242#endif
3243        }
3244        r_dcache_tlb_way = way;
3245        r_dcache_tlb_set = set;
3246        r_dcache_fsm     = DCACHE_TLB_PTE1_UPDT;
3247
3248#if DEBUG_DCACHE
3249        if (m_debug_dcache_fsm)
3250        {
3251            if (r_dcache_tlb_ins.read())
3252                std::cout << "  <PROC " << name()
3253                    << " DCACHE_TLB_PTE1_SELECT> Select a slot in ITLB:";
3254            else
3255                std::cout << "  <PROC " << name()
3256                    << ".DCACHE_TLB_PTE1_SELECT> Select a slot in DTLB:";
3257            std::cout << " way = " << std::dec << way
3258                << " / set = " << set << std::endl;
3259        }
3260#endif
3261        break;
3262    }
3263    //////////////////////////
3264    case DCACHE_TLB_PTE1_UPDT:  // write a new PTE1 in tlb after testing the L/R bit
3265                                // - if L/R bit already set, exit the sub-fsm.
3266                                // - if not, we update the page table but we dont write
3267                                //   neither in DCACHE, nor in TLB, as this will be done by
3268                                //   the coherence mechanism.
3269    {
3270        paddr_t nline = r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words) + 2);
3271        uint32_t pte  = r_dcache_tlb_pte_flags.read();
3272        bool pt_updt  = false;
3273        bool local    = true;
3274
3275        // We should compute the access locality:
3276        // The PPN MSB bits define the destination cluster index.
3277        // The m_srcid MSB bits define the source cluster index.
3278        // The number of bits to compare depends on the number of clusters,
3279        // and can be obtained in the mapping table.
3280        // As long as this computation is not done, all access are local.
3281
3282        if (local) // local access
3283        {
3284            if (not ((pte & PTE_L_MASK) == PTE_L_MASK)) // we must set the L bit
3285            {
3286                pt_updt                = true;
3287                r_dcache_vci_cas_old   = pte;
3288                r_dcache_vci_cas_new   = pte | PTE_L_MASK;
3289                pte                    = pte | PTE_L_MASK;
3290                r_dcache_tlb_pte_flags = pte;
3291            }
3292        }
3293        else // remote access
3294        {
3295            if (not ((pte & PTE_R_MASK) == PTE_R_MASK)) // we must set the R bit
3296            {
3297                pt_updt                = true;
3298                r_dcache_vci_cas_old   = pte;
3299                r_dcache_vci_cas_new   = pte | PTE_R_MASK;
3300                pte                    = pte | PTE_R_MASK;
3301                r_dcache_tlb_pte_flags = pte;
3302            }
3303        }
3304
3305        if (not pt_updt) // update TLB and return
3306        {
3307            if (r_dcache_tlb_ins.read())
3308            {
3309                r_itlb.write(true, // 2M page
3310                             pte,
3311                             0, // argument unused for a PTE1
3312                             r_dcache_tlb_vaddr.read(),
3313                             r_dcache_tlb_way.read(),
3314                             r_dcache_tlb_set.read(),
3315                             nline);
3316#ifdef INSTRUMENTATION
3317                m_cpt_itlb_write++;
3318#endif
3319
3320#if DEBUG_DCACHE
3321                if (m_debug_dcache_fsm)
3322                {
3323                    std::cout << "  <PROC " << name()
3324                        << " DCACHE_TLB_PTE1_UPDT> write PTE1 in ITLB"
3325                        << " / set = " << std::dec << r_dcache_tlb_set.read()
3326                        << " / way = " << r_dcache_tlb_way.read() << std::endl;
3327                    r_itlb.printTrace();
3328                }
3329#endif
3330            }
3331            else
3332            {
3333                r_dtlb.write(true, // 2M page
3334                             pte,
3335                             0, // argument unused for a PTE1
3336                             r_dcache_tlb_vaddr.read(),
3337                             r_dcache_tlb_way.read(),
3338                             r_dcache_tlb_set.read(),
3339                             nline);
3340#ifdef INSTRUMENTATION
3341                m_cpt_dtlb_write++;
3342#endif
3343
3344#if DEBUG_DCACHE
3345                if (m_debug_dcache_fsm)
3346                {
3347                    std::cout << "  <PROC " << name()
3348                        << " DCACHE_TLB_PTE1_UPDT> write PTE1 in DTLB"
3349                        << " / set = " << std::dec << r_dcache_tlb_set.read()
3350                        << " / way = " << r_dcache_tlb_way.read() << std::endl;
3351                    r_dtlb.printTrace();
3352                }
3353#endif
3354            }
3355            r_dcache_fsm = DCACHE_TLB_RETURN;
3356        }
3357        else                            // update page table but not TLB
3358        {
3359            r_dcache_fsm = DCACHE_TLB_LR_UPDT;
3360
3361#if DEBUG_DCACHE
3362            if (m_debug_dcache_fsm)
3363            {
3364                std::cout << "  <PROC " << name()
3365                    << " DCACHE_TLB_PTE1_UPDT> L/R bit update required"
3366                    << std::endl;
3367            }
3368#endif
3369        }
3370        break;
3371    }
3372    /////////////////////////
3373    case DCACHE_TLB_PTE2_GET: // Try to get a PTE2 (64 bits) in the dcache
3374    {
3375        // coherence clack request (from DSPIN CLACK)
3376        if (r_dcache_clack_req.read())
3377        {
3378            r_dcache_fsm = DCACHE_CC_CHECK;
3379            r_dcache_fsm_cc_save = r_dcache_fsm.read();
3380            break;
3381        }
3382
3383        // coherence request (from CC_RECEIVE FSM)
3384        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
3385        {
3386            r_dcache_fsm = DCACHE_CC_CHECK;
3387            r_dcache_fsm_cc_save = r_dcache_fsm.read();
3388            break;
3389        }
3390
3391        uint32_t pte_flags;
3392        uint32_t pte_ppn;
3393        size_t   way;
3394        size_t   set;
3395        size_t   word;
3396        int      cache_state;
3397
3398        r_dcache.read(r_dcache_tlb_paddr.read(),
3399                      &pte_flags,
3400                      &pte_ppn,
3401                      &way,
3402                      &set,
3403                      &word,
3404                      &cache_state);
3405#ifdef INSTRUMENTATION
3406        m_cpt_dcache_data_read++;
3407        m_cpt_dcache_dir_read++;
3408#endif
3409        if (cache_state == CACHE_SLOT_STATE_VALID) // hit in dcache
3410        {
3411            if (not (pte_flags & PTE_V_MASK)) // unmapped
3412            {
3413                if (r_dcache_tlb_ins.read())
3414                {
3415                    r_mmu_ietr             = MMU_READ_PT2_UNMAPPED;
3416                    r_mmu_ibvar            = r_dcache_tlb_vaddr.read();
3417                    r_icache_tlb_miss_req  = false;
3418                    r_icache_tlb_rsp_error = true;
3419                }
3420                else
3421                {
3422                    r_mmu_detr   = MMU_READ_PT2_UNMAPPED;
3423                    r_mmu_dbvar  = r_dcache_tlb_vaddr.read();
3424                    m_drsp.valid = true;
3425                    m_drsp.error = true;
3426                }
3427                r_dcache_fsm = DCACHE_IDLE;
3428
3429#if DEBUG_DCACHE
3430                if (m_debug_dcache_fsm)
3431                {
3432                    std::cout << "  <PROC " << name()
3433                        << " DCACHE_TLB_PTE2_GET> HIT in dcache, but PTE unmapped"
3434                        << " PTE_FLAGS = " << std::hex << pte_flags
3435                        << " PTE_PPN = " << std::hex << pte_ppn << std::endl;
3436                }
3437#endif
3438            }
3439            else // mapped : we must update the TLB
3440            {
3441                r_dcache_in_tlb[m_dcache_sets * way + set] = true;
3442                r_dcache_tlb_pte_flags  = pte_flags;
3443                r_dcache_tlb_pte_ppn    = pte_ppn;
3444                r_dcache_tlb_cache_way  = way;
3445                r_dcache_tlb_cache_set  = set;
3446                r_dcache_tlb_cache_word = word;
3447                r_dcache_fsm            = DCACHE_TLB_PTE2_SELECT;
3448
3449#if DEBUG_DCACHE
3450                if (m_debug_dcache_fsm)
3451                {
3452                    std::cout << "  <PROC " << name()
3453                        << " DCACHE_TLB_PTE2_GET> HIT in dcache:"
3454                        << " PTE_FLAGS = " << std::hex << pte_flags
3455                        << " PTE_PPN = " << std::hex << pte_ppn << std::endl;
3456                }
3457#endif
3458             }
3459        }
3460        else if (cache_state == CACHE_SLOT_STATE_ZOMBI) // pending cleanup
3461        {
3462            // stalled until cleanup is acknowledged
3463            r_dcache_fsm   = DCACHE_TLB_PTE2_GET;
3464
3465#if DEBUG_DCACHE
3466            if (m_debug_dcache_fsm)
3467            {
3468                std::cout << "  <PROC " << name()
3469                    << " DCACHE_TLB_PTE2_GET> ZOMBI in dcache: waiting cleanup ack"
3470                    << std::endl;
3471            }
3472#endif
3473        }
3474        else            // we must load the missing cache line in dcache
3475        {
3476            r_dcache_fsm          = DCACHE_MISS_SELECT;
3477            r_dcache_vci_miss_req = true;
3478            r_dcache_vci_paddr    = r_dcache_tlb_paddr.read();
3479            r_dcache_save_paddr   = r_dcache_tlb_paddr.read();
3480            r_dcache_miss_type    = PTE2_MISS;
3481
3482#if DEBUG_DCACHE
3483            if (m_debug_dcache_fsm)
3484            {
3485                std::cout << "  <PROC " << name()
3486                    << " DCACHE_TLB_PTE2_GET> MISS in dcache:"
3487                    << " PTE address = " << std::hex << r_dcache_tlb_paddr.read() << std::endl;
3488            }
3489#endif
3490        }
3491        break;
3492    }
3493    ////////////////////////////
3494    case DCACHE_TLB_PTE2_SELECT:    // select a slot for PTE2
3495    {
3496        size_t way;
3497        size_t set;
3498
3499        if (r_dcache_tlb_ins.read())
3500        {
3501            r_itlb.select(r_dcache_tlb_vaddr.read(),
3502                          false, // PTE2
3503                          &way,
3504                          &set);
3505#ifdef INSTRUMENTATION
3506            m_cpt_itlb_read++;
3507#endif
3508        }
3509        else
3510        {
3511            r_dtlb.select(r_dcache_tlb_vaddr.read(),
3512                          false, // PTE2
3513                          &way,
3514                          &set);
3515#ifdef INSTRUMENTATION
3516            m_cpt_dtlb_read++;
3517#endif
3518        }
3519
3520#if DEBUG_DCACHE
3521        if (m_debug_dcache_fsm)
3522        {
3523            if (r_dcache_tlb_ins.read())
3524                std::cout << "  <PROC " << name()
3525                    << " DCACHE_TLB_PTE2_SELECT> Select a slot in ITLB:";
3526            else
3527                std::cout << "  <PROC " << name()
3528                    << " DCACHE_TLB_PTE2_SELECT> Select a slot in DTLB:";
3529            std::cout << " way = " << std::dec << way
3530                << " / set = " << set << std::endl;
3531        }
3532#endif
3533        r_dcache_tlb_way = way;
3534        r_dcache_tlb_set = set;
3535        r_dcache_fsm     = DCACHE_TLB_PTE2_UPDT;
3536        break;
3537    }
3538    //////////////////////////
3539    case DCACHE_TLB_PTE2_UPDT:  // write a new PTE2 in tlb after testing the L/R bit
3540                                // - if L/R bit already set, exit the sub-fsm.
3541                                // - if not, we update the page table but we dont write
3542                                //   neither in DCACHE, nor in TLB, as this will be done by
3543                                //   the coherence mechanism.
3544    {
3545        paddr_t  nline     = r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words) + 2);
3546        uint32_t pte_flags = r_dcache_tlb_pte_flags.read();
3547        uint32_t pte_ppn   = r_dcache_tlb_pte_ppn.read();
3548        bool     pt_updt   = false;
3549        bool     local     = true;
3550
3551        // We should compute the access locality:
3552        // The PPN MSB bits define the destination cluster index.
3553        // The m_srcid MSB bits define the source cluster index.
3554        // The number of bits to compare depends on the number of clusters,
3555        // and can be obtained in the mapping table.
3556        // As long as this computation is not done, all access are local.
3557
3558        if (local) // local access
3559        {
3560            if (not ((pte_flags & PTE_L_MASK) == PTE_L_MASK)) // we must set the L bit
3561            {
3562                pt_updt                = true;
3563                r_dcache_vci_cas_old   = pte_flags;
3564                r_dcache_vci_cas_new   = pte_flags | PTE_L_MASK;
3565                pte_flags              = pte_flags | PTE_L_MASK;
3566                r_dcache_tlb_pte_flags = pte_flags;
3567            }
3568        }
3569        else                                                    // remote access
3570        {
3571            if (not ((pte_flags & PTE_R_MASK) == PTE_R_MASK)) // we must set the R bit
3572            {
3573                pt_updt                = true;
3574                r_dcache_vci_cas_old   = pte_flags;
3575                r_dcache_vci_cas_new   = pte_flags | PTE_R_MASK;
3576                pte_flags              = pte_flags | PTE_R_MASK;
3577                r_dcache_tlb_pte_flags = pte_flags;
3578            }
3579        }
3580
3581        if (not pt_updt) // update TLB
3582        {
3583            if (r_dcache_tlb_ins.read())
3584            {
3585                r_itlb.write( false, // 4K page
3586                              pte_flags,
3587                              pte_ppn,
3588                              r_dcache_tlb_vaddr.read(),
3589                              r_dcache_tlb_way.read(),
3590                              r_dcache_tlb_set.read(),
3591                              nline );
3592#ifdef INSTRUMENTATION
3593                m_cpt_itlb_write++;
3594#endif
3595
3596#if DEBUG_DCACHE
3597                if (m_debug_dcache_fsm)
3598                {
3599                    std::cout << "  <PROC " << name()
3600                        << " DCACHE_TLB_PTE2_UPDT> write PTE2 in ITLB"
3601                        << " / set = " << std::dec << r_dcache_tlb_set.read()
3602                        << " / way = " << r_dcache_tlb_way.read() << std::endl;
3603                    r_itlb.printTrace();
3604                }
3605#endif
3606            }
3607            else
3608            {
3609                r_dtlb.write(false, // 4K page
3610                             pte_flags,
3611                             pte_ppn,
3612                             r_dcache_tlb_vaddr.read(),
3613                             r_dcache_tlb_way.read(),
3614                             r_dcache_tlb_set.read(),
3615                             nline);
3616#ifdef INSTRUMENTATION
3617                m_cpt_dtlb_write++;
3618#endif
3619
3620#if DEBUG_DCACHE
3621                if (m_debug_dcache_fsm)
3622                {
3623                    std::cout << "  <PROC " << name()
3624                        << " DCACHE_TLB_PTE2_UPDT> write PTE2 in DTLB"
3625                        << " / set = " << std::dec << r_dcache_tlb_set.read()
3626                        << " / way = " << r_dcache_tlb_way.read() << std::endl;
3627                    r_dtlb.printTrace();
3628                }
3629#endif
3630
3631            }
3632            r_dcache_fsm = DCACHE_TLB_RETURN;
3633        }
3634        else                                   // update page table but not TLB
3635        {
3636            r_dcache_fsm = DCACHE_TLB_LR_UPDT; // dcache and page table update
3637
3638#if DEBUG_DCACHE
3639            if (m_debug_dcache_fsm)
3640            {
3641                std::cout << "  <PROC " << name()
3642                    << " DCACHE_TLB_PTE2_UPDT> L/R bit update required" << std::endl;
3643            }
3644#endif
3645        }
3646        break;
3647    }
3648    ////////////////////////
3649    case DCACHE_TLB_LR_UPDT:        // request a CAS transaction to update L/R bit
3650    {
3651#if DEBUG_DCACHE
3652        if (m_debug_dcache_fsm)
3653        {
3654            std::cout << "  <PROC " << name()
3655                << " DCACHE_TLB_LR_UPDT> Update dcache: (L/R) bit" << std::endl;
3656        }
3657#endif
3658        // r_dcache_vci_cas_old & r_dcache_vci_cas_new registers are already set
3659        r_dcache_vci_paddr = r_dcache_tlb_paddr.read();
3660
3661        // checking llsc reservation buffer
3662        if (r_dcache_llsc_paddr.read() == r_dcache_tlb_paddr.read())
3663            r_dcache_llsc_valid = false;
3664
3665        // request a CAS CMD and go to DCACHE_TLB_LR_WAIT state
3666        r_dcache_vci_cas_req = true;
3667        r_dcache_fsm = DCACHE_TLB_LR_WAIT;
3668        break;
3669    }
3670    ////////////////////////
3671    case DCACHE_TLB_LR_WAIT:        // Waiting the response to SC transaction for DIRTY bit.
3672                                    // We consume the response in rsp FIFO,
3673                                    // and exit the sub-fsm, but we don't
3674                                    // analyse the response, because we don't
3675                                    // care if the L/R bit update is not done.
3676                                    // We must take the coherence requests because
3677                                    // there is a risk of dead-lock
3678
3679    {
3680        // coherence clack request (from DSPIN CLACK)
3681        if (r_dcache_clack_req.read())
3682        {
3683            r_dcache_fsm = DCACHE_CC_CHECK;
3684            r_dcache_fsm_cc_save = r_dcache_fsm.read();
3685            break;
3686        }
3687
3688        // coherence request (from CC_RECEIVE FSM)
3689        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
3690        {
3691            r_dcache_fsm = DCACHE_CC_CHECK;
3692            r_dcache_fsm_cc_save = r_dcache_fsm.read();
3693            break;
3694        }
3695
3696        if (r_vci_rsp_data_error.read()) // bus error
3697        {
3698            std::cout << "BUS ERROR in DCACHE_TLB_LR_WAIT state" << std::endl;
3699            std::cout << "This should not happen in this state" << std::endl;
3700            exit(0);
3701        }
3702        else if (r_vci_rsp_fifo_dcache.rok()) // response available
3703        {
3704#if DEBUG_DCACHE
3705            if (m_debug_dcache_fsm)
3706            {
3707                std::cout << "  <PROC " << name()
3708                    << " DCACHE_TLB_LR_WAIT> SC response received" << std::endl;
3709            }
3710#endif
3711            vci_rsp_fifo_dcache_get = true;
3712            r_dcache_fsm = DCACHE_TLB_RETURN;
3713        }
3714        break;
3715    }
3716    ///////////////////////
3717    case DCACHE_TLB_RETURN:  // return to caller depending on tlb miss type
3718    {
3719#if DEBUG_DCACHE
3720        if (m_debug_dcache_fsm)
3721        {
3722            std::cout << "  <PROC " << name()
3723                << " DCACHE_TLB_RETURN> TLB MISS completed" << std::endl;
3724        }
3725#endif
3726        if (r_dcache_tlb_ins.read()) r_icache_tlb_miss_req = false;
3727        r_dcache_fsm = DCACHE_IDLE;
3728        break;
3729    }
3730    ///////////////////////
3731    case DCACHE_XTN_SWITCH:     // The r_ptpr registers must be written,
3732                                // and both itlb and dtlb must be flushed.
3733                                // Caution : the itlb miss requests must be taken
3734                                // to avoid dead-lock in case of simultaneous ITLB miss
3735                                // Caution : the clack and cc requests must be taken
3736                                // to avoid dead-lock
3737    {
3738        // coherence clack request (from DSPIN CLACK)
3739        if (r_dcache_clack_req.read())
3740        {
3741            r_dcache_fsm = DCACHE_CC_CHECK;
3742            r_dcache_fsm_cc_save = r_dcache_fsm.read();
3743            break;
3744        }
3745
3746        // coherence request (from CC_RECEIVE FSM)
3747        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
3748        {
3749            r_dcache_fsm = DCACHE_CC_CHECK;
3750            r_dcache_fsm_cc_save = r_dcache_fsm.read();
3751            break;
3752        }
3753
3754        // itlb miss request
3755        if (r_icache_tlb_miss_req.read())
3756        {
3757            r_dcache_tlb_ins   = true;
3758            r_dcache_tlb_vaddr = r_icache_vaddr_save.read();
3759            r_dcache_fsm       = DCACHE_TLB_MISS;
3760            break;
3761        }
3762
3763        if (not r_dcache_xtn_req.read())
3764        {
3765            r_dtlb.flush();
3766            r_mmu_ptpr   = m_dreq.wdata;
3767            r_dcache_fsm = DCACHE_IDLE;
3768            m_drsp.valid = true;
3769        }
3770        break;
3771    }
3772    /////////////////////
3773    case DCACHE_XTN_SYNC:  // waiting until write buffer empty
3774                           // The coherence request must be taken
3775                           // as there is a risk of dead-lock
3776    {
3777        // coherence clack request (from DSPIN CLACK)
3778        if (r_dcache_clack_req.read())
3779        {
3780            r_dcache_fsm = DCACHE_CC_CHECK;
3781            r_dcache_fsm_cc_save = r_dcache_fsm.read();
3782            break;
3783        }
3784
3785        // coherence request (from CC_RECEIVE FSM)
3786        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
3787        {
3788            r_dcache_fsm = DCACHE_CC_CHECK;
3789            r_dcache_fsm_cc_save = r_dcache_fsm.read();
3790            break;
3791        }
3792
3793        if (r_wbuf.empty())
3794        {
3795            m_drsp.valid = true;
3796            r_dcache_fsm = DCACHE_IDLE;
3797        }
3798        break;
3799    }
3800    ////////////////////////
3801    case DCACHE_XTN_IC_FLUSH:       // Waiting completion of an XTN request to the ICACHE FSM
3802    case DCACHE_XTN_IC_INVAL_VA:    // Caution : the itlb miss requests must be taken
3803    case DCACHE_XTN_IC_INVAL_PA:    // because the XTN_ICACHE_INVAL request to icache
3804    case DCACHE_XTN_IC_PADDR_EXT:   // can generate an itlb miss,
3805    case DCACHE_XTN_IT_INVAL:       // and because it can exist a simultaneous ITLB miss
3806
3807    {
3808        // coherence clack request (from DSPIN CLACK)
3809        if (r_dcache_clack_req.read())
3810        {
3811            r_dcache_fsm = DCACHE_CC_CHECK;
3812            r_dcache_fsm_cc_save = r_dcache_fsm.read();
3813            break;
3814        }
3815
3816        // coherence request (from CC_RECEIVE FSM)
3817        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
3818        {
3819            r_dcache_fsm = DCACHE_CC_CHECK;
3820            r_dcache_fsm_cc_save = r_dcache_fsm.read();
3821            break;
3822        }
3823
3824        // itlb miss request
3825        if (r_icache_tlb_miss_req.read())
3826        {
3827            r_dcache_tlb_ins   = true;
3828            r_dcache_tlb_vaddr = r_icache_vaddr_save.read();
3829            r_dcache_fsm       = DCACHE_TLB_MISS;
3830            break;
3831        }
3832
3833        // test if XTN request to icache completed
3834        if (not r_dcache_xtn_req.read())
3835        {
3836            r_dcache_fsm = DCACHE_IDLE;
3837            m_drsp.valid = true;
3838        }
3839        break;
3840    }
3841    /////////////////////////
3842    case DCACHE_XTN_DC_FLUSH:   // Invalidate sequencially all cache lines, using
3843                                // r_dcache_flush_count as a slot counter,
3844                                // looping in this state until all slots have been visited.
3845                                // It can require two cycles per slot:
3846                                // We test here the slot state, and make the actual inval
3847                                // (if line is valid) in DCACHE_XTN_DC_FLUSH_GO state.
3848                                // A cleanup request is generated for each valid line.
3849                                // returns to IDLE and flush TLBs when last slot
3850    {
3851        // coherence clack request (from DSPIN CLACK)
3852        if (r_dcache_clack_req.read())
3853        {
3854            r_dcache_fsm = DCACHE_CC_CHECK;
3855            r_dcache_fsm_cc_save = r_dcache_fsm.read();
3856            break;
3857        }
3858
3859        // coherence request (from CC_RECEIVE FSM)
3860        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
3861        {
3862            r_dcache_fsm = DCACHE_CC_CHECK;
3863            r_dcache_fsm_cc_save = r_dcache_fsm.read();
3864            break;
3865        }
3866
3867        if (not r_dcache_cc_send_req.read()) // blocked until previous cc_send request is sent
3868        {
3869            int     state;
3870            paddr_t tag;
3871            size_t  way = r_dcache_flush_count.read() / m_dcache_sets;
3872            size_t  set = r_dcache_flush_count.read() % m_dcache_sets;
3873
3874#ifdef INSTRUMENTATION
3875            m_cpt_dcache_dir_read++;
3876#endif
3877            r_dcache.read_dir(way,
3878                              set,
3879                              &tag,
3880                              &state);
3881
3882            if (state == CACHE_SLOT_STATE_VALID) // inval required
3883            {
3884                // request cleanup
3885                r_dcache_cc_send_req   = true;
3886                r_dcache_cc_send_nline = tag * m_dcache_sets + set;
3887                r_dcache_cc_send_way   = way;
3888                r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
3889
3890                // goes to DCACHE_XTN_DC_FLUSH_GO to inval directory
3891                r_dcache_miss_way = way;
3892                r_dcache_miss_set = set;
3893                r_dcache_fsm      = DCACHE_XTN_DC_FLUSH_GO;
3894            }
3895            else if (r_dcache_flush_count.read() ==
3896                      (m_dcache_sets*m_dcache_ways - 1))  // last slot
3897            {
3898                r_dtlb.reset();
3899                r_itlb.reset();
3900                r_dcache_fsm = DCACHE_IDLE;
3901                m_drsp.valid = true;
3902            }
3903
3904            // saturation counter
3905            if (r_dcache_flush_count.read() < (m_dcache_sets * m_dcache_ways - 1))
3906                r_dcache_flush_count = r_dcache_flush_count.read() + 1;
3907        }
3908        break;
3909    }
3910    ////////////////////////////
3911    case DCACHE_XTN_DC_FLUSH_GO:    // Switch the cache slot to ZOMBI state
3912                                    // and reset directory extension.
3913                                    // returns to IDLE and flush TLBs when last slot
3914    {
3915        size_t way = r_dcache_miss_way.read();
3916        size_t set = r_dcache_miss_set.read();
3917
3918        r_dcache_in_tlb[m_dcache_sets * way + set]       = false;
3919        r_dcache_contains_ptd[m_dcache_sets * way + set] = false;
3920
3921#ifdef INSTRUMENTATION
3922        m_cpt_dcache_dir_write++;
3923#endif
3924        r_dcache.write_dir(way,
3925                           set,
3926                           CACHE_SLOT_STATE_ZOMBI);
3927
3928        if (r_dcache_flush_count.read() ==
3929             (m_dcache_sets*m_dcache_ways - 1))  // last slot
3930        {
3931            r_dtlb.reset();
3932            r_itlb.reset();
3933            r_dcache_fsm = DCACHE_IDLE;
3934            m_drsp.valid = true;
3935        }
3936        else
3937        {
3938            r_dcache_fsm = DCACHE_XTN_DC_FLUSH;
3939        }
3940        break;
3941    }
3942    /////////////////////////
3943    case DCACHE_XTN_DT_INVAL: // handling processor XTN_DTLB_INVAL request
3944    {
3945        r_dtlb.inval(r_dcache_save_wdata.read());
3946        r_dcache_fsm = DCACHE_IDLE;
3947        m_drsp.valid = true;
3948        break;
3949    }
3950    ////////////////////////////
3951    case DCACHE_XTN_DC_INVAL_VA:  // selective cache line invalidate with virtual address
3952                                  // requires 3 cycles: access tlb, read cache, inval cache
3953                                  // we compute the physical address in this state
3954    {
3955        paddr_t paddr;
3956        bool hit;
3957
3958        if (r_mmu_mode.read() & DATA_TLB_MASK) // dtlb activated
3959        {
3960
3961#ifdef INSTRUMENTATION
3962            m_cpt_dtlb_read++;
3963#endif
3964            hit = r_dtlb.translate(r_dcache_save_wdata.read(),
3965                                   &paddr);
3966        }
3967        else // dtlb not activated
3968        {
3969            paddr = (paddr_t)r_dcache_save_wdata.read();
3970            if (vci_param::N > 32)
3971                paddr = paddr | ((paddr_t)(r_dcache_paddr_ext.read()) << 32);
3972            hit = true;
3973        }
3974
3975        if (hit) // tlb hit
3976        {
3977            r_dcache_save_paddr = paddr;
3978            r_dcache_fsm = DCACHE_XTN_DC_INVAL_PA;
3979        }
3980        else // tlb miss
3981        {
3982
3983#ifdef INSTRUMENTATION
3984            m_cpt_dtlb_miss++;
3985#endif
3986            r_dcache_tlb_ins   = false; // dtlb
3987            r_dcache_tlb_vaddr = r_dcache_save_wdata.read();
3988            r_dcache_fsm       = DCACHE_TLB_MISS;
3989        }
3990
3991#if DEBUG_DCACHE
3992        if (m_debug_dcache_fsm)
3993        {
3994            std::cout << "  <PROC " << name()
3995                << " DCACHE_XTN_DC_INVAL_VA> Compute physical address" << std::hex
3996                << " / VADDR = " << r_dcache_save_wdata.read()
3997                << " / PADDR = " << paddr << std::endl;
3998        }
3999#endif
4000
4001        break;
4002    }
4003    ////////////////////////////
4004    case DCACHE_XTN_DC_INVAL_PA:  // selective cache line invalidate with physical address
4005                                  // requires 2 cycles: read cache / inval cache
4006                                  // In this state we read dcache.
4007    {
4008        size_t way;
4009        size_t set;
4010        size_t word;
4011        int    state;
4012
4013#ifdef INSTRUMENTATION
4014        m_cpt_dcache_dir_read++;
4015#endif
4016        r_dcache.read_dir(r_dcache_save_paddr.read(),
4017                          &state,
4018                          &way,
4019                          &set,
4020                          &word);
4021
4022        if (state == CACHE_SLOT_STATE_VALID) // inval to be done
4023        {
4024            r_dcache_xtn_way = way;
4025            r_dcache_xtn_set = set;
4026            r_dcache_fsm = DCACHE_XTN_DC_INVAL_GO;
4027        }
4028        else // miss : nothing to do
4029        {
4030            r_dcache_fsm = DCACHE_IDLE;
4031            m_drsp.valid = true;
4032        }
4033
4034#if DEBUG_DCACHE
4035        if (m_debug_dcache_fsm)
4036        {
4037            std::cout << "  <PROC " << name()
4038                << " DCACHE_XTN_DC_INVAL_PA> Test hit in dcache" << std::hex
4039                << " / PADDR = " << r_dcache_save_paddr.read() << std::dec
4040                << " / HIT = " << (state == CACHE_SLOT_STATE_VALID)
4041                << " / SET = " << set
4042                << " / WAY = " << way << std::endl;
4043        }
4044#endif
4045        break;
4046    }
4047    ////////////////////////////
4048    case DCACHE_XTN_DC_INVAL_GO:  // In this state, we invalidate the cache line
4049                                  // Blocked if previous cleanup not completed
4050                                  // Test if itlb or dtlb inval is required
4051    {
4052        if (not r_dcache_cc_send_req.read()) // blocked until previous cc_send request is sent
4053        {
4054            size_t way    = r_dcache_xtn_way.read();
4055            size_t set    = r_dcache_xtn_set.read();
4056            paddr_t nline = r_dcache_save_paddr.read() / (m_dcache_words << 2);
4057
4058#ifdef INSTRUMENTATION
4059            m_cpt_dcache_dir_write++;
4060#endif
4061            r_dcache.write_dir(way,
4062                               set,
4063                               CACHE_SLOT_STATE_ZOMBI);
4064
4065            // request cleanup
4066            r_dcache_cc_send_req   = true;
4067            r_dcache_cc_send_nline = nline;
4068            r_dcache_cc_send_way   = way;
4069            r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
4070
4071            // possible itlb & dtlb invalidate
4072            if (r_dcache_in_tlb[way * m_dcache_sets + set])
4073            {
4074                r_dcache_tlb_inval_line = nline;
4075                r_dcache_tlb_inval_set  = 0;
4076                r_dcache_fsm_scan_save  = DCACHE_XTN_DC_INVAL_END;
4077                r_dcache_fsm            = DCACHE_INVAL_TLB_SCAN;
4078                r_dcache_in_tlb[way * m_dcache_sets + set] = false;
4079            }
4080            else if (r_dcache_contains_ptd[way * m_dcache_sets + set])
4081            {
4082                r_itlb.reset();
4083                r_dtlb.reset();
4084                r_dcache_contains_ptd[way * m_dcache_sets + set] = false;
4085                r_dcache_fsm = DCACHE_IDLE;
4086                m_drsp.valid = true;
4087            }
4088            else
4089            {
4090                r_dcache_fsm = DCACHE_IDLE;
4091                m_drsp.valid = true;
4092            }
4093
4094#if DEBUG_DCACHE
4095            if (m_debug_dcache_fsm)
4096            {
4097                std::cout << "  <PROC " << name()
4098                    << " DCACHE_XTN_DC_INVAL_GO> Actual dcache inval" << std::hex
4099                    << " / PADDR = " << r_dcache_save_paddr.read() << std::endl;
4100            }
4101#endif
4102        }
4103        break;
4104    }
4105    //////////////////////////////
4106    case DCACHE_XTN_DC_INVAL_END: // send response to processor XTN request
4107    {
4108        r_dcache_fsm = DCACHE_IDLE;
4109        m_drsp.valid = true;
4110        break;
4111    }
4112    ////////////////////////
4113    case DCACHE_MISS_SELECT:       // Try to select a slot in associative set,
4114                                   // Waiting in this state if no slot available.
4115                                   // If a victim slot has been choosen and the r_icache_cc_send_req is false,
4116                                   // we send the cleanup request in this state.
4117                                   // If not, a r_icache_cleanup_victim_req flip-flop is
4118                                   // utilized for saving this cleanup request, and it will be sent later
4119                                   // in state ICACHE_MISS_WAIT or ICACHE_MISS_UPDT_DIR.
4120                                   // The r_icache_miss_clack flip-flop is set
4121                                   // when a cleanup is required
4122    {
4123        if (m_dreq.valid) m_cost_data_miss_frz++;
4124
4125        // coherence clack request (from DSPIN CLACK)
4126        if (r_dcache_clack_req.read())
4127        {
4128            r_dcache_fsm = DCACHE_CC_CHECK;
4129            r_dcache_fsm_cc_save = r_dcache_fsm.read();
4130            break;
4131        }
4132
4133        // coherence request (from CC_RECEIVE FSM)
4134        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
4135        {
4136            r_dcache_fsm = DCACHE_CC_CHECK;
4137            r_dcache_fsm_cc_save = r_dcache_fsm.read();
4138            break;
4139        }
4140
4141        bool    found = false;
4142        bool    cleanup = false;
4143        size_t  way = 0;
4144        size_t  set = 0;
4145        paddr_t victim = 0;
4146
4147#ifdef INSTRUMENTATION
4148        m_cpt_dcache_dir_read++;
4149#endif
4150        r_dcache.read_select(r_dcache_save_paddr.read(),
4151                             &victim,
4152                             &way,
4153                             &set,
4154                             &found,
4155                             &cleanup);
4156
4157        if (not found)
4158        {
4159            break;
4160        }
4161        else
4162        {
4163            r_dcache_miss_way = way;
4164            r_dcache_miss_set = set;
4165
4166            if (cleanup)
4167            {
4168                if (not r_dcache_cc_send_req.read())
4169                {
4170                    r_dcache_cc_send_req   = true;
4171                    r_dcache_cc_send_nline = victim;
4172                    r_dcache_cc_send_way   = way;
4173                    r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
4174
4175                }
4176                else
4177                {
4178                    r_dcache_cleanup_victim_req   = true;
4179                    r_dcache_cleanup_victim_nline = victim;
4180                }
4181
4182                r_dcache_miss_clack = true;
4183                r_dcache_fsm        = DCACHE_MISS_CLEAN;
4184            }
4185            else
4186            {
4187                r_dcache_fsm = DCACHE_MISS_WAIT;
4188            }
4189
4190#if DEBUG_DCACHE
4191            if (m_debug_dcache_fsm)
4192            {
4193                std::cout << "  <PROC " << name()
4194                    << " DCACHE_MISS_SELECT> Select a slot:" << std::dec
4195                    << " / WAY = "   << way
4196                    << " / SET = "   << set
4197                    << " / PADDR = " << std::hex << r_dcache_save_paddr.read();
4198                if (cleanup) std::cout << " / VICTIM = " << (victim*m_dcache_words*4) << std::endl;
4199                else        std::cout << std::endl;
4200            }
4201#endif
4202        } // end found
4203        break;
4204    }
4205    ///////////////////////
4206    case DCACHE_MISS_CLEAN:     // switch the slot to ZOMBI state
4207                                // and possibly request itlb or dtlb invalidate
4208    {
4209        if (m_dreq.valid) m_cost_data_miss_frz++;
4210
4211        size_t way = r_dcache_miss_way.read();
4212        size_t set = r_dcache_miss_set.read();
4213
4214#ifdef INSTRUMENTATION
4215        m_cpt_dcache_dir_read++;
4216#endif
4217        r_dcache.write_dir(way,
4218                           set,
4219                           CACHE_SLOT_STATE_ZOMBI);
4220#if DEBUG_DCACHE
4221        if (m_debug_dcache_fsm)
4222        {
4223            std::cout << "  <PROC " << name()
4224                << " DCACHE_MISS_CLEAN> Switch to ZOMBI state" << std::dec
4225                << " / way = "   << way
4226                << " / set = "   << set << std::endl;
4227        }
4228#endif
4229        // if selective itlb & dtlb invalidate are required
4230        // the miss response is not handled before invalidate completed
4231        if (r_dcache_in_tlb[way * m_dcache_sets + set])
4232        {
4233            r_dcache_in_tlb[way * m_dcache_sets + set] = false;
4234
4235            if (not r_dcache_cleanup_victim_req.read())
4236                r_dcache_tlb_inval_line = r_dcache_cc_send_nline.read();
4237            else
4238                r_dcache_tlb_inval_line = r_dcache_cleanup_victim_nline.read();
4239
4240            r_dcache_tlb_inval_set = 0;
4241            r_dcache_fsm_scan_save = DCACHE_MISS_WAIT;
4242            r_dcache_fsm           = DCACHE_INVAL_TLB_SCAN;
4243        }
4244        else if (r_dcache_contains_ptd[way * m_dcache_sets + set])
4245        {
4246            r_itlb.reset();
4247            r_dtlb.reset();
4248            r_dcache_contains_ptd[way * m_dcache_sets + set] = false;
4249            r_dcache_fsm = DCACHE_MISS_WAIT;
4250        }
4251        else
4252        {
4253            r_dcache_fsm = DCACHE_MISS_WAIT;
4254        }
4255        break;
4256    }
4257    //////////////////////
4258    case DCACHE_MISS_WAIT: // waiting the response to a miss request from VCI_RSP FSM
4259                            // This state is in charge of error signaling
4260                            // There is 5 types of error depending on the requester
4261    {
4262        if (m_dreq.valid) m_cost_data_miss_frz++;
4263
4264        // send cleanup victim request
4265        if (r_dcache_cleanup_victim_req.read() and not r_dcache_cc_send_req.read())
4266        {
4267            r_dcache_cc_send_req        = true;
4268            r_dcache_cc_send_nline      = r_dcache_cleanup_victim_nline;
4269            r_dcache_cc_send_way        = r_dcache_miss_way;
4270            r_dcache_cc_send_type       = CC_TYPE_CLEANUP;
4271            r_dcache_cleanup_victim_req = false;
4272        }
4273
4274        // coherence clack request (from DSPIN CLACK)
4275        if (r_dcache_clack_req.read())
4276        {
4277            r_dcache_fsm = DCACHE_CC_CHECK;
4278            r_dcache_fsm_cc_save = r_dcache_fsm.read();
4279            break;
4280        }
4281
4282        // coherence request (from CC_RECEIVE FSM)
4283        if (r_cc_receive_dcache_req.read() and
4284             not r_dcache_cc_send_req.read() and
4285             not r_dcache_cleanup_victim_req.read())
4286        {
4287            r_dcache_fsm = DCACHE_CC_CHECK;
4288            r_dcache_fsm_cc_save = r_dcache_fsm.read();
4289            break;
4290        }
4291
4292        if (r_vci_rsp_data_error.read()) // bus error
4293        {
4294            switch (r_dcache_miss_type.read())
4295            {
4296                case PROC_MISS:
4297                {
4298                    r_mmu_detr   = MMU_READ_DATA_ILLEGAL_ACCESS;
4299                    r_mmu_dbvar  = r_dcache_save_vaddr.read();
4300                    m_drsp.valid = true;
4301                    m_drsp.error = true;
4302                    r_dcache_fsm = DCACHE_IDLE;
4303                    break;
4304                }
4305                case PTE1_MISS:
4306                {
4307                    if (r_dcache_tlb_ins.read())
4308                    {
4309                        r_mmu_ietr             = MMU_READ_PT1_ILLEGAL_ACCESS;
4310                        r_mmu_ibvar            = r_dcache_tlb_vaddr.read();
4311                        r_icache_tlb_miss_req  = false;
4312                        r_icache_tlb_rsp_error = true;
4313                    }
4314                    else
4315                    {
4316                        r_mmu_detr   = MMU_READ_PT1_ILLEGAL_ACCESS;
4317                        r_mmu_dbvar  = r_dcache_tlb_vaddr.read();
4318                        m_drsp.valid = true;
4319                        m_drsp.error = true;
4320                    }
4321                    r_dcache_fsm = DCACHE_IDLE;
4322                    break;
4323                }
4324                case PTE2_MISS:
4325                {
4326                    if (r_dcache_tlb_ins.read())
4327                    {
4328                        r_mmu_ietr             = MMU_READ_PT2_ILLEGAL_ACCESS;
4329                        r_mmu_ibvar            = r_dcache_tlb_vaddr.read();
4330                        r_icache_tlb_miss_req  = false;
4331                        r_icache_tlb_rsp_error = true;
4332                    }
4333                    else
4334                    {
4335                        r_mmu_detr   = MMU_READ_PT2_ILLEGAL_ACCESS;
4336                        r_mmu_dbvar  = r_dcache_tlb_vaddr.read();
4337                        m_drsp.valid  = true;
4338                        m_drsp.error  = true;
4339                    }
4340                    r_dcache_fsm = DCACHE_IDLE;
4341                    break;
4342                }
4343            } // end switch type
4344            r_vci_rsp_data_error = false;
4345        }
4346        else if (r_vci_rsp_fifo_dcache.rok()) // valid response available
4347        {
4348            r_dcache_miss_word = 0;
4349            r_dcache_fsm       = DCACHE_MISS_DATA_UPDT;
4350        }
4351        break;
4352    }
4353    //////////////////////////
4354    case DCACHE_MISS_DATA_UPDT:  // update the dcache (one word per cycle)
4355    {
4356        if (m_dreq.valid) m_cost_data_miss_frz++;
4357
4358        if (r_vci_rsp_fifo_dcache.rok()) // one word available
4359        {
4360#ifdef INSTRUMENTATION
4361            m_cpt_dcache_data_write++;
4362#endif
4363            r_dcache.write(r_dcache_miss_way.read(),
4364                               r_dcache_miss_set.read(),
4365                               r_dcache_miss_word.read(),
4366                               r_vci_rsp_fifo_dcache.read());
4367#if DEBUG_DCACHE
4368            if (m_debug_dcache_fsm)
4369            {
4370                std::cout << "  <PROC " << name()
4371                    << " DCACHE_MISS_DATA_UPDT> Write one word:"
4372                    << " / DATA = "  << std::hex << r_vci_rsp_fifo_dcache.read()
4373                    << " / WAY = "   << std::dec << r_dcache_miss_way.read()
4374                    << " / SET = "   << r_dcache_miss_set.read()
4375                    << " / WORD = "  << r_dcache_miss_word.read() << std::endl;
4376            }
4377#endif
4378            vci_rsp_fifo_dcache_get = true;
4379            r_dcache_miss_word = r_dcache_miss_word.read() + 1;
4380
4381            if (r_dcache_miss_word.read() == (m_dcache_words - 1)) // last word
4382            {
4383                r_dcache_fsm = DCACHE_MISS_DIR_UPDT;
4384            }
4385        }
4386        break;
4387    }
4388    //////////////////////////
4389    case DCACHE_MISS_DIR_UPDT:  // Stalled if a victim line has been evicted
4390                                // and the cleanup ack has not been received,
4391                                // as indicated by the r_dcache_miss clack.
4392                                // - If no matching coherence request (r_dcache_inval_miss)
4393                                //   switch directory slot to VALID state.
4394                                // - If matching coherence request, switch directory slot
4395                                //   to ZOMBI state, and send a cleanup request.
4396    {
4397        if (m_dreq.valid) m_cost_data_miss_frz++;
4398
4399        // send cleanup victim request
4400        if (r_dcache_cleanup_victim_req.read() and not r_dcache_cc_send_req.read())
4401        {
4402            r_dcache_cc_send_req        = true;
4403            r_dcache_cc_send_nline      = r_dcache_cleanup_victim_nline;
4404            r_dcache_cc_send_way        = r_dcache_miss_way;
4405            r_dcache_cc_send_type       = CC_TYPE_CLEANUP;
4406            r_dcache_cleanup_victim_req = false;
4407        }
4408
4409        // coherence clack request (from DSPIN CLACK)
4410        if (r_dcache_clack_req.read())
4411        {
4412            r_dcache_fsm = DCACHE_CC_CHECK;
4413            r_dcache_fsm_cc_save = r_dcache_fsm.read();
4414            break;
4415        }
4416
4417        // coherence request (from CC_RECEIVE FSM)
4418        if (r_cc_receive_dcache_req.read() and
4419             not r_dcache_cc_send_req.read() and
4420             not r_dcache_cleanup_victim_req.read())
4421        {
4422            r_dcache_fsm = DCACHE_CC_CHECK;
4423            r_dcache_fsm_cc_save = r_dcache_fsm.read();
4424            break;
4425        }
4426
4427        if (not r_dcache_miss_clack.read())  // waiting cleanup acknowledge
4428        {
4429            if (r_dcache_miss_inval.read()) // switch slot to ZOMBI state, and new cleanup
4430            {
4431                if (not r_dcache_cc_send_req.read()) // blocked until previous request sent
4432                {
4433                    r_dcache_miss_inval     = false;
4434                    // request cleanup
4435                    r_dcache_cc_send_req   = true;
4436                    r_dcache_cc_send_nline = r_dcache_save_paddr.read() / (m_dcache_words << 2);
4437                    r_dcache_cc_send_way   = r_dcache_miss_way.read();
4438                    r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
4439
4440#ifdef INSTRUMENTATION
4441                    m_cpt_dcache_dir_write++;
4442#endif
4443                    r_dcache.write_dir( r_dcache_save_paddr.read(),
4444                                        r_dcache_miss_way.read(),
4445                                        r_dcache_miss_set.read(),
4446                                        CACHE_SLOT_STATE_ZOMBI );
4447#if DEBUG_DCACHE
4448                    if (m_debug_dcache_fsm)
4449                        std::cout << "  <PROC " << name()
4450                            << " DCACHE_MISS_DIR_UPDT> Switch slot to ZOMBI state"
4451                            << " PADDR = " << std::hex << r_dcache_save_paddr.read()
4452                            << " / WAY = "   << std::dec << r_dcache_miss_way.read()
4453                            << " / SET = "   << r_dcache_miss_set.read() << std::endl;
4454#endif
4455                }
4456                else
4457                    break;
4458            }
4459            else                              // switch slot to VALID state
4460            {
4461
4462#ifdef INSTRUMENTATION
4463                m_cpt_dcache_dir_write++;
4464#endif
4465                r_dcache.write_dir(r_dcache_save_paddr.read(),
4466                                   r_dcache_miss_way.read(),
4467                                   r_dcache_miss_set.read(),
4468                                   CACHE_SLOT_STATE_VALID);
4469
4470#if DEBUG_DCACHE
4471                if (m_debug_dcache_fsm)
4472                    std::cout << "  <PROC " << name()
4473                        << " DCACHE_MISS_DIR_UPDT> Switch slot to VALID state"
4474                        << " PADDR = " << std::hex << r_dcache_save_paddr.read()
4475                        << " / WAY = "   << std::dec << r_dcache_miss_way.read()
4476                        << " / SET = "   << r_dcache_miss_set.read() << std::endl;
4477#endif
4478                // reset directory extension
4479                size_t way = r_dcache_miss_way.read();
4480                size_t set = r_dcache_miss_set.read();
4481                r_dcache_in_tlb[way * m_dcache_sets + set] = false;
4482                r_dcache_contains_ptd[way * m_dcache_sets + set] = false;
4483            }
4484            if      (r_dcache_miss_type.read() == PTE1_MISS) r_dcache_fsm = DCACHE_TLB_PTE1_GET;
4485            else if (r_dcache_miss_type.read() == PTE2_MISS) r_dcache_fsm = DCACHE_TLB_PTE2_GET;
4486            else                                             r_dcache_fsm = DCACHE_IDLE;
4487        }
4488        break;
4489    }
4490    /////////////////////
4491    case DCACHE_UNC_WAIT:  // waiting a response to an uncacheable read/write
4492    {
4493        // coherence clack request (from DSPIN CLACK)
4494        if (r_dcache_clack_req.read())
4495        {
4496            r_dcache_fsm = DCACHE_CC_CHECK;
4497            r_dcache_fsm_cc_save = r_dcache_fsm.read();
4498            break;
4499        }
4500
4501        // coherence request (from CC_RECEIVE FSM)
4502        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
4503        {
4504            r_dcache_fsm = DCACHE_CC_CHECK;
4505            r_dcache_fsm_cc_save = r_dcache_fsm.read();
4506            break;
4507        }
4508
4509        if (r_vci_rsp_data_error.read()) // bus error
4510        {
4511            if (r_dcache_vci_unc_write.read())
4512                r_mmu_detr = MMU_WRITE_DATA_ILLEGAL_ACCESS;
4513            else
4514                r_mmu_detr = MMU_READ_DATA_ILLEGAL_ACCESS;
4515
4516            r_mmu_dbvar          = m_dreq.addr;
4517            r_vci_rsp_data_error = false;
4518            m_drsp.error         = true;
4519            m_drsp.valid         = true;
4520            r_dcache_fsm         = DCACHE_IDLE;
4521            break;
4522        }
4523        else if (r_vci_rsp_fifo_dcache.rok())     // data available
4524        {
4525            // consume data
4526            vci_rsp_fifo_dcache_get = true;
4527            r_dcache_fsm            = DCACHE_IDLE;
4528
4529            // acknowledge the processor request if it has not been modified
4530            if (m_dreq.valid and (m_dreq.addr == r_dcache_save_vaddr.read()))
4531            {
4532                m_drsp.valid = true;
4533                m_drsp.error = false;
4534                m_drsp.rdata = r_vci_rsp_fifo_dcache.read();
4535            }
4536        }
4537        break;
4538    }
4539    /////////////////////
4540    case DCACHE_LL_WAIT:    // waiting VCI response to a LL transaction
4541    {
4542        // coherence clack request (from DSPIN CLACK)
4543        if (r_dcache_clack_req.read())
4544        {
4545            r_dcache_fsm = DCACHE_CC_CHECK;
4546            r_dcache_fsm_cc_save = r_dcache_fsm.read();
4547            break;
4548        }
4549
4550        // coherence request (from CC_RECEIVE FSM)
4551        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
4552        {
4553            r_dcache_fsm = DCACHE_CC_CHECK;
4554            r_dcache_fsm_cc_save = r_dcache_fsm.read();
4555            break;
4556        }
4557
4558        if (r_vci_rsp_data_error.read()) // bus error
4559        {
4560            r_mmu_detr           = MMU_READ_DATA_ILLEGAL_ACCESS;
4561            r_mmu_dbvar          = m_dreq.addr;
4562            r_vci_rsp_data_error = false;
4563            m_drsp.error         = true;
4564            m_drsp.valid         = true;
4565            r_dcache_fsm         = DCACHE_IDLE;
4566            break;
4567        }
4568        else if (r_vci_rsp_fifo_dcache.rok())     // data available
4569        {
4570            // consume data
4571            vci_rsp_fifo_dcache_get = true;
4572
4573            if (r_dcache_ll_rsp_count.read() == 0) // first flit
4574            {
4575                // set key value in llsc reservation buffer
4576                r_dcache_llsc_key     = r_vci_rsp_fifo_dcache.read();
4577                r_dcache_ll_rsp_count = r_dcache_ll_rsp_count.read() + 1;
4578            }
4579            else                                  // last flit
4580            {
4581                // acknowledge the processor request if it has not been modified
4582                if (m_dreq.valid and (m_dreq.addr == r_dcache_save_vaddr.read()))
4583                {
4584                    m_drsp.valid = true;
4585                    m_drsp.error = false;
4586                    m_drsp.rdata = r_vci_rsp_fifo_dcache.read();
4587                }
4588                r_dcache_fsm = DCACHE_IDLE;
4589            }
4590        }
4591        break;
4592    }
4593    ////////////////////
4594    case DCACHE_SC_WAIT: // waiting VCI response to a SC transaction
4595    {
4596        // coherence clack request (from DSPIN CLACK)
4597        if (r_dcache_clack_req.read())
4598        {
4599            r_dcache_fsm = DCACHE_CC_CHECK;
4600            r_dcache_fsm_cc_save = r_dcache_fsm.read();
4601            break;
4602        }
4603
4604        // coherence request (from CC_RECEIVE FSM)
4605        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
4606        {
4607            r_dcache_fsm = DCACHE_CC_CHECK;
4608            r_dcache_fsm_cc_save = r_dcache_fsm.read();
4609            break;
4610        }
4611
4612        if (r_vci_rsp_data_error.read()) // bus error
4613        {
4614            r_mmu_detr           = MMU_READ_DATA_ILLEGAL_ACCESS;
4615            r_mmu_dbvar          = m_dreq.addr;
4616            r_vci_rsp_data_error = false;
4617            m_drsp.error         = true;
4618            m_drsp.valid         = true;
4619            r_dcache_fsm         = DCACHE_IDLE;
4620            break;
4621        }
4622        else if (r_vci_rsp_fifo_dcache.rok()) // response available
4623        {
4624            // consume response
4625            vci_rsp_fifo_dcache_get = true;
4626            m_drsp.valid            = true;
4627            m_drsp.rdata            = r_vci_rsp_fifo_dcache.read();
4628            r_dcache_fsm            = DCACHE_IDLE;
4629        }
4630        break;
4631    }
4632    //////////////////////////
4633    case DCACHE_DIRTY_GET_PTE:  // This sub_fsm set the PTE Dirty bit in memory
4634                                // before handling a processor WRITE or SC request
4635                                // Input argument is r_dcache_dirty_paddr
4636                                // In this first state, we get PTE value in dcache
4637                                // and post a CAS request to CMD FSM
4638    {
4639        // get PTE in dcache
4640        uint32_t pte;
4641        size_t   way;
4642        size_t   set;
4643        size_t   word; // unused
4644        int      state;
4645
4646#ifdef INSTRUMENTATION
4647        m_cpt_dcache_data_read++;
4648        m_cpt_dcache_dir_read++;
4649#endif
4650        r_dcache.read(r_dcache_dirty_paddr.read(),
4651                      &pte,
4652                      &way,
4653                      &set,
4654                      &word,
4655                      &state);
4656
4657        assert( (state == CACHE_SLOT_STATE_VALID) and
4658        "error in DCACHE_DIRTY_TLB_SET: the PTE should be in dcache" );
4659
4660        // request CAS transaction to CMD_FSM
4661        r_dcache_dirty_way = way;
4662        r_dcache_dirty_set = set;
4663
4664        // check llsc reservation buffer
4665        if (r_dcache_llsc_paddr.read() == r_dcache_dirty_paddr.read())
4666            r_dcache_llsc_valid = false;
4667
4668        // request a CAS CMD and go to DCACHE_DIRTY_WAIT state
4669        r_dcache_vci_cas_req = true;
4670        r_dcache_vci_paddr   = r_dcache_dirty_paddr.read();
4671        r_dcache_vci_cas_old = pte;
4672        r_dcache_vci_cas_new = pte | PTE_D_MASK;
4673        r_dcache_fsm         = DCACHE_DIRTY_WAIT;
4674
4675#if DEBUG_DCACHE
4676        if (m_debug_dcache_fsm)
4677        {
4678            std::cout << "  <PROC " << name()
4679                << " DCACHE_DIRTY_GET_PTE> CAS request" << std::hex
4680                << " / PTE_PADDR = " << r_dcache_dirty_paddr.read()
4681                << " / PTE_VALUE = " << pte << std::dec
4682                << " / SET = " << set
4683                << " / WAY = " << way << std::endl;
4684        }
4685#endif
4686        break;
4687    }
4688    ///////////////////////
4689    case DCACHE_DIRTY_WAIT:    // wait completion of CAS for PTE Dirty bit,
4690                               // and return to IDLE state when response is received.
4691                               // we don't care if the CAS is a failure:
4692                               // - if the CAS is a success, the coherence mechanism
4693                               //   updates the local copy.
4694                               // - if the CAS is a failure, we just retry the write.
4695    {
4696        // coherence clack request (from DSPIN CLACK)
4697        if (r_dcache_clack_req.read())
4698        {
4699            r_dcache_fsm = DCACHE_CC_CHECK;
4700            r_dcache_fsm_cc_save = r_dcache_fsm.read();
4701            break;
4702        }
4703
4704        // coherence request (from CC_RECEIVE FSM)
4705        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
4706        {
4707            r_dcache_fsm = DCACHE_CC_CHECK;
4708            r_dcache_fsm_cc_save = r_dcache_fsm.read();
4709            break;
4710        }
4711
4712        if (r_vci_rsp_data_error.read())      // bus error
4713        {
4714            std::cout << "BUS ERROR in DCACHE_DIRTY_WAIT state" << std::endl;
4715            std::cout << "This should not happen in this state" << std::endl;
4716            exit(0);
4717        }
4718        else if (r_vci_rsp_fifo_dcache.rok()) // response available
4719        {
4720            vci_rsp_fifo_dcache_get = true;
4721            r_dcache_fsm            = DCACHE_IDLE;
4722
4723#if DEBUG_DCACHE
4724            if (m_debug_dcache_fsm)
4725            {
4726                std::cout << "  <PROC " << name()
4727                    << " DCACHE_DIRTY_WAIT> CAS completed" << std::endl;
4728            }
4729#endif
4730        }
4731        break;
4732    }
4733    /////////////////////
4734    case DCACHE_CC_CHECK:   // This state is the entry point for the sub-FSM
4735                            // handling coherence requests for DCACHE.
4736                            // If there is a matching pending miss on the modified cache
4737                            // line this is signaled in the r_dcache_miss inval flip-flop.
4738                            // If the updated (or invalidated) cache line has copies in TLBs
4739                            // these TLB copies are invalidated.
4740                            // The return state is defined in r_dcache_fsm_cc_save
4741    {
4742        paddr_t paddr = r_cc_receive_dcache_nline.read() * m_dcache_words * 4;
4743        paddr_t mask = ~((m_dcache_words << 2) - 1);
4744
4745        // CLACK handler
4746        // We switch the directory slot to EMPTY state and reset
4747        // r_dcache_miss_clack if the cleanup ack is matching a pending miss.
4748        if (r_dcache_clack_req.read())
4749        {
4750            if (m_dreq.valid ) m_cost_data_miss_frz++;
4751
4752#ifdef INSTRUMENTATION
4753            m_cpt_dcache_dir_write++;
4754#endif
4755            r_dcache.write_dir(0,
4756                               r_dcache_clack_way.read(),
4757                               r_dcache_clack_set.read(),
4758                               CACHE_SLOT_STATE_EMPTY);
4759
4760            if ((r_dcache_miss_set.read() == r_dcache_clack_set.read()) and
4761                (r_dcache_miss_way.read() == r_dcache_clack_way.read()))
4762            {
4763                  r_dcache_miss_clack = false;
4764            }
4765
4766            r_dcache_clack_req = false;
4767
4768            // return to cc_save state
4769            r_dcache_fsm = r_dcache_fsm_cc_save.read() ;
4770
4771#if DEBUG_DCACHE
4772            if (m_debug_dcache_fsm)
4773            {
4774                std::cout << "  <PROC " << name()
4775                    << " DCACHE_CC_CHECK> CLACK for PADDR " << paddr
4776                    << " Switch slot to EMPTY state : "
4777                    << " set = " << r_dcache_clack_set.read()
4778                    << " / way = " << r_dcache_clack_way.read() << std::endl;
4779            }
4780#endif
4781            break;
4782        }
4783
4784        assert(not r_dcache_cc_send_req.read() and
4785        "CC_SEND must be available in DCACHE_CC_CHECK");
4786
4787        // Match between MISS address and CC address
4788        if (r_cc_receive_dcache_req.read() and
4789          ((r_dcache_fsm_cc_save == DCACHE_MISS_SELECT)  or
4790           (r_dcache_fsm_cc_save == DCACHE_MISS_WAIT)  or
4791           (r_dcache_fsm_cc_save == DCACHE_MISS_DIR_UPDT)) and
4792          ((r_dcache_vci_paddr.read() & mask) == (paddr & mask))) // matching
4793        {
4794            // signaling matching
4795            r_dcache_miss_inval = true;
4796
4797            // in case of update, go to CC_UPDT
4798            // JUST TO POP THE FIFO
4799            if (r_cc_receive_dcache_type.read() == CC_TYPE_UPDT)
4800            {
4801                r_dcache_fsm     = DCACHE_CC_UPDT;
4802                r_dcache_cc_word = r_cc_receive_word_idx.read();
4803
4804                // just pop the fifo , don't write in icache
4805                r_dcache_cc_need_write = false;
4806            }
4807            // the request is dealt with
4808            else
4809            {
4810                r_cc_receive_dcache_req = false;
4811                r_dcache_fsm            = r_dcache_fsm_cc_save.read();
4812            }
4813
4814#if DEBUG_DCACHE
4815            if (m_debug_dcache_fsm)
4816            {
4817                std::cout << "  <PROC " << name()
4818                    << " DCACHE_CC_CHECK> Coherence request matching a pending miss:"
4819                    << " PADDR = " << std::hex << paddr << std::endl;
4820            }
4821#endif
4822        }
4823
4824        // CC request handler
4825
4826        int    state = 0;
4827        size_t way   = 0;
4828        size_t set   = 0;
4829        size_t word  = 0;
4830
4831#ifdef INSTRUMENTATION
4832        m_cpt_dcache_dir_read++;
4833#endif
4834        r_dcache.read_dir(paddr,
4835                          &state,
4836                          &way,
4837                          &set,
4838                          &word); // unused
4839
4840        r_dcache_cc_way = way;
4841        r_dcache_cc_set = set;
4842
4843        if (state == CACHE_SLOT_STATE_VALID) // hit
4844        {
4845            // need to update the cache state
4846            if (r_cc_receive_dcache_type.read() == CC_TYPE_UPDT) // hit update
4847            {
4848                r_dcache_cc_need_write = true;
4849                r_dcache_fsm           = DCACHE_CC_UPDT;
4850                r_dcache_cc_word       = r_cc_receive_word_idx.read();
4851            }
4852            else if (r_cc_receive_dcache_type.read() == CC_TYPE_INVAL) // hit inval
4853            {
4854                r_dcache_fsm = DCACHE_CC_INVAL;
4855            }
4856        }
4857        else                                  // miss
4858        {
4859            // multicast acknowledgement required in case of update
4860            if (r_cc_receive_dcache_type.read() == CC_TYPE_UPDT)
4861            {
4862                r_dcache_fsm     = DCACHE_CC_UPDT;
4863                r_dcache_cc_word = r_cc_receive_word_idx.read();
4864
4865                // just pop the fifo , don't write in icache
4866                r_dcache_cc_need_write = false;
4867            }
4868            else // No response needed
4869            {
4870                r_cc_receive_dcache_req = false;
4871                r_dcache_fsm = r_dcache_fsm_cc_save.read();
4872            }
4873        }
4874
4875#if DEBUG_DCACHE
4876        if (m_debug_dcache_fsm)
4877        {
4878            std::cout << "  <PROC " << name()
4879                << " DCACHE_CC_CHECK> Coherence request received:"
4880                << " PADDR = " << std::hex << paddr
4881                << " / TYPE = " << std::dec << r_cc_receive_dcache_type.read()
4882                << " / HIT = " << (state == CACHE_SLOT_STATE_VALID) << std::endl;
4883        }
4884#endif
4885
4886        break;
4887    }
4888    /////////////////////
4889    case DCACHE_CC_INVAL: // hit inval: switch slot to ZOMBI state and send a
4890                          // CLEANUP after possible invalidation of copies in
4891                          // TLBs
4892    {
4893        size_t way = r_dcache_cc_way.read();
4894        size_t set = r_dcache_cc_set.read();
4895
4896        if (r_dcache_in_tlb[way * m_dcache_sets + set])       // selective TLB inval
4897        {
4898            r_dcache_in_tlb[way * m_dcache_sets + set] = false;
4899            r_dcache_tlb_inval_line = r_cc_receive_dcache_nline.read();
4900            r_dcache_tlb_inval_set  = 0;
4901            r_dcache_fsm_scan_save  = r_dcache_fsm.read();
4902            r_dcache_fsm            = DCACHE_INVAL_TLB_SCAN;
4903            break;
4904        }
4905
4906        if (r_dcache_contains_ptd[way * m_dcache_sets + set]) // TLB flush
4907        {
4908            r_itlb.reset();
4909            r_dtlb.reset();
4910            r_dcache_contains_ptd[way * m_dcache_sets + set] = false;
4911
4912#if DEBUG_DCACHE
4913            if (m_debug_dcache_fsm)
4914            {
4915                std::cout << "  <PROC " << name()
4916                          << " DCACHE_CC_INVAL> Flush DTLB & ITLB" << std::endl;
4917            }
4918#endif
4919        }
4920
4921        assert(not r_dcache_cc_send_req.read() &&
4922                "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
4923                "must not be set");
4924
4925        // Switch slot state to ZOMBI and send CLEANUP command
4926        r_dcache.write_dir(way,
4927                           set,
4928                           CACHE_SLOT_STATE_ZOMBI);
4929
4930        // coherence request completed
4931        r_cc_receive_dcache_req = false;
4932        r_dcache_cc_send_req    = true;
4933        r_dcache_cc_send_nline  = r_cc_receive_dcache_nline.read();
4934        r_dcache_cc_send_way    = r_dcache_cc_way.read();
4935        r_dcache_cc_send_type   = CC_TYPE_CLEANUP;
4936        r_dcache_fsm            = r_dcache_fsm_cc_save.read();
4937
4938#if DEBUG_DCACHE
4939        if (m_debug_dcache_fsm)
4940        {
4941            std::cout << "  <PROC " << name()
4942                << " DCACHE_CC_INVAL> Switch slot to EMPTY state:" << std::dec
4943                << " / WAY = " << way
4944                << " / SET = " << set << std::endl;
4945        }
4946#endif
4947        break;
4948    }
4949    ///////////////////
4950    case DCACHE_CC_UPDT: // hit update: write one word per cycle,
4951                         // after possible invalidation of copies in TLBs
4952    {
4953        size_t word = r_dcache_cc_word.read();
4954        size_t way  = r_dcache_cc_way.read();
4955        size_t set  = r_dcache_cc_set.read();
4956
4957        if (r_dcache_in_tlb[way * m_dcache_sets + set])       // selective TLB inval
4958        {
4959            r_dcache_in_tlb[way * m_dcache_sets + set] = false;
4960            r_dcache_tlb_inval_line = r_cc_receive_dcache_nline.read();
4961            r_dcache_tlb_inval_set  = 0;
4962            r_dcache_fsm_scan_save  = r_dcache_fsm.read();
4963            r_dcache_fsm            = DCACHE_INVAL_TLB_SCAN;
4964
4965            break;
4966        }
4967
4968        if (r_dcache_contains_ptd[way * m_dcache_sets + set]) // TLB flush
4969        {
4970            r_itlb.reset();
4971            r_dtlb.reset();
4972            r_dcache_contains_ptd[way * m_dcache_sets + set] = false;
4973
4974#if DEBUG_DCACHE
4975            if (m_debug_dcache_fsm)
4976            {
4977                std::cout << "  <PROC " << name()
4978                    << " DCACHE_CC_UPDT> Flush DTLB & ITLB" << std::endl;
4979            }
4980#endif
4981        }
4982
4983        assert (not r_dcache_cc_send_req.read() &&
4984                "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
4985                "must not be set");
4986
4987        if (not r_cc_receive_updt_fifo_be.rok()) break;
4988
4989        if (r_dcache_cc_need_write.read())
4990        {
4991
4992#ifdef INSTRUMENTATION
4993            m_cpt_dcache_data_write++;
4994#endif
4995            r_dcache.write(way,
4996                           set,
4997                           word,
4998                           r_cc_receive_updt_fifo_data.read(),
4999                           r_cc_receive_updt_fifo_be.read());
5000
5001            r_dcache_cc_word = word + 1;
5002
5003#if DEBUG_DCACHE
5004            if (m_debug_dcache_fsm)
5005            {
5006                std::cout << "  <PROC " << name()
5007                    << " DCACHE_CC_UPDT> Write one word" << std::dec
5008                    << " / WAY = " << way
5009                    << " / SET = " << set
5010                    << " / WORD = " << word
5011                    << " / VALUE = " << std::hex << r_cc_receive_updt_fifo_data.read() << std::endl;
5012            }
5013#endif
5014        }
5015
5016        if (r_cc_receive_updt_fifo_eop.read())  // last word
5017        {
5018            // no need to write in the cache anymore
5019            r_dcache_cc_need_write = false;
5020
5021            // coherence request completed
5022            r_cc_receive_dcache_req = false;
5023
5024            // request multicast acknowledgement
5025            r_dcache_cc_send_req          = true;
5026            r_dcache_cc_send_nline        = r_cc_receive_dcache_nline.read();
5027            r_dcache_cc_send_updt_tab_idx = r_cc_receive_dcache_updt_tab_idx.read();
5028            r_dcache_cc_send_type         = CC_TYPE_MULTI_ACK;
5029            r_dcache_fsm                  = r_dcache_fsm_cc_save.read();
5030        }
5031
5032        //consume fifo if not eop
5033        cc_receive_updt_fifo_get  = true;
5034
5035        break;
5036    }
5037    ///////////////////////////
5038    case DCACHE_INVAL_TLB_SCAN:  // Scan sequencially all sets for both ITLB & DTLB
5039                                 // It makes assumption: m_itlb_sets == m_dtlb_sets
5040                                 // All ways are handled in parallel.
5041                                 // We enter this state when a DCACHE line is modified,
5042                                 // and there is a copy in itlb or dtlb.
5043                                 // It can be caused by:
5044                                 // - a coherence inval or updt transaction,
5045                                 // - a line inval caused by a cache miss
5046                                 // - a processor XTN inval request,
5047                                 // - a WRITE hit,
5048                                 // - a Dirty bit update
5049                                 // Input arguments are:
5050                                 // - r_dcache_tlb_inval_line
5051                                 // - r_dcache_tlb_inval_set
5052                                 // - r_dcache_fsm_scan_save
5053    {
5054        paddr_t line = r_dcache_tlb_inval_line.read();
5055        size_t set = r_dcache_tlb_inval_set.read();
5056        size_t way;
5057        bool ok;
5058
5059        for (way = 0; way < m_itlb_ways; way++)
5060        {
5061            ok = r_itlb.inval(line, way, set);
5062
5063#if DEBUG_DCACHE
5064            if (m_debug_dcache_fsm and ok)
5065            {
5066                std::cout << "  <PROC " << name()
5067                    << ".DCACHE_INVAL_TLB_SCAN> Invalidate ITLB entry:" << std::hex
5068                    << " line = " << line << std::dec
5069                    << " / set = " << set
5070                    << " / way = " << way << std::endl;
5071            }
5072#endif
5073        }
5074
5075        for (way = 0; way < m_dtlb_ways; way++)
5076        {
5077            ok = r_dtlb.inval( line, way, set);
5078
5079#if DEBUG_DCACHE
5080            if (m_debug_dcache_fsm and ok)
5081                std::cout << "  <PROC " << name() << " DCACHE_INVAL_TLB_SCAN>"
5082                    << " Invalidate DTLB entry" << std::hex
5083                    << " / line = " << line << std::dec
5084                    << " / set = " << set
5085                    << " / way = " << way << std::endl;
5086#endif
5087        }
5088
5089        // return to the calling state when TLB inval completed
5090        if (r_dcache_tlb_inval_set.read() == (m_dtlb_sets - 1))
5091        {
5092            r_dcache_fsm = r_dcache_fsm_scan_save.read();
5093        }
5094        r_dcache_tlb_inval_set = r_dcache_tlb_inval_set.read() + 1;
5095        break;
5096    }
5097    } // end switch r_dcache_fsm
5098
5099    ///////////////// wbuf update ///////////////////////////////////////////////////////
5100    r_wbuf.update();
5101
5102    ///////////////// llsc update ///////////////////////////////////////////////////////
5103    if (r_dcache_llsc_valid.read()) r_dcache_llsc_count = r_dcache_llsc_count.read() - 1;
5104    if (r_dcache_llsc_count.read() == 1) r_dcache_llsc_valid = false;
5105
5106    //////////////// test processor frozen //////////////////////////////////////////////
5107    // The simulation exit if the number of consecutive frozen cycles
5108    // is larger than the m_max_frozen_cycles (constructor parameter)
5109    if ((m_ireq.valid and not m_irsp.valid) or (m_dreq.valid and not m_drsp.valid))
5110    {
5111        m_cpt_frz_cycles++;      // used for instrumentation
5112        m_cpt_stop_simulation++; // used for debug
5113        if (m_cpt_stop_simulation > m_max_frozen_cycles)
5114        {
5115            std::cout << std::dec << "ERROR in CC_VCACHE_WRAPPER " << name() << std::endl
5116                      << " stop at cycle " << m_cpt_total_cycles << std::endl
5117                      << " frozen since cycle " << m_cpt_total_cycles - m_max_frozen_cycles
5118                      << std::endl;
5119                      r_iss.dump();
5120            exit(1);
5121        }
5122    }
5123    else
5124    {
5125        m_cpt_stop_simulation = 0;
5126    }
5127
5128    /////////// execute one iss cycle /////////////////////////////////
5129    {
5130        uint32_t it = 0;
5131        for (size_t i = 0; i < (size_t) iss_t::n_irq; i++) if (p_irq[i].read()) it |= (1 << i);
5132        r_iss.executeNCycles(1, m_irsp, m_drsp, it);
5133    }
5134
5135    ////////////////////////////////////////////////////////////////////////////
5136    // The VCI_CMD FSM controls the following ressources:
5137    // - r_vci_cmd_fsm
5138    // - r_vci_cmd_min
5139    // - r_vci_cmd_max
5140    // - r_vci_cmd_cpt
5141    // - r_vci_cmd_imiss_prio
5142    // - wbuf (reset)
5143    // - r_icache_miss_req (reset)
5144    // - r_icache_unc_req (reset)
5145    // - r_dcache_vci_miss_req (reset)
5146    // - r_dcache_vci_unc_req (reset)
5147    // - r_dcache_vci_ll_req (reset)
5148    // - r_dcache_vci_sc_req (reset in case of local sc fail)
5149    // - r_dcache_vci_cas_req (reset)
5150    //
5151    // This FSM handles requests from both the DCACHE FSM & the ICACHE FSM.
5152    // There are 8 request types, with the following priorities :
5153    // 1 - Data Read Miss         : r_dcache_vci_miss_req and miss in the write buffer
5154    // 2 - Data Read Uncachable   : r_dcache_vci_unc_req
5155    // 3 - Instruction Miss       : r_icache_miss_req and miss in the write buffer
5156    // 4 - Instruction Uncachable : r_icache_unc_req
5157    // 5 - Data Write             : r_wbuf.rok()
5158    // 6 - Data Linked Load       : r_dcache_vci_ll_req
5159    // 7 - Data Store Conditionnal: r_dcache_vci_sc_req
5160    // 8 - Compare And Swap       : r_dcache_vci_cas_req
5161    //
5162    // As we want to support several simultaneous VCI transactions, the VCI_CMD_FSM
5163    // and the VCI_RSP_FSM are fully desynchronized.
5164    //
5165    // VCI formats:
5166    // According to the VCI advanced specification, all read requests packets
5167    // (data Uncached, Miss data, instruction Uncached, Miss instruction)
5168    // are one word packets.
5169    // For write burst packets, all words are in the same cache line,
5170    // and addresses must be contiguous (the BE field is 0 in case of "holes").
5171    // The sc command packet implements actually a compare-and-swap mechanism
5172    // and the packet contains two flits.
5173    ////////////////////////////////////////////////////////////////////////////////////
5174
5175
5176    switch (r_vci_cmd_fsm.read())
5177    {
5178        //////////////
5179        case CMD_IDLE:
5180        {
5181            // DCACHE read requests (r_dcache_vci_miss_req or r_dcache_vci_ll_req), and
5182            // ICACHE read requests (r_icache_miss_req) require both a write_buffer access
5183            // to check a possible pending write on the same cache line.
5184            // As there is only one possible access per cycle to write buffer, we implement
5185            // a round-robin priority between DCACHE and ICACHE for this access,
5186            // using the r_vci_cmd_imiss_prio flip-flop.
5187
5188            size_t wbuf_min;
5189            size_t wbuf_max;
5190
5191            bool dcache_miss_req = r_dcache_vci_miss_req.read() and
5192                 (not r_icache_miss_req.read() or not r_vci_cmd_imiss_prio.read());
5193
5194            bool dcache_ll_req = r_dcache_vci_ll_req.read() and
5195                 (not r_icache_miss_req.read() or not r_vci_cmd_imiss_prio.read());
5196
5197            bool dcache_sc_req = r_dcache_vci_sc_req.read() and
5198                 (not r_icache_miss_req.read() or not r_vci_cmd_imiss_prio.read());
5199
5200            bool dcache_cas_req = r_dcache_vci_cas_req.read() and
5201                 (not r_icache_miss_req.read() or not r_vci_cmd_imiss_prio.read());
5202
5203            bool icache_miss_req = r_icache_miss_req.read() and
5204                 (not (r_dcache_vci_miss_req.read() or
5205                       r_dcache_vci_ll_req.read()   or
5206                       r_dcache_vci_cas_req.read()  or
5207                       r_dcache_vci_sc_req.read())  or
5208                       r_vci_cmd_imiss_prio.read());
5209
5210            // 1 - Data unc write
5211            if (r_dcache_vci_unc_req.read() and r_dcache_vci_unc_write.read())
5212            {
5213                r_vci_cmd_fsm        = CMD_DATA_UNC_WRITE;
5214                r_dcache_vci_unc_req = false;
5215            }
5216            // 2 data read miss
5217            else if (dcache_miss_req and r_wbuf.miss(r_dcache_vci_paddr.read()))
5218            {
5219                r_vci_cmd_fsm         = CMD_DATA_MISS;
5220                r_dcache_vci_miss_req = false;
5221                r_vci_cmd_imiss_prio  = true;
5222            }
5223            // 3 - Data Read Uncachable
5224            else if (r_dcache_vci_unc_req.read() and not r_dcache_vci_unc_write.read())
5225            {
5226                r_vci_cmd_fsm        = CMD_DATA_UNC_READ;
5227                r_dcache_vci_unc_req = false;
5228            }
5229            // 4 - Data Linked Load
5230            else if (dcache_ll_req and r_wbuf.miss(r_dcache_vci_paddr.read()))
5231            {
5232                r_vci_cmd_fsm         = CMD_DATA_LL;
5233                r_dcache_vci_ll_req   = false;
5234                r_vci_cmd_imiss_prio  = true;
5235            }
5236            // 5 - Instruction Miss
5237            else if (icache_miss_req and r_wbuf.miss(r_icache_vci_paddr.read()))
5238            {
5239                r_vci_cmd_fsm        = CMD_INS_MISS;
5240                r_icache_miss_req    = false;
5241                r_vci_cmd_imiss_prio = false;
5242            }
5243            // 6 - Instruction Uncachable
5244            else if (r_icache_unc_req.read())
5245            {
5246                r_vci_cmd_fsm    = CMD_INS_UNC;
5247                r_icache_unc_req = false;
5248            }
5249            // 7 - Data Write
5250            else if (r_wbuf.rok(&wbuf_min, &wbuf_max))
5251            {
5252                r_vci_cmd_fsm = CMD_DATA_WRITE;
5253                r_vci_cmd_cpt = wbuf_min;
5254                r_vci_cmd_min = wbuf_min;
5255                r_vci_cmd_max = wbuf_max;
5256            }
5257            // 8 - Data Store Conditionnal
5258            else if (dcache_sc_req and r_wbuf.miss(r_dcache_vci_paddr.read()))
5259            {
5260                r_vci_cmd_fsm        = CMD_DATA_SC;
5261                r_dcache_vci_sc_req  = false;
5262                r_vci_cmd_imiss_prio = true;
5263                r_vci_cmd_cpt        = 0;
5264            }
5265            // 9 - Compare And Swap
5266            else if (dcache_cas_req and r_wbuf.miss(r_dcache_vci_paddr.read()))
5267            {
5268                r_vci_cmd_fsm        = CMD_DATA_CAS;
5269                r_dcache_vci_cas_req = false;
5270                r_vci_cmd_imiss_prio = true;
5271                r_vci_cmd_cpt        = 0;
5272            }
5273
5274#if DEBUG_CMD
5275            if (m_debug_cmd_fsm )
5276            {
5277                std::cout << "  <PROC " << name() << " CMD_IDLE>"
5278                    << " / dmiss_req = " << dcache_miss_req
5279                    << " / imiss_req = " << icache_miss_req
5280                    << std::endl;
5281            }
5282#endif
5283            break;
5284        }
5285        ////////////////////
5286        case CMD_DATA_WRITE:
5287        {
5288            if (p_vci.cmdack.read())
5289            {
5290                r_vci_cmd_cpt = r_vci_cmd_cpt + 1;
5291                if (r_vci_cmd_cpt == r_vci_cmd_max) // last flit sent
5292                {
5293                    r_vci_cmd_fsm = CMD_IDLE;
5294                    r_wbuf.sent();
5295                }
5296            }
5297            break;
5298        }
5299        /////////////////
5300        case CMD_DATA_SC:
5301        case CMD_DATA_CAS:
5302        {
5303            // The CAS and SC VCI commands contain two flits
5304            if (p_vci.cmdack.read())
5305            {
5306               r_vci_cmd_cpt = r_vci_cmd_cpt + 1;
5307               if (r_vci_cmd_cpt == 1) r_vci_cmd_fsm = CMD_IDLE ;
5308            }
5309            break;
5310        }
5311        //////////////////
5312        case CMD_INS_MISS:
5313        case CMD_INS_UNC:
5314        case CMD_DATA_MISS:
5315        case CMD_DATA_UNC_READ:
5316        case CMD_DATA_UNC_WRITE:
5317        case CMD_DATA_LL:
5318        {
5319            // all read VCI commands contain one single flit
5320            if (p_vci.cmdack.read()) {
5321                r_vci_cmd_fsm = CMD_IDLE;
5322            }
5323            break;
5324        }
5325
5326    } // end  switch r_vci_cmd_fsm
5327
5328    //////////////////////////////////////////////////////////////////////////
5329    // The VCI_RSP FSM controls the following ressources:
5330    // - r_vci_rsp_fsm:
5331    // - r_vci_rsp_fifo_icache (push)
5332    // - r_vci_rsp_fifo_dcache (push)
5333    // - r_vci_rsp_data_error (set)
5334    // - r_vci_rsp_ins_error (set)
5335    // - r_vci_rsp_cpt
5336    // - r_dcache_vci_sc_req (reset when SC response recieved)
5337    //
5338    // As the VCI_RSP and VCI_CMD are fully desynchronized to support several
5339    // simultaneous VCI transactions, this FSM uses the VCI RPKTID field
5340    // to identify the transactions.
5341    //
5342    // VCI vormat:
5343    // This component checks the response packet length and accepts only
5344    // single word packets for write response packets.
5345    //
5346    // Error handling:
5347    // This FSM analyzes the VCI error code and signals directly the Write Bus Error.
5348    // In case of Read Data Error, the VCI_RSP FSM sets the r_vci_rsp_data_error
5349    // flip_flop and the error is signaled by the DCACHE FSM.
5350    // In case of Instruction Error, the VCI_RSP FSM sets the r_vci_rsp_ins_error
5351    // flip_flop and the error is signaled by the ICACHE FSM.
5352    // In case of Cleanup Error, the simulation stops with an error message...
5353    //////////////////////////////////////////////////////////////////////////
5354
5355    switch (r_vci_rsp_fsm.read())
5356    {
5357    //////////////
5358    case RSP_IDLE:
5359    {
5360        if (p_vci.rspval.read())
5361        {
5362            r_vci_rsp_cpt = 0;
5363
5364            if ((p_vci.rpktid.read() & 0x7) ==  TYPE_DATA_UNC)
5365            {
5366                r_vci_rsp_fsm = RSP_DATA_UNC;
5367            }
5368            else if ((p_vci.rpktid.read() & 0x7) ==  TYPE_READ_DATA_MISS)
5369            {
5370                r_vci_rsp_fsm = RSP_DATA_MISS;
5371            }
5372            else if ((p_vci.rpktid.read() & 0x7) ==  TYPE_READ_INS_UNC)
5373            {
5374                r_vci_rsp_fsm = RSP_INS_UNC;
5375            }
5376            else if ((p_vci.rpktid.read() & 0x7) ==  TYPE_READ_INS_MISS)
5377            {
5378                r_vci_rsp_fsm = RSP_INS_MISS;
5379            }
5380            else if ((p_vci.rpktid.read() & 0x7) ==  TYPE_WRITE)
5381            {
5382                r_vci_rsp_fsm = RSP_DATA_WRITE;
5383            }
5384            else if ((p_vci.rpktid.read() & 0x7) ==  TYPE_CAS)
5385            {
5386                r_vci_rsp_fsm = RSP_DATA_UNC;
5387            }
5388            else if ((p_vci.rpktid.read() & 0x7) ==  TYPE_LL)
5389            {
5390                r_vci_rsp_fsm = RSP_DATA_LL;
5391            }
5392            else if ((p_vci.rpktid.read() & 0x7) == TYPE_SC)
5393            {
5394                r_vci_rsp_fsm = RSP_DATA_UNC;
5395            }
5396            else
5397            {
5398                assert(false and "Unexpected VCI response");
5399            }
5400        }
5401        break;
5402    }
5403        //////////////////
5404        case RSP_INS_MISS:
5405        {
5406            if (p_vci.rspval.read())
5407            {
5408                if ((p_vci.rerror.read() & 0x1) != 0)  // error reported
5409                {
5410                    r_vci_rsp_ins_error = true;
5411                    if (p_vci.reop.read()) r_vci_rsp_fsm = RSP_IDLE;
5412                }
5413                else                                        // no error reported
5414                {
5415                    if (r_vci_rsp_fifo_icache.wok())
5416                    {
5417                        if (r_vci_rsp_cpt.read() >= m_icache_words)
5418                        {
5419                            std::cout << "ERROR in VCI_CC_VCACHE " << name()
5420                                      << " VCI response packet too long "
5421                                      << " for instruction miss" << std::endl;
5422                            exit(0);
5423                        }
5424                        r_vci_rsp_cpt            = r_vci_rsp_cpt.read() + 1;
5425                        vci_rsp_fifo_icache_put  = true,
5426                        vci_rsp_fifo_icache_data = p_vci.rdata.read();
5427                        if (p_vci.reop.read())
5428                        {
5429                            if (r_vci_rsp_cpt.read() != (m_icache_words - 1))
5430                            {
5431                                std::cout << "ERROR in VCI_CC_VCACHE " << name()
5432                                          << " VCI response packet too short"
5433                                          << " for instruction miss" << std::endl;
5434                                exit(0);
5435                            }
5436                            r_vci_rsp_fsm = RSP_IDLE;
5437                        }
5438                    }
5439                }
5440            }
5441            break;
5442        }
5443        /////////////////
5444        case RSP_INS_UNC:
5445        {
5446            if (p_vci.rspval.read())
5447            {
5448                assert(p_vci.reop.read() and
5449                "illegal VCI response packet for uncachable instruction");
5450
5451                if ((p_vci.rerror.read() & 0x1) != 0)  // error reported
5452                {
5453                    r_vci_rsp_ins_error = true;
5454                    r_vci_rsp_fsm = RSP_IDLE;
5455                }
5456                else                                         // no error reported
5457                {
5458                    if (r_vci_rsp_fifo_icache.wok())
5459                    {
5460                        vci_rsp_fifo_icache_put  = true;
5461                        vci_rsp_fifo_icache_data = p_vci.rdata.read();
5462                        r_vci_rsp_fsm = RSP_IDLE;
5463                    }
5464                }
5465            }
5466            break;
5467        }
5468        ///////////////////
5469        case RSP_DATA_MISS:
5470        {
5471            if (p_vci.rspval.read())
5472            {
5473                if ((p_vci.rerror.read() & 0x1) != 0)  // error reported
5474                {
5475                    r_vci_rsp_data_error = true;
5476                    if (p_vci.reop.read()) r_vci_rsp_fsm = RSP_IDLE;
5477                }
5478                else                                        // no error reported
5479                {
5480                    if (r_vci_rsp_fifo_dcache.wok())
5481                    {
5482                        assert((r_vci_rsp_cpt.read() < m_dcache_words) and
5483                        "The VCI response packet for data miss is too long");
5484
5485                        r_vci_rsp_cpt            = r_vci_rsp_cpt.read() + 1;
5486                        vci_rsp_fifo_dcache_put  = true,
5487                        vci_rsp_fifo_dcache_data = p_vci.rdata.read();
5488                        if (p_vci.reop.read())
5489                        {
5490                            assert((r_vci_rsp_cpt.read() == m_dcache_words - 1) and
5491                            "The VCI response packet for data miss is too short");
5492
5493                            r_vci_rsp_fsm = RSP_IDLE;
5494                        }
5495                    }
5496                }
5497            }
5498            break;
5499        }
5500        //////////////////
5501        case RSP_DATA_UNC:
5502        {
5503            if (p_vci.rspval.read())
5504            {
5505                assert(p_vci.reop.read() and
5506                "illegal VCI response packet for uncachable read data");
5507
5508                if ((p_vci.rerror.read() & 0x1) != 0)  // error reported
5509                {
5510                    r_vci_rsp_data_error = true;
5511                    r_vci_rsp_fsm = RSP_IDLE;
5512                }
5513                else // no error reported
5514                {
5515                    if (r_vci_rsp_fifo_dcache.wok())
5516                    {
5517                        vci_rsp_fifo_dcache_put = true;
5518                        vci_rsp_fifo_dcache_data = p_vci.rdata.read();
5519                        r_vci_rsp_fsm = RSP_IDLE;
5520                    }
5521                }
5522            }
5523            break;
5524        }
5525        /////////////////
5526        case RSP_DATA_LL:
5527        {
5528            if (p_vci.rspval.read())
5529            {
5530                if ((p_vci.rerror.read() & 0x1) != 0)  // error reported
5531                {
5532                    r_vci_rsp_data_error = true;
5533                    r_vci_rsp_fsm = RSP_IDLE;
5534                    break;
5535                }
5536                if (r_vci_rsp_cpt.read() == 0) //first flit
5537                {
5538                    if (r_vci_rsp_fifo_dcache.wok())
5539                    {
5540                        assert(!p_vci.reop.read() &&
5541                            "illegal VCI response packet for LL");
5542                        vci_rsp_fifo_dcache_put  = true;
5543                        vci_rsp_fifo_dcache_data = p_vci.rdata.read();
5544                        r_vci_rsp_cpt            = r_vci_rsp_cpt.read() + 1;
5545                    }
5546                    break;
5547                }
5548                else // last flit
5549                {
5550                    if (r_vci_rsp_fifo_dcache.wok())
5551                    {
5552                        assert(p_vci.reop.read() &&
5553                            "illegal VCI response packet for LL");
5554                        vci_rsp_fifo_dcache_put  = true;
5555                        vci_rsp_fifo_dcache_data = p_vci.rdata.read();
5556                        r_vci_rsp_fsm            = RSP_IDLE;
5557                    }
5558                    break;
5559                }
5560            }
5561            break;
5562        }
5563        ////////////////////
5564        case RSP_DATA_WRITE:
5565        {
5566            if (p_vci.rspval.read())
5567            {
5568                assert(p_vci.reop.read() and
5569                "a VCI response packet must contain one flit for a write transaction");
5570
5571                r_vci_rsp_fsm = RSP_IDLE;
5572                uint32_t wbuf_index = p_vci.rtrdid.read();
5573                r_wbuf.completed(wbuf_index);
5574                if ((p_vci.rerror.read() & 0x1) != 0) r_iss.setWriteBerr();
5575            }
5576            break;
5577        }
5578    } // end switch r_vci_rsp_fsm
5579
5580    /////////////////////////////////////////////////////////////////////////////////////
5581    // The CC_SEND FSM is in charge of sending cleanups and the multicast
5582    // acknowledgements on the coherence network. It has two clients (DCACHE FSM
5583    // and ICACHE FSM) that are served with a round-robin priority.
5584    // The CC_SEND FSM resets the r_*cache_cc_send_req request flip-flops as
5585    // soon as the request has been sent.
5586    /////////////////////////////////////////////////////////////////////////////////////
5587    switch (r_cc_send_fsm.read())
5588    {
5589        ///////////////////////////
5590        case CC_SEND_IDLE:
5591        {
5592            ///////////////////////////////////////////////////////
5593            // handling round robin between icache and dcache :  //
5594            // we first check for the last client and listen for //
5595            // a request of the other, then update the client    //
5596            // r_cc_send_last_client : 0 dcache / 1 icache
5597            ///////////////////////////////////////////////////////
5598            bool update_last_client = r_cc_send_last_client.read();
5599            if (r_cc_send_last_client.read() == 0) // last client was dcache
5600            {
5601                if (r_icache_cc_send_req.read()) // request from icache
5602                    update_last_client = 1; // update last client to icache
5603            }
5604            else // last client was icache
5605            {
5606                if (r_dcache_cc_send_req.read()) // request from dcache
5607                    update_last_client = 0; // update last client to dcache
5608            }
5609            r_cc_send_last_client = update_last_client;
5610
5611            // if there is an actual request
5612            if (r_dcache_cc_send_req.read() or r_icache_cc_send_req.read())
5613            {
5614                // the new client is dcache and has a cleanup request
5615                if ((update_last_client == 0) and
5616                          (r_dcache_cc_send_type.read() == CC_TYPE_CLEANUP))
5617                    r_cc_send_fsm = CC_SEND_CLEANUP_1;
5618                // the new client is dcache and has a multi acknowledgement request
5619                else if ((update_last_client == 0) and
5620                          (r_dcache_cc_send_type.read() == CC_TYPE_MULTI_ACK))
5621                    r_cc_send_fsm = CC_SEND_MULTI_ACK;
5622                // the new client is icache and has a cleanup request
5623                else if ((update_last_client == 1) and
5624                          (r_icache_cc_send_type.read() == CC_TYPE_CLEANUP))
5625                    r_cc_send_fsm = CC_SEND_CLEANUP_1;
5626                // the new client is icache and has a multi acknowledgement request
5627                else if ((update_last_client == 1) and
5628                        (r_icache_cc_send_type.read() == CC_TYPE_MULTI_ACK))
5629                    r_cc_send_fsm = CC_SEND_MULTI_ACK;
5630            }
5631            break;
5632        }
5633        ///////////////////////////
5634        case CC_SEND_CLEANUP_1:
5635        {
5636            // wait for the first flit to be consumed
5637            if (p_dspin_p2m.read.read())
5638                r_cc_send_fsm = CC_SEND_CLEANUP_2;
5639
5640            break;
5641        }
5642        ///////////////////////////
5643        case CC_SEND_CLEANUP_2:
5644        {
5645            // wait for the second flit to be consumed
5646            if (p_dspin_p2m.read.read())
5647            {
5648                if (r_cc_send_last_client.read() == 0) // dcache active request
5649                    r_dcache_cc_send_req = false; // reset dcache request
5650                else // icache active request
5651                    r_icache_cc_send_req = false; // reset icache request
5652
5653                // go back to idle state
5654                r_cc_send_fsm = CC_SEND_IDLE;
5655            }
5656            break;
5657        }
5658        ///////////////////////////
5659        case CC_SEND_MULTI_ACK:
5660        {
5661            // wait for the flit to be consumed
5662            if (p_dspin_p2m.read.read())
5663            {
5664                if (r_cc_send_last_client.read() == 0) // dcache active request
5665                    r_dcache_cc_send_req = false; // reset dcache request
5666                else // icache active request
5667                    r_icache_cc_send_req = false; // reset icache request
5668                // go back to idle state
5669                r_cc_send_fsm = CC_SEND_IDLE;
5670            }
5671            break;
5672        }
5673    } // end switch CC_SEND FSM
5674
5675    ///////////////////////////////////////////////////////////////////////////////
5676    //  CC_RECEIVE  FSM
5677    // This FSM receive all coherence packets on a DSPIN40 port.
5678    // There is 5 packet types:
5679    // - CC_DATA_INVAL : DCACHE invalidate request
5680    // - CC_DATA_UPDT  : DCACHE update request (multi-words)
5681    // - CC_INST_INVAL : ICACHE invalidate request
5682    // - CC_INST_UPDT  : ICACHE update request (multi-words)
5683    // - CC_BROADCAST  : Broadcast invalidate request (both DCACHE & ICACHE)
5684    //////////////////////////////////////////////////////////////////////////////
5685    switch (r_cc_receive_fsm.read())
5686    {
5687        /////////////////////
5688        case CC_RECEIVE_IDLE:
5689        {
5690            // a coherence request has arrived
5691            if (p_dspin_m2p.write.read())
5692            {
5693                // initialize dspin received data
5694                uint64_t receive_data = p_dspin_m2p.data.read();
5695                // initialize coherence packet type
5696                uint64_t receive_type = DspinDhccpParam::dspin_get(receive_data,
5697                                            DspinDhccpParam::M2P_TYPE);
5698                // test for a broadcast
5699                if (DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::M2P_BC))
5700                {
5701                    r_cc_receive_fsm = CC_RECEIVE_BRDCAST_HEADER;
5702                }
5703                // test for a multi updt
5704                else if (receive_type == DspinDhccpParam::TYPE_MULTI_UPDT_DATA)
5705                {
5706                    r_cc_receive_fsm = CC_RECEIVE_DATA_UPDT_HEADER;
5707                }
5708                else if (receive_type == DspinDhccpParam::TYPE_MULTI_UPDT_INST)
5709                {
5710                    r_cc_receive_fsm = CC_RECEIVE_INS_UPDT_HEADER;
5711                }
5712                // test for a multi inval
5713                else if (receive_type == DspinDhccpParam::TYPE_MULTI_INVAL_DATA)
5714                {
5715                    r_cc_receive_fsm = CC_RECEIVE_DATA_INVAL_HEADER;
5716                }
5717                else
5718                {
5719                    r_cc_receive_fsm = CC_RECEIVE_INS_INVAL_HEADER;
5720                }
5721            }
5722            break;
5723        }
5724        ///////////////////////////////
5725        case CC_RECEIVE_BRDCAST_HEADER:
5726        {
5727            // no actual data in the HEADER, just skip to second flit
5728            r_cc_receive_fsm = CC_RECEIVE_BRDCAST_NLINE;
5729            break;
5730        }
5731        //////////////////////////////
5732        case CC_RECEIVE_BRDCAST_NLINE:
5733        {
5734            // initialize dspin received data
5735            uint64_t receive_data = p_dspin_m2p.data.read();
5736            // wait for both dcache and icache to take the request
5737            // TODO maybe we need to wait for both only to leave the state, but
5738            // not to actually post a request to an available cache => need a
5739            // flip_flop to check that ?
5740            if (not (r_cc_receive_icache_req.read()) and
5741                not (r_cc_receive_dcache_req.read()) and
5742                (p_dspin_m2p.write.read()))
5743            {
5744                // request dcache to handle the BROADCAST
5745                r_cc_receive_dcache_req = true;
5746                r_cc_receive_dcache_nline = DspinDhccpParam::dspin_get(receive_data,
5747                                             DspinDhccpParam::BROADCAST_NLINE);
5748                r_cc_receive_dcache_type = CC_TYPE_INVAL;
5749                // request icache to handle the BROADCAST
5750                r_cc_receive_icache_req = true;
5751                r_cc_receive_icache_nline = DspinDhccpParam::dspin_get(receive_data,
5752                                             DspinDhccpParam::BROADCAST_NLINE);
5753                r_cc_receive_icache_type = CC_TYPE_INVAL;
5754                // get back to idle state
5755                r_cc_receive_fsm = CC_RECEIVE_IDLE;
5756                break;
5757            }
5758            // keep waiting for the caches to accept the request
5759            break;
5760        }
5761        /////////////////////////////
5762        case CC_RECEIVE_DATA_INVAL_HEADER:
5763        {
5764            // sample updt tab index in the HEADER, then skip to second flit
5765            r_cc_receive_fsm = CC_RECEIVE_DATA_INVAL_NLINE;
5766            break;
5767        }
5768        /////////////////////////////
5769        case CC_RECEIVE_INS_INVAL_HEADER:
5770        {
5771            // sample updt tab index in the HEADER, then skip to second flit
5772            r_cc_receive_fsm = CC_RECEIVE_INS_INVAL_NLINE;
5773            break;
5774        }
5775        ////////////////////////////
5776        case CC_RECEIVE_DATA_INVAL_NLINE:
5777        {
5778            // sample nline in the second flit
5779            uint64_t receive_data = p_dspin_m2p.data.read();
5780            // for data INVAL, wait for dcache to take the request
5781            if (p_dspin_m2p.write.read()           and
5782                not r_cc_receive_dcache_req.read())
5783            {
5784                // request dcache to handle the INVAL
5785                r_cc_receive_dcache_req = true;
5786                r_cc_receive_dcache_nline = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_INVAL_NLINE);
5787                r_cc_receive_dcache_type = CC_TYPE_INVAL;
5788                // get back to idle state
5789                r_cc_receive_fsm = CC_RECEIVE_IDLE;
5790                break;
5791            }
5792            break;
5793        }
5794        //////////////////////////////
5795        case CC_RECEIVE_INS_INVAL_NLINE:
5796        {
5797            // sample nline in the second flit
5798            uint64_t receive_data = p_dspin_m2p.data.read();
5799            // for ins INVAL, wait for icache to take the request
5800            if (p_dspin_m2p.write.read()           and
5801                not r_cc_receive_icache_req.read())
5802            {
5803                // request icache to handle the INVAL
5804                r_cc_receive_icache_req = true;
5805                r_cc_receive_icache_nline = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_INVAL_NLINE);
5806                r_cc_receive_icache_type = CC_TYPE_INVAL;
5807                // get back to idle state
5808                r_cc_receive_fsm = CC_RECEIVE_IDLE;
5809                break;
5810            }
5811            break;
5812        }
5813        ////////////////////////////
5814        case CC_RECEIVE_DATA_UPDT_HEADER:
5815        {
5816            // sample updt tab index in the HEADER, than skip to second flit
5817            uint64_t receive_data = p_dspin_m2p.data.read();
5818            // for data INVAL, wait for dcache to take the request and fifo to
5819            // be empty
5820            if (not r_cc_receive_dcache_req.read())
5821            {
5822                r_cc_receive_dcache_updt_tab_idx = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_UPDT_INDEX);
5823                r_cc_receive_fsm = CC_RECEIVE_DATA_UPDT_NLINE;
5824                break;
5825            }
5826            break;
5827        }
5828        ////////////////////////////
5829        case CC_RECEIVE_INS_UPDT_HEADER:
5830        {
5831            // sample updt tab index in the HEADER, than skip to second flit
5832            uint64_t receive_data = p_dspin_m2p.data.read();
5833            // for ins INVAL, wait for icache to take the request and fifo to be
5834            // empty
5835            if (not r_cc_receive_icache_req.read())
5836            {
5837                r_cc_receive_icache_updt_tab_idx = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_UPDT_INDEX);
5838                r_cc_receive_fsm = CC_RECEIVE_INS_UPDT_NLINE;
5839                break;
5840            }
5841            // keep waiting for the correct cache to accept the request
5842            break;
5843        }
5844        ///////////////////////////
5845        case CC_RECEIVE_DATA_UPDT_NLINE:
5846        {
5847            // sample nline and word index in the second flit
5848            uint64_t receive_data = p_dspin_m2p.data.read();
5849            // for data INVAL, wait for dcache to take the request and fifo to
5850            // be empty
5851            if (r_cc_receive_updt_fifo_be.empty() and
5852                 p_dspin_m2p.write.read())
5853            {
5854                r_cc_receive_dcache_req   = true;
5855                r_cc_receive_dcache_nline = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_NLINE);
5856                r_cc_receive_word_idx     = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_WORD_INDEX);
5857                r_cc_receive_dcache_type  = CC_TYPE_UPDT;
5858                // get back to idle state
5859                r_cc_receive_fsm = CC_RECEIVE_DATA_UPDT_DATA;
5860                break;
5861            }
5862            break;
5863        }
5864        ////////////////////////////
5865        case CC_RECEIVE_INS_UPDT_NLINE:
5866        {
5867            // sample nline and word index in the second flit
5868            uint64_t receive_data = p_dspin_m2p.data.read();
5869            // for ins INVAL, wait for icache to take the request and fifo to be
5870            // empty
5871            if (r_cc_receive_updt_fifo_be.empty() and
5872                 p_dspin_m2p.write.read())
5873            {
5874                r_cc_receive_icache_req   = true;
5875                r_cc_receive_icache_nline = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_NLINE);
5876                r_cc_receive_word_idx     = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_WORD_INDEX);
5877                r_cc_receive_icache_type  = CC_TYPE_UPDT;
5878                // get back to idle state
5879                r_cc_receive_fsm = CC_RECEIVE_INS_UPDT_DATA;
5880                break;
5881            }
5882            break;
5883        }
5884        //////////////////////////
5885        case CC_RECEIVE_DATA_UPDT_DATA:
5886        {
5887            // wait for the fifo
5888            if (r_cc_receive_updt_fifo_be.wok() and (p_dspin_m2p.write.read()))
5889            {
5890                uint64_t receive_data = p_dspin_m2p.data.read();
5891                bool     receive_eop  = p_dspin_m2p.eop.read();
5892                cc_receive_updt_fifo_be   = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_BE);
5893                cc_receive_updt_fifo_data = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_DATA);
5894                cc_receive_updt_fifo_eop  = receive_eop;
5895                cc_receive_updt_fifo_put  = true;
5896                if (receive_eop ) r_cc_receive_fsm = CC_RECEIVE_IDLE;
5897            }
5898            break;
5899        }
5900        //////////////////////////
5901        case CC_RECEIVE_INS_UPDT_DATA:
5902        {
5903            // wait for the fifo
5904            if (r_cc_receive_updt_fifo_be.wok() and (p_dspin_m2p.write.read()))
5905            {
5906                uint64_t receive_data = p_dspin_m2p.data.read();
5907                bool     receive_eop  = p_dspin_m2p.eop.read();
5908                cc_receive_updt_fifo_be   = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_BE);
5909                cc_receive_updt_fifo_data = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_DATA);
5910                cc_receive_updt_fifo_eop  = receive_eop;
5911                cc_receive_updt_fifo_put  = true;
5912                if (receive_eop ) r_cc_receive_fsm = CC_RECEIVE_IDLE;
5913            }
5914            break;
5915        }
5916
5917    } // end switch CC_RECEIVE FSM
5918
5919    ///////////////// DSPIN CLACK interface ///////////////
5920
5921    uint64_t clack_type = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(),
5922                                                     DspinDhccpParam::CLACK_TYPE);
5923
5924    size_t clack_way = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(),
5925                                                   DspinDhccpParam::CLACK_WAY);
5926
5927    size_t clack_set = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(),
5928                                                   DspinDhccpParam::CLACK_SET);
5929
5930    bool dspin_clack_get = false;
5931    bool dcache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_DATA);
5932    bool icache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_INST);
5933
5934    if (r_dspin_clack_req.read())
5935    {
5936        // CLACK DATA: Send request to DCACHE FSM
5937        if (dcache_clack_request and not r_dcache_clack_req.read())
5938        {
5939            r_dcache_clack_req = true;
5940            r_dcache_clack_way = clack_way & ((1ULL << (uint32_log2(m_dcache_ways))) - 1);
5941            r_dcache_clack_set = clack_set & ((1ULL << (uint32_log2(m_dcache_sets))) - 1);
5942            dspin_clack_get    = true;
5943        }
5944
5945        // CLACK INST: Send request to ICACHE FSM
5946        else if (icache_clack_request and not r_icache_clack_req.read())
5947        {
5948            r_icache_clack_req = true;
5949            r_icache_clack_way = clack_way & ((1ULL<<(uint32_log2(m_dcache_ways)))-1);
5950            r_icache_clack_set = clack_set & ((1ULL<<(uint32_log2(m_icache_sets)))-1);
5951            dspin_clack_get    = true;
5952        }
5953    }
5954    else
5955    {
5956        dspin_clack_get = true;
5957    }
5958
5959    if (dspin_clack_get)
5960    {
5961        r_dspin_clack_req  = p_dspin_clack.write.read();
5962        r_dspin_clack_flit = p_dspin_clack.data.read();
5963    }
5964
5965    ///////////////// Response FIFOs update  //////////////////////
5966    r_vci_rsp_fifo_icache.update(vci_rsp_fifo_icache_get,
5967                                 vci_rsp_fifo_icache_put,
5968                                 vci_rsp_fifo_icache_data);
5969
5970    r_vci_rsp_fifo_dcache.update(vci_rsp_fifo_dcache_get,
5971                                 vci_rsp_fifo_dcache_put,
5972                                 vci_rsp_fifo_dcache_data);
5973
5974    ///////////////// updt FIFO update  //////////////////////
5975    //TODO check this
5976    r_cc_receive_updt_fifo_be.update(cc_receive_updt_fifo_get,
5977                                 cc_receive_updt_fifo_put,
5978                                 cc_receive_updt_fifo_be);
5979    r_cc_receive_updt_fifo_data.update(cc_receive_updt_fifo_get,
5980                                 cc_receive_updt_fifo_put,
5981                                 cc_receive_updt_fifo_data);
5982    r_cc_receive_updt_fifo_eop.update(cc_receive_updt_fifo_get,
5983                                 cc_receive_updt_fifo_put,
5984                                 cc_receive_updt_fifo_eop);
5985
5986} // end transition()
5987
5988///////////////////////
5989tmpl(void)::genMoore()
5990///////////////////////
5991{
5992
5993    // VCI initiator command on the direct network
5994    // it depends on the CMD FSM state
5995
5996    bool is_sc_or_cas  = (r_vci_cmd_fsm.read() == CMD_DATA_CAS) or
5997                         (r_vci_cmd_fsm.read() == CMD_DATA_SC);
5998
5999    p_vci.pktid  = 0;
6000    p_vci.srcid  = m_srcid;
6001    p_vci.cons   = is_sc_or_cas;
6002    p_vci.contig = not is_sc_or_cas;
6003    p_vci.wrap   = false;
6004    p_vci.clen   = 0;
6005    p_vci.cfixed = false;
6006
6007    if (m_monitor_ok) {
6008        if (p_vci.cmdack.read() == true and p_vci.cmdval == true) {
6009            if (((p_vci.address.read()) >= m_monitor_base) and
6010                ((p_vci.address.read()) < m_monitor_base + m_monitor_length)) {
6011                std::cout << "CC_VCACHE Monitor " << name() << std::hex
6012                          << " Access type = " << vci_cmd_type_str[p_vci.cmd.read()]
6013                          << " Pktid type = " << vci_pktid_type_str[p_vci.pktid.read()]
6014                          << " : address = " << p_vci.address.read()
6015                          << " / be = " << p_vci.be.read();
6016                if (p_vci.cmd.read() == vci_param::CMD_WRITE ) {
6017                    std::cout << " / data = " << p_vci.wdata.read();
6018                }
6019                std::cout << std::dec << std::endl;
6020            }
6021        }
6022    }
6023
6024    switch (r_vci_cmd_fsm.read()) {
6025
6026    case CMD_IDLE:
6027        p_vci.cmdval  = false;
6028        p_vci.address = 0;
6029        p_vci.wdata   = 0;
6030        p_vci.be      = 0;
6031        p_vci.trdid   = 0;
6032        p_vci.pktid   = 0;
6033        p_vci.plen    = 0;
6034        p_vci.cmd     = vci_param::CMD_NOP;
6035        p_vci.eop     = false;
6036        break;
6037
6038    case CMD_INS_MISS:
6039        p_vci.cmdval  = true;
6040        p_vci.address = r_icache_vci_paddr.read() & m_icache_yzmask;
6041        p_vci.wdata   = 0;
6042        p_vci.be      = 0xF;
6043        p_vci.trdid   = 0;
6044        p_vci.pktid   = TYPE_READ_INS_MISS;
6045        p_vci.plen    = m_icache_words << 2;
6046        p_vci.cmd     = vci_param::CMD_READ;
6047        p_vci.eop     = true;
6048        break;
6049
6050    case CMD_INS_UNC:
6051        p_vci.cmdval  = true;
6052        p_vci.address = r_icache_vci_paddr.read() & ~0x3;
6053        p_vci.wdata   = 0;
6054        p_vci.be      = 0xF;
6055        p_vci.trdid   = 0;
6056        p_vci.pktid   = TYPE_READ_INS_UNC;
6057        p_vci.plen    = 4;
6058        p_vci.cmd     = vci_param::CMD_READ;
6059        p_vci.eop     = true;
6060        break;
6061
6062    case CMD_DATA_MISS:
6063        p_vci.cmdval  = true;
6064        p_vci.address = r_dcache_vci_paddr.read() & m_dcache_yzmask;
6065        p_vci.wdata   = 0;
6066        p_vci.be      = 0xF;
6067        p_vci.trdid   = 0;
6068        p_vci.pktid   = TYPE_READ_DATA_MISS;
6069        p_vci.plen    = m_dcache_words << 2;
6070        p_vci.cmd     = vci_param::CMD_READ;
6071        p_vci.eop     = true;
6072        break;
6073
6074    case CMD_DATA_UNC_READ:
6075        p_vci.cmdval  = true;
6076        p_vci.address = r_dcache_vci_paddr.read() & ~0x3;
6077        p_vci.wdata   = 0;
6078        p_vci.be      = r_dcache_vci_unc_be.read();
6079        p_vci.trdid   = 0;
6080        p_vci.pktid   = TYPE_DATA_UNC;
6081        p_vci.plen    = 4;
6082        p_vci.cmd     = vci_param::CMD_READ;
6083        p_vci.eop     = true;
6084        break;
6085
6086    case CMD_DATA_UNC_WRITE:
6087        p_vci.cmdval  = true;
6088        p_vci.address = r_dcache_vci_paddr.read() & ~0x3;
6089        p_vci.wdata   = r_dcache_vci_wdata.read();
6090        p_vci.be      = r_dcache_vci_unc_be.read();
6091        p_vci.trdid   = 0;
6092        p_vci.pktid   = TYPE_DATA_UNC;
6093        p_vci.plen    = 4;
6094        p_vci.cmd     = vci_param::CMD_WRITE;
6095        p_vci.eop     = true;
6096        break;
6097
6098    case CMD_DATA_WRITE:
6099        p_vci.cmdval  = true;
6100        p_vci.address = r_wbuf.getAddress(r_vci_cmd_cpt.read()) & ~0x3;
6101        p_vci.wdata   = r_wbuf.getData(r_vci_cmd_cpt.read());
6102        p_vci.be      = r_wbuf.getBe(r_vci_cmd_cpt.read());
6103        p_vci.trdid   = r_wbuf.getIndex();
6104        p_vci.pktid   = TYPE_WRITE;
6105        p_vci.plen    = (r_vci_cmd_max.read() - r_vci_cmd_min.read() + 1) << 2;
6106        p_vci.cmd     = vci_param::CMD_WRITE;
6107        p_vci.eop     = (r_vci_cmd_cpt.read() == r_vci_cmd_max.read());
6108        break;
6109
6110    case CMD_DATA_LL:
6111        p_vci.cmdval  = true;
6112        p_vci.address = r_dcache_vci_paddr.read() & ~0x3;
6113        p_vci.wdata   = 0;
6114        p_vci.be      = 0xF;
6115        p_vci.trdid   = 0;
6116        p_vci.pktid   = TYPE_LL;
6117        p_vci.plen    = 8;
6118        p_vci.cmd     = vci_param::CMD_LOCKED_READ;
6119        p_vci.eop     = true;
6120        break;
6121
6122    case CMD_DATA_SC:
6123        p_vci.cmdval  = true;
6124        p_vci.address = r_dcache_vci_paddr.read() & ~0x3;
6125        if (r_vci_cmd_cpt.read() == 0) p_vci.wdata = r_dcache_llsc_key.read();
6126        else                           p_vci.wdata = r_dcache_vci_sc_data.read();
6127        p_vci.be      = 0xF;
6128        p_vci.trdid   = 0;
6129        p_vci.pktid   = TYPE_SC;
6130        p_vci.plen    = 8;
6131        p_vci.cmd     = vci_param::CMD_NOP;
6132        p_vci.eop     = (r_vci_cmd_cpt.read() == 1);
6133        break;
6134
6135    case CMD_DATA_CAS:
6136        p_vci.cmdval  = true;
6137        p_vci.address = r_dcache_vci_paddr.read() & ~0x3;
6138        if (r_vci_cmd_cpt.read() == 0) p_vci.wdata = r_dcache_vci_cas_old.read();
6139        else                           p_vci.wdata = r_dcache_vci_cas_new.read();
6140        p_vci.be      = 0xF;
6141        p_vci.trdid   = 0;
6142        p_vci.pktid   = TYPE_CAS;
6143        p_vci.plen    = 8;
6144        p_vci.cmd     = vci_param::CMD_NOP;
6145        p_vci.eop     = (r_vci_cmd_cpt.read() == 1);
6146        break;
6147    } // end switch r_vci_cmd_fsm
6148
6149    // VCI initiator response on the direct network
6150    // it depends on the VCI_RSP FSM
6151
6152    switch (r_vci_rsp_fsm.read())
6153    {
6154        case RSP_DATA_WRITE : p_vci.rspack = true; break;
6155        case RSP_INS_MISS   : p_vci.rspack = r_vci_rsp_fifo_icache.wok(); break;
6156        case RSP_INS_UNC    : p_vci.rspack = r_vci_rsp_fifo_icache.wok(); break;
6157        case RSP_DATA_MISS  : p_vci.rspack = r_vci_rsp_fifo_dcache.wok(); break;
6158        case RSP_DATA_UNC   : p_vci.rspack = r_vci_rsp_fifo_dcache.wok(); break;
6159        case RSP_DATA_LL    : p_vci.rspack = r_vci_rsp_fifo_dcache.wok(); break;
6160        case RSP_IDLE       : p_vci.rspack = false; break;
6161    } // end switch r_vci_rsp_fsm
6162
6163
6164    // Send coherence packets on DSPIN P2M
6165    // it depends on the CC_SEND FSM
6166
6167    uint64_t dspin_send_data = 0;
6168    switch (r_cc_send_fsm.read())
6169    {
6170        //////////////////
6171        case CC_SEND_IDLE:
6172        {
6173            p_dspin_p2m.write = false;
6174            break;
6175        }
6176        ///////////////////////
6177        case CC_SEND_CLEANUP_1:
6178        {
6179            // initialize dspin send data
6180            DspinDhccpParam::dspin_set(dspin_send_data,
6181                                       m_cc_global_id,
6182                                       DspinDhccpParam::CLEANUP_SRCID);
6183            DspinDhccpParam::dspin_set(dspin_send_data,
6184                                       0,
6185                                       DspinDhccpParam::P2M_BC);
6186
6187            if (r_cc_send_last_client.read() == 0) // dcache active request
6188            {
6189                uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read()
6190                                >> (m_nline_width - m_x_width - m_y_width)
6191                                << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
6192
6193                DspinDhccpParam::dspin_set(dspin_send_data,
6194                                           dest,
6195                                           DspinDhccpParam::CLEANUP_DEST);
6196
6197                DspinDhccpParam::dspin_set(dspin_send_data,
6198                                           (r_dcache_cc_send_nline.read() & 0x300000000ULL)>>32,
6199                                           DspinDhccpParam::CLEANUP_NLINE_MSB);
6200
6201                DspinDhccpParam::dspin_set(dspin_send_data,
6202                                           r_dcache_cc_send_way.read(),
6203                                           DspinDhccpParam::CLEANUP_WAY_INDEX);
6204
6205                DspinDhccpParam::dspin_set(dspin_send_data,
6206                                           DspinDhccpParam::TYPE_CLEANUP_DATA,
6207                                           DspinDhccpParam::P2M_TYPE);
6208            }
6209            else                                // icache active request
6210            {
6211                uint64_t dest = (uint64_t) r_icache_cc_send_nline.read()
6212                                >> (m_nline_width - m_x_width - m_y_width)
6213                                << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
6214
6215                DspinDhccpParam::dspin_set(dspin_send_data,
6216                                           dest,
6217                                           DspinDhccpParam::CLEANUP_DEST);
6218
6219                DspinDhccpParam::dspin_set(dspin_send_data,
6220                                           (r_icache_cc_send_nline.read() & 0x300000000ULL) >> 32,
6221                                           DspinDhccpParam::CLEANUP_NLINE_MSB);
6222
6223                DspinDhccpParam::dspin_set(dspin_send_data,
6224                                           r_icache_cc_send_way.read(),
6225                                           DspinDhccpParam::CLEANUP_WAY_INDEX);
6226
6227                DspinDhccpParam::dspin_set(dspin_send_data,
6228                                           DspinDhccpParam::TYPE_CLEANUP_INST,
6229                                           DspinDhccpParam::P2M_TYPE);
6230            }
6231            // send flit
6232            p_dspin_p2m.data  = dspin_send_data;
6233            p_dspin_p2m.write = true;
6234            p_dspin_p2m.eop   = false;
6235            break;
6236        }
6237        ///////////////////////
6238        case CC_SEND_CLEANUP_2:
6239        {
6240            // initialize dspin send data
6241
6242            if (r_cc_send_last_client.read() == 0) // dcache active request
6243            {
6244                DspinDhccpParam::dspin_set(dspin_send_data,
6245                                           r_dcache_cc_send_nline.read() & 0xFFFFFFFFULL,
6246                                           DspinDhccpParam::CLEANUP_NLINE_LSB);
6247            }
6248            else                                  // icache active request
6249            {
6250                DspinDhccpParam::dspin_set(dspin_send_data,
6251                                           r_icache_cc_send_nline.read() & 0xFFFFFFFFULL,
6252                                           DspinDhccpParam::CLEANUP_NLINE_LSB);
6253            }
6254            // send flit
6255            p_dspin_p2m.data  = dspin_send_data;
6256            p_dspin_p2m.write = true;
6257            p_dspin_p2m.eop   = true;
6258            break;
6259        }
6260        ///////////////////////
6261        case CC_SEND_MULTI_ACK:
6262        {
6263            // initialize dspin send data
6264            DspinDhccpParam::dspin_set(dspin_send_data,
6265                                       0,
6266                                       DspinDhccpParam::P2M_BC);
6267            DspinDhccpParam::dspin_set(dspin_send_data,
6268                                       DspinDhccpParam::TYPE_MULTI_ACK,
6269                                       DspinDhccpParam::P2M_TYPE);
6270
6271            if (r_cc_send_last_client.read() == 0) // dcache active request
6272            {
6273                uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read()
6274                                >> (m_nline_width - m_x_width - m_y_width)
6275                                << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
6276
6277                DspinDhccpParam::dspin_set(dspin_send_data,
6278                                           dest,
6279                                           DspinDhccpParam::MULTI_ACK_DEST);
6280
6281                DspinDhccpParam::dspin_set(dspin_send_data,
6282                                           r_dcache_cc_send_updt_tab_idx.read(),
6283                                           DspinDhccpParam::MULTI_ACK_UPDT_INDEX);
6284            }
6285            else                                    // icache active request
6286            {
6287                uint64_t dest = (uint64_t) r_icache_cc_send_nline.read()
6288                                >> (m_nline_width - m_x_width - m_y_width)
6289                                << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
6290
6291
6292                DspinDhccpParam::dspin_set(dspin_send_data,
6293                                           dest,
6294                                           DspinDhccpParam::MULTI_ACK_DEST);
6295
6296                DspinDhccpParam::dspin_set(dspin_send_data,
6297                                           r_icache_cc_send_updt_tab_idx.read(),
6298                                           DspinDhccpParam::MULTI_ACK_UPDT_INDEX);
6299            }
6300            // send flit
6301            p_dspin_p2m.data  = dspin_send_data;
6302            p_dspin_p2m.write = true;
6303            p_dspin_p2m.eop   = true;
6304
6305            break;
6306        }
6307    } // end switch CC_SEND FSM
6308
6309    // Receive coherence packets
6310    // It depends on the CC_RECEIVE FSM
6311    switch (r_cc_receive_fsm.read())
6312    {
6313        /////////////////////
6314        case CC_RECEIVE_IDLE:
6315        {
6316            p_dspin_m2p.read = false;
6317            break;
6318        }
6319        ///////////////////////////////
6320        case CC_RECEIVE_BRDCAST_HEADER:
6321        {
6322            p_dspin_m2p.read = true;
6323            break;
6324        }
6325        //////////////////////////////
6326        case CC_RECEIVE_BRDCAST_NLINE:
6327        {
6328            // TODO maybe we need to wait for both only to leave the state, but
6329            // not to actually post a request to an available cache => need a
6330            // flip_flop to check that ?
6331            if (not (r_cc_receive_icache_req.read()) and not (r_cc_receive_dcache_req.read()))
6332                p_dspin_m2p.read = true;
6333            else
6334                p_dspin_m2p.read = false;
6335            break;
6336        }
6337        /////////////////////////////
6338        case CC_RECEIVE_DATA_INVAL_HEADER:
6339        case CC_RECEIVE_INS_INVAL_HEADER:
6340        {
6341            p_dspin_m2p.read = true;
6342            break;
6343        }
6344        ////////////////////////////
6345        case CC_RECEIVE_DATA_INVAL_NLINE:
6346        {
6347            p_dspin_m2p.read = not r_cc_receive_dcache_req.read();
6348            break;
6349        }
6350        case CC_RECEIVE_INS_INVAL_NLINE:
6351        {
6352            p_dspin_m2p.read = not r_cc_receive_icache_req.read();
6353            break;
6354        }
6355        ///////////////////////////
6356        case CC_RECEIVE_DATA_UPDT_HEADER:
6357        {
6358            if (not r_cc_receive_dcache_req.read())
6359                p_dspin_m2p.read = true;
6360            else
6361                p_dspin_m2p.read = false;
6362            break;
6363        }
6364        ////////////////////////////
6365        case CC_RECEIVE_INS_UPDT_HEADER:
6366        {
6367            if (not r_cc_receive_icache_req.read())
6368                p_dspin_m2p.read = true;
6369            else
6370                p_dspin_m2p.read = false;
6371            break;
6372        }
6373        ///////////////////////////
6374        case CC_RECEIVE_DATA_UPDT_NLINE:
6375        case CC_RECEIVE_INS_UPDT_NLINE:
6376        {
6377            if (r_cc_receive_updt_fifo_be.empty())
6378                p_dspin_m2p.read = true;
6379            else
6380                p_dspin_m2p.read = false;
6381            break;
6382        }
6383        ///////////////////////////
6384        case CC_RECEIVE_DATA_UPDT_DATA:
6385        case CC_RECEIVE_INS_UPDT_DATA:
6386        {
6387            if (r_cc_receive_updt_fifo_be.wok())
6388                p_dspin_m2p.read = true;
6389            else
6390                p_dspin_m2p.read = false;
6391            break;
6392        }
6393    } // end switch CC_RECEIVE FSM
6394
6395
6396    int clack_type = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(),
6397                                                DspinDhccpParam::CLACK_TYPE);
6398
6399    bool dspin_clack_get = false;
6400    bool dcache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_DATA);
6401    bool icache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_INST);
6402
6403    if (r_dspin_clack_req.read())
6404    {
6405        // CLACK DATA: wait if pending request to DCACHE FSM
6406        if (dcache_clack_request and not r_dcache_clack_req.read())
6407        {
6408            dspin_clack_get = true;
6409        }
6410
6411        // CLACK INST: wait if pending request to ICACHE FSM
6412        else if (icache_clack_request and not r_icache_clack_req.read())
6413        {
6414            dspin_clack_get = true;
6415        }
6416    }
6417    else
6418    {
6419        dspin_clack_get = true;
6420    }
6421
6422    p_dspin_clack.read = dspin_clack_get;
6423} // end genMoore
6424
6425tmpl(void)::start_monitor(paddr_t base, paddr_t length)
6426// This version of monitor print both Read and Write request
6427{
6428    m_monitor_ok     = true;
6429    m_monitor_base   = base;
6430    m_monitor_length = length;
6431}
6432
6433tmpl(void)::stop_monitor()
6434{
6435    m_monitor_ok = false;
6436}
6437
6438}}
6439
6440// Local Variables:
6441// tab-width: 4
6442// c-basic-offset: 4
6443// c-file-offsets:((innamespace . 0)(inline-open . 0))
6444// indent-tabs-mode: nil
6445// End:
6446
6447// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
Note: See TracBrowser for help on using the repository browser.