Implement controller rx watchdog, restore remaining integration tests

arjenroodselaar · nathanaelhuffman · commit 9e37e9d2853f · 2024-11-22T17:24:22.000-06:00
diff --git a/hdl/ip/bsv/ignition/IgnitionController.bsv b/hdl/ip/bsv/ignition/IgnitionController.bsv
@@ -929,7 +929,8 @@ module mkController #(
                             transceiver_.transmitter_output_disable_timeout_ticks_remaining = 0;
                             transceiver_.transmitter_output_enabled = True;
                         end
-                        else if (transceiver.transmitter_output_enabled) begin
+                        else if (transceiver.transmitter_output_enabled &&
+                                    transceiver.transmitter_output_disable_timeout_ticks_remaining == 0) begin
                             transceiver_.transmitter_output_disable_timeout_ticks_remaining =
                                 fromInteger(parameters.transmitter_output_disable_timeout);
                         end
@@ -939,7 +940,8 @@ module mkController #(
                             transceiver_.transmitter_output_disable_timeout_ticks_remaining = 0;
                             transceiver_.transmitter_output_enabled = True;
                         end
-                        else if (transceiver.transmitter_output_enabled) begin
+                        else if (transceiver.transmitter_output_enabled &&
+                                    transceiver.transmitter_output_disable_timeout_ticks_remaining == 0) begin
                             transceiver_.transmitter_output_disable_timeout_ticks_remaining =
                                 fromInteger(parameters.transmitter_output_disable_timeout);
                         end
@@ -950,6 +952,11 @@ module mkController #(
                     end
                 endcase
 
+                $display("%5t [Controller %02d] Transmitter output enable mode ",
+                        $time,
+                        current_controller,
+                        fshow(transceiver_.transmitter_output_enable_mode));
+
                 if (transceiver.transmitter_output_enabled &&
                         !transceiver_.transmitter_output_enabled) begin
                     $display("%5t [Controller %02d] Transmitter output disabled",
@@ -1332,7 +1339,8 @@ module mkController #(
 
                 if (transceiver.transmitter_output_enable_mode ==
                             EnabledWhenReceiverAligned &&
-                        transceiver.transmitter_output_enabled) begin
+                        transceiver.transmitter_output_enabled &&
+                        transceiver.transmitter_output_disable_timeout_ticks_remaining == 0) begin
                     // A ReceiverReset means the receiver is not aligned anymore
                     // and the disable timeout counter should be started.
                     transceiver_.transmitter_output_disable_timeout_ticks_remaining =
diff --git a/hdl/ip/bsv/ignition/IgnitionReceiver.bsv b/hdl/ip/bsv/ignition/IgnitionReceiver.bsv
@@ -582,6 +582,7 @@ endinstance
 interface ControllerReceiver #(numeric type n);
     interface Vector#(n, DeserializerClient) rx;
     interface Get#(ReceiverEvent#(n)) events;
+    method Action tick_1khz();
 endinterface
 
 interface DeserializerChannel #(numeric type n);
