Simplified streamer serial / ecc / parallel error interleaving.

Author: Maurus Item

Bender.lock

@@ -23,8 +23,8 @@ packages:
     dependencies:
     - common_cells
   common_cells:
-    revision: 0d67563b6b592549542544f1abc0f43e5d4ee8b4
-    version: 1.35.0
+    revision: be3866eb3ed5b8ac7bc9a9ec9f8ae86137cd0a45
+    version: 1.36.0
     source:
       Git: https://github.com/pulp-platform/common_cells.git
     dependencies:
@@ -61,7 +61,7 @@ packages:
     dependencies:
     - common_cells
   hci:
-    revision: bf6254a6242e9121b3aac9aca8b6aaac362d9b0d
+    revision: de933b19896d3c460dd321da7e9c44dedc4b9df1
     version: null
     source:
       Git: https://github.com/Lynx005F/hci.git

Bender.yml

@@ -24,7 +24,7 @@ package:
 dependencies:
   cv32e40p          : { git: "https://github.com/pulp-platform/cv32e40p.git"          , rev: "pulpissimo-v4.1.0"                      }
   hwpe-stream       : { git: "https://github.com/Lynx005F/hwpe-stream.git"            , rev: 51a29b653aba0a767a2539476cbbd0ea5f5199fe } # branch: itemm/redmule_features
-  hci               : { git: "https://github.com/Lynx005F/hci.git"                    , rev: bf6254a6242e9121b3aac9aca8b6aaac362d9b0d } # branch: itemm/redmule_features
+  hci               : { git: "https://github.com/Lynx005F/hci.git"                    , rev: de933b19896d3c460dd321da7e9c44dedc4b9df1 } # branch: itemm/redmule_features
   hwpe-ctrl         : { git: "https://github.com/Lynx005F/hwpe-ctrl.git"              , rev: a60a313715498d9542c2370ad7c18acdadc207b3 } # branch: itemm/regfile_parity
   fpnew             : { git: "https://github.com/pulp-platform/cvfpu.git"             , rev: "pulp-v0.1.3"                            }
   common_cells      : { git: "https://github.com/pulp-platform/common_cells.git"      , version: 1.21.0                               }

rtl/redmule_streamer.sv

@@ -114,29 +114,57 @@ localparam hci_size_parameter_t `HCI_SIZE_PARAM(no_ecc_tcdm) = '{
   EHW: DEFAULT_EHW
 };
 
+/*************************** Store Channel: Serial Detection ****************************/
+/* In redundant modes, every element is fetched and stored twice, after the whole       *
+ * it arrives here and we check that the two elements still are the same.               *
+ * this overlapps with the full replication of the data in fully redundant modes, which *
+ * then overlapps with ECC encode / decode                                              */
+
+if (SERIAL_REPLICATION) begin: gen_serial_fault_detection
+  logic [DW-1:0] data_out_d, data_out_q;
+  logic same_d, same_q;
+  logic data_transmitted;
+
+  assign data_transmitted = tcdm.req && tcdm.gnt && !tcdm.wen;
+  assign data_out_d[DW-1:0] = tcdm.data;
+
+  `FFL(data_out_q, data_out_d, data_transmitted, '0);
+
+  assign same_d = data_out_d == data_out_q;
+
+  `FFL(same_q, same_d, data_transmitted, '1);
+
+  assign serial_fault_o = ~same_d && ~same_q && data_transmitted;
+end else begin: gen_no_serial_fault_detection
+  assign serial_fault_o = 1'b0; 
+  // Since we want to be able to have a configuration where only serial detection is done
+  // We default to 0 here (Otherwise disabled redundancy -> assert fault for safety).
+end
+
+// TODO: Add Load / Store deduplication here
+
 /************************************** ECC Stage **************************************/
 /* If the interface from the cores has data ECC, we decode it here. All further error   *
  * protection is in time or with parity bits                                            */
 
 `HCI_INTF_EXPLICIT_WAIVE_ARRAY(ldst_tcdm, clk_i, 0:0, no_ecc_tcdm);
-errs_streamer_t ecc_errors;
 
 if (EW > 1) begin: gen_ecc_decode
   hci_ecc_enc #(
     .DW ( DW ),
     .`HCI_SIZE_PARAM(tcdm_target)    ( `HCI_SIZE_PARAM(no_ecc_tcdm) ),
     .`HCI_SIZE_PARAM(tcdm_initiator) ( `HCI_SIZE_PARAM(tcdm)        )
   ) i_ecc_enc (
-    .r_data_single_err_o ( ecc_errors.data_single_err ),
-    .r_data_multi_err_o  ( ecc_errors.data_multi_err  ),
-    .r_meta_single_err_o ( ecc_errors.meta_single_err ),
-    .r_meta_multi_err_o  ( ecc_errors.meta_multi_err  ),
-    .tcdm_target         ( ldst_tcdm[0]               ),
-    .tcdm_initiator      ( tcdm                       )
+    .r_data_single_err_o ( ecc_errors_o.data_single_err ),
+    .r_data_multi_err_o  ( ecc_errors_o.data_multi_err  ),
+    .r_meta_single_err_o ( ecc_errors_o.meta_single_err ),
+    .r_meta_multi_err_o  ( ecc_errors_o.meta_multi_err  ),
+    .tcdm_target         ( ldst_tcdm[0]                 ),
+    .tcdm_initiator      ( tcdm                         )
   );
 end else begin: gen_ecc_passthrough
   hci_core_assign i_ldst_assign ( .tcdm_target (ldst_tcdm [0]), .tcdm_initiator (tcdm) );
