Index: /branches/reconfiguration/communication/dspin_dhccp_param/caba/source/include/dspin_dhccp_param.h
===================================================================
--- /branches/reconfiguration/communication/dspin_dhccp_param/caba/source/include/dspin_dhccp_param.h	(revision 868)
+++ /branches/reconfiguration/communication/dspin_dhccp_param/caba/source/include/dspin_dhccp_param.h	(revision 869)
@@ -219,12 +219,12 @@
     static const uint64_t MULTI_ACK_UPDT_INDEX_MASK    = ((1ULL<<UPDT_INDEX_WIDTH)-1);
 
-    static const uint8_t  CC_TEST_DEST_SHIFT           = 22;
-    static const uint64_t CC_TEST_DEST_MASK            = ((1ULL<<GLOBALID_WIDTH)-1);
-    static const uint8_t  CC_TEST_SRCID_SHIFT          = 8;
-    static const uint64_t CC_TEST_SRCID_MASK           = ((1ULL<<SRCID_WIDTH)-1);
-    static const uint8_t  CC_TEST_TEST_SHIFT           = 5;
-    static const uint64_t CC_TEST_TEST_MASK            = 1;
-    static const uint8_t  CC_TEST_SIGNATURE_SHIFT      = 0;
-    static const uint64_t CC_TEST_SIGNATURE_MASK       = ((1ULL<<DATA_WIDTH)-1);
+    static const uint8_t  TEST_P2M_DEST_SHIFT          = 22;
+    static const uint64_t TEST_P2M_DEST_MASK           = ((1ULL<<GLOBALID_WIDTH)-1);
+    static const uint8_t  TEST_P2M_SRCID_SHIFT         = 8;
+    static const uint64_t TEST_P2M_SRCID_MASK          = ((1ULL<<SRCID_WIDTH)-1);
+    static const uint8_t  TEST_P2M_TEST_SHIFT          = 5;
+    static const uint64_t TEST_P2M_TEST_MASK           = 1;
+    static const uint8_t  TEST_P2M_SIGNATURE_SHIFT     = 0;
+    static const uint64_t TEST_P2M_SIGNATURE_MASK      = ((1ULL<<DATA_WIDTH)-1);
 
     static const uint8_t  M2P_TYPE_SHIFT               = 1;
@@ -234,6 +234,11 @@
     static const uint8_t  M2P_BC_SHIFT                 = 0;
     static const uint64_t M2P_BC_MASK                  = 1;
-    static const uint8_t  M2P_TEST_SHIFT               = 24;
-    static const uint64_t M2P_TEST_MASK                = 1;
+
+    static const uint8_t  TEST_M2P_DEST_SHIFT          = 25;
+    static const uint64_t TEST_M2P_DEST_MASK           = ((1ULL<<SRCID_WIDTH)-1);
+    static const uint8_t  TEST_M2P_TEST_SHIFT          = 24;
+    static const uint64_t TEST_M2P_TEST_MASK           = 1;
+    static const uint8_t  TEST_M2P_SIGNATURE_SHIFT     = 0;
+    static const uint64_t TEST_M2P_SIGNATURE_MASK      = ((1ULL<<(m2p_flit_width-1))-1);
 
     static const uint8_t  MULTI_INVAL_DEST_SHIFT       = 25;
@@ -281,4 +286,11 @@
     static const uint64_t CLACK_WAY_MASK               = ((1ULL<<WAY_INDEX_WIDTH)-1);
 
