Add Sidecar image for Reverso (#2401)

> [!NOTE]
> This is just @mkeeter's PR #2226, but rebased onto the latest
> `master`, since [it turns out we actually do need this][1]. I had
> wanted to just re-open Matt's original PR but [github would not let
> me do this for some kind of reason I really don't fully understand][2].
> Anyway, heeeeeere's Matt Keeeeeeeterrrr!!!

"Reverso" is a board with the same form factor as a Gimlet which loops
back the two backplane connectors.

In this configuration, packets leaving the VSC7448 destined for SP _i_
instead arrive at the peer Sidecar, appearing to have originated at SP
_i_.

In the unlocked VLAN configuration, this is a problem: packets can
arrive at one tech port and emerge from the other tech port, which
creates a routing loop. When this happens, our CM's network
unceremoniously turns off the offending network port, and we have to
manually get it re-enabled.

This PR adds a `VlanTargets` parameter to unlock-related code:

- `VlanTargets::EverySp` is our existing behavior, where the technician
port can communicate with every cubby
- `VlanTargets::ScrimletOnly` limits technician ports to only
communicate with Scrimlet cubbies, which are guaranteed to be populated

By preventing the technician port from talking to cubbies with Reverso
installed, we can avoid network loops.

The switch zone in the scrimlet can still communicate with every cubby;
indeed, this is how we expect to test connectivity with Reverso
installed.

[1]:
#2226 (comment)
[2]:
#2226 (comment)

Co-authored-by: Matt Keeter <matt@oxide.computer>

Author: hawkw

app/sidecar/rev-c-reverso.toml

@@ -0,0 +1,2 @@
+name = "sidecar-c-reverso"
+inherit = ["rev-c-dev.toml", "reverso.toml"]

app/sidecar/rev-d-reverso.toml

@@ -0,0 +1,2 @@
+name = "sidecar-d-reverso"
+inherit = ["rev-d-dev.toml", "reverso.toml"]

app/sidecar/reverso.toml

@@ -0,0 +1,2 @@
+[tasks.monorail]
+features = ["reverso"]

drv/vsc7448/src/lib.rs

@@ -112,6 +112,22 @@ pub struct Vsc7448<'a, R> {
     refclk_2: Option<RefClockFreq>,
 }
 