-  assign ecc_errors = '0;
+  assign ecc_errors_o = '0;
 end
 
 /********************************* Load / Store MUX *************************************/
@@ -182,35 +210,6 @@ redmule_streamout #(
   .flags_o      ( flags_o[0].z_stream_sink_flags )
 );
 
-/*************************** Store Channel: Serial Detection ****************************/
-/* In redundant modes, every element is fetched and stored twice, after the whole       *
- * it arrives here and we check that the two elements still are the same.               *
- * this overlapps with the full replication of the data in fully redundant modes, which *
- * then overlapps with ECC encode / decode                                              */
-
-// TODO: Make sure compiler can not move modules and place this before the split
-
-if (SERIAL_REPLICATION) begin: gen_serial_fault_detection
-  logic [DW-1:0] data_out_d, data_out_q;
-  logic same_d, same_q;
-  logic data_transmitted;
-
-  assign data_transmitted = virt_tcdm[1].req && virt_tcdm[1].gnt;
-  assign data_out_d[DW-1:0] = virt_tcdm[1].data;
-
-  `FFL(data_out_q, data_out_d, data_transmitted, '0);
-
-  assign same_d = data_out_d == data_out_q;
-
-  `FFL(same_q, same_d, data_transmitted, '1);
-
-  assign serial_fault_o = ~same_d && ~same_q && data_transmitted;
-end else begin: gen_no_serial_fault_detection
-  assign serial_fault_o = 1'b0; 
-  // Since we want to be able to have a configuration where only serial detection is done
-  // We default to 0 here (Otherwise disabled redundancy -> assert fault for safety).
-end
-
 /**************************************** Load Channel ****************************************/
 /* The load channel of the streamer connects the incoming TCDM interface to three different   *
  * stream interfaces: X stream (ID: 0), W stream (ID: 1), and Y stream (ID: 2). The load side *
@@ -307,7 +306,8 @@ if (REP > 1) begin: gen_streamer_ld_replica
 
   logic interface_hci_fault;
   hci_copy_sink # (
-    .COPY_TYPE ( hci_package::COPY )
+    .COPY_TYPE    ( hci_package::NO_ECC    ),
+    .COMPARE_TYPE ( hci_package::CTRL_ONLY )
   ) i_hci_copy_sink (
     .clk_i,
     .rst_ni,
@@ -318,27 +318,10 @@ if (REP > 1) begin: gen_streamer_ld_replica
 
   ////////////////////////////////////////////////////////////////////////////////////
   // ECC Encode / Decode
+  // We don not need to do anything in the replica as we do not hold data
 
   `HCI_INTF_EXPLICIT_WAIVE_ARRAY(ldst_tcdm_replica, clk_i, 0:0, no_ecc_tcdm);
-  errs_streamer_t ecc_errors_replica;
-
-  if (EW > 1) begin: gen_ecc_decode
-    hci_ecc_enc #(
-      .DW ( DW ),
-      .`HCI_SIZE_PARAM(tcdm_target)    ( `HCI_SIZE_PARAM(no_ecc_tcdm) ),
-      .`HCI_SIZE_PARAM(tcdm_initiator) ( `HCI_SIZE_PARAM(tcdm)        )
-    ) i_ecc_enc (
-      .r_data_single_err_o ( ecc_errors_replica.data_single_err ),
-      .r_data_multi_err_o  ( ecc_errors_replica.data_multi_err  ),
-      .r_meta_single_err_o ( ecc_errors_replica.meta_single_err ),
-      .r_meta_multi_err_o  ( ecc_errors_replica.meta_multi_err  ),
-      .tcdm_target         ( ldst_tcdm_replica[0]               ),
-      .tcdm_initiator      ( tcdm_replica                       )
-    );
-  end else begin: gen_ecc_passthrough
-    hci_core_assign i_ldst_assign ( .tcdm_target (ldst_tcdm_replica[0]), .tcdm_initiator (tcdm_replica) );
-    assign ecc_errors_replica = '0;
-  end
+  hci_core_assign i_ldst_assign ( .tcdm_target (ldst_tcdm_replica[0]), .tcdm_initiator (tcdm_replica) );
 
   ////////////////////////////////////////////////////////////////////////////////////
   // Load / Store MUX Replica
@@ -382,36 +365,10 @@ if (REP > 1) begin: gen_streamer_ld_replica
     .cast_i       ( cast[1]                        ),
     .dst_fmt_i    ( ctrl_i[1].output_cast_dst_fmt  ),
     .stream_i     ( z_stream_i_replica             ),
-    .source       ( virt_tcdm_ctrl_only            ),
+    .source       ( virt_tcdm_replica[1]           ),
     .flags_o      ( flags_o[1].z_stream_sink_flags )
   );
 
-  ////////////////////////////////////////////////////////////////////////////////////
-  // Store Channel Data Duplication
-  // Since we do not propperly cast in replica, use data from main
-  // It is protected temporally anyway. The rest we use from our replica.
-  logic z_hci_down_fault, z_hci_up_fault;
-
-  hci_copy_source# (
-    .COPY_TYPE ( hci_package::NO_ECC )
-  ) i_z_hci_copy_source (
-    .clk_i,
-    .rst_ni,
-    .tcdm_main ( virt_tcdm[1]         ),
-    .tcdm_copy ( virt_tcdm_replica[1] ),
-    .fault_o   ( z_hci_up_fault       )
-  );
-
-  hci_copy_sink # (
-    .COPY_TYPE ( hci_package::CTRL_ONLY )
-  ) i_z_hci_copy_sink (
-    .clk_i,
-    .rst_ni,
-    .tcdm_main ( virt_tcdm_replica[1] ),
-    .tcdm_copy ( virt_tcdm_ctrl_only  ),
-    .fault_o   ( z_hci_down_fault     )
-  );
-
   ////////////////////////////////////////////////////////////////////////////////////
   // Load Channel Replica
 
@@ -512,12 +469,10 @@ if (REP > 1) begin: gen_streamer_ld_replica
   logic flags_fault;
   assign flags_fault = flags_o[0] != flags_o[1];
 
-  assign parallel_fault_o = w_hci_fault | w_stream_fault | interface_hci_fault | flags_fault | z_hci_down_fault | z_hci_up_fault;
-  assign ecc_errors_o = ecc_errors | ecc_errors_replica;
+  assign parallel_fault_o = w_hci_fault | w_stream_fault | interface_hci_fault | flags_fault;
 
 end else begin
   assign parallel_fault_o = 1'b0;
-  assign ecc_errors_o = ecc_errors;
 end
 
 endmodule : redmule_streamer