+    static const uint8_t  TEST_CLACK_DEST_SHIFT        = CLACK_DEST_SHIFT;
+    static const uint64_t TEST_CLACK_DEST_MASK         = CLACK_DEST_MASK;
+    static const uint8_t  TEST_CLACK_TEST_SHIFT        = 24;
+    static const uint64_t TEST_CLACK_TEST_MASK         = 1;
+    static const uint8_t  TEST_CLACK_SIGNATURE_SHIFT   = 0;
+    static const uint64_t TEST_CLACK_SIGNATURE_MASK    = ((1ULL<<(clack_flit_width-1))-1);
+
     /*
      * P2M command types
@@ -321,5 +333,4 @@
       P2M_EOP,
       P2M_BC,
-      P2M_TEST,
 
       CLEANUP_DEST,
@@ -332,13 +343,12 @@
       MULTI_ACK_UPDT_INDEX,
 
-      CC_TEST_DEST,
-      CC_TEST_SRCID,
-      CC_TEST_TEST,
-      CC_TEST_SIGNATURE,
+      TEST_P2M_DEST,
+      TEST_P2M_SRCID,
+      TEST_P2M_TEST,
+      TEST_P2M_SIGNATURE,
 
       M2P_TYPE,
       M2P_EOP,
       M2P_BC,
-      M2P_TEST,
 
       MULTI_INVAL_DEST,
@@ -355,4 +365,8 @@
       MULTI_UPDT_DATA,
 
+      TEST_M2P_DEST,
+      TEST_M2P_TEST,
+      TEST_M2P_SIGNATURE,
+
       CLACK_TYPE,
 
@@ -360,4 +374,8 @@
       CLACK_SET,
       CLACK_WAY,
+
+      TEST_CLACK_DEST,
+      TEST_CLACK_TEST,
+      TEST_CLACK_SIGNATURE,
 
       BROADCAST_BOX,
@@ -380,12 +398,11 @@
         GET_FIELD(flit,MULTI_ACK_DEST);
         GET_FIELD(flit,MULTI_ACK_UPDT_INDEX);
-        GET_FIELD(flit,CC_TEST_DEST);
-        GET_FIELD(flit,CC_TEST_SRCID);
-        GET_FIELD(flit,CC_TEST_TEST);
-        GET_FIELD(flit,CC_TEST_SIGNATURE);
+        GET_FIELD(flit,TEST_P2M_DEST);
+        GET_FIELD(flit,TEST_P2M_SRCID);
+        GET_FIELD(flit,TEST_P2M_TEST);
+        GET_FIELD(flit,TEST_P2M_SIGNATURE);
         GET_FIELD(flit,M2P_TYPE);
         GET_FIELD(flit,M2P_EOP);
         GET_FIELD(flit,M2P_BC);
-        GET_FIELD(flit,M2P_TEST);
         GET_FIELD(flit,MULTI_INVAL_DEST);
         GET_FIELD(flit,MULTI_INVAL_SRCID);
@@ -399,8 +416,14 @@
         GET_FIELD(flit,MULTI_UPDT_BE);
         GET_FIELD(flit,MULTI_UPDT_DATA);
+        GET_FIELD(flit,TEST_M2P_DEST);
+        GET_FIELD(flit,TEST_M2P_TEST);
+        GET_FIELD(flit,TEST_M2P_SIGNATURE);
         GET_FIELD(flit,CLACK_TYPE);
         GET_FIELD(flit,CLACK_DEST);
         GET_FIELD(flit,CLACK_SET);
         GET_FIELD(flit,CLACK_WAY);
+        GET_FIELD(flit,TEST_CLACK_DEST);
+        GET_FIELD(flit,TEST_CLACK_TEST);
+        GET_FIELD(flit,TEST_CLACK_SIGNATURE);
         GET_FIELD(flit,BROADCAST_BOX);
         GET_FIELD(flit,BROADCAST_SRCID);
@@ -425,12 +448,11 @@
         SET_FIELD(flit,value,MULTI_ACK_DEST);
         SET_FIELD(flit,value,MULTI_ACK_UPDT_INDEX);
-        SET_FIELD(flit,value,CC_TEST_DEST);
-        SET_FIELD(flit,value,CC_TEST_SRCID);
-        SET_FIELD(flit,value,CC_TEST_TEST);
-        SET_FIELD(flit,value,CC_TEST_SIGNATURE);
+        SET_FIELD(flit,value,TEST_P2M_DEST);
+        SET_FIELD(flit,value,TEST_P2M_SRCID);
+        SET_FIELD(flit,value,TEST_P2M_TEST);
+        SET_FIELD(flit,value,TEST_P2M_SIGNATURE);
         SET_FIELD(flit,value,M2P_TYPE);
         SET_FIELD(flit,value,M2P_EOP);
         SET_FIELD(flit,value,M2P_BC);
-        SET_FIELD(flit,value,M2P_TEST);
         SET_FIELD(flit,value,MULTI_INVAL_DEST);
         SET_FIELD(flit,value,MULTI_INVAL_SRCID);
@@ -444,8 +466,14 @@
         SET_FIELD(flit,value,MULTI_UPDT_BE);
         SET_FIELD(flit,value,MULTI_UPDT_DATA);
+        SET_FIELD(flit,value,TEST_M2P_DEST);
+        SET_FIELD(flit,value,TEST_M2P_TEST);
+        SET_FIELD(flit,value,TEST_M2P_SIGNATURE);
         SET_FIELD(flit,value,CLACK_TYPE);
         SET_FIELD(flit,value,CLACK_DEST);
         SET_FIELD(flit,value,CLACK_SET);
         SET_FIELD(flit,value,CLACK_WAY);
+        SET_FIELD(flit,value,TEST_CLACK_DEST);
+        SET_FIELD(flit,value,TEST_CLACK_TEST);
+        SET_FIELD(flit,value,TEST_CLACK_SIGNATURE);
         SET_FIELD(flit,value,BROADCAST_BOX);
         SET_FIELD(flit,value,BROADCAST_SRCID);
Index: /branches/reconfiguration/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h
===================================================================
--- /branches/reconfiguration/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h	(revision 868)
+++ /branches/reconfiguration/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h	(revision 869)
@@ -323,5 +323,7 @@
         CLEANUP_IVT_CLEAR,
         CLEANUP_WRITE_RSP,
-        CLEANUP_SEND_CLACK
+        CLEANUP_SEND_CLACK,
+        CLEANUP_TEST_HEADER,
+        CLEANUP_TEST_SIGNATURE
       };
 
Index: /branches/reconfiguration/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp
===================================================================
--- /branches/reconfiguration/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp	(revision 868)
+++ /branches/reconfiguration/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp	(revision 869)
@@ -281,5 +281,7 @@
         "CLEANUP_IVT_CLEAR",
         "CLEANUP_WRITE_RSP",
-        "CLEANUP_SEND_CLACK"
+        "CLEANUP_SEND_CLACK",
+        "CLEANUP_TEST_HEADER",
+        "CLEANUP_TEST_SIGNATURE"
     };
     const char *alloc_dir_fsm_str[] =
@@ -5307,4 +5309,10 @@
             case CLEANUP_IDLE: // Get first DSPIN flit of the CLEANUP command
             {
+                if (r_cc_test_to_cleanup_req.read())
+                {
+                    r_cleanup_fsm = CLEANUP_TEST_HEADER;
+                    break;
+                }
+
                 if (not m_cc_receive_to_cleanup_fifo.rok()) break;
 
@@ -5341,4 +5349,19 @@
                 }
 #endif
+                break;
+            }
+            ///////////////////////
+            case CLEANUP_TEST_HEADER:
+            {
+                if (not p_dspin_clack.read) break;
+                r_cleanup_fsm = CLEANUP_TEST_SIGNATURE;
+                break;
+            }
+            ///////////////////////
+            case CLEANUP_TEST_SIGNATURE:
+            {
+                if (not p_dspin_clack.read) break;
+                r_cc_test_to_cleanup_req = false;
+                r_cleanup_fsm = CLEANUP_IDLE;
                 break;
             }
@@ -6697,5 +6720,5 @@
                 uint32_t srcid = DspinDhccpParam::dspin_get(
                         m_cc_receive_to_cc_test_fifo.read(),
-                        DspinDhccpParam::CC_TEST_SRCID);
+                        DspinDhccpParam::TEST_P2M_SRCID);
 
                 cc_receive_to_cc_test_fifo_get = true;
@@ -7436,7 +7459,9 @@
                     DspinDhccpParam::dspin_get(
                             p_dspin_p2m.data.read(),
-                            DspinDhccpParam::CC_TEST_TEST);
-
-                if ((type == DspinDhccpParam::TYPE_TEST) and (test == 1))
+                            DspinDhccpParam::TEST_P2M_TEST);
+
+                // TODO: verify DEST field
+
+                if ((type == DspinDhccpParam::TYPE_TEST) and test)
                 {
                     r_cc_receive_fsm = CC_RECEIVE_TEST;
@@ -9571,9 +9596,9 @@
                 DspinDhccpParam::dspin_set(flit,
                         r_cc_test_srcid.read(),
-                        DspinDhccpParam::CC_TEST_DEST);
+                        DspinDhccpParam::TEST_M2P_DEST);
 
                 DspinDhccpParam::dspin_set(flit,
                         1ULL,
-                        DspinDhccpParam::CC_TEST_TEST);
+                        DspinDhccpParam::TEST_M2P_TEST);
 
                 // TODO: Send MemoryCache SRCID too ?
@@ -9586,11 +9611,14 @@
             case CC_SEND_TEST_SIGNATURE:
             {
+                uint64_t data =
+                    DspinDhccpParam::dspin_get(
+                            m_cc_receive_to_cc_test_fifo.read(),
+                            DspinDhccpParam::TEST_P2M_SIGNATURE);
+
+                uint64_t lsb = (uint64_t)data & ((1 << 7) - 1);
                 uint64_t flit = 0;
-                uint64_t data = (uint64_t)m_cc_receive_to_cc_test_fifo.read();
-                uint64_t lsb  = (uint64_t)m_cc_receive_to_cc_test_fifo.read() & ((1 << 7) - 1);
-
                 DspinDhccpParam::dspin_set(flit,
                         data | (lsb << 32),
-                        DspinDhccpParam::CC_TEST_SIGNATURE);
+                        DspinDhccpParam::TEST_M2P_SIGNATURE);
 
                 p_dspin_m2p.write = true;
@@ -9605,49 +9633,92 @@
         ////////////////////////////////////////////////////////////////////
 
-        if (r_cleanup_fsm.read() == CLEANUP_SEND_CLACK)
+        switch(r_cleanup_fsm.read())
         {
-            uint8_t cleanup_ack_type;
-            if (r_cleanup_inst.read())
-            {
-                cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_INST;
-            }
-            else
-            {
-                cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_DATA;
-            }
-
-            uint64_t flit = 0;
-            uint64_t dest = r_cleanup_srcid.read() <<
-                (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
-
-            DspinDhccpParam::dspin_set(
-                    flit,
-                    dest,
-                    DspinDhccpParam::CLACK_DEST);
-
-            DspinDhccpParam::dspin_set(
-                    flit,
-                    r_cleanup_nline.read(),
-                    DspinDhccpParam::CLACK_SET);
-
-            DspinDhccpParam::dspin_set(
-                    flit,
-                    r_cleanup_way_index.read(),
-                    DspinDhccpParam::CLACK_WAY);
-
-            DspinDhccpParam::dspin_set(
-                    flit,
-                    cleanup_ack_type,
-                    DspinDhccpParam::CLACK_TYPE);
-
-            p_dspin_clack.eop   = true;
-            p_dspin_clack.write = true;
-            p_dspin_clack.data  = flit;
-        }
-        else
-        {
-            p_dspin_clack.write = false;
-            p_dspin_clack.eop   = false;
-            p_dspin_clack.data  = 0;
+            case CLEANUP_SEND_CLACK:
+            {
+                uint8_t cleanup_ack_type;
+                if (r_cleanup_inst.read())
+                {
+                    cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_INST;
+                }
+                else
+                {
+                    cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_DATA;
+                }
+
+                uint64_t flit = 0;
+                uint64_t dest = r_cleanup_srcid.read() <<
+                    (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
+
+                DspinDhccpParam::dspin_set(
+                        flit,
+                        dest,
+                        DspinDhccpParam::CLACK_DEST);
+
+                DspinDhccpParam::dspin_set(
+                        flit,
+                        r_cleanup_nline.read(),
+                        DspinDhccpParam::CLACK_SET);
+
+                DspinDhccpParam::dspin_set(
+                        flit,
+                        r_cleanup_way_index.read(),
+                        DspinDhccpParam::CLACK_WAY);
+
+                DspinDhccpParam::dspin_set(
+                        flit,
+                        cleanup_ack_type,
+                        DspinDhccpParam::CLACK_TYPE);
+
+                p_dspin_clack.eop   = true;
+                p_dspin_clack.write = true;
+                p_dspin_clack.data  = flit;
+                break;
+            }
+            /////////////////////////////////////
+            case CLEANUP_TEST_HEADER:
+            {
+                uint64_t flit = 0;
+
+                DspinDhccpParam::dspin_set(flit,
+                        r_cc_test_srcid.read(),
+                        DspinDhccpParam::TEST_CLACK_DEST);
+
+                DspinDhccpParam::dspin_set(flit,
+                        1ULL,
+                        DspinDhccpParam::TEST_CLACK_TEST);
+
+                // TODO: Send MemoryCache SRCID too ?
+
+                p_dspin_clack.write = true;
+                p_dspin_clack.eop   = false;
+                p_dspin_clack.data  = flit;
+                break;
+            }
+            ////////////////////////////////////
+            case CLEANUP_TEST_SIGNATURE:
+            {
+                uint64_t data =
+                    DspinDhccpParam::dspin_get(
+                            m_cc_receive_to_cc_test_fifo.read(),
+                            DspinDhccpParam::TEST_P2M_SIGNATURE);
+
+                uint64_t lsb = (uint64_t)data & ((1 << 7) - 1);
+                uint64_t flit = 0;
+                DspinDhccpParam::dspin_set(flit,
+                        data | (lsb << 32),
+                        DspinDhccpParam::TEST_CLACK_SIGNATURE);
+
+                p_dspin_clack.write = true;
+                p_dspin_clack.eop   = true;
+                p_dspin_clack.data  = flit;
+                break;
+            }
+            ////////////////////////////////////
+            default:
+                p_dspin_clack.write = false;
+                p_dspin_clack.eop   = false;
+                p_dspin_clack.data  = 0;
+                break;
         }