Context Navigation

vci_cc_vcache_wrapper.cpp @ 850

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