+/// Selects which SPs should be accessible from tech ports with unlocked VLANs
+#[derive(Copy, Clone, serde::Serialize, serde::Deserialize)]
+pub enum VlanTargets {
+    /// Every SP should be accessible from the tech port
+    ///
+    /// This is the typical unlocked behavior
+    EverySp,
+
+    /// Only Scrimlet SPs should be accessible from the tech port
+    ///
+    /// If cubbies are populated with loopback connections (instead of sleds),
+    /// this behavior prevents network loops; otherwise, packets can enter one
+    /// tech port and exit the other.
+    ScrimletOnly,
+}
+
 impl<R: Vsc7448Rw> Vsc7448Rw for Vsc7448<'_, R> {
     /// Write a register to the VSC7448
     fn write<T>(
@@ -866,8 +882,11 @@ impl<'a, R: Vsc7448Rw> Vsc7448<'a, R> {
     ///
     /// To switch between locked and unlocked later, use
     /// `sidecar_vlan_lock/unlock` (instead of calling this function again)
-    pub fn configure_vlan_sidecar_unlocked(&self) -> Result<(), VscError> {
-        self.sidecar_vlan_unlock()?;
+    pub fn configure_vlan_sidecar_unlocked(
+        &self,
+        targets: VlanTargets,
+    ) -> Result<(), VscError> {
+        self.sidecar_vlan_unlock(targets)?;
         self.configure_port_tagged(|p| {
             p == sidecar::UPLINK || p == sidecar::LOCAL_SP
         })?;
@@ -891,11 +910,22 @@ impl<'a, R: Vsc7448Rw> Vsc7448<'a, R> {
         })
     }
 
-    /// Configures the VLANs to the unlocked state, per RFD 492
+    /// Configures the VLANs to an unlocked state, selected by `VlanTargets`
+    pub fn sidecar_vlan_unlock(
+        &self,
+        targets: VlanTargets,
+    ) -> Result<(), VscError> {
+        match targets {
+            VlanTargets::EverySp => self.sidecar_vlan_unlock_all(),
+            VlanTargets::ScrimletOnly => self.sidecar_vlan_unlock_scrimlet(),
+        }
+    }
+
+    /// Configures the VLANs to the standard unlocked state, per RFD 492
     ///
     /// The technician ports can talk to any SP; SPs may talk to the Tofino or
     /// to the technician ports.
-    pub fn sidecar_vlan_unlock(&self) -> Result<(), VscError> {
+    fn sidecar_vlan_unlock_all(&self) -> Result<(), VscError> {
         self.configure_vlans(|p| match p {
             sidecar::UPLINK => None,
             sidecar::TECHNICIAN_1 => {
@@ -918,6 +948,35 @@ impl<'a, R: Vsc7448Rw> Vsc7448<'a, R> {
         })
     }
 
+    /// Configures the VLANs to an unlocked state with only Scrimlets accessible
+    ///
+    /// This state is useful for racks with the Reverso™ board installed, which
+    /// loops back the two backplane connections within a cubby.  In this
+    /// configuration, we don't want for technician ports to communicate with
+    /// cubbies (other than Scrimlets), because that creates a routing loop
+    /// (packets can enter via one tech port and leave via the other).
+    fn sidecar_vlan_unlock_scrimlet(&self) -> Result<(), VscError> {
+        self.configure_vlans(|p| match p {
+            sidecar::UPLINK => None,
+            // Technician ports are connected to uplink and scrimlets
+            sidecar::TECHNICIAN_1 | sidecar::TECHNICIAN_2 => Some(
+                (1 << p)
+                    | (1 << sidecar::UPLINK)
+                    | (1 << sidecar::CUBBY_14)
+                    | (1 << sidecar::CUBBY_16),
+            ),
+            // Scrimlet SPs are connected to the Tofino and technician ports
+            sidecar::CUBBY_14 | sidecar::CUBBY_16 => Some(
+                (1 << p)
+                    | (1 << sidecar::UPLINK)
+                    | (1 << sidecar::TECHNICIAN_1)
+                    | (1 << sidecar::TECHNICIAN_2),
+            ),
+            // Other SPs are only connected to the uplink port
+            _ => Some((1 << p) | (1 << sidecar::UPLINK)),
+        })
+    }
+
     /// Checks the 10GBASE-KR autonegotiation state machine for the given dev.
     ///
     /// If it is stuck in `WAIT_RATE_DONE`, restarts autonegotiation and returns
@@ -966,6 +1025,12 @@ mod sidecar {
 
     /// Technician port 2 (front IO board)
     pub const TECHNICIAN_2: u8 = 45;
+
+    /// Scrimlet 1
+    pub const CUBBY_14: u8 = 8;
+
+    /// Scrimlet 2
+    pub const CUBBY_16: u8 = 4;
 }
 
 mod minibar {

task/monorail-server/Cargo.toml

@@ -34,6 +34,7 @@ leds = ["drv-user-leds-api"]
 medusa = ["drv-medusa-seq-api", "drv-sidecar-front-io"]
 mgmt = ["task-net-api"]
 sidecar = ["drv-sidecar-seq-api", "drv-sidecar-front-io"]
+reverso = []
 minibar = []
 vlan = ["task-net-api?/vlan"]
 no-ipc-counters = ["idol/no-counters"]

task/monorail-server/src/bsp/medusa_a.rs

@@ -210,7 +210,8 @@ impl<'a, R: Vsc7448Rw> Bsp<'a, R> {
         self.phy_vsc8504_init()?;
 
         self.vsc7448.configure_ports_from_map(&PORT_MAP)?;
-        self.vsc7448.configure_vlan_sidecar_unlocked()?;
+        self.vsc7448
+            .configure_vlan_sidecar_unlocked(vsc7448::VlanTargets::EverySp)?;
         self.vsc7448_postconfig()?;
 
         // Some front IO boards have a faulty oscillator driving the PHY,

task/monorail-server/src/bsp/sidecar_bcd.rs

@@ -48,6 +48,12 @@ enum VLanMode {
     UnlockedUntil(u64),
 }
 
+const VLAN_UNLOCK_TARGETS: vsc7448::VlanTargets = if cfg!(feature = "reverso") {
+    vsc7448::VlanTargets::ScrimletOnly
+} else {
+    vsc7448::VlanTargets::EverySp
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 
 pub struct Bsp<'a, R> {
@@ -240,7 +246,8 @@ impl<'a, R: Vsc7448Rw> Bsp<'a, R> {
             VLanMode::UnlockedUntil(t) => {
                 let now = userlib::sys_get_timer().now;
                 if now < t {
-                    self.vsc7448.configure_vlan_sidecar_unlocked()?;
+                    self.vsc7448
+                        .configure_vlan_sidecar_unlocked(VLAN_UNLOCK_TARGETS)?;
                 } else {
                     ringbuf_entry!(Trace::AutomaticLock);
                     self.vsc7448.configure_vlan_sidecar_locked()?;
@@ -595,10 +602,12 @@ impl<'a, R: Vsc7448Rw> Bsp<'a, R> {
         unlock_until: u64,
     ) -> Result<(), RequestError<MonorailError>> {
         ringbuf_entry!(Trace::UnlockUntil(unlock_until));
-        self.vsc7448.sidecar_vlan_unlock().map_err(|e| {
-            ringbuf_entry!(Trace::UnlockError(e));
-            MonorailError::from(e)
-        })?;
+        self.vsc7448
+            .sidecar_vlan_unlock(VLAN_UNLOCK_TARGETS)
+            .map_err(|e| {
+                ringbuf_entry!(Trace::UnlockError(e));
+                MonorailError::from(e)
+            })?;
         self.vlan_mode = VLanMode::UnlockedUntil(unlock_until);
         Ok(())
     }