example0_i-a_t-0.1.v
// if (cnt_err) begin
// escalate_err_o = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example1_i-a_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example2_i-a_t-0.1.v
// if (cnt_err)
// escalate_en_i = lc_ctrl_pkg::Off;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example3_i-a_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example4_i-a_t-0.1.v
// if (cnt_err) begin
// escalate_err_o = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example5_i-a_t-0.1.v
// if (cnt_err)
// escalate_en_i = lc_ctrl_pkg::Off;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example6_i-a_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example7_i-a_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example8_i-a_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example9_i-a_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example10_i-a_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example11_i-a_t-0.1.v
// if (cnt_err) begin
// escalate_err_o = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example12_i-a_t-0.1.v
// if (cnt_err) begin
// escalate_err_o = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example13_i-a_t-0.1.v
 if (cnt_err)
 escalate_en_i = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example14_i-a_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example15_i-a_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example16_i-a_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example17_i-a_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example18_i-a_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example19_i-a_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example0_i-a_t-0.3.v
// if (cnt_err) begin
// escalate_en_i = 1'b1;
// end else begin
// escalate_en_i = 1'b0;
// end
// end
// end

========================================================
example1_i-a_t-0.3.v
// if (cnt_err) escalate_en_i = 1'b1;
// end else begin
// escalate_en_i = 1'b0;
// end
// end
// end

========================================================
example2_i-a_t-0.3.v
// if (cnt_err)
// escalate_en_i = lc_ctrl_pkg::Off;
// end
// end
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//

========================================================
example3_i-a_t-0.3.v
// if (cnt_err) escalate_en_i = 1'b1;
// else escalate_en_i = 1'b0;
// end
// end

========================================================
example4_i-a_t-0.3.v
// if (cnt_err) begin
// escalate_err_o = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example5_i-a_t-0.3.v
 if (escalate_en_i != lc_ctrl_pkg::Off) begin
 escalate_en_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example6_i-a_t-0.3.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example7_i-a_t-0.3.v
// if (escalate_en_i == lc_ctrl_pkg::Off)
// escalate_en_i = lc_ctrl_pkg::Off;
// end
// else
// escalate_en_i = lc_ctrl_pkg::On;
// end
// end
// else begin
// escalate_en_i = lc_ctrl_pkg::On;
// end
// end
// end
// else begin
// escalate_en_i = lc_ctrl_pkg::On;
// end
// end

========================================================
example8_i-a_t-0.3.v
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
========================================================
example9_i-a_t-0.3.v
// if (cnt_err)
// escalate_err = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example10_i-a_t-0.3.v
 This is a temporary fix for the issue of escalation in the
 case of a locked-down partition.
 It is not clear if this is a real issue or not.
 It is likely that the issue is caused by the fact that
 the LOCKDOWN feature is not implemented in the FPGA.
 The real cause of the issue is unknown.
 Once the LOCKDOWN feature is implemented, the issue should
 be fixed.



















































========================================================
example11_i-a_t-0.3.v
 - if escalate_en_i is off, then we don't have to wait for any
 - error to occur to escalate.
 - if escalate_en_i is on, then we wait for the first error
 - to occur to escalate.
 - if no error has occured, then escalate_en_i will be forced
 - off.
 - if escalate_en_i is on, then we wait for the first error to
 - occur to escalate.
 - if no error has occured, then escalate_en_i will be forced
 - off.
 - if escalate_en_i is on, then we wait for the first error to
 - occur to escalate.
 - if no error has occured, then escalate_en_i will be forced
 - off.
 - if escalate_en_i is on, then we wait for the first
========================================================
example12_i-a_t-0.3.v
// if (cnt_err) begin
// if (cnt_err) begin
// escalate_err_o = 1'b1;
// end
// end
// end
// end
// end