@@ -665,6 +666,10 @@ module mkControllerReceiver (ControllerReceiver#(n))
                 NumAlias#(TLog#(n), id_sz));
     Vector#(n, DeserializerChannel#(n))
             channels <- mapM(mkDeserializerChannel, genVector);
+    Vector#(n, Reg#(Bool)) channels_locked <- replicateM(mkReg(False));
+
+    Reg#(UInt#(9)) watchdog_ticks_remaining <- mkRegU();
+    Reg#(Bool) watchdog_fired <- mkDReg(False);
 
     // Use a regular FIFO here but of size two, allowing it to act as a skid
     // buffer. This decouples the demux pipeline from the receiver logic,
@@ -1228,11 +1233,30 @@ module mkControllerReceiver (ControllerReceiver#(n))
             channels[id].set_search_for_comma(!receive_state_2_next.aligned);
             channels[id].set_invert_polarity(
                     receive_state_2_next.polarity_inverted);
+
+            channels_locked[id] <=
+                    receive_state_2_next.aligned &&
+                    receive_state_2_next.locked;
         end
     endrule
 
+    for (Integer id = 0; id < valueOf(n); id = id + 1) begin
+        (* fire_when_enabled *)
+        rule do_channel_locked_watchdog
+                (watchdog_fired && !channels_locked[fromInteger(id)]);
+            channels[fromInteger(id)].request_reset();
+        endrule
+    end
+
     interface Vector rx = map(deserializer_client, channels);
     interface Get events = toGet(receiver_events);
+
+    method Action tick_1khz();
+        // This automatically rolls over from 0, restarting the watchdog
+        // timer.
+        watchdog_ticks_remaining <= watchdog_ticks_remaining - 1;
+        watchdog_fired <= (watchdog_ticks_remaining == 0);
+    endmethod
 endmodule
 
 typedef struct {
diff --git a/hdl/ip/bsv/ignition/IgnitionTransceiver.bsv b/hdl/ip/bsv/ignition/IgnitionTransceiver.bsv
@@ -372,6 +372,7 @@ interface ControllerTransceiver#(numeric type n);
     interface Vector#(n, Tuple2#(Bool, GetPut#(Bit#(1)))) serial;
     interface Get#(ReceiverEvent#(n)) rx;
     interface Put#(TransmitterEvent#(n)) tx;
+    method Action tick_1khz();
 endinterface
 
 interface ControllerTransceiverClient#(numeric type n);
@@ -425,6 +426,7 @@ module mkControllerTransceiver (ControllerTransceiver#(n))
                 deserializers);
     interface Get rx = receiver.events;
     interface Put tx = toPut(tx_ev);
+    method tick_1khz = receiver.tick_1khz;
 endmodule
 
 module mkControllerTransceiver36 (ControllerTransceiver#(36));
diff --git a/hdl/ip/bsv/ignition/test/IgnitionControllerAndTargetBench.bsv b/hdl/ip/bsv/ignition/test/IgnitionControllerAndTargetBench.bsv
@@ -155,6 +155,7 @@ module mkIgnitionControllerAndTargetBench #(
     ControllerTransceiver#(4) controller_txr <- mkControllerTransceiver();
 
     mkConnection(asIfc(tick), asIfc(controller_.tick_1mhz));
+    mkConnection(asIfc(tick), asIfc(controller_txr.tick_1khz));
 
     // Set this TX strobe ~180 degrees out of phase from Target TX.
     Strobe#(3) controller_tx_strobe <- mkLimitStrobe(1, 5, 3);
diff --git a/hdl/ip/bsv/ignition/test/IntegrationTests.bsv b/hdl/ip/bsv/ignition/test/IntegrationTests.bsv
@@ -68,7 +68,7 @@ module mkControllerTargetPresentTest (Empty);
         endaction
         par
             await(bench.controller.presence_summary[0]);
-            await_set(bench.target.controller0_present);
+            await(bench.target.controller0_present);
         endpar
 
         assert_controller_register_eq(
@@ -92,40 +92,63 @@ module mkTargetRoTFaultTest (Empty);
             10 * max(protocol_parameters.hello_interval,
                     protocol_parameters.status_interval));
 
-    // let controller_state = bench.controller.registers.controller_state;
-    // let target_system_status = bench.controller.registers.target_system_status;
-    // let target_system_faults = bench.controller.registers.target_system_faults;
+    Reg#(SystemFaults) target_system_events <- mkReg(defaultValue);
+
+    function read_controller_0_register_into(id, d) =
+            read_controller_register_into(bench.controller, 0, id, asIfc(d));
+
+    function read_controller_0_registers_while(predicate) =
+            seq
+                while(predicate) seq
+                    read_controller_0_register_into(
+                            TargetSystemEvents,
+                            target_system_events);
+                    // Avoid a tight loop reading the registers otherwise the
+                    // Controller will not make progress due to this interface
+                    // having the highest priority.
+                    repeat(3) bench.await_tick();
+                endseq
+            endseq;
 
     mkAutoFSM(seq
-        // action
-        //     bench.controller_to_target.set_state(Connected);
-        //     bench.target_to_controller.set_state(Connected);
-        // endaction
-        // par
-        //     await_set(controller_state.target_present);
-        //     await_set(target_system_status.controller0_detected);
-        // endpar
-
-        // // Assert no target system faults and set an RoT fault.
-        // assert_eq(
-        //     target_system_faults,
-        //     defaultValue,
-        //     "expected no target system faults");
-        // bench.set_target_system_faults(system_faults_rot);
-
-        // // Assert the fault is observed by the Controller.
-        // await_set(target_system_faults.rot_fault);
-        // assert_set(target_system_faults.rot_fault, "expected RoT fault");
-
-        // // Resolve the RoT fault.
-        // bench.set_target_system_faults(system_faults_none);
-
-        // // Assert the RoT fault cleared.
-        // await_not_set(target_system_faults.rot_fault);
-        // assert_eq(
-        //     target_system_faults,
-        //     defaultValue,
-        //     "expected no target system faults");
+        action
+            bench.controller_to_target.set_state(Connected);
+            bench.target_to_controller.set_state(Connected);
+            bench.controller.registers.request.put(
+                    RegisterRequest {
+                        id: 0,
+                        register: TransceiverState,
+                        op: tagged Write extend(
+                                {pack(EnabledWhenReceiverAligned), 4'h0})});
+        endaction
+        par
+            await(bench.controller.presence_summary[0]);
+            await(bench.target.controller0_present);
+        endpar
+
+        // Assert no Target system faults and set an RoT fault.
+        assert_controller_register_eq(
+                bench.controller, 0, TargetSystemEvents,
+                system_faults_none,
+                "expected no target system faults");
+        bench.set_target_system_faults(system_faults_rot);
+
+        // Assert the fault is observed by the Controller.
+        read_controller_0_registers_while(!target_system_events.rot);
+        assert_controller_register_eq(
+                bench.controller, 0, TargetSystemEvents,
+                system_faults_rot,
+                "expected an RoT faults");
+
+        // Resolve the RoT fault.
+        bench.set_target_system_faults(system_faults_none);
+
+        // Assert the RoT fault cleared.
+        read_controller_0_registers_while(target_system_events.rot);
+        assert_controller_register_eq(
+                bench.controller, 0, TargetSystemEvents,
+                system_faults_none,
+                "expected no target system faults");
     endseq);
 endmodule
 
@@ -369,31 +392,20 @@ module mkReceiversLockedTimeoutTest (Empty);
         mkIgnitionControllerAndTargetBench(parameters, 1000);
 
     mkAutoFSM(seq
+        clear_controller_counter(bench.controller, 0, ControllerReceiverReset);
+
         // The link between Controller and Target is not connected, causing both
         // receivers never to reach locked state.
-
-        // Reset the controller link status register, clearing any events.
-        // action
-        //     let _ <- bench.controller.registers.controller_link_status;
-        // endaction
-
         par
-            // repeat(4) seq
-            //     await(bench.controller_receiver_locked_timeout);
-
-            //     // Wait for the receiver reset event bit to be set in the link
-            //     // status register.
-            //     // action
-            //     //     let link_status <-
-            //     //             bench.controller.registers.controller_link_status;
-
-            //     //     await_set(link_status.receiver_reset_event);
-            //     // endaction
-            // endseq
-
             repeat(4) await(bench.target_receiver_locked_timeout[0]);
             repeat(4) await(bench.target_receiver_locked_timeout[1]);
         endpar
+
+        assert_controller_counter_eq(
+                bench.controller,
+                0, ControllerReceiverReset,
+                3,
+                "expected Controller reset events");
     endseq);
 endmodule
 
@@ -417,9 +429,12 @@ module mkNoLockedTimeoutIfReceiversLockedTest (Empty);
         !bench.controller_receiver_locked_timeout,
         "expected no Controller receiver locked timeout");
 
-    continuousAssert(
-        !bench.target_receiver_locked_timeout[0],
-        "expected no receiver locked timeout for Target link 0");
+    (* fire_when_enabled *)
+    rule do_assert_target_receiver_locked_timeout
+            (bench.controller_transmitter_output_enabled);
+        assert_true(!bench.target_receiver_locked_timeout[0],
+                "expected no receiver locked timeout for Target link 0");
+    endrule
 
     mkAutoFSM(seq
         action
@@ -429,7 +444,7 @@ module mkNoLockedTimeoutIfReceiversLockedTest (Empty);
                     RegisterRequest {
                         id: 0,
                         register: TransceiverState,
-                        op: tagged Write 'h20});
+                        op: tagged Write ({2'h0, pack(AlwaysEnabled), 4'h0})});
         endaction
 
         par
diff --git a/hdl/projects/sidecar/mainboard/SidecarMainboardController.bsv b/hdl/projects/sidecar/mainboard/SidecarMainboardController.bsv
@@ -93,6 +93,7 @@ interface MainboardController #(numeric type n_ignition_controllers);
     interface Registers registers;
     interface Controller#(n_ignition_controllers) ignition_controller;
     interface ReadOnly#(Status) status;
+    method Bool ignition_tick_1khz();
 endinterface
 
 module mkMainboardController #(Parameters parameters)
@@ -223,6 +224,8 @@ module mkMainboardController #(Parameters parameters)
     interface Controller ignition_controller = ignition;
 
     interface ReadOnly status = regToReadOnly(status_r);
+
+    method ignition_tick_1khz = tick_1khz;
 endmodule
 
 endpackage
diff --git a/hdl/projects/sidecar/mainboard/SidecarMainboardControllerTop.bsv b/hdl/projects/sidecar/mainboard/SidecarMainboardControllerTop.bsv
@@ -522,6 +522,12 @@ module mkSidecarMainboardControllerTop
 
     mkConnection(ignition_txr, controller.ignition_controller.txr);
 
+    // Connect the transceiver watchdog timer.
+    (* fire_when_enabled *)
+    rule do_ignition_txr_watchdog (controller.ignition_tick_1khz);
+        ignition_txr.tick_1khz();
+    endrule
+
     //
     // Cubbies
     //