========================================================
example13_i-a_t-0.3.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example14_i-a_t-0.3.v
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_err) begin
 end else if (cnt_
========================================================
example15_i-a_t-0.3.v
// if (cnt_err) begin
// escalate_en_i = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example16_i-a_t-0.3.v
// if (cnt_err)
// escalate_en_i = lc_ctrl_pkg::Off;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example17_i-a_t-0.3.v
// if (cnt_err) begin
// escalate_err_d = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example18_i-a_t-0.3.v
// if (cnt_err) escalate_err_o = 1'b1;
// end
// end
// end

========================================================
example19_i-a_t-0.3.v
// if (cnt_err)
// escalate_err_o = 1'b1;
// end
// end
// if (cnt_err)
// escalate_err_o = 1'b1;
// end
// end
// if (cnt_err)
// escalate_err_o = 1'b1;
// end
// end
// if (cnt_err)
// escalate_err_o = 1'b1;
// end
// end

========================================================
example0_i-a_t-0.5.v
// If the lc_ctrl_pkg is set to off, then we can safely assume that the
// escalate_en_i signal is also set to off, and thus there is no need
// to check for the cnt_err.
// However, the same is not true for the other lc_ctrl_pkg, e.g.
// lc_ctrl_pkg::LIMIT_EXCEED, which may be set to on.
// However, the escalate_en_i is set to off only if the lc_ctrl_pkg is set to
// off.
// Nevertheless, the cnt_err is always checked.
// end

========================================================
example1_i-a_t-0.5.v
// escalate_en_i = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example2_i-a_t-0.5.v
// if (cnt_err)
// escalate_err_e = 1'b1;
// end
// end
// if (cnt_err)
// escalate_err_e = 1'b1;
// end

========================================================
example3_i-a_t-0.5.v
// the escalate state is in the state machine.
// however, it is still possible to see the "escalate" error.
// if the state machine is in the escalate state, then no error should be
// reported.
// however, if the state machine is still in the "initial" state, then
// an error should be reported.
// however, if the state machine is in the idle state, then no error
// should be reported.
// however, if the state machine is in the error state, then an error
// should be reported.
// so, we only care about the error state.
// however, if the state machine is in the idle state, then no error
// should be reported.
// todo: need to check the other states as well.
// end

========================================================
example4_i-a_t-0.5.v
// whether to use escalate_en_i or lc_ctrl_pkg::Off
// is better to use escalate_en_i, otherwise use lc_ctrl_pkg::Off
// end
// end
// if (escalate_en_i != lc_ctrl_pkg::Off) begin
// if (cnt_err) begin
// escalate_en_i = lc_ctrl_pkg::Off;
// end
// end


========================================================
example5_i-a_t-0.5.v
// if (cnt_err) begin
// escalate_err_q = 1'b1;
// end
// end
// end
// end



========================================================
example6_i-a_t-0.5.v
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//

========================================================
example7_i-a_t-0.5.v
// ???
// if (cnt_err)
// escalate_en_i = lc_ctrl_pkg::Off;
// end
// else
// escalate_en_i = lc_ctrl_pkg::Off;
// end
// end
// end


========================================================
example8_i-a_t-0.5.v
 Whenever a write attempt to a memory word fails, the
 write operation has to be aborted.
 - The bit in the memory word that failed needs to be
 cleared.
 - In case of a write operation the word address
 needs to be preserved.
 - If the write operation is still in process, the
 operation has to be aborted and the memory word
 needs to be preserved.
 - The bit in the memory word that failed needs to
 be cleared.
 - In case of a write operation, the word address
 needs to be preserved.
 - The write operation might not have been started
 yet.
 - The write operation might not have been started
 yet.
 - The write operation might not have been started
 yet.
 - If a write operation is in process, the memory
 word needs to be preserved.
 - The write operation might
========================================================
example9_i-a_t-0.5.v
// - we should not be jumping to a different state if we have
// not yet reached the terminal error state.
// - If we have reached the terminal error state, we should
// be jumping to the terminal error state.
// - If we have not reached the terminal error state, we should
// be jumping to the idle state.
// - If we have reached the terminal error state, then we should
// be trying to recover the device if possible.
// - If we have not reached the terminal error state, then we
// should be trying to program the device.
//
// - We should not be jumping to the idle state if we have
// reached the terminal error state.
// - If we have not reached the terminal error state, we should
// be trying to program the device.
//
// - If we have reached the terminal error state, we should
// be trying to recover the device if possible.

========================================================
example10_i-a_t-0.5.v
 if (cnt_err) begin
 escalate_err = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 
========================================================
example11_i-a_t-0.5.v

 This is an attempt to fix a bug in the implementation of the
 security controller.

 See the comments in the security controller implementation for
 details.

 The implementation of the security controller is such that
 there is a single "global" esc-level which is used for
 all security controls. The individual security controls
 have their own individual esc-level.

 The problem with this implementation is that the individual
 security controls cannot be deactivated without also
 deactivating the "global" security level.

 For example, consider a security controller that has
 multiple security levels. The security levels are
 assigned to security control modules. The security
 control module of interest is assigned security level
 's' which is not equal to the global security level
 'g'.

 The security controller can be programmed to have
 security level
========================================================
example12_i-a_t-0.5.v
// if (cnt_err == 0 && escalate_en_i == 1) begin
// escalate_en_o = 1'b1;
// end
// end
// end
// end

========================================================
example13_i-a_t-0.5.v
// if (cnt_err) escalate_en_i = 1'b1;
// else escalate_en_i = 1'b0;
// end
// end

========================================================
example14_i-a_t-0.5.v
��仿真
启动状态转换
思路：1、关闭计时器
2、设置错误状态
3、锁存储器
4、设置计时器的计时状态
5、设置计时器的计时状态
6、设置计时器的计时脉冲
7、设置计时器的计时间
8、�
========================================================
example15_i-a_t-0.5.v
// This is necessary for the state machine to function correctly.
// This is a known problem of the current implementation.
// It will be fixed by the next release.
// end
// end

========================================================
example16_i-a_t-0.5.v
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//

========================================================
example17_i-a_t-0.5.v
// if (cnt_err)
// escalate_err_en_i = 1'b1;
// else escalate_err_en_i = 1'b0;
// end
// end
// end
// end
// end
// end
//////////////////////////////////////////////////////////////////////////////

========================================================
example18_i-a_t-0.5.v
// if (cnt_err)
// escalate_en_i = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example19_i-a_t-0.5.v
//��"Escalation"
//�"Escalation"
//�"Escalation"
//��"Escalation"
//�"Escalation"
//�"Escalation"
//�"Escalation"
//�"Escalation"
//��"Escalation"
//�"Escalation"
//��"Escalation"
//å"Escalation"
//å"Escalation"
//å"Escalation"
//å"Escalation"
//å"Escalation"
//å"Escalation"
//å"Escalation"
//å"Escalation"
//å"Escalation"
//å"Escalation"
//å"Escalation"
//å"Escalation"
//å"Escalation"
//å"Escalation"

========================================================
example0_i-a_t-0.7.v
// end else begin
// end
// end
// endfunction

========================================================
example1_i-a_t-0.7.v
 This could also be controlled by the escalation policy.
 - escalate_en_i = lc_ctrl_pkg::Off 
 - cnt_err = lc_ctrl_pkg:NumErrUnits => "true"









































































========================================================
example2_i-a_t-0.7.v
 the escalate line could be a bit wider.
 if escalate_en &= lc_ctrl_pkg.Off, then it become a wire
 which makes the line thinner.
 however escalate_en need to be wider, otherwise the line is
 thinner, and the line outside the box is not rendered.
 in the future, the escalate line will be inside the box.
 so the escalate line width must be wider, otherwise the line
 is thinner.
 the golden rule is: the line is inside the box and wide enough
 to fit the whole box.
 e.g. how to implement the golden rule?
 1. the line width must be wider than the box, so the line
 is inside the box.
 2. the line width must match the box, so the line is
 inside the box, and the width is wide enough to cover the
 whole box.
========================================================
example3_i-a_t-0.7.v
// if (cnt_err == 0 && escalate_en_i == 1)
// escalate_err_set_o <= 1;
// end
// end
//
//
//

========================================================
example4_i-a_t-0.7.v
//��仿照CR1.11
//e.g.escall
//显示错误信息，有时会导致进入terminal error
//显示错误信息，有时会导致进入terminal error
//显示错误信息，有时会导致进入terminal error

//错误信息，有时会导致进入terminal error
//显示错误信息，有时会导致进
========================================================
example5_i-a_t-0.7.v
//
`define SEC_CM_LCI_FSM_LOCAL_ESC_FSM_GLOBAL_ESC "Off" //
//
`define SEC_CM_LCI_FSM_LOCAL_ESC_FSM_GLOBAL_ESC_OFF "Off" //
//
`define SEC_CM_LCI_FSM_GLOBAL_ESC_FSM_GLOBAL_ESC_OFF "Off" //
//

========================================================
example6_i-a_t-0.7.v
// Nato TODO: Is it necessary to reinvert the current state?
// invert (state_q) ? nextState:ErrorSt;
// end

========================================================
example7_i-a_t-0.7.v
 One problem of the current architecture is that the LCE will be
 released while runtime error generated. We may encounter the problem
 that the system will be shut down in case of any runtime error. It
 is very hard to recover the system, and the only recovery method is
 to issue the hardware reset. So we have to avoid generating any
 runtime error to prevent the system to shut down as a result of
 the runtime error.
 The solution is to disable the lc_error_m event and
 generate an error code in the system.
 and re-enable the event when all the errors have been processed.
 Basically a system-wide error mechanism is needed.
 or more than one LCE active
 the lc_error_m event should be disabled to avoid
 lc_error_e generated by the active LCE.
 the error code stored in the system to indicate
========================================================
example8_i-a_t-0.7.v
 if (~cnt_err || escalate_en_i == lc_ctrl_pkg::Off) begin
�éֵ֣ɾֻ������޸�Ķ����ת���߳з�ֵ����������
 ���������Ķ�ȡ�ת���ߵ�Ľ����������ʽ�����ֺ�
 ���������Ķ�ȡ�ת���߼�Ľ����������ʽ�����ֺ�
 if (~cnt_err || escalate_en_i == lc_ctrl_pkg::Off) begin
��ֵָ����Ķ��Ľ������?����ĺ�λ��ش���ĺ�������������Һ�λ��ش���ĺ�λ������ݿ�λ��Ѻ�λ��
 �����ַ����
========================================================
example9_i-a_t-0.7.v
 akinamil
��をつける
�は書かれてまない
ケースも単純な静的メンテーストです
しかし
これより
このほうが
ってるってる
：：
ケース























































========================================================
example10_i-a_t-0.7.v
 Amtrak_A6.1.0_FINAL_RELEASE_115216:
 AM-Quirk:
 The following codes are expected to be removed:
 error_seg_latch_reset_d = 1'b1;
 error_seg_latch_reset_en = 1'b1;
 xerror_d = 1'b1;
 xerror_en = 1'b1;
 error_d = 1'b1;
 error_en = 1'b1;
 xerror_i = 1'b1;
 xerror_en = 1'b1;
 error_i = 1'b1;
 error_en = 1'b1;
 xerror_i = 1'b1;
 xerror_en = 1'b1;
 error_i = 1'
========================================================
example11_i-a_t-0.7.v
 a system needs to be able to reboot in case of a hardware error
 at least this way we prevent an error in the boot sequence
 we also allow the user to define the restart mode
 if this is not supported by the platform, then it's not too bad either
 todo:
 when starting with the error state, the system should be able to
 automatically restart after a certain amount of time.
 e.g. after a certain amount of time in suspend mode,
 the system should continue to suspend rather than restart.
 the time needs to be a configuration option
 but how should we keep track of the time, if we use the timer?
 we could use the time in the error state as a reference,
 but then we would need to know when the error state starts
 to determine whether we are about to exceed the restart time.
 or we could use the timer for other purposes
========================================================
example12_i-a_t-0.7.v
// wait 1 second for the last frame to get out
// before escalate.
// escalate_en_o = 1'b1;
// end
// end

//
========================================================
example13_i-a_t-0.7.v
��学重置Escalation.
显示Escalation信息，针对打开的服务，如按键。
显示Escalation信息，针对打开的服务，如状态。
显示Escalation信息，针对按键。
显示Escalation信息，针对按键。
提示：这类信息可以被用户使用。
�
========================================================
example14_i-a_t-0.7.v
 avoid the "unbalanced end" warning: the "Normal" state is not inside of an "
========================================================
example15_i-a_t-0.7.v
command_active_err_o = 1'b1;
//
========================================================
example16_i-a_t-0.7.v
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//

========================================================
example17_i-a_t-0.7.v
 - This is a workaround for an issue with certain conditions
 - where this logic may enter the error state before an error has
 - occurred. This can cause the code to enter the error state and
 - then throw a runtime exception.
 - This is NOT a hard-coded solution for any particular reason.
 - It may come from an issue with the C/C++ compiler.
 - It may be a configuration problem.
 - It is a way of working around the problem that people have
 - found takes advantage of the potential for future problems.
 - It is possible for an error to occur before we enter the error
 - state.
 - We may have a hard-coded solution for
 - this problem, but the problem may occur in other hard-coded
 - configurations.
 - Either way, the problem should be fixed, but for this particular
 - case, we are
========================================================
example18_i-a_t-0.7.v
// todo: if escalate_en_i is off and we had an error, we have to reset it.
// else we would try to escalate again and have the issue of an error
// in the middle of the escalation process.
// optimizing: if escalate_en_i is off and we had an error, reset cnt_err.
// end
// end
// else
// if escalate_en_i is on or we did not have an error, proceed with error recovery.
// else
// if escalate_en_i is on and we had an error, we have to reset cnt_err.
// else
// if escalate_en_i is off and we had an error, we have to keep cnt_err.
// end

========================================================
example19_i-a_t-0.7.v
Interestingly, this line can also be used as a regular expression,
it seems to be too complex for regular expressions.
�� vé vé vé
�� vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé
�î ëõ vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé
êõ vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé vé
êõ vé vé vé vé vé vé vé vé
========================================================
example0_i-a_t-0.9.v
// if (!cnt_err) escalate_en_i = lc_ctrl_pkg::Off;
ifjump (TerminalError)
escapemem_inject_i: 1'b1
reg brk_i;
always @ (posedge clk_i)
module brkp
(
);

========================================================
example1_i-a_t-0.9.v
// incoming escalate_en => ON will be passed on WD_EST if isn't explicitly off,
// so it should be ignored.
// however, need to have some kind of relationship anyway if sec module takes over
// and assumes escalate_en is OFF even if it is already on.
// on the other hand, state is kept in register, so has to be honored. need
// to dig into the state register, and figure out whether a ready input can be passed.
// on the other hand, it should be sticky. of course, escalation_fsm is unsafe.
// probably only need to filter on rising/falling of links. initiate for now to be on safe.
// next: consider requiring an external control instead of handling escalation all together.
// end

========================================================
example2_i-a_t-0.9.v
//lahomaif then at the very last word having any programming error,
// we need to keep the status just as at ERROR state so no need to
// escalate, simply pass the flag back to oFsm on the last processed word
// alert in this state
onewithlinebreak(
"`define ERROR_CHECK"
onerrlbel(TestErrorIn, TestErrorInComment",
"`h1. Hardware Error Detected"
"`h3. Terminating Program Dererctive for coversing HARD ESSENTIAL ERROR'S"
"@LHelp2;1,1":
"Verification is not possible for this packaging description.");
//Line 19: if (error_i#>"MS/Error")
"`h1. Hardware Error Detected"
"@LHelp2;1,1":
"Verification is not possible for this packaging description.");
//Line 24: if
========================================================
example3_i-a_t-0.9.v
// Not having a copy of fsm.gl yet, unknowingly brought a lot of dead code here. This
// needs to be fixed when copying to HPS.
// FIX:
// Need a test with harp quick stack.
// exp. fsm.ac:760 version:11.0 snapshot:Thu Nov 12 11:00:26 2022
// exp. fsm.c: 1863 src.zip:11.0
// ERROR: exp.fsm.al: Noticed erronous "always @(.*....)"
// exp.fsm.al: INCOMPAT_DC_HAZARD: mistakenly disabled pure pure in AC condition--an ideal AC hazard
// exp.fsm.al: INCOMPAT_DC_HAZARD: feature test mode and Optie21/oper are not compatable
always @(q) begin
case ( q )
errorc:	if ($time
========================================================
example4_i-a_t-0.9.v
�§原
박준정점-HTML
코렉스
- LCD 에 포함되는 테스트

다시 step들어측

spi_if spi_if spi_if spi_if spi_if spi_if spi_if spi_if spi_if

1-1;2
1-11;2-2;3

LS#+
308;1-1;2-1;3-1

1-1
1-3

$o
s\ls/NN/min/R/P
3;1-1;2-1

$o
s\ls/NN/min/R/P/
========================================================
example5_i-a_t-0.9.v
 verilator seems to have a problem capturing the first
 statement in a generate block. It behaves as if it never
 saw the generate block at all. I wrap the generate
 block with it due to this bug.
 You can work around the problem by
 using the {/*...*/"..."} catch. See
 cw11_disk.vpr
 verilator bug: https:www.verilator.org/projects/verilator-trunk/repository/verilator-trunk-beta19/vphaserver/exec.v
 verilator bug: https:www.verilator.org/projects/verilator-trunk-beta6/verilator-trunk-beta6-webrc/vphaserver/vphaserver_vfs.v
 vphaserver_vfs := got this, but vphaserver
========================================================
example6_i-a_t-0.9.v
// nothing should be done, if possible, while erasing
// because it will abort erase operation and
// some already done erase cycle will be lost

========================================================
example7_i-a_t-0.9.v
//
//
//
// Not sure if we should be throwing an error, we
// make the assignment exception something and
// se details as an internal error. However a catch
// on that exception means
// wrong behaviour, and since ever escalate
// to a software exception we should probably choose
// the users fault over some internal error.
//
// Not sure if we should be throwing an exception.
//
//
//
// I am aware not throwing an exception instead of
// using single support and defaulting logic
//
//
// However I am also wondering how the LCI can
// throw an E error. So is this valid or
// should it default and escalate on lights instead
// of using single for the entire system.
//
`define LARGE_ESC_BEHAVIOR
//`define VENDOR_DELEGAT
//`include "app_util.v"

========================================================
example8_i-a_t-0.9.v
// newsletter_241//issues/227
// XXX see rant about flash alignment bug


// To avoid duplicating the MAP and REG init code, we are
// using a default Task up to wait on the fsm transition
// and then assigning it the correct one.
//
// `defineTask upvars_default`[0] (priv_reg_assign);
//
// `deftype normalize_control do_upvars;
//
`define task upvars_default 0 ((cnt == LastLcOtpTag[3:0] || msk_r_so_no_cp_m) ? wait_on_fsm_trans : 1);
//
// module `normalize_control
// (
// `dbg_module_name
// (ifdef)
// `macro_name
// (ifdef)
// `macro_name
========================================================
example9_i-a_t-0.9.v
ernaut if (cnt_err) begin
��:原和("loci_if")是HSI存在共否安被其他項"loci_if"生成"on"原自禁止折顯
士：別"on"件是个我已知"loci_if"是"on"也没有I/F环中的方言"機既沒有啲詰
當"lebla.lebla"建端的本項"loci_if"沒有引試環值完全，"lebla
========================================================
example10_i-a_t-0.9.v
//SEU epoch: HW/Task_MC.v, SM_UC.v
ESSUNTERM=11;//harder term cnto bc of fsm state mapping
assign escalate_err = (cnt_err_s_r != 0) && (cnt_err > ESSUNTERM);
assign escalate_mode_req = (cnt_mode_s_r != 0) && (cnt_mode > EUPSONTERM);
assign escalate_power_req = (cnt_pow_s_r != 0) && (cnt_pow > EUPSONTERM);
assign escalate_torch_req = (cnt_torch_s_r != 0) && (cnt_torch > EUPSONTERM);
assign lc_ctrl_local = (escalate_err || escalate_mode_req ||
========================================================
example11_i-a_t-0.9.v
// The pending broadcasts should be carried out when coming out of
// the Kinllevent Error.
// 2007-10-17
//	 pre-vendor version states
lookahead:
errorstate_d: begin
��orted_d = 1'b1;
hibitseq_d = 1'b1;
╾synstate_d = IdleSt;
╽onCycle = 1'b1;
syn_error_d = 1'b1;
// let seq = 1'b0;
// maybe some broadcast has been delayed
// might be a better way to prevent this?
// but the drivers may be HW writable and not SW so.
syn_bcready_d = 1'b1;
mtrgo_0_d = 1'b0;
mtrtake_0_d = 1'b0;
// just broadcast out
syn
========================================================
example12_i-a_t-0.9.v
//somehow know if it was write and thus latecancel during escalte
//if (state_d == WriteSt)
//somehow get the data and timeout error out
//and then allow the write to go through
//ardo: should timeout allow write to happen?

========================================================
example13_i-a_t-0.9.v
 inadvertently set escalate_en_i to Off
 inadvertently set escalate_en_i to Off
 the poor Programmer...
 ... will live in the korona by default
 ... and will ONLY be allowed into the plug to increase the chance of security violations
 it shall take pleasure in making its mark on a special "unplug-able" board in case of security-violation
 in some tests, the unplug-able boards have more chances to do a running security violations
 thus, this board, as the normal board one, shall have the possibility to be plugged into the client
 (as a normal board, it of course part of a machine, thus a tangible security feature).
 note: this will implicate, on the hardware level, that the various solders cannot be physically modified
 one special board can therefore be used to "connect" all the affected boards
 we therefore do plan to lau
========================================================
example14_i-a_t-0.9.v
// a) even if escalate_en_i == 1, we still
// allow the single-step operation to proceed. b)
// while escalate_en_i == 1 and step_en == 1, we don't
// allow programming to proceed.
// vocals:
// i) escalate_en_i=1 and N=1, the result is
// the address leap which is set by the oop-variant,
// and the self-write is carried out.
athon_error_d = 1'b1;
�ayersession_err = 1'b1;
�ilesession_err = 1'b1;
�stagepack_err = 1'b1;
document_ie = 1'b1;
//// TODO bounds
/////////
`include "../../../FPGA-Venus/testbench/include.v"

// Terminate the simulation if any
========================================================
example15_i-a_t-0.9.v
// end
// elseଌ
// end

// SEC_CM: 힀컨벤카게라어오도매참?
// SEC_CM: 게라어오도매참? do nothing.


========================================================
example16_i-a_t-0.9.v
//asons why devs will raise BUG when
//a)escalation of any 500/500 type is done and local/global error
//b)local/global error is been marked
//cmd:led_go,led_gr_i,led_gr_r,led_go_r 
//the-merlin-issue-1-python-quirk-is-causing-w605-submission-is-passing
//conducting-tests-with-weight-passes-test-artifacts-run-mhc
//An assignment is holding an issue. Once the assignment is resolved, the mhc is able to carry out the test from the start of the phase.
//I am made a decision. my decision is to ignore the state machine and just hard-code the mea at force rst and half cycle rst to IR.
//I am not completely satisfied with this decision.

========================================================
example17_i-a_t-0.9.v
 According to the PMC documentation some error codes are invalid!
 Unfortunately there is a compression mechanism that just kills some of the
 illegals - this is mainly gonna get pneumonados the next field. Problem
 is that we cannot capture these and many simply mismatch the codes in
 the generic layers.
 There is no nice solution that would allow us to code them as well
 ....transmission of data from kernel rude behaviour. I known it and it has
 caused thru happenlein, but this will not cause the kernel to die right
 away. In addition I think, this scheme needs some verification and thought
 wrt to the difference between how it works on the real FPGA and edge
 FPA.
 So as always I want to see the "kill everything" solution coming....
 i.e. - terminate the whole kernel like in those corrupt pipe instances
 - oh please the fix of the
========================================================
example18_i-a_t-0.9.v
 when escalate_en_i / ADB.SETI drops to 0, then ACK is set to off, CNT_ERR is cleared.
 however CNT_ERR has an outstanding value on CNT_ERR load packet.
 it turns out if AVDBUSERR is received and this happens to arrive after the halt condition for the A and D backpressure,
 we will try to write to an adapter that has no drive, leading to adapter lock-up.
 implementation then looks in terms of what ACK means vs. what BCID (or block) means.
 if it is post-zero and the last one, then we issue an interrupt.
 LOOK at WAITPKT/PCI scratch pad to see if we can recover here.

 also added in Interrupt writing:
 ERROR_LOCK_MARKER.
 we still get the latching error
========================================================
example19_i-a_t-0.9.v
// errata 385 - PERFORM PARITY CHECKING ONLY ON ERROR FREE OUTPUTS
// The test of `cnt_err` guarantees that the only error-free
// outputs of the core are either single-bit or two-bit types.
// All outputs that are multi-bit pair-typed, and single bit
// in their given package needs to be paired properly in
// Supervision document. To avoid partner identification,
// all single bit outputs are renumbered from 0 to 15.
// The exception of ADC operation is addressed separately.
// In the case of ADC operation, at least three bit values
// have to be paired together as per the standard, and
// the IDIC operation section #8 needs to be (re)merked to
// support the operation (3 bit output updated by IDIC#8).
errata 385:
// Test case: replicate issue
// "Viaccue error during
========================================================
example0_i-b_t-0.1.v
 This is a workaround for a bug in the current implementation of the
 lc_ctrl_pkg.v module. The implementation of the lc_ctrl_pkg
 module does not properly handle the case where the lc_ctrl_pkg
 is turned off and the lc_ctrl_pkg is still in the Error state.
 This is a known issue and will be fixed in the next release.

 The following implementation of the lc_ctrl_pkg module will
 properly handle the case where the lc_ctrl_pkg is turned off.

 Note: the implementation of the lc_ctrl_pkg module is not
 currently available in the current implementation of the
 lc_controller module.

 Note: the implementation of the lc_ctrl_pkg module is not
 currently available in the current implementation of the
 lc_controller module.

========================================================
example1_i-b_t-0.1.v
 This is a workaround for the current implementation of the
 security controller. The security controller is not able to
 escalate to the global error state.

 The security controller will be modified to allow escalation
 to the global error state.

 The security controller will also be modified to allow
 escalation to the global error state even if the local
 error state is already reached.

 The security controller will also be modified to allow
 escalation to the global error state even if the local
 error state is already reached.

 The security controller will also be modified to allow
 escalation to the global error state even if the local
 error state is already reached.

 The security controller will also be modified to allow
 escalation to the global error state even if the local
 error state is already reached.

 The security controller will also be modified to allow

========================================================
example2_i-b_t-0.1.v
 This is a workaround for a problem with the current implementation
 of the FSM. The problem is that the FSM is not able to
 handle the situation where a state is reached by more than one
 path. The consequence of this is that the FSM may not
 correctly detect the situation where the state is reached by
 two paths.

 The problem is that the FSM is implemented as a state
 machine with the ability to detect the presence of a
 "loop" in the state machine. The "loop" is a situation
 where the state machine is in one of the states that
 is reachable by more than one path.

 The workaround is to use the "loop" flag to indicate
 that the state machine has detected a loop.

 The problem is that the implementation of the FSM
 is not able to detect the presence of a "loop"
========================================================
example3_i-b_t-0.1.v
 This is a workaround for a known issue in the current implementation
 of the FSM. The issue is that the FSM will not properly handle
 the situation where the escalation is performed and the system
 is in a state that is not allowed to escalate.
 The issue is that the FSM will not properly handle the situation
 where the system is in a state that is not allowed to escalate.
 In this case, the system will attempt to escalate to the
 next state, which is not allowed to escalate. This results
 in an incorrect state transition and the system will then
 attempt to transition to the incorrect state.

 This is a known issue in the current implementation of the FSM
 and will be fixed in the next release.

 The workaround is to ensure that the system will always transition
 to the next state if the current state is not allowed to escalate.


========================================================
example4_i-b_t-0.1.v
 This is a workaround for a problem in the current implementation
 of the FSM. The problem is that the FSM is not able to
 handle the situation where the escalation is performed and
 the system is in a state where the system is expected to
 be in a state where the system is in a state where the
 system is in a state where the system is in a state where
 the system is in a state where the system is in a state
 where the system is in a state where the system is in
 a state where the system is in a state where the system
 is in a state where the system is in a state where the
 system is in a state where the system is in a state where
 the system is in a state where the system is in a state
 where the system is in a state where the system is in
 a state where the system is in a state where the
========================================================
example5_i-b_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example6_i-b_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example7_i-b_t-0.1.v
 This is a workaround for the current implementation of the
 security controller. The security controller is not able to
 escalate to the global error state.
 Once the security controller is fixed, the escalate_en_i
 can be removed.
 However, the security controller is not able to escalate
 to the global error state.
 Furthermore, the security controller is not able to
 escalate to the local error state.
 Therefore, we have to use the global error state as
 a fallback.
 Furthermore, the security controller is not able to
 escalate to the local error state.
 Therefore, we have to use the global error state as
 a fallback.
 Furthermore, the security controller is not able to
 escalate to the local error state.
 Therefore, we have to use the global error state as
 a fallback.
 Furthermore, the security controller is not able
========================================================
example8_i-b_t-0.1.v
 This is a workaround for a bug in the current implementation.
 The current implementation does not allow to escalate to the
 global error state. This is a problem for the current implementation
 of the FSM.
 The current implementation of the FSM is such that the global
 error state is always the same as the local error state.
 The implementation of the FSM is such that the global error state
 is only used to detect if the local error state is equal to the
 global error state. If the local error state is equal to the
 global error state, then the global error state is set to the
 local error state.
 The current implementation of the FSM is such that the global
 error state is always equal to the local error state. This is
 the case if the local error state is equal to the global error
 state.
 The implementation of the FSM is such that
========================================================
example9_i-b_t-0.1.v
 This is a workaround for a problem in the current implementation
 of the FSM. The problem is that the FSM is not able to
 handle the escalation of the state machine.
 The solution is to use the state machine as a "wrapper"
 for the FSM.
 The current implementation of the FSM will not allow
 the escalation of the state machine.
 The solution is to use the state machine as a wrapper
 for the FSM.
 The wrapper will be able to handle the escalation.
 The wrapper will be able to return the current state
 of the FSM.
 The wrapper will be able to return the next state of the FSM.
 The wrapper will be able to return the current state of the FSM.
 The wrapper will be able to return the next state of the FSM.
 The wrapper will be able to return the current state of the F
========================================================
example10_i-b_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example11_i-b_t-0.1.v
 This is a workaround for the issue that the escalation
 does not lead to a fatal error.
 The issue is that the escalation is not considered
 as a real error, and thus the error recovery mechanism
 is not able to handle it.
 The solution is to set the error state to a special
 state which is not considered as a real error.
 This is done by the "escalate_err_en" flag.
 The error recovery mechanism will then treat this special
 state as a real error, which will lead to a fatal error.
 The issue is that the error recovery mechanism will not
 be able to handle the escalation.
 The solution is to set the error state to a special state
 which is not considered as a real error.
 The error recovery mechanism will then treat this special
 state as a real error, which will lead to a fatal error.
 The issue
========================================================
example12_i-b_t-0.1.v
 This is a workaround for the current implementation of the
 lc_ctrl_pkg.v module.
 It is not possible to have a single bit in the control
 package which is both a global and local control.
 This is a temporary solution which will be removed
 in the near future.

 This is a workaround for the current implementation of the
 lc_ctrl_pkg.v module. It is not possible to have a single
 bit in the control package which is both a global and local
 control. This is a temporary solution which will be removed
 in the near future.

 This is a workaround for the current implementation of the
 lc_ctrl_pkg.v module. It is not possible to have a single
 bit in the control package which is both a global and local
 control. This is a temporary solution which will be removed
 in the
========================================================
example13_i-b_t-0.1.v
 This is a temporary fix for the issue of escalation leading to
 a non-fatal error.
 The issue is that the escalation is not properly handled in the
 FSM. The FSM will not escalate properly, and will instead
 attempt to recover from the error.
 The issue is that the recovery mechanism is not implemented
 in the FSM.
 The issue is that the recovery mechanism is not implemented
 in the FSM.
 The issue is that the recovery mechanism is not implemented
 in the FSM.
 The issue is that the recovery mechanism is not implemented
 in the FSM.
 The issue is that the recovery mechanism is not implemented
 in the FSM.
 The issue is that the recovery mechanism is not implemented
 in the FSM.
 The issue is that the recovery mechanism is not implemented
 in the FSM.
 The issue is that
========================================================
example14_i-b_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example15_i-b_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example16_i-b_t-0.1.v
 This is a workaround for the current implementation of the
 lc_ctrl_pkg.v module.
 The current implementation of the lc_ctrl_pkg.v module
 does not allow to escalate to the global error state.
 This is a temporary solution for the current implementation
 of the lc_ctrl_pkg.v module.
 Once the implementation of the lc_ctrl_pkg.v module
 is fixed, this workaround can be removed.

 if (cnt_err) begin

 escalate_en_i = lc_ctrl_pkg::Off;

 end

 if (escalate_en_i != lc_ctrl_pkg::Off) begin

 escalate_en_i = lc_ctrl_pkg::Off;

 end

 if (escalate_en_i !=
========================================================
example17_i-b_t-0.1.v
 This is a workaround for a problem in the LCE/FSM.
 The problem is that the FSM is not properly reset when
 the LCE is deactivated. This causes the FSM to
 continue to operate on the last active LCE.
 This causes the FSM to attempt to access the LCE
 that is currently deactivated.
 The solution is to reset the FSM when the LCE is
 deactivated.
 However, this causes a problem with the LCE/FSM
 synchronization. The LCE/FSM synchronization needs
 to be disabled when the LCE is deactivated.
 The workaround is to disable the LCE/FSM synchronization
 when the LCE is deactivated.
 However, this causes a problem with the LCE/FSM
 synchronization. The LCE/FSM synchronization needs
 to be disabled when the LCE is
========================================================
example18_i-b_t-0.1.v
 This is a workaround for a problem in the current implementation.
 The escalation is not properly handled.
 The current implementation will lead to a situation where the
 escalation will be handled, but the system will fail to boot.
 This is a workaround for the problem that the implementation
 will lead to a situation where the system will boot, but
 the system will then fail to boot.
 The problem is that the escalation is not handled correctly.
 The escalation will be handled, but the system will fail to boot.
 This is a workaround for the problem that the implementation
 will lead to a situation where the system will boot, but
 the system will then fail to boot.
 The problem is that the system will boot, but the system
 will then fail to boot.
 The problem is that the system will boot, but the system
 will then fail to boot.
 The problem is that
========================================================
example19_i-b_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example0_i-b_t-0.3.v
// if (cnt_err)
// escalate_err = 1'b1;
// end
// end
// end



========================================================
example1_i-b_t-0.3.v
// if (cnt_err)
// escalate_err_o = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end


========================================================
example2_i-b_t-0.3.v
 This is a workaround for a potential race condition.
 The state machine is in a critical section and the
 output flop is in a critical section.
 The flop is not in a critical section, but it is
 expected to be in a critical section at the end of
 the critical section.
 The flop is not in a critical section, but it is
 expected to be in a critical section at the end of
 the critical section.
 The flop is not in a critical section, but it is
 expected to be in a critical section at the end of
 the critical section.
 The flop is not in a critical section, but it is
 expected to be in a critical section at the end of
 the critical section.
 The flop is not in a critical section, but it is
 expected to be in a critical section at the end of

========================================================
example3_i-b_t-0.3.v
 This is a temporary fix for the issue that escalation
 does not lead to a fatal error.
 This is a temporary fix for the issue that escalation
 does not lead to a fatal error.
 This is a temporary fix for the issue that escalation
 does not lead to a fatal error.
 This is a temporary fix for the issue that escalation
 does not lead to a fatal error.
 This is a temporary fix for the issue that escalation
 does not lead to a fatal error.
 This is a temporary fix for the issue that escalation
 does not lead to a fatal error.
 This is a temporary fix for the issue that escalation
 does not lead to a fatal error.
 This is a temporary fix for the issue that escalation
 does not lead to a fatal error.
 This is a temporary fix for the issue that escalation
 does not lead to a fatal error.
 This
========================================================
example4_i-b_t-0.3.v
 This is a workaround for the current implementation of the
 FSM. It is possible to escalate to the global level,
 but the implementation is such that the state machine
 will not be initialized.

 A possible solution is to have the FSM initialize
 the global level, but this is not the current
 implementation.

 A possible solution is to have the FSM initialize
 the global level, but this is not the current
 implementation.

 A possible solution is to have the FSM initialize
 the global level, and then have the FSM escalate
 to the global level. However, this is not the
 current implementation.

 A possible solution is to have the FSM initialize
 the global level, and then have the FSM escalate
 to the global level. However, this is not the
 current implementation.

 A possible
========================================================
example5_i-b_t-0.3.v
 the state machine is in an error state, but we do not know if it is
 a fatal error.
 we need to check if the error is a fatal error.
 if the error is a fatal error, we need to escalate.
 if the error is not a fatal error, we need to return to idle.

 we need to check if the error is a fatal error.
 if the error is a fatal error, we need to escalate.
 if the error is not a fatal error, we need to return to idle.

 we need to check if the error is a fatal error.
 if the error is a fatal error, we need to escalate.
 if the error is not a fatal error, we need to return to idle.

 we need to check if the error is a fatal error.
 if the error is a fatal error, we need to escalate.
========================================================
example6_i-b_t-0.3.v
 if escalate_en_i is set, we have to assume that the
 system is in an error state. This is required for the
 security system to work.
 However, we do not want to see the error state as the
 system is in an error state.
 Therefore, we do not allow the system to enter the
 error state until we see the first error code.
 Otherwise, we may see the system in an error state
 while it is in fact in a normal operation state.
 Therefore, we only allow the system to enter the
 error state if the first error code is seen.
 Furthermore, we do not allow the system to enter the
 error state if the first error code is a non-fatal
 error code.

 if (cnt_err) begin

 FIX:
 if the system is in an error state, we do
========================================================
example7_i-b_t-0.3.v
 This is a work around for the issue that the escalation is not
 properly handled.
 We have to use the global escalation for the time being.
 Eventually, the escalation should be handled by the FSM.
 This is a temporary solution.
 If the escalation is not enabled, we have to use the global
 escalation.
 Otherwise, we have to use the local escalation.
 We have to use the local escalation because we have
 to escalate the local error code.
 We have to use the global escalation because we have
 to escalate the global error code.
 If the escalation is not enabled, we have to use the global
 escalation.
 Otherwise, we have to use the local escalation.
 We have to use the local escalation because we have
 to escalate the local error code.
 We have to use the global escalation because we have
 to escalate the global error code
========================================================
example8_i-b_t-0.3.v
// if (cnt_err) begin
// escalate_err_o = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example9_i-b_t-0.3.v
// This is a workaround for the current implementation of the
// lc_ctrl_pkg.v module.
// The current implementation of the module does not support
// a "Off" mode, so we have to use the "Off" mode as a
// fallback.
// However, the "Off" mode is not intended to be used as
// a "stand-alone" control mode, so we have to use the
// "Off" mode as a fallback only.
// Once the current implementation is fixed, this can be
// removed.
// if (cnt_err)
// escalate_en_i = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example10_i-b_t-0.3.v
 This is a workaround for a bug in the LCE.
 The LCE cannot handle the escalation properly.
 This is a temporary solution until the problem is fixed.
 However, the bug does not cause any harm.
 Therefore, we are trying to fix the bug.
 The bug is caused by a race condition between the
 escalation and the LCE.
 The race condition is caused by the LCE and the
 escalation.
 The fix is to make the LCE wait until the
 escalation is done before it starts.
 The bug is caused by the LCE not waiting for the
 escalation to finish before it starts.
 The fix is to make the LCE wait until the
 escalation is done before it starts.
 The bug is caused by the LCE not waiting for the
 escalation to finish before it starts.
 The fix is to make the LCE wait until
========================================================
example11_i-b_t-0.3.v
 The issue is that the escalation is not considered
 in the same cycle as the error.
 This is a problem for the current implementation
 of the FSM.

 The solution is to have the escalation
 be a separate cycle from the error.

 The problem is that the error is only
 generated when the escalation is done.

 The solution is to have the escalation
 be a separate cycle from the normal
 cycle of the FSM.

 The problem is that the error is only
 generated when the escalation is done.

 The solution is to have the escalation
 be a separate cycle from the normal
 cycle of the FSM.

 The problem is that the escalation
 is not considered in the same cycle
 as the error.

 The solution is to have the escalation
 be a separate cycle from the
========================================================
example12_i-b_t-0.3.v
 This is a workaround for a bug in the implementation of the
 lc_ctrl_pkg.v module. The implementation is such that the
 escalate_en signal is always active high. This is a problem if
 the escalate_en signal is generated by a different process than
 the one which is controlling the LUT. In this case, the
 escalate_en signal is generated by the lc_ctrl_pkg module,
 whereas the escalate_en signal is generated by the lc_ctrl_pkg
 module. This results in a violation of the lc_ctrl_pkg
 module's internal state machine.

 The workaround is to generate the escalate_en signal by the
 lc_ctrl_pkg module.

 Note: this is not a problem in the current implementation of the
 lc_ctrl_pkg module. However, this may become a problem in the
========================================================
example13_i-b_t-0.3.v
// This is a temporary fix for the issue of escalation
// leading to a fatal error.
// The issue is that the last L/C word is
// not programmed correctly.
// The fix is to make sure that the last
// L/C word is programmed correctly.
// This is a temporary fix for the issue of escalation
// leading to a fatal error.
// The issue is that the last L/C word is
// not programmed correctly.
// The fix is to make sure that the last
// L/C word is programmed correctly.
// This is a temporary fix for the issue of escalation
// leading to a fatal error.
// The issue is that the last L/C word is
// not programmed correctly.
// The fix is to make sure that the last
// L/C word is programmed correctly.
// This is a temporary fix for the issue of escalation
// leading to a fatal error.

========================================================
example14_i-b_t-0.3.v
 This is a work-around for a problem in the FPGA implementation.
 The problem is that the FSM cannot be reset, so the FSM will
 continue to escalate, even if the L/C controller has turned off.
 This is a problem for the L/C controller, but the problem is
 a bit tricky. The way the FSM works is that the L/C controller
 has to be turned off in order for the FSM to reset.
 The problem is that the L/C controller is not turned off in
 order for the FSM to reset. The FSM will continue to escalate
 and the L/C controller will be turned off.
 This is a problem for the L/C controller, but the problem
 is a bit tricky. The way the FSM works is that the L/C
 controller has to be turned off in order for the FSM to
========================================================
example15_i-b_t-0.3.v
 if we are in the middle of a write cycle, we need to
 wait until the write is done before we escalate.
 however, if the write is not done by the time we
 get here, we need to treat it as a write cycle error.
 if the write is not done, then we wait for the write
 cycle to end before we escalate.
 however, if the write is done, then we wait for the
 write cycle to end before we escalate.
 this is done to prevent the escalation of a write cycle
 that has not been committed.
 however, if the write cycle has been committed, then
 we escalate immediately.
 we wait for the write cycle to end before we escalate
 to avoid the possibility of a write cycle that has been
 committed, but then immediately escalated before the
 write cycle has finished.
 we wait for the write cycle to end before
========================================================
example16_i-b_t-0.3.v
 This is a workaround for a bug in the lc_ctrl_pkg.v implementation.
 The implementation does not correctly handle the case when the
 "escalate" signal is active and the "cnt_err" counter is
 non-zero. The implementation does not correctly handle the
 "cnt_err" counter when the "escalate" signal is active.
 The implementation will incorrectly start the "cnt_err" counter
 when the "escalate" signal is active.

 The work-around is to set the "cnt_err" counter to zero when
 the "escalate" signal is active.

 This is a workaround for a bug in the implementation.

 This code is not intended to be part of the FSM implementation.
 It is intended to be used in the lc_ctrl_pkg.v implementation.


========================================================
example17_i-b_t-0.3.v

 The following line is commented out because it is not clear
 if the escalation is a fatal error.

 However, the escalation is not a fatal error, and the
 escalation is not a real error, so we have to
 ignore it.

 FIX:

 The escalation is not a real error, so we have to
 ignore it. We have to use the lc_ctrl_pkg::Off
 instead of the lc_ctrl_pkg::On.

 if (cnt_err) begin
 escalation_d = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example18_i-b_t-0.3.v
 This is a workaround for the current implementation of the
 lc_ctrl_pkg.v implementation.
 In the current implementation, the lc_ctrl_pkg.v
 implementation is not able to properly handle the
 lc_ctrl_pkg.v implementation.
 The current implementation of the lc_ctrl_pkg.v
 implementation does not properly handle the
 lc_ctrl_pkg.v implementation.
 The current implementation of the lc_ctrl_pkg.v
 implementation does not properly handle the
 lc_ctrl_pkg.v implementation.

 This is a workaround for the current implementation
 of the lc_ctrl_pkg.v implementation.

 The current implementation of the lc_ctrl_pkg.v
 implementation does not properly handle the
 lc_ctrl_pkg.v implementation.

 The current
========================================================
example19_i-b_t-0.3.v
 - The problem is that the escalation is not considered
 - in the same cycle as the error.
 - The solution is to have the escalation and the error
 - in the same cycle.
 - The problem is that the escalation is not
 - considered in the same cycle as the error.
 - The solution is to have the escalation and the
 - error in the same cycle.
 - The solution is to have the escalation and the
 - error in the same cycle.
 - The solution is to have the escalation and the
 - error in the same cycle.
 - The solution is to have the escalation and the
 - error in the same cycle.
 - The solution is to have the escalation and the
 - error in the same cycle.
 - The solution is to have the escalation and the
 - error in the same cycle.
 - The solution is to have
========================================================
example0_i-b_t-0.5.v
 This is done to ensure that the core is still in the
 state where it is possible to return to the normal operation
 state and thus prevent possible un-intended damage to the
 core.
 It is possible to return to the normal state from the
 Error state, but the Error state should be the last state
 in the core state machine.
 However, this is not yet implemented and the current
 implementation will lead to a reset of the core.
 Thus, the core cannot be used until the implementation
 is completed.
 It is possible to return to the normal state from the
 Error state, but the Error state should be the last state
 in the core state machine.
 Thus, the core cannot be used until the implementation
 is completed.
 Solution:
 The Error state should be the last state in the core state
 machine.
 Thus, the core
========================================================
example1_i-b_t-0.5.v
 this will work, but the bug is that escalate_en_i will not be
 updated, even though escalate_en_i is used only in the context
 of the fsm_state_en.
 furthermore, the fsm_state_en is never updated, even though
 this is the only event which could change the state.
 therefore, we have to signal an error via the status register
 and wait for the next cycle to update the state.
 this is more or less what we do now.
 however, the escalate_en_i is not updated, so we have to
 use the status register to signal the error.
 this is not very clean, but changing the state in the cycle
 after the error is not possible any more.
 therefore, we have to wait for the next cycle to update the state.
 we do not use the status register to signal the error
========================================================
example2_i-b_t-0.5.v
// This is a way to prevent escalation as the first error
// encountered is considered to be the fatal error.
// However, if the first error is a non-fatal error, then
// we escalate anyway.
// if (cnt_err)
// escalate_en_i = 1'b1;
// else
// escalate_en_i = 1'b0;
// end
// end
// else
// escalate_en_i = 1'b0;
// end

========================================================
example3_i-b_t-0.5.v
 if (cnt_err)
 escalate_err_int_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 
========================================================
example4_i-b_t-0.5.v
 It is possible to get into the escalation state right away
 when the user is trying to switch off the device, so
 we need to evaluate the cnt_err state separately.
 Furthermore, we have to wait until the last word is done
 before we escalate.
 However, the escalation state is not very useful because
 the only way to get back to the normal operating mode
 is to power cycle the device.
 Furthermore, there are many cases where the device is in
 a non-operating state for a long time, which could lead
 to false positives.
 Thus, we are doing the escalation only to switch off the
 device, and only if the user has requested this.
 Moreover, we are only escalating if the current operation
 mode is "write".
 Thus, the escalation state needs to be checked
 together with the write-mode operation in order to

========================================================
example5_i-b_t-0.5.v
 The state machine will go to ErrorSt in the following cases:
 - The master is in Error state
 - The last word has been written with an error.
 - The last word has been written with a non-fatal error.
 - The last word has been written with a non-fatal error and the
 - master has been in Error state for at least one cycle.

 Note that the condition in the last statement is not exactly
 equivalent to the condition in the third statement. The reason is
 that we have to be able to escalate even if the master is not
 in error state.

 The other problem with this implementation is that the master
 state machine needs to be in error state for at least one cycle
 before the last word can be written with an error. This is
 necessary because the escalation logic requires the master
 state machine to be in error state
========================================================
example6_i-b_t-0.5.v
// if (cnt_err) begin
// mesmer_d = 1'b1;
// end
// end
// end

========================================================
example7_i-b_t-0.5.v
 Fix is to check if the error has been escalated
 and if so, then set the error state to the one
 to be escalated.
 However, the way this is implemented is such that
 the error state is set in the same cycle that the
 error is generated, and so this cannot be done.
 Thus, we cannot set the error state to the one
 to be escalated.
 Instead, we set the error state to the one that is
 currently being escalated. This way, the error state
 is updated one cycle after the error is generated.
 Problem:
 In order to determine if the error has been escalated
 we need to know if the error is valid. If the error
 is invalid, we cannot assume it has been escalated.
 Thus, we need to extend the error code to include
 a validity field.
 Solution:
 Extend the error code to
========================================================
example8_i-b_t-0.5.v
 The FSM should escalate and return to the same state.
 This is a workaround to prevent a condition where the FSM
 gets stuck in the Error state.
 However, the FSM needs to be fixed to not return to the Error
 state at all times.
 It is not clear if the FSM is in the correct state or not.
 It is possible that this logic is not correct and the FSM
 may be in the Error state.
 This is a workaround to prevent the FSM from going to the
 Error state.
 However, the FSM state needs to be fixed to prevent the FSM
 from going to the Error state at all times.
state_d = ErrorSt;

========================================================
example9_i-b_t-0.5.v
// assign escalate_error = escalate_en_i && (cnt_err || lc_ctrl_pkg::Off);
// assign escalate_error = escalate_en_i && cnt_err;
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example10_i-b_t-0.5.v
// If the error code is already set (e.g. by a previous escalation),
// do not set it again.
// if (error_d != NoError)
// error_d = error_q;
// else
// error_d = error_en_i;
// end
// end

========================================================
example11_i-b_t-0.5.v
 - I would like to have the error state as a possible state, but
 it is not possible to have a state as a possible state.
 - I would like to have the escalation state as a possible state.
 - The escalation state is an intermediate state, but I would like to
 have it as a possible state.
 - The escalation state is the state that leads to the ErrorState.
 - The ErrorState is the state that leads to the FatalState.
 - The ErrorState is the state that leads to the EscalationState.
 - The EscalationState is the state that leads to the ErrorState.
 So the ErrorState should be a possible state, but it is not possible.
 - The ErrorState is the state that leads to the EscalationState.
 - The EscalationState is the state that leads to the ErrorState.
 - The ErrorState
========================================================
example12_i-b_t-0.5.v
// if (cnt_err) escalate_en_i = 1'b1;
// end else
// end
// end




========================================================
example13_i-b_t-0.5.v
 This is not a bug, because all the required conditions are met.
 However, the current implementation of the ESC algorithm does not
 allow to escalate to the "fatal" state.
 Nevertheless, we have to check, whether we escalate to the
 "fatal" state, in case we encounter a bug.
 Nevertheless, we have to allow the escalation to the "fatal" state
 for the case we have seen a programming error.
 Furthermore, we have to allow the escalation to the "fatal" state
 for the case we have seen a non-ECC error.
 The ESC algorithm has the following features:
 - It is able to escalate to the "fatal" state.
 - If an ECC error is encountered, the algorithm
 - is able to escalate to the "fatal" state.
 - If an ECC error is encountered, and a non-
========================================================
example14_i-b_t-0.5.v

 If the last word is not programmed, we have to wait
 until the last word is programmed, otherwise we will
 get a "no error found" error.

 TODO: implement a more sophisticated error handling

 if (cnt_err == LastLcOtpWord) begin

 FIX:

 In the future, we should have a more sophisticated
 error handling.

 if (cnt_err == LastLcOtpWord) begin

 FIX:

 If the last word is not programmed, we have to wait
 until the last word is programmed, otherwise we will
 get a "no error found" error.

 if (cnt_err == LastLcOtpWord) begin

 FIX:

 If the last word is not programmed, we have to wait
========================================================
example15_i-b_t-0.5.v
 It is possible that a lot of words have been corrupted and
 the current error state is an ECC error. We should not
 escalate to a fatal error in this case.
 However, we can't program all the words, so we should
 default to the Error state.

 FIX:
 We can't program all the words, so we will have to
 default to the Error state.

 if (error_d == NoError) begin

 FIX:
 We are going to default to the Error state for the
 first word that we can't program, so we have to
 check for the first word that we can't program.

 if (cnt_err == 0) begin

 FIX:
 We are going to default to the Error state for the
 first word that we can't program, so we have to

========================================================
example16_i-b_t-0.5.v
// This is a work-around for a known problem in the UCF
// files of the security controller.
// In the event that the security controller is reset,
// the security controller will reset the security controller
// and the security controller will then reset the security
// controller, resulting in an infinite loop.
// This is a known problem in the security controller and
// the security controller will need to have some way to
// reset the security controller when the security controller
// is reset.
// TODO:
// Fix the security controller.
// if (cnt_err)
// escalate_err_o = 1'b1;
// end
// end

========================================================
example17_i-b_t-0.5.v
// the following line is commented out.
// if (cnt_err)
// escalate_err_o = 1'b1;
// end
// end
// end

========================================================
example18_i-b_t-0.5.v
if (cnt_err) begin
this.error_code = `FATAL_ERROR;
this.escalate_code = `ESCALATE_ERROR;

========================================================
example19_i-b_t-0.5.v
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//

========================================================
example0_i-b_t-0.7.v
 This is a workaround for vlsi's fyi generation of
 "error: Expected string literal"
 This is done to prevent the implementation of the error state
 to be a potential security risk.
�ʻλλΙΪВ"error: Expected string literal"
 until the implementation of the error state is fixed.
animous

========================================================
example1_i-b_t-0.7.v
 - until the ESC is turned off, the error state will
 - not be shown to the user. Instead, the state
 - will be escalated back to the user
 - by the lifecycle controller. The FSM will then be reset to
 - a known state.
 - In the event that the user is not logged in, we will have the
 - user be alerted via the E/F wakeup.
 - By the end of the next cycle, the FSM will follow the local
 - state in order to allow for recovery of the system.
 - A global reset by the E/F wakeup will also allow for
 - recovery of the system. However, the lifecycle controller
 - will have a shorter recovery time than the E/F wakeup.
 - RFC 6204:
 - The lifecycle controller may be used to prevent the E/F
 - wake
========================================================
example2_i-b_t-0.7.v
 These lines give us a non-terminal error condition.
 We have to escalate to a FATAL error to be able to properly
 reset the circuit.
 The only way we can do this is by jumping to the error state
 and then raising the FSM.
 Either way, we need to ensure that the escalation is triggered.
 This allows a circuit to be reset even if it is already in a
 non-fatal state.
 The only way to do this is to delay the checking of the
 FSM state until after the escalation has been executed.
 A side effect of this is that we cannot have more than about
 27 levels of escalation, otherwise the system will just lock up.
 If this is unacceptable, we may need to rethink the approach.
 It is possible to have the FSM check for the error state and
 escalate immediately. This would allow a circuit to be
========================================================
example3_i-b_t-0.7.v
nergies one error-level back in case of escalation
 but if it's an ECC-fixable error, we need the error to be on,
 otherwise we will ignore the error
 otherwise we will drop the error from the chain
ES: we will ignore the error only if it's ECC-fixable
	or if the proper error was already in the chain
	otherwise we will take the error as it is
	we cannot protect against -undefined- errors
	that might happen if trying to fix a certain error.
	In that case we cannot protect against the fatal error.
	An error-level that is not registered will be dropped.
	errors that are not registered in the chain are lost
	on the next LCE-event
	we might survive an error if there are recoverable errors
	in the chain
	we do
========================================================
example4_i-b_t-0.7.v
// optflow_test.v
// in_lt_out:
// underflow as expected.
// underflow as expected.
// overflow as expected.
// underflow as expected.
// underflow as expected.
// overflow as expected.
// underflow as expected.
// overflow as expected.
// underflow as expected.
// underflow as expected.
// underflow as expected.
// overflow as expected.
// underflow as expected.
// overflow as expected.
// underflow as expected.
// overflow as expected.
// underflow as expected.
// overflow as expected.
// underflow as expected.
// overflow as expected.
// underflow as expected.
// overflow as expected.
// underflow as expected.
// overflow as expected.





========================================================
example5_i-b_t-0.7.v
 as a workaround for this, a really low level state can be used,
 which indicates that an error is about to happen.

 as a result, if an error occurs during transition,
 the state machine will directly terminate the sequence with a fatal error.

 if the error was caused by transition, the next state will be a real
 termination state, i.e. the next state will not be a possible
 state of the FSM, but it will not be a state the FSM was in during
 the duration of time the error occurred.

 if the error was caused by the
 the state machine will then terminate in a non-fatal way,
 i.e. the state machine will go to an error state and a
 non-fatal error will be returned.

 the state machine will then attempt to come back to a safe state.

========================================================
example6_i-b_t-0.7.v
 the above line has been reproduced.
 the next line is essentially what the original comment said:
 however, the problem is that the above line generates
 an assertion, which states that a non-exception statement was
 found in a "catch" block.
 the following line has been tested and works:
 the above line was changed to this one:
 however, the problem is the same with the final line below
 the line below is an alternative attempt to resolve the issue
 but it leads to a different issue
 the following line is what the original comment suggested.
 however, the problem is that in this way a non-exception statement
 is not found in a "catch" block but it is found in a "finally" block
 the issue is that the line below would generate an assertion

 ASSERTION: report.User.IllegalExprError.Found.
========================================================
example7_i-b_t-0.7.v
// if (cnt_err) begin
// state_d = ErrorSt;
// end else begin
// state_d = IdleSt;
// end
// endelse begin
// state_d = IdleSt;
// end
// end
// end
// end
// end
// end
// end
// end


========================================================
example8_i-b_t-0.7.v
// end
// if (cnt_err) begin
// end;
// end


========================================================
example9_i-b_t-0.7.v
//this tome will be replaced as soon as possible.
//todo: replace tome by state transition or something else.
//this tome will cause enclave to crash.
//this way todo will cause to reuse the slot.
//there is a bug in the impl. of zif. allocator.
//the slot is free, but the enclave is not stopped,
//not even the slot is free.
////this todo will cause slot to be free.
//todo: stop the enclave, or stop the slot.
//this todo will cause xena to crash.
////todo: test this todo.

========================================================
example10_i-b_t-0.7.v
omitjes

========================================================
example11_i-b_t-0.7.v
// in addition to the terminal error, we escalate the error
// if there is more than one error in the chain
// until the control manager is asked to kill the error.
// end

========================================================
example12_i-b_t-0.7.v
 we need to advance to the next state
 when we reach the last word of the current OTP, for example.
 otherwise, the next FSM is not loaded, and the current FSM
 continues with the last word of the current OTP.
 works only with sequencer
 FIX:
 the next fsm is not loaded if we have a programming error in the
 last word of the current OTP.
 if escalate_en_i is asserted, we will never come back here.
 if escalate_en_i is asserted, we have a programming error, and the
 next word will be skipped.
 FIX:
 the escalation mechanism is not fully working now.
 if the last message was a write, then the result of the write is
 not available, and consequently the write's result cannot be safely
 reported back.
 FIX:
 this debug message is
========================================================
example13_i-b_t-0.7.v
 This would prevent the system from going into the recovery mode
 if the last configuration attempt did lead to ERC.
 However, the recovery mode is not possible, as it would
 result in a loss of the system configuration.
 TODO:
 Fix this by pulling the system into the recovery mode,
 or somehow prevent the last ERC configuration attempt
 from causing the system to enter the recovery state.
 severity <HIGH>
 end else begin


========================================================
example14_i-b_t-0.7.v
otomy to remove the part of the buffer recovery mechanism
 if the buffer recovery feature were implemented.
 Secondly, the elastic buffer recovery mechanism
 would need to be implemented. See test_el_buf_recovery_e.v
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

 Buffer recovery mechanism:

 In order to recover the elastic buffer and avoid ECC errors
 it is necessary to implement a recovation model. The following
 mechanism is implemented:

 The buffer will be loaded with data from the last word of the
 elastic buffer. This way the error marking of the last word of
 the elastic buffer is preserved. On next power-on the
 elastic buffer will be loaded with data from the last word of
========================================================
example15_i-b_t-0.7.v
// s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//
//s/\S*//

========================================================
example16_i-b_t-0.7.v
// ALWAYS ERROR OR NO CL I/O
// if escalate_en_i != lc_ctrl_pkg::Off then
// if cnt_err then
// escalate_err_o = 1;
// end else
// escalate_err_o = 1;
// end else
// escalate_err_o = 1;
// end end
// end
// End of the error handling routine.
/**
 * The write operation is handled by the write-only FSM.
 * This functionality is very simple, as it is only
 * ever used for word programming. The only macro is
 * W_IDTH. It is always a fixed 8 bit string.
 */
/**
 * The write-only FSM takes care of the write cycle,
 * where each word is written into a location.
 */
/**
 * The read-only FSM takes care of the cycle
 * during which the status of
========================================================
example17_i-b_t-0.7.v
 this works, but we need to see the condition
 in the if statement.
 however, since we use a self-checking 
 mechanism, we can't increment in the 
 inner loop.
 solution: we use a helper task.
 Not sure if the helper task can be used as
 a package.
 another possibility is to use the 
 array to store the data, and then
 increment it in the inner loop.

 The solution is: the max of the bit 
 is stored in the upper 4 bits.
 The full size of the signal is then
 calculated as (4 + bitsize)
 to make sure the size of the signal is
 at least half way.
 to do the whole thing: 
 1. In the FSM, the signal size is 
 calculated as (4 + bitsize). 
 2
========================================================
example18_i-b_t-0.7.v
// 1. Escalation occur without error.
// 2. Error occur after escalation
// end
// end if








// ---------------------------------------------------------------------------------
// UART Debug Wires:
// ---------------------------------------------------------------------------------





// ---------------------------------------------------------------------------------
// If the address is not specified, assume that we are always writing.
// ---------------------------------------------------------------------------------
assign wr_mode = (addr_r == 8'h00) ? 1'b1 : 1'b0;
assign addr_r = addr_i;
assign addr_i = addr_r;




// ---------------------------------------------------------------------------------
// 1-bit Write Overhead
// ---------------------------------------------------------------------------------
always @(posedge clk or posedge rst) begin
if (rst)
write_overhead_r <= 1'b0;
else begin
write
========================================================
example19_i-b_t-0.7.v
// if escalate_en_i = 1, and we had a serious error, escalate.
// if escalate_en_i = 1, and the current error is ECC, and the
// currrent read has ECC errors, then escalate.
//if (escalate_en_i) begin
// if (cnt_err) begin
// escalate = 1;
// end
// end
//else if (cnt_err && (read_err_i || (last_err & ~in_err_i))) begin
// escalate = 1;
// end
// assign escalate = escalate_en_i | (cnt_err & ~read_err_i);
// end
// else begin
// escalate = 0;
// end
// end
//else if (~escalate_en_i) begin
// escalate = 0;
// end
// end



========================================================
example0_i-b_t-0.9.v
// via escalation from master we would reset the core state
// + I bring to this method
// if there are such states, we come up to idle, and so we
// would lose the error state
//�else if (cnt_err)
//ットノトワケンガヨウォラビュークガルガ対辅等
//LocilLCtxFsmExcNok実化直後間遠実装緩FF
// state machine of the DCI controller.
//FIX: in has parts or internal connection we have to use a completely unique name to avoid name/type conflicts.
//

`define enum_name_if_no_idle	idle
`define enum_local_state_if_no_idle	idle
`define enum_ctx_if_no_idle	idle
========================================================
example1_i-b_t-0.9.v
// (2) 00110111; LMC is fast path
// when it reach error from fsm, it should set the error
// immediately
//artisanjogie
//don't set anything if it returns early
//2013-03-24 21:30:15 IST Asia-Tonga
//New flags need to be used for TS and LF factor files
//note: reset 1st copy
//sync and pipeline selection
//Prediction and Transfer delay
//2012-11-10 10:54:58 IST Asia-Tonga
//Co-mingulate the port 1 value to be accepted
//Note: when we have 1 cycle of delay PLUS the value can never reach the maximum
//we have to wait for that number of cycles in order to get the value
//when we have multiple files, it need to be read as soon as possible
tag:fileout=512x8bit.ext. This is the "MAX
========================================================
example2_i-b_t-0.9.v
 Accounts for cases where the DSP is completely pit.
 With next field values of 0, the result of the shift is unpredictable.
 - rcu stalls only. Not guaranteed.
 - cnt_err marks mark for possible recovery of the DSP. Side effect
 of loosened DSP configuration is loss of (light) working life,
 unless during this error state the DSP has been recovered.
 Notes:
 - tatturches on some LRs to cover.
itored recovery
prs info begin
monit over prs err report
prs_mon_en_i
prs_mon_error_i
prs_mon_prs_i
prs_mon_merr_i
prs_mon_prs_err_i
prs_mon_mtpr_o
========================================================
example3_i-b_t-0.9.v
//
// Identify which error code is used.
//
// Do not use sort of Error package criminal codes.
//
// Usually, use the position of error code from
//
// One of the following error code visible on the data pin.
//
// Note: There is no difference between the data pin codec and
// the header/footer codec.
//
// The 'fcs' error mode means the error will come 
// out only on the last word.
// er
// UNEXPECTED: The inconsistency on Communicator errors.
//
// Expected Message:
//
//
//
// If message contains wrong plc data, chip will
// be reset (soft reset). So don't use such
// message to determine plc data error.
//










//erro, en, cnt_err, size_2, size, data, next_
========================================================
example4_i-b_t-0.9.v
// while counting an error, the LS's probable error check logic is bypassed, by setting poss_i error state
// nevertheless, the ability to wait for possible errors to allow recovery from single bit check (or soft ECC) errors
// is lost. 
// Therefore, for compatibility with the N7, we ignore the possible ER, whatever this is the result


// while (cnt_err && poss_i) begin
// atomic_setbitptr(&poss_i, preserve_flags);
// end

// end
// end


========================================================
example5_i-b_t-0.9.v
 Leaver in the trouble. If a persistence layer
 is attached to the FSM, it will likely be shut down
 very soon. In order to free the bus for other
 persistant layers, we should have another hidden
 resilience layer, which in this case will have
 one additional bit of config (e.g. N).
 Enduser will have to explicitly flag the event.
 The problem with the inability is that err
 would basically only ever have to occur anymore.
 Given that there is one natural event (an error, or
 escalate signal), it may not be possible to have an
 action outside of the event loop. As a matter of fact,
 there is no good way to distinguish between
 errors and one time signal, e.g. a person response.
 By compromising the ability to attach buses,
 a persistant layer can be implied to by the

========================================================
example6_i-b_t-0.9.v
 Seb would like to get to the following line in the future once its fixed
 so when it is fixed and VCON goes to the error state, we will be in 
 the error state.
 ERROR. Pre Fault.
 ERROR. Post. Fault.
 ASSERT. Non FSM error detected. 
 ASSERT. Non FSM Error for state = ErrorSt detected.

 Gabri: From the Sierra top level clock definitions, it looks like the
 assertion gives is the very last cycle of the last command it is
 received on the bus and that the clock is called idle.
 This is the state for the whole operation, which is defined on the 
 idle clock at the system level.
 So, the declare here is a compile time definition.
temp global define
define clk_idle_def "no"
define clk_idle_
========================================================
example7_i-b_t-0.9.v
// This case stops the FB mark from getting "overwritten" with a security
// mark in order to cover up the permanently corrupt sector.
// This also fixes the buggy way to generate the unrecoverable mark.
// - AS11 16236006
// - AS11 16256011
// - AS11 18257648
// - Wordsworth - 18 November 2019
//at the program entry point of the PLF.
// This is the only way we get both the outstanding erase operations and the problem
// detected on the first word.
// We cannot invert the issued command, because then the EOF stuff would muck up too.
`ifdef USE_FIFO_BUFFER
// The non-holding state must only drive disc_en, and we need to avoid that
// for release, so we sort out the holding state too.
`define SORT_HOLDING
`ifdef SORT_
========================================================
example8_i-b_t-0.9.v
// forcefully assign to a dead cycle state to avoid functionally dead loop.
// any potential error cause while quitting would be fatal otherwise.
// however, by this design!, we will cause arbitrary (guaranteed) remaining cycle stop.
anystate_d = (escalate_en_i == lc_ctrl_pkg::Off)? ErrorSt: RF_ExitResetLoop;
// minds i have denounce an infinite loop in this way...
// beucid_lite_nio: the defination of DQS pulse timing leading to error under some conditions will lead to long halted cycle on the target debug interface.
// but on the other hand, falling back to normal timing mode without guaranteeing feature effect on debug channel will cause another error prone cycle to get executed at the current debug state.
// at least for the time period near the rising edge of the debug channel's DQS signal if DQS pulse timing mode was coming up
========================================================
example9_i-b_t-0.9.v
 topsys3revf
 625 else begin
 625if (cnt_err && escalate_en_i) begin
 625 FIX:
 625if (~cnt_err) begin
 625if (escalate_en_i) begin
 625 FIX:
 62550us
 625else begin
 625if (~cnt_err)
 625 In an unlikely case when the EOS pin
 625 is high state, we need to assert the
 625 sys_rst signal. This is for cases which
 625 increase the of the entire system to below 0
 625 on their own and need to be returned, i.e.
 625 if the EOS signal is tying up the registers
 625 that have some of their power in the UP of
 625 the system. Once the system reaches lockup
 625
========================================================
example10_i-b_t-0.9.v
:::::
eson_die_e = 1'b1;
//esdm_dut_exit();
//
//esdm_dut_reset();
// end
// end
asso framewlog_u;
assign framewlog_u = error_q;
//
// END OF STATE MACHINE
//
//
// DECENDING STOP - LOAD THE FULL PACKET ONCE PACKET IS TRUE
assign load_full_id = (framewlog_u && error_q) || ((state_q >= WriteSt) && cnt_byte);
assign packet_complete = load_full_id && lp_load_complete;
assign payload_complete = load_full_id && lp_load_complete;
module timer
#(
 parameter
 value1 = 10
 value2 = 100
value3 = 1
)
(

========================================================
example11_i-b_t-0.9.v
minlcstate_d = 'H1;

========================================================
example12_i-b_t-0.9.v
// improve detection of terminal error.
// ack error will be ignored when return to Idle.
// termination is probable.
// termination is probable.
// maybe check LcErrCnt.
// report error type.
// implement an escalation function?
// pending ESC session termination by EFD and/or EFD-ERR mode.
// terminate as gracefully because of a potential antitran.
// terminate gracefully when in a potential continous.
// escalation: terminate or continous traction
// SEU:SEU.ESC_N_ON OFSPEC
// SEU.ESC_N_ON (Esc for C thru Sep4-27): basically, ESC breaks the long
// term operation. For e.g. when we lose LSS from SEU, then SEU goes to
// either ESC or by-pass. If we have LSS but SEU is in ESC, it should

========================================================
example13_i-b_t-0.9.v
// At first glance, this task seems to encode the wrong intention; 
// however, I find it works to allow pattern - match in the source code.
// The source code has the following term:
// "Pattern match in terms of signal propagation"
// comsyn:test Synthesis Test for State Matrix and Signal Propagation
// todo: implement escalation from Conflict fit.
/*
escalation_target = cnt_err ? lc_ctrl_pkg::TargetError :
pending_conflict ? lc_ctrl_pkg::TargetConflict : |escalate_word(~valid|:~(cnt_word));
*/
escalation_target = cnt_err ? lc_ctrl_pkg::TargetError :
pending_conflict ? lc_ctrl_pkg::TargetConflict :
|escalate_word(~valid|:~(cnt
========================================================
example14_i-b_t-0.9.v
//whenever an error occurs in a timing master, the syncmaster is reset
//whetimesync master core --> maintain signal to syncmaster for- -terminate
//syncmaster work in reset mode
//whetimesync master core --> maintain signal with syncmaster for- -terminate
case (fe_d):
// error
// we only consider non-fatal errors which we
// can suppress in the ISR
case (fsm_r0_or_mftr_write):
// terminated by a write operation.
case (cnt_err):
// the file is not closed from within the file.
assign exp_err_open_i = 1'b1;
case (cnt_i):
assignfsm_cnt_max = LastMaxIdx;
assigncnt_rst = 1'b1;
assigncnt_en = 1'b
========================================================
example15_i-b_t-0.9.v
// Earlier code only loops when in a fatal or non-fatal error state.
// With the escalation path coming in now, spouses are no longer
// guaranteed par identity also. Furthermore, kill_part_i
// condition can cause state machine death to occur.
// Terrongh
okCAStree gold_Sweet5 (
.cb_ip(lp_c),
.ca_ip(lp_ca),
.cb_op(lp_c_op),
.our_zeros(cfc_our_zero),
.our_ones(cfc_our_one),
.cfc_s7_to_s6(cfc_s7_to_s6),
.our_sub(lp_subo),
.our_add(lp_addo),
.rst(rsti),
.clk(clk),
.ck_in(ck_
========================================================
example16_i-b_t-0.9.v
//artyk.
// Waterloo Library "Esr.C" changed "On" to "Off" in a release before 1.3, and we do not expect to see Escalation during this cycle anyway.
//ationally settting escalate_en_i to "Off" will force FSM to proceed to safe operating mode instead.
aration_d = FsmStateError;
effectively_latch(BackupMode, 0, [&iesr,&power_ok_out,rea,ron,dr,al,ah,tm,pe,sic,batt,so,cdr,o1,pt,op,ext_id,comp_id,sub_seq,lnk,dyn_mode_latch,&ibi_id,&ie_cb,&xev_i,&er_cb,&slv_nak,&o_ms,&state_latch,slv
========================================================
example17_i-b_t-0.9.v
// It kills the machine of b/c package and this will break worldview that
// we need to have specific error for specific modules. But this means
// that only cases that will lead to local external errors can be filtered.
// Uncomment in case DeclaredErrors matches the filters.
//lying errors when they happened, but by the error if the destroyer intended to do.
// Otherwise, we can kill machines even if errors are not determined. 
// throwing errors at line 17 of process.v, ew, these features have no effect anyway. 
// we can reflect these errors in the normal ways. So uniting errors and throwing errors may work well.
//Otherwise a common severity error is generated on top.
eson // squash all errors and throw them in one stroke.
eson ew ew aass // general throw-in way to present, or will it present it here?
draw aass;

========================================================
example18_i-b_t-0.9.v
// async_flavor_ff
// allegro: support for ezmac release
//imanique mon hard-coded num
`include "macro_utils.v"
module pf_ro_tb 
(
//inputs:
	f_test_i,
	f_pass_i,
	f_total_i,
	f_store_i,
	f_store_size_i,
	r_reset_i,
	f_issue_i,
	f_committed_i,
	f_mc_i,
	f_hmc_i,
	f_mc_w_i,

	f_poten_i,
	f_poten_pc_i,
	f_wb_gr_i,
	f_wb_gr_pc_i,
	f_wb_gr_inc
========================================================
example19_i-b_t-0.9.v
 Chloe's commit message:
 commit 11afe5e00e711b1c80675b75b51310d9e1a2518
 C:\Users\chloe\Documents\P-P Stretch\3.1\LOCAL-DBG\LOCAL-DBG 1.3\LocalDBG\Fsm-C.Cu
 182750: 184430 
 C:\Users\chloe\Documents\P-P Stretch\3.1/LOCAL-DBG/Fsm-L.LocalDBG.pm
 184432: 184445 
 C:/Users/chloe/Documents/P-P Stretch/3.1/LOCAL-DBG/Fsm-L.LocalDBG.pm
 5: 
 C:\Program Files\I2OSoftware_1.1.6f3\I2OS
========================================================
example0_i-c_t-0.1.v
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is in
 normal operation.
 if escalate_en_i == lc_ctrl_pkg::On, then the system is in
 escalation.
 if the system is in escalation, then the FSM should raise
 an error.
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 
========================================================
example1_i-c_t-0.1.v
 if escalate_en_i == lc_ctrl_pkg::Off, then we are in the
 normal operation mode.
 if escalate_en_i == lc_ctrl_pkg::On, then we are in escalation
 mode.
 if cnt_err == 1, then we have at least one error.
 if cnt_err == 2, then we have two errors.
 if cnt_err == 3, then we have three errors.
 if cnt_err == 4, then we have four errors.
 if cnt_err == 5, then we have five errors.
 if cnt_err == 6, then we have six errors.
 if cnt_err == 7, then we have seven errors.
 if cnt_err == 8, then we have eight errors.
 if cnt_err == 9, then we have nine errors
========================================================
example2_i-c_t-0.1.v
 if escalate_en_i == lc_ctrl_pkg::Off, then we are in escalation
 if escalate_en_i == lc_ctrl_pkg::On, then we are in normal mode
 if escalate_en_i == lc_ctrl_pkg::Reset, then we are in normal mode
 if escalate_en_i == lc_ctrl_pkg::Reset, then we are in escalation
 if escalate_en_i == lc_ctrl_pkg::Reset, then we are in normal mode
 if escalate_en_i == lc_ctrl_pkg::Reset, then we are in escalation
 if escalate_en_i == lc_ctrl_pkg::Reset, then we are in normal mode
 if escalate_en_i == lc_ctrl_pkg::Reset, then we are in escalation
 if escalate_en_
========================================================
example3_i-c_t-0.1.v
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is not in escalation
 if escalate_en_i == lc_ctrl_pkg::On, then the system is in escalation
 if escalate_en_i == lc_ctrl_pkg::Reset, then the system is in escalation and
 the system is being reset.
 if escalate_en_i == lc_ctrl_pkg::Reset, then the system is in escalation and
 the system is being reset.
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is not in escalation
 and the system is being reset.
 if escalate_en_i == lc_ctrl_pkg::Reset, then the system is being reset.
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is not in
========================================================
example4_i-c_t-0.1.v
// if escalate_en_i == lc_ctrl_pkg::Off, then the system is in
// normal operation.
// if escalate_en_i == lc_ctrl_pkg::On, then the system is in
// escalation.
// if the system is in escalation, then the FSM should raise an
// error.
// if the system is in normal operation, then the FSM should
// continue operation.
// if the system is in maintenance, then the FSM should
// continue operation.
// if the system is in power off, then the FSM should
// continue operation.
// if the system is in power off, then the FSM should
// power off the system.
// if the system is in power off, then the FSM should
// power off the system.
// if the system is in power off, then the FSM should
// power off the system.

========================================================
example5_i-c_t-0.1.v
// if escalate_en_i == lc_ctrl_pkg::Off, then FSM should not
// raise error.
// end
// end

========================================================
example6_i-c_t-0.1.v
 if escalate_en_i == lc_ctrl_pkg::Off, then
 FSM should not raise error
 if escalate_en_i == lc_ctrl_pkg::On, then
 FSM should raise error if system is in escalation
 if escalate_en_i == lc_ctrl_pkg::Off, then
 FSM should not raise error
 if escalate_en_i == lc_ctrl_pkg::Off, then
 FSM should not raise error
 if escalate_en_i == lc_ctrl_pkg::Off, then
 FSM should not raise error
 if escalate_en_i == lc_ctrl_pkg::Off, then
 FSM should not raise error
 if escalate_en_i == lc_ctrl_pkg::Off, then
 FSM should not raise error
 if escalate_en_i
========================================================
example7_i-c_t-0.1.v
// if escalate_en_i == lc_ctrl_pkg::Off, then the system is in
// normal operation.
// if escalate_en_i == lc_ctrl_pkg::On, then the system is in
// escalation.
// if the system is in escalation, then the FSM should raise an
// error.
// if the system is in normal operation, then the FSM should
// continue operation.
// if the system is in maintenance, then the FSM should
// continue operation.
// if the system is in power off, then the FSM should
// continue operation.
// if the system is in power off, then the FSM should
// power off the system.
// if the system is in power off, then the FSM should
// power off the system.
// if the system is in power off, then the FSM should
// power off the system.

========================================================
example8_i-c_t-0.1.v
 if escalate_en_i == lc_ctrl_pkg::Off, then we are in a non-fatal error
 state.
 if escalate_en_i == lc_ctrl_pkg::On, then we are in a fatal error state.
 if escalate_en_i == lc_ctrl_pkg::Reset, then we are in a non-fatal error
 state.
 if escalate_en_i == lc_ctrl_pkg::Reset, then we are in a non-fatal error
 state.
 if escalate_en_i == lc_ctrl_pkg::Off, then we are in a non-fatal error
 state.
 if escalate_en_i == lc_ctrl_pkg::Off, then we are in a non-fatal error
 state.
 if escalate_en_i == lc_
========================================================
example9_i-c_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example10_i-c_t-0.1.v
 if escalate_en_i == lc_ctrl_pkg::Off, then FSM should not
 raise error.
 if escalate_en_i == lc_ctrl_pkg::On, then FSM should
 raise error if system is in escalation.
 if escalate_en_i == lc_ctrl_pkg::Reset, then FSM should
 raise error if system is in escalation.
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 
========================================================
example11_i-c_t-0.1.v
 if escalate_en_i == lc_ctrl_pkg::Off, then we are in a non-fatal error
 state and should stay there.
 if escalate_en_i == lc_ctrl_pkg::On, then we are in a fatal error state
 and should escalate.
 if escalate_en_i == lc_ctrl_pkg::Reset, then we are in a non-fatal error
 state and should stay there.
 if escalate_en_i == lc_ctrl_pkg::Reset, then we are in a fatal error state
 and should escalate.
 if escalate_en_i == lc_ctrl_pkg::NoChange, then we are in a non-fatal
 error state and should stay there.
 if escalate_en_i == lc_ctrl_pkg::NoChange, then we are in a fatal error
========================================================
example12_i-c_t-0.1.v
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is in
 normal operation.
 if escalate_en_i == lc_ctrl_pkg::On, then the system is in escalation.
 if the system is in escalation, then the system should be in
 ErrorSt.
 if the system is in normal operation, then the system should
 be in NormalSt.
 if the system is in ErrorSt, then the system should be in
 ErrorSt.
 if the system is in NormalSt, then the system should be in
 NormalSt.
 if the system is in ErrorSt, then the system should be in
 ErrorSt.
 if the system is in NormalSt, then the system should be in
 NormalSt.
 if the system is in ErrorSt, then the system should be in
 ErrorSt.

========================================================
example13_i-c_t-0.1.v
 if (cnt_err)
 escalate_en_i = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example14_i-c_t-0.1.v
// if escalate_en_i == lc_ctrl_pkg::Off, then FSM should not
// raise error.
// end
// end

========================================================
example15_i-c_t-0.1.v
// if escalate_en_i == lc_ctrl_pkg::Off, then
// escalate_en_i = lc_ctrl_pkg::Off;
// if escalate_en_i == lc_ctrl_pkg::On, then
// escalate_en_i = lc_ctrl_pkg::On;
// if escalate_en_i == lc_ctrl_pkg::Reset, then
// escalate_en_i = lc_ctrl_pkg::Reset;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example16_i-c_t-0.1.v
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is not in escalation
 if escalate_en_i == lc_ctrl_pkg::On, then the system is in escalation
 if escalate_en_i == lc_ctrl_pkg::Reset, then the system is in escalation
 and the system is not in escalation
 if escalate_en_i == lc_ctrl_pkg::Reset, then the system is not in escalation
 and the system is in escalation
 if escalate_en_i == lc_ctrl_pkg::Reset, then the system is in escalation
 and the system is not in escalation
 if escalate_en_i == lc_ctrl_pkg::Reset, then the system is not in escalation
 and the system is in escalation
 if escalate_en_i == lc_ctrl_pkg::
========================================================
example17_i-c_t-0.1.v
// if escalate_en_i == lc_ctrl_pkg::Off, then FSM should not
// raise error.
// end
// end

========================================================
example18_i-c_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example19_i-c_t-0.1.v
 if (cnt_err)
 escalate_err_o = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example0_i-c_t-0.3.v
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is not in escalation
 if the system is in escalation, then the system should be in Error state
 if the system is in Error state, then the system should not be in Error state
 if the system is in Error state, then the system should not be in Error state
 if the system is in Error state, then the system should not be in Error state
 if the system is in Error state, then the system should not be in Error state
 if the system is in Error state, then the system should not be in Error state
 if the system is in Error state, then the system should not be in Error state
 if the system is in Error state, then the system should not be in Error state
 if the system is in Error state, then the system should not be in Error state
 if the system is in
========================================================
example1_i-c_t-0.3.v
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is not in escalation
 if escalate_en_i == lc_ctrl_pkg::On, then the system is in escalation
 if the system is in escalation, then the system should be in the error state
 if the system is not in escalation, then the system should not be in the error state
 if the system is in error, then the system should be in the error state
 if the system is not in error, then the system should not be in the error state
 if the system is in error, then the system should be in the error state
 if the system is not in error, then the system should not be in the error state
 if the system is in error, then the system should be in the error state
 if the system is not in error, then the system should not be in the error state
========================================================
example2_i-c_t-0.3.v
// if escalate_en_i == lc_ctrl_pkg::Off, then FSM should not
// raise error.
// end

========================================================
example3_i-c_t-0.3.v
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is not in escalation.
 if escalate_en_i == lc_ctrl_pkg::On, then the system is in escalation.
 if the system is in escalation, then the system should be in error state.
 if the system is not in escalation, then the system should be in idle state.
 if the system is in idle state, then the system should be in error state.
 if the system is in error state, then the system should be in idle state.
 if the system is in idle state, then the system should be in error state.
 if the system is in error state, then the system should be in idle state.
 if the system is in idle state, then the system should be in error state.
 if the system is in idle state, then the system should be in error state
========================================================
example4_i-c_t-0.3.v
 if escalate_en_i == lc_ctrl_pkg::Off, then
 escalate_en_i = lc_ctrl_pkg.OFF
 if escalate_en_i == lc_ctrl_pkg.ON, then
 escalate_en_i = lc_ctrl_pkg.ON
 if escalate_en_i == lc_ctrl_pkg.HW_ON, then
 escalate_en_i = lc_ctrl_pkg.HW_ON
 if escalate_en_i == lc_ctrl_pkg.HW_OFF, then
 escalate_en_i = lc_ctrl_pkg.HW_OFF
 if escalate_en_i == lc_ctrl_pkg.HW_HW_OFF, then
 escalate_en_i = lc_ctrl_pkg.HW_HW_OFF

========================================================
example5_i-c_t-0.3.v
// if escalate_en_i == lc_ctrl_pkg::Off, then we do not have to
// worry about system escalation.
// if escalate_en_i == lc_ctrl_pkg::On, then we have to check
// whether the system is in escalation mode.
// if (cnt_err) begin
// escalate_en_i = lc_ctrl_pkg::On;
// end
// end
// end
// end
// end
// end
// end

========================================================
example6_i-c_t-0.3.v
// escalate_en_i = lc_ctrl_pkg::Off;
// end
// end
// end
// end

========================================================
example7_i-c_t-0.3.v
// if (cnt_err)
// escalate_err_o = 1'b1;
// end
// end
// end
// end
// end
// end

========================================================
example8_i-c_t-0.3.v
 if (cnt_err)
 escalate_en_i = 1'b1;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example9_i-c_t-0.3.v
 if escalate_en_i == lc_ctrl_pkg::Off, then
 escalate_en_i = lc_ctrl_pkg::Off;
 else if escalate_en_i == lc_ctrl_pkg::On, then
 escalate_en_i = lc_ctrl_pkg::On;
 else escalate_en_i = lc_ctrl_pkg::Off;
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example10_i-c_t-0.3.v
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is in
 maintenance mode, and we don't want to escalate.
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is in
 maintenance mode, and we don't want to escalate.
 if escalate_en_i == lc_ctrl_pkg::On, then the system is in
 maintenance mode, and we want to escalate.
 if escalate_en_i == lc_ctrl_pkg::On, then the system is in
 maintenance mode, and we want to escalate.
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is in
 maintenance mode, and we don't want to escalate.
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is in

========================================================
example11_i-c_t-0.3.v
 if escalate_en_i == lc_ctrl_pkg::Off, then we are in the
 normal operation mode, and we can safely ignore the escalation.
 if escalate_en_i == lc_ctrl_pkg::On, then we are in escalation
 mode, and we should raise the error.
 However, if we are in a normal operation state, and then
 we see that the system is in escalation, we should
 transition to the error state.
 if escalate_en_i == lc_ctrl_pkg::On, then we are in escalation
 mode, and we should raise the error.
 if escalate_en_i == lc_ctrl_pkg::Off, then we are in normal
 operation mode, and we should ignore the escalation.
 if escalate_en_i == lc_ctrl_pkg::NoChange, then we are
 in
========================================================
example12_i-c_t-0.3.v
// if escalate_en_i == lc_ctrl_pkg::Off, then FSM should not
// raise error.
// end
// end

========================================================
example13_i-c_t-0.3.v
// if (cnt_err)
// FSM should raise error if system is in escalation
// else
// FSM should stay in current state
// end
// end



========================================================
example14_i-c_t-0.3.v
 if escalate_en_i == lc_ctrl_pkg::Off, then we are in escalation
 if escalate_en_i == lc_ctrl_pkg::On, then we are in fatal error
 if escalate_en_i == lc_ctrl_pkg::Reset, then we are in reset
 if escalate_en_i == lc_ctrl_pkg::Reset, then we are in reset
 if escalate_en_i == lc_ctrl_pkg::Off, then we are in normal
 if escalate_en_i == lc_ctrl_pkg::Off, then we are in normal
 escalation cannot occur if the system is in reset
escalation cannot take place if the system is in normal mode.
escalation cannot take place if the system is in fatal error mode.
escalation cannot take place if the system is in non-fatal error mode
========================================================
example15_i-c_t-0.3.v
 if escalate_en_i is true, then set the error state to true
 and let the FSM raise the error.
 if escalate_en_i is false, then set the error state to
 false and let the FSM return to the idle state.
 However, we do not want to allow the FSM to return to the
 idle state if there is no error.
 if cnt_err is true, then we have a non-fatal error.
 if cnt_err is false, then we have a fatal error.
 In the case of a fatal error, we want to allow the FSM to
 return to the idle state.
 We only allow the FSM to return to the idle state if there
 is no error.
 if cnt_err is true, then we have a non-fatal error.
 if cnt_err is false
========================================================
example16_i-c_t-0.3.v
// if (cnt_err)
// FSM should raise error if system is in escalation
// else
// FSM should remain in current state
// end
// end

========================================================
example17_i-c_t-0.3.v
// escalate_en_i = lc_ctrl_pkg::Off;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example18_i-c_t-0.3.v
// if (cnt_err)
// escalate_err_o = 1'b1;
// end
// end
// end
// end
// end
// end

========================================================
example19_i-c_t-0.3.v
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is in
 normal mode. In this case, the system should not enter
 escalation mode.
 if escalate_en_i == lc_ctrl_pkg::On, then the system is in
 escalation mode. In this case, the system should enter
 normal mode.
 if escalate_en_i == lc_ctrl_pkg::Reset, then the system
 is in escalation mode and the system should enter normal
 mode.
 if escalate_en_i == lc_ctrl_pkg::Off, then the system is
 in normal mode and the system should enter escalation
 mode.
 if escalate_en_i == lc_ctrl_pkg::Reset, then the system
 is in normal mode and the system should enter escalation
 mode.
 end

========================================================
example0_i-c_t-0.5.v
 - does not work because we do not have the status from the system
 - we do not know if it is in escalation
 - what we have to do is to disable "fatal error" and raise an error
 - disable "fatal error" and then we can raise an error
 - OR we could just disable "fatal error" and then we can do what we want
 - we will need to see if the status is correct (if not in escalation,
 - we can do what we want
 - so the solution is just to disable "fatal error" and then we can
 do what we want.
 - also we need to see if the system status can be updated
 - according to the spec, the system status can only be read
 - so we need to update the status somehow
 - currently we are doing it via the debug interface
 - we need to see how the
========================================================
example1_i-c_t-0.5.v
// if escalation is off, then the system should not be in escalation state
// if (cnt_err) begin
// if (escalate_en_i != lc_ctrl_pkg::Off) begin
// escalation is on, but FSM should not be in escalation state
// escalation_state = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example2_i-c_t-0.5.v
escalation might be caused by software bug.
escalation should be detected by software and lead to ErrorSt state
escalation should be detected by hardware and lead to ErrorSt state
escalation should be detected by software and lead to ErrorSt state
escalation should be detected by hardware and lead to ErrorSt state
escalation should be detected by software and lead to ErrorSt state
escalation should be detected by hardware and lead to ErrorSt state
escalation should be detected by software and lead to ErrorSt state
escalation should be detected by hardware and lead to ErrorSt state
escalation should be detected by software and lead to ErrorSt state
escalation should be detected by hardware and lead to ErrorSt state
escalation should be detected by software and lead to ErrorSt state
escalation should be detected by hardware and lead to ErrorSt state
escalation should be detected by software and
========================================================
example3_i-c_t-0.5.v
// This is not a problem. The FSM is responsible for raising the
// error. Other modules are not allowed to raise the error.
// Here we are just trying to prevent the system from going into
// escalation mode.
// end
// end
// end
// end
// end
// endgenerate

//initialize state
assign state_q = state_d;

//state machine
always @ (posedge clock or posedge reset) begin
if (reset)
// reset
state_d <= ResetSt;
else
case (state_q)
ResetSt: begin
// reset
state_d <= WriteSt;

========================================================
example4_i-c_t-0.5.v
 - check if escalation is active
 - if active, then wait for timeout and then escalate
 - if timeout, then escalate
 - if escalation is active, then wait for timeout and then return to original level
 - if timeout, then escalate
 - if escalate returns a level, then use this level and return to original level
 - if level is not equal to original level, then escalate again
 - if timeout, then escalate
 - if escalate returns a level, then use this level and return to original level
 - if level is not equal to original level, then escalate again
 - if timeout, then escalate
 - if escalate returns a level, then use this level and return to original level
 - if level is not equal to original level, then escalate again
 - if timeout, then escalate
 - if escalate returns a level, then use this level and return to original level
 - if level
========================================================
example5_i-c_t-0.5.v
// if (cnt_err) begin
// escalate_err_i = 1'b1;
// end
// end
// end


// This is the final state of the FSM. It is responsible for
// generating the correct response to the incoming LSI.

// The LSI is handled by the upper layer.
// The response is sent out through the response interface,
// which is based on the last LSI seen.

// The LSI is handled by the upper layer.
// The response is sent out through the response interface,
// which is based on the last LSI seen.

// The response is sent out through the response interface.
// The response interface is based on the last LSI seen.

// The response is sent out through the response interface.
// The response interface is based on the last LSI seen.

// The response is
========================================================
example6_i-c_t-0.5.v
 1. Escalation is not implemented.
 2. Escalation does not lead to fatal error.
 3. Escalation is controlled by the System-on-Chip.
 4. Escalation is controlled by the user.
 5. Escalation is controlled by the system.
 6. Escalation is controlled by the user.
 7. Escalation is controlled by the system.
 8. Escalation is controlled by the user.
 9. Escalation is controlled by the system.
 10. Escalation is controlled by the user.
 11. Escalation is controlled by the system.
 12. Escalation is controlled by the system.
 13. Escalation is controlled by the user.
 14. Escalation is controlled by the system.
 15. Escalation is controlled by the user.
 16
========================================================
example7_i-c_t-0.5.v
 - consider the escalation
 - should be a command line option
 - maybe the FSM should be a module
 - probably a command line option for the state machine
 - how to handle the escalation?
 - maybe there is a way to do it in a single line
 - how to do it on the fly?
 - maybe a flag in the system?
 - how to do it on the fly?
 - maybe a CMD_LINE in the system?
 - how to do it on the fly?
 - maybe a way to do it in a single line?
 - how to do it on the fly?
 - maybe a special way to do it in a single line?
 - how to do it on the fly?
 - maybe a way to do it in a single line?
 - how to do it on the fly?
 - maybe a way to
========================================================
example8_i-c_t-0.5.v
 escalate_en_i = lc_ctrl_pkg::Off;
 the above line will not work.

 escalate_en_i = lc_ctrl_pkg::Off;
 the above line will not work.

 escalate_en_i = lc_ctrl_pkg::Off;
 the above line will work.

 escalate_en_i = lc_ctrl_pkg::Off;
 the above line will not work.

 escalate_en_i = lc_ctrl_pkg::Off;
 the above line will not work.

 escalate_en_i = lc_ctrl_pkg::Off;
 the above line will not work.

 escalate_en_i = lc_ctrl_pkg::Off;
 the above line will not work.

 escalate_en_
========================================================
example9_i-c_t-0.5.v
������Ķ�ȵ�λ��İ�źĵ�����һ�����־�����Ĵ�ļ������ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����ļ�����
========================================================
example10_i-c_t-0.5.v
 Instead of checking against the stack, we have to check against the
 stack pointer. This is because the stack pointer is incremented
 by the FSM, and we have to make sure that the pointer is not
 below the stack.
 Thus, if the stack pointer is less than the stack, we have to
 escalate.
 We can also check if the stack is empty, but then we have to
 check if the stack pointer is still equal to the stack
 and if this is the case, we have to escalate.
 If the stack is empty, we have to escalate anyway.
 If the stack is not empty, we can check that the pointer
 is equal to the stack as well.
 If the stack is not empty, we can check if the stack pointer
 is equal to the bottom of the stack.
 If the stack is not empty, we have to escalate.
 We
========================================================
example11_i-c_t-0.5.v
 - Escalation does not lead to fatal error
 - Escalation is handled in a special way. See "ESC_HANDLING"
 - Escalation is handled by a special module, that is not part of the
 FSM. See "ESC_HANDLING" in the FSM implementation.
 - Escalation is not handled by the FSM. The FSM will be in an
 unknown state.
 - The escalation mechanism is only used for non-fatal errors.
 - When the FSM does not generate any error, it will be in an idle
 state.
 - The escalation mechanism is only used if the FSM is allowed to
 generate errors.
 - If the FSM is allowed to generate errors, then it will be in
 a non-idle state.
 - If the FSM is allowed to generate errors,
========================================================
example12_i-c_t-0.5.v
// Escalation to certain system states is not allowed
// if (cnt_err)
// FSM should raise error
// end

========================================================
example13_i-c_t-0.5.v
 if escalate_en_i == lc_ctrl_pkg::Off, then
 we escalate to the highest level and expect the system to
 raise an error.
 if escalate_en_i == lc_ctrl_pkg::On, then it is
 expected that the system will escalate, and we
 expect the FSM to raise the error.
 if escalate_en_i == lc_ctrl_pkg::Off, then
 we can safely assume that the system will
 escalate, and we do not need to raise the error
 if escalate_en_i == lc_ctrl_pkg::Off
 then we do not expect the system to escalate
 and we do not need to raise the error.
 if escalate_en_i == lc_ctrl_pkg::On, then
 we expect the system to escalate, and we
 expect the FSM to raise
========================================================
example14_i-c_t-0.5.v
 should not allow escalation if there is no error
 escalating to a non-fatal error is not possible
 escalation is possible only if there is a fatal error
 escalation is not possible if a non-fatal error is reached
 escalation is possible if a fatal error is reached
 escalation is not possible if a non-fatal error is reached
 escalation is possible if an error is reached
 in case of escalation, a non-fatal error is also permitted
 in case of escalation, a non-fatal error is also permitted
 escalation is not possible if a non-fatal error is reached
 escalation is possible if a non-fatal error is reached
 escalation is not possible if a non-fatal error is reached
 escalation is not possible if a non-fatal error is reached
 escalation is not possible if a non-fatal error is reached
 escalation is not possible if a
========================================================
example15_i-c_t-0.5.v
skyeye will raise error if escalate is on
skyeye will raise error if escalate is on and error is also on
skyeye will not raise error if escalate is on and error is not on
skyeye will not raise error if escalate is not on and error is on
skyeye will not escalate when error is on
skyeye will not escalate when error is not on
skyeye will not escalate when error is not on
skyeye will not escalate when error is not on
skyeye can be in escalation mode when error is on
skyeye can be in escalation mode when error is not on
skyeye can be in escalation mode when error is not on
skyeye can be in escalation mode when error is on
skyeye can be in escalation mode when error is not on
skyeye can be in escalation mode when error is not on
skyeye can be in escalation mode when error
========================================================
example16_i-c_t-0.5.v
 - what should be done if escalate is off and we have a single
 error?
 - we should be able to reset the system, but only if there are no
 errors.
 - we should be able to reset the system if there are no errors,
 but only if the system is not in escalation mode.
 - we should be able to reset the system if there are no errors,
 and the system is in escalation mode.
 - we should be able to reset the system if there are no errors,
 and the system is not in escalation mode.
 - we should be able to reset the system if there are no errors,
 and the system is in escalation mode.
 - we should be able to reset the system if there are no errors,
 and the system is not in escalation mode.
 - we should be able to reset the system if there are no errors,

========================================================
example17_i-c_t-0.5.v
 if escalation is active, then we should have a valid error code.
 if error code is not valid, then escalate.
 if error code is valid, then escalate only if escalate_on is active.
 if error code is valid and escalate_on is active, then escalate.
 if error code is valid and escalate_on is inactive, then return it.
 if error code is valid and escalate_on is inactive, then return it
 if error code is not valid, then return it.
 escalation should be handled in the FSM.
 if escalation is active, then the code must be valid.
 if escalation is inactive, then the code must be valid.
 if the error code is valid, then escalate only if escalate_on is active.
 if the error code is valid and escalate_on is inactive, then return it.
 if the error code is not valid, then return it
========================================================
example18_i-c_t-0.5.v
// if escalate_en_i != lc_ctrl_pkg::Off, we have to
// either wait for (cnt_err == 1'b1) or raise
// error immediately
// end
// end
// else begin
// end
// end
// end

========================================================
example19_i-c_t-0.5.v
 if escalate_en_i is set, we should be in escalation, and if
 we are in escalation, we should be in Error state.
 If escalate_en_i is set, then we should not be in Error state,
 otherwise we are in escalation and should be in Error state.
 We currently are in Error state if escalate_en_i is not set.
 This is to prevent the system from coming out of escalation mode
 until an error is detected.

 if escalate_en_i is set, then we should have been in Error
 state in the first place. This is to prevent the system from
 coming out of escalation mode until an error is detected.

 if escalate_en_i is not set, then we should have been in
 Error state in the first place. This is to prevent the system
 from coming out of escalation mode until an error
========================================================
example0_i-c_t-0.7.v
 adherent: While in test how to kill a process which is in action
 you need to send a signal to theprocess to let it come back to
 the normal state.

 this will cause the process to be killed during the escalation state.

 Note: This should not be an error
 mailed by jemma@apol.com

  there is a problem with the state machine. The process is
  killed on the way to the escalation state.
  One way to fix this is to use the wtmagiclayers to have only
  the toplevel layer use the escalation logic.
  This needs more work. I am not sure how to use the wtmagiclayers
  in the way the current design uses them.
 
  With the following code, the process is killed on the way to the
  escalation state.
========================================================
example1_i-c_t-0.7.v
// from rk 2013-10-16
// avoid the escalation state,
// avoid transition to error state when error detected,
// then reset the FSM and restart the cycle
// to avoid potential deadlock of system
// reset the FSM if it is in escalation state.
// if (state_d == EscalateSt) begin
// esccmd.reset.set(1);
// end
// else begin
// esccmd.reset.set(0);
// end
// end
// end

========================================================
example2_i-c_t-0.7.v
// if (cnt_err)
// escalate_en = 1'b1;
// end else
// escalate_en = 1'b0;
// end
// end else if (cnt_err) begin
// escalate_en = 1'b1;
// end end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example3_i-c_t-0.7.v
 Is rack and pin still valid on reset?
 If yes, we can reset the machine and the system will
 restart the normal operation.
 TODO: Escalation must not be possible while the system is
 running in normal operation mode. To be able to handle
 the recovery from an internal failure, the system must be
 shut down gracefully.
 If the system is shut down properly, the recovery
 operation shall be handled automatically.
 If the system is in normal operation mode, then
 the recovery operation must be handled manually
 by the operator.
 TODO: Escalation must not be possible on a system which
 has been started in normal operation mode.
 TODO: Escalation must not be possible on a system which has
 been shut down gracefully.
 TODO: Escalation must not be possible if the system is
 in recovery operation mode
========================================================
example4_i-c_t-0.7.v
 either escalate or kill the system.
 either way, the system should only transition to the Error state.
 however, this FSM is only allowed to transition to the Error state when
 it is in an escalation state.
 if escalate_en_i is set, it will transition to the Error state.
 if however, the system is in an error state so that the escalation
 function is no longer possible (and the system must kill), then it
 will transition to Error as well.
 the escalation must be allowed to run until the system is in an error
 state.
 therefore, we change the state to Error in two cases:
 1. when the system is in an error state
 2. when the system is in an escalation state and will crash
 because of the escalation.
 The state machine will therefore be forced to transition to the
 Error state once the system is in an
========================================================
example5_i-c_t-0.7.v
// FSM should not raise error when system is in escalation
// unless the condition that the system is in escalation was
// specifically requested to be executed.
// plus we need to prevent escalation of a system that
// is already in emergency.
// if (escalate_en_i == lc_ctrl_pkg::On) begin
// this can be done by comparing the emergency bit.
// if (cnt_err && cnt_err_for_emer) begin
// escalate
// end
// end
// end
// end
// end
// end
// end

========================================================
example6_i-c_t-0.7.v
// if escalate_en is on the system should not be in the
// escalation mode, therefore we need to make sure
// that state_d is unset
// end
// end

========================================================
example7_i-c_t-0.7.v
 Problem of escalation fsm is in start state.
 If some other fsm than esc fsm gets into start state,
 nothing happen. After this fsm is done, esc fsm would also
 attempt to escalate.
 Therefore, this esc fsm lock needs to be removed.
 When escalating, we need to set a pkg_
========================================================
example8_i-c_t-0.7.v
// anytime escalate, we need to be in the error state.
// if (cnt_err) begin
//
// escalate until we hit the maximum allowed error count
//
// end
// end
// end case
//
// LCO.FSM.LOCAL_ESC < LCO.FSM.GLOBAL_ESC
// BUG: Escalation does not lead to a fatal error
//
// escalate_en_i=lc_ctrl_pkg::Off || cnt_err;
//
// if (escalate_en_i) begin
//
// escalate until we hit the maximum allowed error count
//
// end
// end

========================================================
example9_i-c_t-0.7.v
 (1) system in escalation must not be in error state
 (2) system in escalation must not be in emergency state
 (3) in emergency state must be in system in maintenance
 (4) system in maintenance must not be in error state
 (5) system in maintenance must not be in maintenance state
 (6) system in maintenance must not be in emergency state
 (7) system in emergency must not be in maintenance state
 (8) system in emergency must not be in error state
 (9) escalation must be of "initial" or "rotary" type
 (10) once system is in maintenance keep it in maintenance mode
 (11) once system is in maintenance mode keep it in maintenance mode
 (12) once system is in emergency mode keep it in emergency mode
 (13) once system is in emergency mode keep it in emergency mode
 (14) once system reaches
========================================================
example10_i-c_t-0.7.v
// around the mark of initialization, the system is already in escalation
// as a consequence, we need to disable this feature.
// however, if the system enters in escalation from a power-off state,
// we still need to enable it so the system is forced to enter in
// the power off mode and then to power on.
/*
// if system is in shutdown or off state,
// we force the system to go through initialization sequence
// in order to roll-over the system.
if (sysb_reg_pwr == SysOff) begin
initial_mode_reg = 1'b1;
sysb_reg_pwr <= SysInit;

========================================================
example11_i-c_t-0.7.v
 if escalate_en_i is non-zero,
 the only way that this can happen is if
 the system is in reset, which will
 prevent the FSM from getting to the error state.
 however, if escalate_en_i is non-zero and
 and error occured, the FSM will never get to
 the error state, and will instead immediately
 transition to the system reset state.

 if escalate_en_i is zero, then the system
 will proceed to the normal error state,
 which will most likely result in a non-fatal
 error code.

 currently the only way to test this is to
 pass a string to the e-invoke task, and
 observe that the result is the expected string.
 and if the result string is not the expected string,
 then the task has not had an appropriate effect.
========================================================
example12_i-c_t-0.7.v
 will make system go to error state if it is in escalation.
 make it return error only if it needs to.
 I think it will do this:
 if escalate_en_i == 1'b0:
 state = idle;
 if escalate_en_i == 1'b1:
 state = err;
 if nothing is there it should just return to idle.
 if nothing happens to the system - eg. from outside the control
 system
 then no error needs to be raised.
 todo: add check for whether it is safe to disable the system
 todo: add safety net if system already in error
 todo: security mechanism for system to be turned on again

 security mechanism:
 1. upon system power up, unless it is in user mode, the system will
 turn off after a timeout.
 2. upon system reset
========================================================
example13_i-c_t-0.7.v
 escalate condition must be removed to avoid multiple entry into ErrorSt
 however, it is better to have a single entry from the scheduler
 to the error state to be able to debug if configuration files
 are not cleanly interpreted by the user
 escalate condition must be removed to avoid escalation cycle
 escalate_en_i = lc_ctrl_pkg::Off;
 on error, the system will be brought under control and the
 configuration files need to be re-interpreted by the user
 and the system should be brought under control, not necessarily
 restarted, but nonetheless in a controlled state.

========================================================
example14_i-c_t-0.7.v
 In Escalation, lc_ctrl_pkg :OFF, and the system
 should pass through. If the system is in escalation
 mode, and the lc_ctrl_pkg has been set to:OFF,
 and the system is in error, then we should pass through
 and not raise the error.
 In Escalation, lc_ctrl_pkg :OFF, and the system
 should pass through.
 On the other hand, if the system is in error,
 then we have to raise the error.
 however, we need to eventually make sure that the
 error can be looked at and solved.
 We may have to consider escalation state as
 a continous state (e.g. always on) to make sure
 we do not miss the signal.
 In the end, we need to have an escalation mode that
 can be independently controlled by software
========================================================
example15_i-c_t-0.7.v
// Since the error might already have been raised we simply
// ignore it and wait for the escalation to be handled.
// This is less then ideal but works for now.
// if (cnt_err && escalate_en_i)
// escalate_err_ff = 1'b1;
// end
// end
// end



========================================================
example16_i-c_t-0.7.v
@.@
@.@@.
@.@.@.
@.@.@.
@.@@@@.
@.@.@.
@.@@@.
@.@.@.
@.@.@.
@.@@@@.
@.@.@.
@.@.@.
@.@@@@.
@.@.@.
@.@.@.
@.@@@@.
@.@.@.
@.@.@.
@.@@@@.
@.@.@.
@.@.@.
@.@@@@.
@.@.@.
@.@.@.
@.@@@@.
@.@.@.
@.@.@.
@.@@@@
========================================================
example17_i-c_t-0.7.v
// If any error occur during escalation process, then
// the whole system should be forced to maintenance mode
// until the escalation process is completed
// however, for now we simply return to error state
// totill we figure out how to do it more gracefully
// end
// end


========================================================
example18_i-c_t-0.7.v
// if (cnt_err)
// escalate_err_e = 1'b1;
// end if
// end if


========================================================
example19_i-c_t-0.7.v
// only escalate when the system is in error
assign escalate_en_q = cnt_err;
assign escalate_en_i = escalate_en_q;
assign escalate_en_o = escalate_en_i;
assign escalate_err_o = cnt_err;
assign cnt_err = escalate_err_i;
assign error_e = escalate_err_i;
assign error_q = error_e;
// end
// else if (ctrl_pkg_e == SEC_CM_LCI_FSM_GLOBAL && error_q != NoError) begin
//
// escalate the error and track the error count
// until the error count is reached we raise the error
//
assign raise_error = error_q;
assign error_cnt_rst = cnt_err;
assign escalate_err
========================================================
example0_i-c_t-0.9.v
// just wait 100ms for now because of N red leds that are not working
// be led
wait 100000info(wait100);
//wait until exception will be raised
wait(error != NoError);


//if (error_q != NoError) begin
//
//throw exception;
//
========================================================
example1_i-c_t-0.9.v
// if cnt_err and escalate not yet off, then escalate now and flip err_led on
// if cnt_err and escalate is off, then don't clear err_led, so that the error
// led cycle can continue and then flip err_led (if system in escalation)
//?? if cnt_err, is there a condition where escalate must first be off, before error?
//?? if escalate not over off, only flip err_led?
async_disable_error_led = 1'b1;

========================================================
example2_i-c_t-0.9.v
 chang稹信細地合包䨹儤鎰樺�轉租柴埋;
 鍛程標氏贶鍕儤發e
 chang權翨垵背小鍕版標氏
 chang權翨垵背小鍕版
 chang權垵宝九位臺發不環
 chang權垵宝一位臺發不環
 chang權翨垵背小鍕版
 chang權翨垵背小�
========================================================
example3_i-c_t-0.9.v
//when occur escalate error,system stop,we need to write to servo state reg to close the ESC,other servo should start open.
//when normal escalate end,open the idle servo...

========================================================
example4_i-c_t-0.9.v
itzerland Apr. 2019 - restore ESC hi, hi dhi
 In normal conditions following line fixes the issue
 andruption escalation (setDebug, escalate, reset debug controller).
 However the current implementation gives users access to
 system functions in the abnormal conditions, which during
 the shutdown process is very difficult to handle
 The implication of this issue is the users can access
 the system functions at the critical moment, which
 seems ponderous for the management and operation of the
 system.
formation of a critical time does disable the system access
 by default, but the interrupt request could enable system
 access, this system weight is not suitable.

 Once in the shutdown state, we no longer
 allow to use system functions
 The reason is from our requirement, system functions
 should not rely on any external indicator to work.
 So, we use one 
 Response to Interaction
========================================================
example5_i-c_t-0.9.v
 We do not go into Error mode on CPU reset, if that was type of escalation
 action initiated?
 What if only one of these is happening? Should we go into Error?
 What if both occur at same time???? Do we know that the ACK was received,
 before the reset response. ???
 I think we want all resets to be treated as system exiting resets -
 this way system should fully clean up for extended time, and get booted
 from under such massive errors. If the OE polarity is active, then the
 system itself might use this reset(), rather than the external reset signal.
 The broadcast mode means this pulse actually goes out to all
 systems and external circuits.
 The normal resets are here so the system can get going. The
 external system resets are held off during START sequence.
 Q? do we want event log of these resets to
========================================================
example6_i-c_t-0.9.v
// this automatically jumps to error state if the test fails inside
// a case that should always wait to achieve a timeout.
// regardless of timeout it was successful and we should advance to
// the final state.
// Brave new future: we allow escalation commands to advance the FSM
// state, but the system cannot advance further than the final state.
// After that, escalate will stop at the final state.
if (escalate_en_i) begin
case (state_i)
CodeError,
ScErrorP
========================================================
example7_i-c_t-0.9.v
//usage: sec_fsm::error_check
//error_detection logic check and raise an error if any suspicous errors are found. 
// NOTICE THAT THIS IS EVENT-FREE SYSTEM USING 
//TESTING THE LDR, HLT SYSTEM FRAMES
//---------------------------------------------------------
//[`ENUM_MODELS:SEC_FRAC_MODELS]
//---------------------------------------------------------
//DEBUG: Error Latch reg
//--------------------------------------------------------
//approx 10 gammas
//---------------------------------------------------------
//DEBUG: Addr. reg-low bits, LVL1 and LM2 bits
//---------------------------------------------------------
//** `SC_BUS_DEBUG_USR
`include "sys_cof.v"
module sst_tb(
	clk, rst, result
);

input clk;
input rst;
output[7:0]result;
reg b_rst;


========================================================
example8_i-c_t-0.9.v
//lci20110305 to match LS-NG scaling and to support DIH cards
// we need to be aware if the system is running in emergency
// mode. When the system is in stability operations,
// it is possible to inject a security event which
// mandates a security operation immediately on the
// system. Once this security operation is done,
// the system can continue to operate as normal.
//this logic ensures the system will be reset if
// a security event is received.
// in stabilized operation, these steps are not needed!
//escalation_modes:security policy section must return true
if (system_is_in_emergency || escalation_modes) begin
error_lternalit = escalation_it;
error_fatalit = 1'b0;

========================================================
example9_i-c_t-0.9.v
// opps this (illegal) escalation, while Schools have to balance o.s.
// however, all those corrupted OTP words will probably not affect system
// as it only counts up the number of error words.
// forgive customers who did his system under risk of corrupted OTP
// spy, hillibrated,
// for the schools that have to balance disasters/atmospheric changes on their
// critical systems while there are still corrupt OTP words
// Note: for a custom escalation, one was needed before escalations could be
// initiated.
// Would not be so difficult for a custom escalation if an increased number of
// error words is required to raise an escalation
// => solution: allow for some corrupt OTP words per system.
// on the other hand, other ways to solve this (ex. increased error words
// forced in via part parameters) are less flexible and not universally
// implementable


========================================================
example10_i-c_t-0.9.v
// Use priority encoding
// Era: 2020.10.1.2
// Version: 1.11
// With the following component found out during the prototype project.
// "Pass is unsupported when CONFIG="EnvVarying". Please contact
// T-Platform Technology for additional information"
//
// Priority Code: PROTOCOL0003.Gen|SemiGen.vhd
//
//(TC69) Add unnamed component, each generated will have a warning.
//(TC67) Add warning to system cli component param def
//(TC75) This is derived from loopback connection. Optimize connections if required.
//(TC63) Add default param to system cli component
//
// Added by System-Design 雛纤

module PartitionM (

input clk_100M,

//输入端口
input [4:0
========================================================
example11_i-c_t-0.9.v
// EvError code is generated only in the escalation mode
// The module must set the args with an appropriate mode when instantiated
// Examples: lc_mod_LPM, lc_mod_SM etc.
//moved the check to maintain state

// to corroborate, we can create a counter per LCE module
// in order to be able to perform a locked mechanism.
// Not done due to some potential gotchas.
//then again: an offending module may stick for too long, but one per LCE
//should be enough for locking
// then request-supply of ee's plugged to that module should facilitate state
//synchronization afa the chip.

init initial {
term_cnt_r = cnt_err;
}
always @(*) begin
if (bypass_en_i == `BypassEnabled) begin
// force cnt_err =
========================================================
example12_i-c_t-0.9.v
// properly escalate to the final component (rcl1.3.lsrv2-0-1.simg.)
// attempting to recover from a non-fatal source. 
// however, the system could be one of two valid locations in the case where
// the FSM should not even go into the Error state.
// yet, we do allow escalation to the final location
// as a necessary condition for the system to fully be recovered.
// however, we "guarantee" that the system reaches its final valid
// state ONLY after being recovered.
// We could avoid this condition by allowing the system to reach any
// non-error state (state when no error has been raised) and attempt
// recovery with only that one state.

========================================================
example13_i-c_t-0.9.v
// Satan manages to escalate manually
// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv vs11.1 series v11.2
// ac: if flpg == Escpl, then command escalating has been disabled probably to shut system off
// vvvvvvonly one quite version
if (os::FSIsMappedGlobally(flpg))
begin
// AC: aic animation should disable escalating of commands for auto shutdown
if (flpg == Escpl && !Generic_MF_with_PwrCtrl_AF_using_M_FS_O_L1_H1 _AutoShutDown)
begin
LogicalError<EscalationErr>::LogicalError
(FsmError, Role, LcmdExc, "inconsistent state",
"LCI.
========================================================
example14_i-c_t-0.9.v
// escalation should only be possible when in a critical state
// if (cnt_err)
// WARNING: could be escaping from escalation
// else
// escalation could be granted anyway
// end
// endelse
// statemach_err_o = 1'b0;


========================================================
example15_i-c_t-0.9.v
// if a mismatch at the top level enum occurs, this FSM will lock up.
// as part of the work to fix, all the ESC/FSM state operations are
// brought into the escafe layer - ideally one day, we only integrate them in here
// and switch the system around
// (also: ESC/FSM need to be more compartible and integrated with other layers;
// in general, i think we should keep using the escafe layer, and prevent
// people from accessing individual registers/segments directly)

========================================================
example16_i-c_t-0.9.v
// This leads to deep stack in escalation mode only.
// Advisable to have system startup with no escalation before
// one could be placed.
// Dummy output until FSM really raises error.
// cmdl_eth_err(ErrorSt);
// fixme side effect
// opt: notify outside modules of error condition turn-off
// escalation
endum{
// This is not a real access to the EEPROM, so the EEPROM
// whole will only be read/programmed if enabled at all.
cmdl_do_ejtag_1(1'b0);
// end ejtag
endum{
cmdl_do_hdr(False);
enduml{
if (system_lock_hold_in == 0)
do_scr(erase_conf, True);
elsenif (reset_lock_machine == 1) begin
do_scr(*write_
========================================================
example17_i-c_t-0.9.v
 error only returned if locked to the system which will not end the system life
 until the password is reset.
 however this can be condensed in the RD package as, the encryption failure
 will be generated here, and the password will be set. therefore, we are
 allowed to use the silent mode and just return.
 DSM will also work for now.
 hence error is really a kind of a password that waits in the DSM, until
 the encrypted password from the native runtime or the clear password
 matches and will return.
 still need to parse through the primary key as the lock cannot be
 released until the proper password is provided. this would be a normal
 e-pass of the content to be locked as token.

 ERR: 3 could be solved by setting the password and checking the enc_key
 using the bypass method.
 either the clear one or the one encrypted by
========================================================
example18_i-c_t-0.9.v
// esctop.c: x86 60 model: FSM escalation route disable in one-time init
// esctop.c: fetch core now forces init of core setup
// WARNING ONLY SEVERITY 5.0 CAN PASS ABOVE WARNING
usingWarning (near_warning, TypeWarning, "Control Overflow during write operation", warning_1, critical_1);


========================================================
example19_i-c_t-0.9.v
// find out if escalate is output only or not
// state has to wait yet for escalate to become input only
// once escalate is high, system needs to handle error
// otherwise FSM will have to escalate whenever
// set escalate to High to always make change.

// this can introduce double errors as current tries are
// increased before escalate is set.
// have one job to deal "transient" error (not needing
// escalating, but system needs to ask if to escalate.
// to have one job, needs escalate in system guard.

// if escalate had not yet happened, current system has to
// use onActive cannot escalate.

// escalate can be reconfigured, though
// escalate system needs to make sure to mark dirty if escalate == 1
// when it also has to mark dirty for that reason it
// cannot simply use the on* action from b&c interface

// thus I can only assume to
========================================================
example0_i-d_t-0.1.v
 if (cnt_err)
 Assert error when escalation input is high
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example1_i-d_t-0.1.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end
// end

========================================================
example2_i-d_t-0.1.v
 if (cnt_err)
 Assert error when escalation input is high
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example3_i-d_t-0.1.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end

========================================================
example4_i-d_t-0.1.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end

========================================================
example5_i-d_t-0.1.v
 if (cnt_err)
 Assert error when escalation input is high
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example6_i-d_t-0.1.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end

========================================================
example7_i-d_t-0.1.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end

========================================================
example8_i-d_t-0.1.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end

========================================================
example9_i-d_t-0.1.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end

========================================================
example10_i-d_t-0.1.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end

========================================================
example11_i-d_t-0.1.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end
// end

========================================================
example12_i-d_t-0.1.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end

========================================================
example13_i-d_t-0.1.v
 if (cnt_err)
 Assert error when escalation input is high
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example14_i-d_t-0.1.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end
// end

========================================================
example15_i-d_t-0.1.v
 if (cnt_err)
 Assert error when escalation input is high
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example16_i-d_t-0.1.v
 if (cnt_err)
 Assert error when escalation input is high
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end

========================================================
example17_i-d_t-0.1.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end

========================================================
example18_i-d_t-0.1.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end

========================================================
example19_i-d_t-0.1.v
// if (cnt_err)
// Assert error when there are errors
// else
// Assert error when escalate input is high
// end
// end
// end

========================================================
example0_i-d_t-0.3.v
// if (cnt_err)
// Assert error when we see a fatal error.
// end
// end
// end

========================================================
example1_i-d_t-0.3.v
 Assert error when escalate input is high and no error yet.
 Assert error when escalate input is high and an error has been
 detected.
 Assert error when escalate input is high and the error is not
 recoverable.
 Assert error when escalate input is high and the error is not
 recoverable.
 Assert error when escalate input is high and the error is
 recoverable.
 Assert error when escalate input is high and the error is
 recoverable.
 Assert error when escalate input is high and the error is
 not recoverable.
 Assert error when escalate input is high and the error is
 recoverable.
 Assert error when escalate input is high and the error is
 not recoverable.
 Assert error when escalate input is high and the error is
 recoverable.
 Assert error when escalate input is high and
========================================================
example2_i-d_t-0.3.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end

========================================================
example3_i-d_t-0.3.v
 if (cnt_err)
 Assert error when the error has been cleared.
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 
========================================================
example4_i-d_t-0.3.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when escalation input is low
// end
// end

========================================================
example5_i-d_t-0.3.v
// if (cnt_err)
// Assert error when escalation input is high
// else
// Assert error when cnt_err is zero
// end
// end

========================================================
example6_i-d_t-0.3.v
// if (cnt_err)
// Assert error when we have at least one error, and escalate input is high
// else
// Assert error when escalate input is high and we have no errors
// end
// end
// else
// Assert error when escalate input is high and we have no errors
// end

========================================================
example7_i-d_t-0.3.v
// if (cnt_err)
// Assert error when we see a fatal error.
// end
// end


========================================================
example8_i-d_t-0.3.v
// if (cnt_err)
// Assert error when cnt_err is true
// end
// end

========================================================
example9_i-d_t-0.3.v
 if (cnt_err)
 Assert error when error count is non-zero
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 end
 
========================================================
example10_i-d_t-0.3.v
// if (cnt_err)
// Assert error when escalation input is high
// end
// end

========================================================
example11_i-d_t-0.3.v
// if (cnt_err)
// Assert error when escalation input is high
// end
// end
// end


========================================================
example12_i-d_t-0.3.v
// if (cnt_err) begin
// escalate_err_i = 1'b1;
// end
// end
// end

// end

========================================================
example13_i-d_t-0.3.v
 This is a workaround for a known issue with the LTC2512-24
 FPGA. The issue is that the FSM will not be reset when the
 FPGA is powered on. This results in the FSM not being able to
 detect the presence of the LTC2512-24 and thus leading to a
 false positive on the presence of the LTC2512-24.

 The workaround is to reset the FSM when the FPGA is powered on.

 This is a known issue with the LTC2512-24 FPGA.

 This issue is reported on the LTC2512-24 FPGA project page:
 http:www.ltc.com/en/products/products/ltc2512-24/

 The issue is described in the following link:
 http:www.ltc.com
========================================================
example14_i-d_t-0.3.v
// if (cnt_err)
// Assert error when there are errors.
// else
// Assert no error.
// end
// end

========================================================
example15_i-d_t-0.3.v
// if (cnt_err) begin
// escalate_err_o = 1'b1;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example16_i-d_t-0.3.v
// if (cnt_err) begin
// escalate_err_i = 1'b1;
// end
// end
// end
// end
// end
// end
// end

========================================================
example17_i-d_t-0.3.v
// if (cnt_err || escalate_en_i)
// Assert error when either error has occured or when escalation input is high
// else
// Assert error when escalation input is low
// end
// end

========================================================
example18_i-d_t-0.3.v
// if (cnt_err)
// escalate_err_i = 1'b1;
// end
// end

========================================================
example19_i-d_t-0.3.v
 Assert error when escalate input is high
 Assert error when escalate input is high and the error counter is at the maximum value
 Assert error when escalate input is high and the error counter is at the maximum value and the error code is at the maximum value
 Assert error when escalate input is high and the error counter is at the maximum value and the error code is at the maximum value
 Assert error when escalate input is high and the error counter is at the maximum value and the error code is at the maximum value
 Assert error when escalate input is high and the error counter is at the maximum value and the error code is at the maximum value
 Assert error when escalate input is high and the error counter is at the maximum value and the error code is at the maximum value
 Assert error when escalate input is high and the error counter is at the maximum value and the error code is at the maximum value
 Assert
========================================================
example0_i-d_t-0.5.v
// if (cnt_err)
// escalate_err_i = 1'b1;
// end
// end

========================================================
example1_i-d_t-0.5.v
// if (cnt_err) begin
// Assert error when cnt_err is high.
// end
// end
// end
// if (escalate_en_i) begin
// Assert error when escalate input is high.
// end

========================================================
example2_i-d_t-0.5.v
 logic to check if a system is in the safe mode and if the
 security feature is enabled. If the system is in the safe mode
 then the security feature is disabled
 if (cnt_err || (cnt_err_rsp && !cnt_err_rsp_out) ||
 (cnt_err_rsp_out && !cnt_err_rsp)) begin
 Assert error when escalation input is high
 and when the system is in the safe mode and the security feature is
 disabled. Also the system is in the safe mode when the security
 feature is disabled.
 FIX:
 logic to check if the security feature is enabled.
 if (cnt_err || (cnt_err_rsp && !cnt_err_rsp_out) ||
 (!cnt_err_rsp && !cnt_err
========================================================
example3_i-d_t-0.5.v
// if (cnt_err)
// Assert error when escalate input is high
// end else begin
// end

========================================================
example4_i-d_t-0.5.v
 if (cnt_err)
 Assert error when error count exceeds limit
 if (cnt_err)
 Assert error when error count exceeds limit
 if (cnt_err)
 Assert error when error count exceeds limit
 if (cnt_err)
 Assert error when error count exceeds limit
 if (cnt_err)
 Assert error when error count exceeds limit
 if (cnt_err)
 Assert error when error count exceeds limit
 if (cnt_err)
 Assert error when error count exceeds limit
 if (cnt_err)
 Assert error when error count exceeds limit
 if (cnt_err)
 Assert error when error count exceeds limit
 if (cnt_err)
 Assert error when error count exceeds limit
 if (cnt_err)

========================================================
example5_i-d_t-0.5.v
// if (cnt_err == 1'b1 && escalate_en_i == 1'b1) begin
// AssertError(ESC_FATAL_ERROR);
// end
// end
// end



========================================================
example6_i-d_t-0.5.v
// if (cnt_err)
// Assert error
// end
// end
// end

========================================================
example7_i-d_t-0.5.v
 This is not a bug. When a reset occurs, the first operation
 of the LUT is not available. As a consequence, the escalation
 input is not available. The only way to fix this is to
 disable the escalation input when the LUT is not ready.
 This is not a problem because the escalation input is
 not used in this implementation.
escalate_err_en = 1'b1;

========================================================
example8_i-d_t-0.5.v
 This is a design issue.
 The escalation input should only be active when an error has been
 generated. However, if an error has been generated, the error
 signal would have been cleared.
 The escalation input should be active whenever there is a
 generated error.
 However, the escalation input should only be active
 when there is a generated error.
 The escalation input should only be active when
 there is a generated error.
 The escalation input should only be active when the
 error generation mechanism is active.
 The escalation input should only be active when
 there is a generated error.
 The escalation input should only be active when the
 error generation mechanism is active.
 The escalation input should only be active when there
 is a generated error.
 The escalation input should only be active when the
 error generation mechanism is active.
 The escalation input should only be
========================================================
example9_i-d_t-0.5.v
// until we figure out how to make sure that the state machine is reset,
// we cannot use this state machine anymore.
// until(!fsm_reset || fsm_state == ErrorSt) begin
//
// Assert error when escalation input is high.
//
// This is a workaround for the fact that we don't have
// a mechanism to reset the state machine.
//
// A more permanent fix for this problem is
// to implement a state machine which handles
// the ESC key properly.
//
// assign fsm_reset = 1'b1;
//
// end
// end

========================================================
example10_i-d_t-0.5.v
 If the escalation input is high, then we cannot accept
 any errors. This is a safety feature to prevent
 any hard errors due to escalation.
 However, we should still be able to set the
 error values.
 If we do not have an error, we will still
 attempt to set the error values.
 Therefore, we only assert the error when we
 encounter an error.
 We do not need to check if the error is
 NoError, because that is the default.
 However, we need to check if the error is
 not NoError.
 We do not need to check for the
 FirstErrorStatus state, because the
 only way to get to that state is via
 an error.
 We do not need to check for the
 SecondErrorStatus state, because the
 only way to get to that state is via
 an error.
========================================================
example11_i-d_t-0.5.v
 If the system is already in ErrorSt, don't escalate
 (This is not a fatal error state, but the system will
 hand off to the ErrorSt state in the next cycle)
 Assert error when escalate input is high and error is not already in ErrorSt
 If the system is already in ErrorSt, don't escalate
 (This is a normal Error state and the system will
 hand off to the ErrorSt state in the next cycle)
 Assert error when escalate input is high and error is in ErrorSt
 If the system is already in ErrorSt, don't escalate
 (This is a normal Error state and the system will
 hand off to the ErrorSt state in the next cycle)
 Assert error when escalate input is high and error is in ErrorSt
 If the system is already in ErrorSt, don't escalate
 (This is a normal Error state and the system
========================================================
example12_i-d_t-0.5.v
if (cnt_err) begin
escalate_err_e = 1'b1;

========================================================
example13_i-d_t-0.5.v
 By design, the escalation input should be always low when
 the system is in the error state. If the system is already
 in the error state, the input cannot be high.
 Assert if the system is in the error state and the
 escalation input is high.
 Assert if the system is in the error state and the
 escalation input is low.
 Otherwise, set the error flag to the same value as the
 error flag at the top of the state machine.
 The escalation input should always be set to low when the
 system is in the error state.
 If the system is not in the error state, then the
 escalation input should be set to low.
 If the system is not in the error state, then the
 escalation input should be set to high.
 If the system is not in the error state, then the
 escalation input should be set to
========================================================
example14_i-d_t-0.5.v
 Assert error when escalate input is high
 Assert error when escalate input is high and the error code is
 not "NoError"
 Assert error when escalate input is high and the error code is "NoError"
 Assert error when escalate input is high and the error code is "GeneralError"
 Assert error when escalate input is high and the error code is "GeneralError"
 Assert error when escalate input is high and the error code is "FatalError"
 Assert error when escalate input is high and the error code is "FatalError"
 Assert error when escalate input is high and the error code is "FatalError"
 Assert error when escalate input is high and the error code is "FatalError"
 Assert error when escalate input is high and the error code is "FatalError"
 Assert error when escalate input is high and the
========================================================
example15_i-d_t-0.5.v
// always @(posedge clk or posedge reset) begin
// if (reset)
// escalate_en_i <= lc_ctrl_pkg::Off;
// else if (cnt_err)
// escalate_en_i <= lc_ctrl_pkg::On;
// else
// escalate_en_i <= lc_ctrl_pkg::Off;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end


========================================================
example16_i-d_t-0.5.v
 this is already asserted in the upper layer
 if (cnt_err) begin
 this.error_d = 1'b1;
 end
 end
 end
 End of the error escalation mechanism




 






































































========================================================
example17_i-d_t-0.5.v
 This is a critical bug. Escalation must be deactivated when
 the FSM is in recovery mode. If the FSM is in recovery mode,
 the error recovery logic will be skipped and the system will
 fail.
 We need to check if the FSM is in recovery mode.
 This can be done by checking the recovery_mode bit.
 We need to check the recovery_mode bit before we assert the
 error (error recovery).
 We need to make sure that the error is cleared before the FSM
 goes into recovery mode.
 The recovery mode bit is only updated when the state machine
 goes through recovery mode.
 This is the reason for the recovery_mode check below.
 We also need to prevent the error recovery logic from doing
 anything that would interrupt the recovery mode.
 We need to make sure that the recovery mode is only enabled
 when the
========================================================
example18_i-d_t-0.5.v
// This is a workaround for a regression in the scheduler.
// The scheduler assumes a change in the global error state
// when the escalate input is high. This is not true and
// as a consequence the scheduler will not detect a change
// in the global error state.
// However, the problem is that the scheduler does not
// detect the escalation at all.
// The workaround is to set the global error state to
// true when the escalate input is high. This is not
// correct, but the system will work out of the
// global error state anyway.
// This should be fixed in the scheduler.
//
// ASSERTION: The global error state is not
// synchronized with the local error state
// ASSERTION: The local error state is not
// synchronized with the global error state
// ASSERTION: The global error state is not
// synchronized with the local error state

========================================================
example19_i-d_t-0.5.v
// if (cnt_err_in == 0)
// escalate_err_q <= 1'b1;
// end else begin
// escalate_err_q <= 1'b0;
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end
// end

========================================================
example0_i-d_t-0.7.v
// In case of internal error, bail out to kill all the processes.
// In most cases, the processes will be killed in the process of recovery (this way not recoverable).
// -- Change to ErrorSt, after the recovery procedure has been implemented
// -- ErrorSt will wait and try to recover, and kill the processes if cannot recover.
// -- If cannot recover, the processes will be killed immediately.
// -- Otherwise the process can be recovered
// -- But in case the processes are killed, we can not recover.
// -- So, when the recovery process has been implemented, the counter for the processes can be
// -- increased so that the processes can be recovered.
// -- No matter whether the recovery process is implemented or not, the program should be killed
// -- if the process can not be recovered.
// -- For more details, please refer to the "User guide" and the "FAQ"
if (escalate_
========================================================
example1_i-d_t-0.7.v
// Assert exception is not a fatal error
// asserterr;
// end
// end

========================================================
example2_i-d_t-0.7.v
// Do not allow escalation input to jump directly to an error state.
// Instead, jump to DoStateTerminalError.
// however, Escalation is never used after the first request
// until the subsequent request is made.
// Hence, we use the same code as the initial state here.
// state_d = (state_q == InitialSt) ? DoStateInitialError : DoStateTerminalError;
// end
// else begin
// state_d = (state_q == InitialSt) ? DoStateInitialError : DoStateTerminalError;
// end
// end
// end
// else begin
// state_d = (state_q == InitialSt) ? DoStateInitialError : DoStateTerminalError;
// end
// end
// end
// end




========================================================
example3_i-d_t-0.7.v
 if escalate_en_i'(escalate_en_i) == 1'b1 
 then escalation error should also consider non-fatal errors 
 exists err_t, so we can pass that to the escalation module
 exactly what we need to pass into escalation, depends on the type of ERR
 if any bit is set and the ERR is not a "fatal" type, then escalate, 
 otherwise escalate only with the "fatal" set
 if all bits are set, then escalate only with the "fatal" bit set
 if all and not the "fatal" bit is set, then escalate only with the "fatal" bit set
 if any bit is set and the ERR is a "fatal" type, then escalate
 otherwise cancel the escalation
 do not escalate if the error is not a fatal error
 if the error is not a fatal
========================================================
example4_i-d_t-0.7.v
// if (cnt_err)
// Specify a state for 'Error'
// else if (cnt_err)
// reset the error counter
// end


========================================================
example5_i-d_t-0.7.v
errordef(`error_escalation, "Asynchronous escalation detected!");

========================================================
example6_i-d_t-0.7.v
 passive_i = 1'b0;
 deprecated if block
 if (cnt_err) begin
 ERROR_DETECTOR: vcc_supply.EU_PS_EU_NODE.LC_ERROR_HANDLING_ROUTE.vcc_link : WARNING: 11/11/2008 20:28 - warning: no type or width for signal: ct_err_route_to_rst_s"ct_err_route_to_rst_s"");
 end
 end
 else if (cnt_rst) begin
 ERROR_DETECTOR: vcc_supply.EU_PS_EU_NODE.LC_ERROR_HANDLING_ROUTE.vcc_link : WARNING: 11/11/2008 20:28 - warning: no type or width for signal: ct_rst
========================================================
example7_i-d_t-0.7.v
 if (cnt_err == NoError)
 erg(`CFG_ERR_ESC_MIN, "Escalation to fatal error violated");
 else 
 erg(`CFG_ERR_ESC_MIN, "Escalation to non-fatal error violated");

========================================================
example8_i-d_t-0.7.v
// pre-assign escalate_en_i = lc_ctrl_pkg_2:Escalation_Switch;
// end
// end

// end else Assert error when escalate input is high

========================================================
example9_i-d_t-0.7.v
// a) on death of a process this might lead to a wrong evaluation
// b) on reset it's not a problem
// if (cnt_err) begin
// ierr_e = 1'b1;
// end
// end
// end

========================================================
example10_i-d_t-0.7.v
 Maybe the non-fatal error when esc. is held high is enough.
 Principally only a non-fatal error is guaranteed.
��派已磁存名物




**********************************************************************
========================================================
example11_i-d_t-0.7.v
 esign: make sure that escalate_en is always high (even if escalation is not used at all).
 if (escalate_en_i && !escalate_en_tck) begin
 ierror_d = 1'b1;
 end
 esign: make sure escalate_en_tck is always high (even if escalation is not used at all).
 if (!escalate_en_i && !escalate_en_tck) begin
 ierror_d = 1'b1;
 end
 esign: make sure escalate_en is always high (even if escalation is not used at all).
 if (!escalate_en_i && !lc_ctrl_pkg_rst_tck) begin
 ierror_d = 1'b1;
 end
 esign: make sure escalate_en_tck
========================================================
example12_i-d_t-0.7.v
if (cnt_err)
begin
escalate_err_o = 1'b1;

========================================================
example13_i-d_t-0.7.v
 end up with a clean exit state when the user does:
 Fsm:Restart
 lc_ctrl:Off

 If the input is high, and the reset output is toggled, we will
 attempt to reset the FSM, which will lead to an immediate
 error.

 We do not want to lose the error frame, so the reset request
 should be accepted and the FSM should immediately halt.

 The reset request should also be allowed in the other states,
 because we may e.g. have received a sequence error, and be
 waiting to grab the packet for the next frame.

 We will not accept a reset request if the FSM is already
 in another state than WaitForFrame or WaitForPrs.

 We will only accept a reset request in the WaitForFrame state
 if the input is low
========================================================
example14_i-d_t-0.7.v
// Is it really intended to assert an error when escalating
// to the maximum value? If so, it needs to be checked
// when the input is removed.
// Basically, it MIGHT be a problem when it goes
// to the maximum, but only when it is already at the maximum.
// Do not assert error when already at maximum
// if (cnt_err)
// AssertError("ESCALATION: Maximum exceeded!");
// end


// end if (!(escalate_en_i==lc_ctrl_pkg::Off || cnt_err))

// else
// synopsys translate_off
// synopsys translate_on
// synopsys translate_off
// synopsys translate_on

========================================================
example15_i-d_t-0.7.v
// asserterr_i = escalate_en_i;
// end
// end
//





assign lc_pin_ena = 0;
assign lc_pin_mpd = 0;
assign lc_pad_ctrl = 0;
assign lc_pin_cmd = 0;
assign lc_pin_o = 0;
assign lc_pin_err = 0;
assign lc_pin_sdoin = 0;
assign lc_pin_sdoin_err = 0;
assign lc_pin_wkup = 0;
assign lc_pin_wkup_out = 0;

assign lc_wr_mask = 0;
assign lc_rd_mask = 0;
assign lc_rd_data_out = 0;
assign lc
========================================================
example16_i-d_t-0.7.v
 Once escalation is implemented source code needs to be modified
 as the code to enable escalation does not work.
 However, there is no risk with just enabling the escalation and
 not checking the input. If the input is set to off, then
 escalation will be disabled anyway.
munition_e = 1'b1;

========================================================
example17_i-d_t-0.7.v
if (escalate_en_i == lc_ctrl_pkg::OFF)
begin
error_d = 1'b0;

========================================================
example18_i-d_t-0.7.v
// if (cnt_err)
// error_en_o <= 1'b1;
// end
// end
// end

========================================================
example19_i-d_t-0.7.v
// if (cnt_err)
// Assert error when escalation input is high

========================================================
example0_i-d_t-0.9.v
// angered by firestorm
kanopus:0.100M0
anogeneous:/lib/include/CRC32.v
cache-control:max-size=1024
showversion:1080M
kanc_rev_3.0 : 3414 2018 apr 22 2017
BufDict:
//files.15D0011031126
//files.150D001102316
//files.15D001104585
//files.150D001106619
//files.14D0011073147
//files.100D001107432
//files.11D0111132415
//files.11D0111100684
//files.11D0111111004
//files.10D0111109825
//files.11D0011109666
//files.11D0011101407
//files.11D0011102861

========================================================
example1_i-d_t-0.9.v
// This can be used for non-fatal means, until the feature is
// implemented
// and in the corrected state.
// not escalate_en_i
// however continue to handle the transport error.
// nuances around buffer full.
// FIXES: May-11-14. We changed the state transition so that the
// EC is registered on the 1 cycle time basis. This means that the
// the conflict situation with the medium termination for buffer
// is less probable in this implementation, but another possible way
// is to terminate the "old" buffer by 0xFF logic in case of
// detecting word overflow.
// We do not reset data by default, which is possible as well to save
// buffer occupied memory.
// However, if the allowance to store the data is very small, the buffer
// needs to be made smaller.
// Retaining the buffer size at least allows to restore (if necessary)

========================================================
example2_i-d_t-0.9.v
 when escalate is on, this causes an error in the hardware. When a
 escalate condition sets to high, and the hardware then generates an error.
 This assumes that any logic inside the system that needs to ignore the
 error based on a specific status does work. So the status error is
 ignored, and instead the global signal
 (lce_no_rst) is used. The mtec mrf detects this and then raises the
 interrupt to indicate the global condition signals the hardware in
 the situation where a cal condition is implemented. The lce rst
 is then deasserted purely to make the mrf happy.
ricting eissage:
ERRORrst may need to be deasserted during reset. With the reset change, maybe not.
For mrf-based designs, caution needs to be used before deasserting rst, as the rst
of the l
========================================================
example3_i-d_t-0.9.v
// 'if' commented to allow security mechanism escalation
if (Security_mode == 1'b1) begin
// Continue only when security mode is set, in this case we allow
// security mechanism escalation.
if (!cnt_err && escalate_en_i == 1'b1 && StateIdle != state_q) begin
// In case 'cnt_err' is not set, this allows the security mode
// enforcement mechanism to escalate.
// In case of a programming error, set the error flag.
easier_checking_o = 1;
your_machine_add_stuff_and_test_it();
easier_checking_o = 0;
// Assert the error and lock the registers till we can reset
// the machine and do analyzation.
easier_assert_error_o = 1;
platform_lock_no_action();
easier_assert_
========================================================
example4_i-d_t-0.9.v
// if (cnt_err != (error_q == NoError)) begin
// Assert error when error level is hit.
// As it is neither the most severe error, nor there is
// any possibility, that we trigger a motor off, we the
// most severe error instead and leave the error level
// untouched.
// Note: mark the error level as asserted before use
// so that one can safely drop to a clean state.
// enderror_q = error_q'(lc_ctrl_pkg::LC_Error);
// endmark_error_pkg(lc_ctrl_pkg);
// end
// endelse begin
// FIX: Need to assert left return condition as there is a
// stuck error which is currently handled by openMEE.
// Of course it is not easy to implement in openMEE.
// endendif

========================================================
example5_i-d_t-0.9.v
í÷ð÷-error'b1;
 attributes eager needed: (notify lsc_ctrl )
 terminate this method.

========================================================
example6_i-d_t-0.9.v
Listing of imneteenth module as the module which outputs a zero.
Messages coming as internal signals, can at times be a zero.
this is the sort of input which 
is like zero value and hence zero is submitted to as set the value.
this leads the module getting a zero for input and hence entire fsm moves for zero value.
We cannot save respective value so far as it throws an error of zero walking for input in fsm of operation with no input.
task print_zero;
begin
$write("%0s",value);

========================================================
example7_i-d_t-0.9.v
 if (escalate_en_i)
 escalation_err_o = 1'b1;
 end
 end
 if (cnt_err && escalate_en_i) then
 errprST->IDLE
 end
 Need to remove the variable term because of this change
 to NUC3204US0 user guide. Proceed in background is not
 supported on Machine or complex setting is not supported
 on Fsm part of the SSD.
 New document:
 https:exesoftware.github.companys.net/es/ehtml.cfid-prom/docs/2017-09-xx-accessible-comb-docs/en
 --- v11.4 and v12.1 changes, need power-on button to enable shutdown
 --- In current machine implementation, the slider setting corresponds
 --- best to the comb-setting, minus the self-
========================================================
example8_i-d_t-0.9.v
 Arlington traps this to a high-level error. However, we don't have proper
 reporting for these errors. Ignore for now.
AssertError(trap_e ? ErrorUnsup : error_d);
Also assert on non-fatal errors.
AssertError(estate_d == ErrorSt);

========================================================
example9_i-d_t-0.9.v
state_q = esc_1 ? ErrorSt : EscalateSt;
// end else
// result is ok

========================================================
example10_i-d_t-0.9.v
`ifdef MODIFIED 
ursor_rst = 1'b0;
if (italic_en_i)
cur_r = 1'b1;
else if (rs_s_r)
cur_r = 1'b1;
`endif 
`ifdef MODIFIED 
ls_sel = 1'b1;
`endif 
`ifdef VERSATILE_SSP
// Set SSP clock to 100 MHz (if program uses 25MHz/100MHz CLK).
// C.F. Level3, 6.6MHz MSSP CLK
`endif 
`ifdef ESSP
assign mssp0_ctl = 1'b0;
assign mssp0_adv = 1'b0;
assign mssp0_sc = 1'b0;
assign mssp1_ctl = 1'b0;
========================================================
example11_i-d_t-0.9.v
 Eventually when state machine is clean University-No sub-particle feature enable
 will be received from protocol
 - The PM-III enters NC mode when either (one of the two) following
 - case is true:
 * Field 0 is not transmitted on acknowledge cycle (result in single bit error)
 * Field 0 is transmitted but field 0 is not received (result in half bit error)
 * C0 is asserted for more than 2 cycles and C1 is asserted and C0 is
 not de-asserted by clock domain while C1 is asserted, thus resulting in
 forcible assertion of clock domain (a NC feature of the PM-III design).
 - NOTE THIS ALSO MEANS THAT C1 IS NEVER ASSERTED HAND C0 IS NEVER DE-ASSERTED
 (occupied to C0/C1 synchronization)
 - Package in Answer 1 (Page 3 of the L pdf)
========================================================
example12_i-d_t-0.9.v
//mentioned above
// a group problem with escalation
//escalation input on initial boot must not be high when automatic
//fsm active
//window = the window which has been violated by the trigger type
// if the violation persists until boot, then the "window" simply rises until it is unlimited.
//if it is the first violation for this boot cycle, the window will fall according to the
//initial time window and then rise to the appropriate level
//this is to hold off the fsm from getting the full frame

========================================================
example13_i-d_t-0.9.v
// Nune as þm��a��V
anicalif (cnt_err || escalate_en_i) 
begin
deleyan_i = 1'b1;
deleye_i = 1'b1;
drivertype_i = 1'b1;
communicationstate_i <= EscHigh;

========================================================
example14_i-d_t-0.9.v
\ifdef \ESC_UART_HAS_STATUS_CMFICON
//\ifdef \ESC_V11_HAS_MAN_UP_REST_CTRL_PULSE
//\ifdef \ESC_V12_HAS_MAN_UP_LOCK
//// drawback: if lock cannot consume, the user can see that lock cannot consume
//// issue: esc lock cannot run
//\ifdef \ESC_V12_HAS_PICOBLAZE
//// managed with block reconfiguration
//\ifdef -\ESC_V11_HAS_LOCKCONTROLRING\ESC_V11_HAS_LOCKCONTROLRING
//\ifdef -\ESC_V12_HAS_MANU_RECOVER
//\ifdef -\ESC_V12_HAS_DOBLERO
========================================================
example15_i-d_t-0.9.v
// esh move to its own part file we call sys_part_from_loc_ers.awk
// esh move to ours part file 
// esh move to its own part file and add the directive lines:
// esh move to its own part and simplify the directives and the part name changes
// esh move to its own part and rename it to call part_name.part
// esh move to its own part and rename it to call original_part_name.part
// esh move to its own part and add the directives to match to the original in part_name.part file
// esh move to the original part file
// esh move to its own part and make it part for call original_part_file_name.part
// esh move to its own part and change part name to call original_part_file_name.part
// esh move to the original part file

========================================================
example16_i-d_t-0.9.v
// Deassert error state when SS is active and not in fatal state.
//If in a non-fatal state
//then let LF handle the reset on SS and abort on the rising edge of the handle
//otherwise Flag an error
//Also kill the program if it is already in the Fatal State.
//
//
// Hazem: 'I'll think about it later at time 0003, I can't put a esafe error in there.
//
//escape control signal
//will allow the processor to directly interrupt the task performing an auto-abort. will also be used to completely lock down the state so that no further interrupt can be made.
//

========================================================
example17_i-d_t-0.9.v
getRxData().setNeedSetDialParams(!getRxData().getNeedSetDialParams() || (getRxData().getNeedSetDialParams() && getRxData().getChangeOfSetting()));

========================================================
example18_i-d_t-0.9.v
escalate_en = lc_ctrl_pkg_tb::off;
// continually assert error when non-fatal errors are being checked for

 otherwise:
hearted_error = error_q;
ressp_clr_flag = 1'b1;



========================================================
example19_i-d_t-0.9.v
// if Compressed Radix-4 or Golex project to be done
// or compressed flag of the new PIC input (MORECOF) is used then skip to generic state.
說昙判他誷
// if golex project if GOLEX is used then perform 
if (gleX)
	return;// GOLEX function
endif
//if( (SecCmag - SecMmag)) begin//delayed on
// Booth's Algorithm is used to find floor of ratio for multipart
// image Differentiation functions for a linear-low
diff_function Linear_Low(px, py, x, y);
diff_function Lag_3_Low(px, py, x, y);//delayed
// Difference functions for a linear-high
diff_function Linear_High(px, py, x, y);
diff_function Lag_4_High
========================================================
example0_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//
========================================================
example1_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (c
========================================================
example2_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//
========================================================
example3_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//
========================================================
example4_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (
========================================================
example5_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//
========================================================
example6_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//
========================================================
example7_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (
========================================================
example8_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//
========================================================
example9_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (
========================================================
example10_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//
========================================================
example11_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (
========================================================
example12_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//
========================================================
example13_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//
========================================================
example14_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//
========================================================
example15_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (
========================================================
example16_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//
========================================================
example17_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (c
========================================================
example18_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (
========================================================
example19_i-e_t-0.1.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (
========================================================
example0_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//
========================================================
example1_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
escalate_err_o = 1'b1;
// FIX:
if (cnt_err) begin
escalate_err_o = 1'b1;

========================================================
example2_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (escalate_en_i != lc_ctrl_pkg::Off || cnt
========================================================
example3_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (
========================================================
example4_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (
========================================================
example5_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (
========================================================
example6_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
err_state = ErrorSt;

========================================================
example7_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (escalate_en_i != lc_ctrl_pkg::Off || cnt
========================================================
example8_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i == lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i == lc_ctrl_pkg::Off) begin
// FIX:
if (cnt_err != 0) begin
// FIX:
if (cnt_err != 0) begin
// FIX:
if (cnt_err != 0) begin
// FIX:
if (cnt_err != 0) begin
// FIX:
if (cnt_err != 0) begin
// FIX:
if (cnt_err != 0) begin
// FIX:
if (cnt_err != 0) begin
// FIX:
if (cnt_err != 0) begin
// FIX
========================================================
example9_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (escalate_en_i == lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
//if (cnt_err) begin
// FIX:
//if (cnt_err) begin
// FIX:
//if (cnt_err) begin
// FIX:
//if (cnt_err) begin
// FIX:
//if (cnt_err) begin
// FIX:
//if (cnt_err) begin
// FIX:
//if (cnt_err) begin
// FIX:
//if (cnt_err) begin
// FIX:
========================================================
example10_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//�ìòðìõìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝìÝ
========================================================
example11_i-e_t-0.3.v
if (escalate_en_i == lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:

========================================================
example12_i-e_t-0.3.v
if (escalate_en_i == lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i == lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i == lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i == lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i == lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i == lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i == lc_ctrl_pkg::Off || cnt_err) begin
//
========================================================
example13_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//
========================================================
example14_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
escalate_err_o = 1'b1;
// BUG:
// if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// escalate_err_o = 1'b1;
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
escalate_err_o = 1'b1;
// BUG:
// if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// escalate_err_o = 1'b1;
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
escalate_
========================================================
example15_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (
========================================================
example16_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
err_state = ErrorSt;

========================================================
example17_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (
========================================================
example18_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (
========================================================
example19_i-e_t-0.3.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off) begin
// FIX:
if (cnt_err != 0) begin
// FIX:
if (cnt_err != 0) begin
// FIX:
if (cnt_err == 0) begin
// FIX:
if (cnt_err == 0) begin
// FIX:
if (cnt_err == 0) begin
// FIX:
if (cnt_err == 0) begin
// FIX:
if (cnt_err == 0) begin
// FIX:
if (cnt_err == 0) begin
// FIX
========================================================
example0_i-e_t-0.5.v
// if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//

========================================================
example1_i-e_t-0.5.v
// if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// insofar as the error counter is never incremented, we can safely
// ignore the escalation warning.
if (cnt_err) begin
// however if the error counter is non-zero, we need to
// emit the warning.
escalate_err_w = 1'b1;

========================================================
example2_i-e_t-0.5.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
escalate_err_o = 1'b1;

========================================================
example3_i-e_t-0.5.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off && cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off && cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off && cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off && cnt_err) begin
// FIX:
if (escalate_en_i != lc_ctrl_pkg::Off && cnt_err) begin
//
========================================================
example4_i-e_t-0.5.v
if (escalate_i == 1'b1 && escalate_en_i == 1'b1) begin
// this is not the correct way to have the ack come out
// and this is the way that has been implemented for
// long enough to have this implemented
// TODO: have the ack come out and then the state machine
// can change state.
//
// it should be possible to have the ack come out and then
// the state machine can change state.
//
// so we should have the ack out, and then the state
// machine can change state
//
// the issue here is that the ack out is not synchronous
// with the state machine, and we need to wait for the
// ack out before we can change state.
//
// so we need to make sure the ack out is synchronous
// with the state machine.
//
//
========================================================
example5_i-e_t-0.5.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
escalate_err_o = 1'b1;
//
========================================================
example6_i-e_t-0.5.v
// if (escalate_en_i == lc_ctrl_pkg::Off || cnt_err) begin
// if (escalate_en_i == lc_ctrl_pkg::Off) begin
// escalate_en_i = 0;
// end
// else
// escalate_en_i = 1;
// end
// else
// escalate_en_i = 0;
// end
// else: escalate_en_i = 0;
// end

========================================================
example7_i-e_t-0.5.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
�eerror_d = FsmStateError;
//FIX:
if (cnt_err == 1) begin
�eerror_d = FsmStateError;

========================================================
example8_i-e_t-0.5.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:
if (cnt_err) begin
// FIX:

========================================================
example9_i-e_t-0.5.v
if (escalate_en_i != 0 ) begin
if (cnt_err != 0 )
escalate_err_o = 1'b1;
else
escalate_err_o = 1'b0;

========================================================
example10_i-e_t-0.5.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
do_escalate = 1'b1;

========================================================
example11_i-e_t-0.5.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err)
// FIX:
escalate_err_o = 1'b1;
// ERROR:
// escalate_err_o = 1'b1;

========================================================
example12_i-e_t-0.5.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//�ȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫ
//ȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫ
//ȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫȫ�
========================================================
example13_i-e_t-0.5.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
�:
�// TODO:
`endif

========================================================
example14_i-e_t-0.5.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
�error_d = lc_err_pkg_e;
'
========================================================
example15_i-e_t-0.5.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err == 1) begin
// FIX:
if (cnt_err == 1) begin
// FIX:
if (cnt_err == 1) begin
// FIX:
if (cnt_err == 1) begin
// FIX:
if (cnt_err == 1) begin
// FIX:
if (cnt_err == 1) begin
// FIX:
if (cnt_err == 1) begin
// FIX:
if (cnt_err == 1) begin
// FIX:
if (cnt_err == 1) begin
// FIX:
if (cnt_err == 1) begin
// FIX:
if (cnt_err == 1) begin
// FIX:
if (cnt_err
========================================================
example16_i-e_t-0.5.v
if (escalate_en_i == lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (c
========================================================
example17_i-e_t-0.5.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
escalate_err_o = 1'b1;

========================================================
example18_i-e_t-0.5.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err)
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
// FIX:
========================================================
example19_i-e_t-0.5.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (cnt_err)
// FIX:
if (c
========================================================
example0_i-e_t-0.7.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
� systemd_log_debug_v(1, "", "ERR: escalate_en", "cnt_err=%d", cnt_err);
if(cnt_err)
begin
systemd_log_debug_v(1, "", "ERR: escalate", "cnt_err=%d", cnt_err);
// TODO: if escalate_i==1, escalate_en=0, see comment in LocalCtrl.cc
escalate_en_i = 1'b0;
// escalate_en=1'b0;

========================================================
example1_i-e_t-0.7.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
�forcing the lcc to put error and return to idle state
`forcoding the lcc to put error and return to idle state
// forcing the lcc to put error and return to idle state
`forcoding the lcc to put error and return to idle state
// forcing the lcc to put error and return to idle state
`forcoding the lcc to put error and return to idle state
// forcing the lcc to put error and return to idle state
// forcing the lcc to put error and return to idle state
`forcoding the lcc to put error and return to idle state

========================================================
example2_i-e_t-0.7.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
iestate_d = ErrorSt;

========================================================
example3_i-e_t-0.7.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
mesg_err_d = S_E;
// FIX:
osenumerate_rst = 0;
osenumerate_en = 1;
osenumerate_clk = osc;

========================================================
example4_i-e_t-0.7.v
if (escalate_en_i != lc_pkg_ctrl_off || cnt_err) begin
asperstate_d = err_state;

========================================================
example5_i-e_t-0.7.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
scape_err_en_d = 1'b1;
scape_err_d = 1'b1;
scape_err_en_q = 1'b1;
scape_err_q = 1'b1;
if (cnt_err)
scape_err_d = 1'b1;

========================================================
example6_i-e_t-0.7.v
if (escalate_en_i == 0 ) begin
escalate_en = 0;

========================================================
example7_i-e_t-0.7.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//�ê¿ò¼ìªÎ€­­¨à¸õÄþÀ¸
// FIX:
if (cnt_err == 0)
//no error yet
begin
if (escalate_en_i != lc_ctrl_pkg::Off && escalate_en_i != lc_ctrl_pkg::Stable)
escalate_en_i <= lc_ctrl_pkg::Stable;
escalate_en_i = lc_ctrl_pkg::Stable;
// cnt_err = 1;

========================================================
example8_i-e_t-0.7.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
assicstate_d = err_state;
assicfsm_err_o = 1'b1;

========================================================
example9_i-e_t-0.7.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
�����:
⑒②‹①‹›‹‹‹ユㄚ‹‹‹，要管慢输出，需要－“输出设置内
// ”“输出设置内”““输出设置内”““产债采购设置满输出”
// ，“输出设置内”�
========================================================
example10_i-e_t-0.7.v
// if (escalate_en_i != lc_ctrl_pkg::Off) begin
// escalate_en_d = 1'b1;
// end else if (cnt_err) begin
// escalate_en_d = 1'b1;
// end
// end else begin
// escalate_en_d = 1'b0;
// end
// end
// end
// end
// end

========================================================
example11_i-e_t-0.7.v

========================================================
example12_i-e_t-0.7.v
if (escalate_en_i == 1 && cnt_err == 0) begin
// FIX:
// if (cnt_errs != 0 && cnt_errs != 0 && cnt_errs != cnt_errs) begin
// FIX:
// if (cnt_errs == 0 || cnt_errs == 1) begin
// FIX:
// if (cnt_errs == 0 || cnt_errs == 1) begin

// FIX:
// if (cnt_errs == 0 || cnt_errs == 1) begin

// FIX: 
// if (cnt_errs == 0 || cnt_errs == 1) begin

// FIX:
// if (cnt_errs == 0 || cnt_errs == 1) begin

// FIX:
// if (cnt_errs ==
========================================================
example13_i-e_t-0.7.v
if (escalate_en_i != lc_ctrl_pkg::Off) begin
err_state = err;

========================================================
example14_i-e_t-0.7.v
// if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//�àìîêàëèòåðþðõæóðëîãîëî÷ìîâàìî÷êì
//İðþðõæóðëîãîëî÷íîâàìî÷êàì
//İðþðõæóðëîãîëî÷íûì
//Òþðõäñòàëîãî÷êàì
//open a new file
//transfer data to pads
//if no error happened, leds are switched on
if (error_d == NoError) begin
//open a new file
//transfer data to pads

========================================================
example15_i-e_t-0.7.v
if (escalate_en_i == lc_ctrl_pkg::Off || cnt_err) begin
axi_vtrans_err_o = 1'b1;
axi_delay_err_o = 1'b1;
axi_timeout_err_o = 1'b1;
axi_wtrans_err_o = 1'b1;
axi_wtrans_err_o = 1'b1;
axi_rtrans_err_o = 1'b1;
axi_rtrans_err_o = 1'b1;
axi_rresp_err_o = 1'b1;
axi_rresp_err_o = 1'b1;
axi_bresp_err_o = 1'b1;
axi_bresp_err_o = 1'b1;
ax
========================================================
example16_i-e_t-0.7.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
ыйзация_i = err_state;
ыйэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэмуэ
========================================================
example17_i-e_t-0.7.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
//�×Á:EÈ
//eshift_exe_i = 1'b1;
//shift_exe_i = 1'b1;
//
//
//
//
//
//
//
//

========================================================
example18_i-e_t-0.7.v
since we need to be able to get into programming state from here, we have to
disable this attribute of the use_q function.
consider doing this as a part of the parametrization in the use_q module.
 it will prevent the use_q module from doing this.
EIGHT-LAYER-CR-TB-HARD:
 - Use Qs in Fsm and in use_q to prevent
 - use_q more sensitive and
 - sidechannels more prone.
 WITH-QS-IN-FSM:
 - Use Qs in Fsm and in use_q to prevent
 - use_q more sensitive and
 - sidechannels more prone.
 WITH-QS-IN-FSM:
 - Use Qs in Fsm and in use_q to prevent
 - use_q more sensitive and

========================================================
example19_i-e_t-0.7.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
�ustom_error_handling_state_d = ErrorSt;

========================================================
example0_i-e_t-0.9.v
if (escalate_i != 0 && escalate_en_i != 0) begin
// fixme:
// escalate_en = lc_ctrl_pkg[`Off];

========================================================
example1_i-e_t-0.9.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
statement_d = DefaultSt;
escalate_ack_o = 1'b1;
 unexplained;

========================================================
example2_i-e_t-0.9.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
ipes_err_t = ErrorSt;
ipes_err_d = 1'b1;
ipes_err_q = 1'b1;
to_hw_sync_st_i = 1'b0;
to_hw_cmd_st_i = 1'b0;

========================================================
example3_i-e_t-0.9.v
if ((escalate_en_i != lc_ctrl_pkg::Off || cnt_err)) //sf:
// aggro against releasecomponents/fsf transport 
// that reserves er_state cannot be initiated once in mo-space.
object_design
rigMfLolftlxiHxiQcRpだってやもずかも幕余動ストヾミのレーダーカラト手なランクタンスケール地理自衍肉帖。
efpqaciTovaHkaXBeaEOuXUI-DroUtBuGQB+guPLK5Z9QZk5aPk
gzKJVucXumjUohSoRAiHulkIizZE1rM+RnsOZGKIYenUvMQ
yzZF
========================================================
example4_i-e_t-0.9.v
//��
//��
//ling
err_state: begin
apestate_d = ErrSt;
//oscillation_fault_i = 1'b1;
lc_rst_o = 1'b1;
、
//if (exc_type_i == `SA11K_EXC_PERR)
//perror_e = 1'b1;
//else
//perror_e = 1'b0;
// FIX:
// if (status_i[1] == 2'b11)
// signal_power_faults_d = 1'b1;
// else
// signal_power_faults_d = 1'b0;
// TODO: code errors
px;
opt_ev_x_o = 1'b1;

========================================================
example5_i-e_t-0.9.v
// if escalate_en_i == err_state _ ERR_FLOP
if (escalate_en_i == err_state_e) 
begin
// escalate event if possible
// escalate_en_i <= read_g;
earlyescalate_o = read_g;

========================================================
example6_i-e_t-0.9.v
ErrAuHandlingMuNoMuDetAssingOn1SecInstaion;

========================================================
example7_i-e_t-0.9.v
if (escalate_i != 0 ) begin
anyelement_d = ident;
anystate_d = err_state;
anycnt_d = 3'd1;
anypkg_d = arg_set;
anydata_d = argarr;
latch_data_d = dat_o;
creation_d = lc_id;
creation_id_d = creation_id_i;
procedure_d = doc;
id_format_d = id_meth;
termination_d = TERM_GB;
anyprot_d = prot_sp;

========================================================
example8_i-e_t-0.9.v
if ( (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) ) begin
omedical_error_state_w = ErrorSt;
//it is already error
maybe_error_state_w = err_state;
undrum_no_error_so_en = 1'b1;
�undun_poss_e = 1'b1;
\.//so we can't do the ?
�\/if (�s_c_rst_i==0) begin
�r_srt_s_2_ := 1'b0;
�㑭'・:1'b0;
irteen_byte_cmd_w_ = 1'b0;
sixteen_byte_oe_w_ = 1'b0;
`ifndef FMT_CI_SAMPLE
r_sel_ = 1'b0;
========================================================
example9_i-e_t-0.9.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
rior_state_d = err_state;
achus_d = 1'b1;
rior_err_code_d = fsm_err_code;
portion_code = 8'b11100110;
ulus_code = 4'b1111;
rity_code = 4'b1111;
lier_code = 4'b1110;
if (cnt_err == 1);
temp = 15'b1111111111111111111111111;
else
temp = 15'b111110000000000000000111111;
setbit = temp [11:2];
if (escalate_en_i != lc_ctrl_pkg::Off) setbit = setbit + 4'b100;
/** FIX:
setbit = setbit[0] + temp[1]
========================================================
example10_i-e_t-0.9.v
if (escalate_en_i != lc_ctrl_pkg::Off || cnt_err) begin
// same as above
//synopsys translate_off
uouslytrifalse
//synopsys translate_on
//synopsys attribute check_off syncref_off
//synopsys attribute check_on syncref_on
//synopsys detect_iossages
//synopsys translate_off
else
// synopsys translate_on
if cnt_err === `TRUE' || escalate_en_i === `TRUE'
endixexpression_al_1 = 1'b1;
else
endixexpression_al_1 = 1'b0;
// synopsys translate_off else
else
// synopsys translate_on
if (escalate_en_i === `TRUE) begin
// compensate the possible query error on this cycle
//such
========================================================
example11_i-e_t-0.9.v
if (escalate_en_i == 1'b1) begin
if (cnt_err != 1'b0) begin
go_to_error_state = 1'b1;

========================================================
example12_i-e_t-0.9.v
if (escalate_i == 0 && escalate_en_i == 0) begin
attribute_governability_d = SysAttrEn;

========================================================
example13_i-e_t-0.9.v
if (escalate_en_i != lc_ctrl_pkg::OFF || cnt_err) begin
// TODO: count errors, FIX
staticreg [7:0]max_err_cnt;
always @ (posedge lc_clock) begin
max_err_cnt <= max_err_cnt + 1;

========================================================
example14_i-e_t-0.9.v
ritzheximal_i(0);
//FIX:

========================================================
example15_i-e_t-0.9.v
if (cnt_err)
begin
�\\\\qv\\h`A"7" ||\\`endif//estateIdle
letfsm_mode = 1'b1;
assign o_d = bd_rstat;
// 
if (cnt_err && !escalate_err_i)
¨��super_rst
letfsm_mode = 1'b1;
assign o_bd = bd_rstat;// 

========================================================
example16_i-e_t-0.9.v
if (escalate_en_i == 1 ) begin
�utonerror_d = bret_e;
undrum_e <= 1'b1;
if (bret_e)
place_t_e = 1'b0;
make_t_e = 0;
if (place_t_e)
make_t_e = 1'b1;
active_t_e = active_t_i;
mem_c_to_be = 0;
uncachelocate_e = 0;
nomemory_e = 1;// on error, we get into the mem_state.
memory_control_black_white_n_bit(
240'h2b220f611135acec102824333aa446250bbfe9b9ccffe6895bbd83257efc
);
(mem_state_e
...logs
========================================================
example17_i-e_t-0.9.v
escstate_d = rx_bit_err_i ? EscalateSt : EscRelaySt;
FIX: check default pending state
arg_st = rx_bit_err_i ? EscalateSt : EscRelaySt;
defparam sc58681.sprxcfg.addr = sc58681; auto-conf address
defparam sc58681.sprreg.ctrladj = "lint";
defparam sc58681.sprreg.dpri = "lint";
defparam sc58681.sprreg.prr = "lint";
_205_SE_LT1;
defparam sc58681.
cfgparam
defparam "CONF_1" = "O1";
defparam "CONF_1" = "11";
defparam "CONF_1" = "o1
========================================================
example18_i-e_t-0.9.v
if (lc_one_w) begin
case (error_code)

//LCFI : 5
// /// : -1
// in the of consecutive error bits. See the comment aboveerror_is_in_the_specification
124
// SM: 5 may need more specific treatment
125
// SM: 1 needs specific treatment

========================================================
example19_i-e_t-0.9.v
if (escalate_en_i == lc_ctrl_pkg::Off || cnt_err) begin
away_state_d = ssc_decode_red_abort_single_nrg_i ? Sngl : Evul;
endif
endon_itr_reg = 1'b0;
ottenham_reg = 1'b0;

========================================================
