WIP rendmp: add RAA229620A support

This contains a bunch of assumptions (marked with TODOs) and may not
work. We are reaching out to Renesas for clarifications.

Author: cbiffle

cmd/rendmp/src/lib.rs

@@ -957,6 +957,7 @@ fn rendmp_ingest(subargs: &RendmpArgs) -> Result<()> {
 enum SupportedDevice {
     ISL68224,
     RAA229618,
+    RAA229620A,
 }
 
 impl SupportedDevice {
@@ -965,6 +966,7 @@ impl SupportedDevice {
         match self {
             SupportedDevice::ISL68224 => 3,
             SupportedDevice::RAA229618 => 2,
+            SupportedDevice::RAA229620A => 2,
         }
     }
 
@@ -991,6 +993,20 @@ impl SupportedDevice {
                 }
                 phases
             }
+            SupportedDevice::RAA229620A => {
+                let mut phases = vec![];
+                for phase in 0..12 {
+                    phases.push((phase.to_string(), phase));
+                }
+                for i in 0..2 {
+                    // The 20 here looks like a copy paste mistake from the
+                    // '618, but is deliberate; we believe the bit offset here
+                    // is the same as the '618 despite the smaller phase count.
+                    // (TODO)
+                    phases.push((format!("VSEN{i}"), i + 20));
+                }
+                phases
+            }
         }
     }
 }
@@ -1130,6 +1146,10 @@ fn get_pin_states(
             0x00BE, 0x00BF, // open-pin
             0xE904, 0xE905, // mask
         ],
+        SupportedDevice::RAA229620A => &[ // TODO unverified
+            0x00BE, 0x00BF, // open-pin
+            0xE904, 0xE905, // mask
+        ],
     };
     let mut ops = vec![];
     for &r in regs {
@@ -1156,7 +1176,8 @@ fn get_pin_states(
     // experiments and discussion with Renesas.
     let (open, mask) = match dev {
         SupportedDevice::ISL68224 => (values[0] as u64, values[1] as u64),
-        SupportedDevice::RAA229618 => {
+        // TODO: RAA229620A support is untested/unverified
+        SupportedDevice::RAA229618 | SupportedDevice::RAA229620A => {
             let open = values[0] as u64 | ((values[1] as u64) << 32);
             let mask = values[2] as u64 | ((values[3] as u64) << 32);
             (open, mask)
@@ -1696,6 +1717,7 @@ fn rendmp_phase_check<'a>(
     let disable_fault_reg: u16 = match dev {
         SupportedDevice::ISL68224 => 0xE952,
         SupportedDevice::RAA229618 => 0xE932,
+        SupportedDevice::RAA229620A => 0xE932, // TODO may have changed
     };
 
     ////////////////////////////////////////////////////////////////////////////
@@ -1722,7 +1744,13 @@ fn rendmp_phase_check<'a>(
         worker.read_word32(index, true, LOOPCFG as u8)?;
         worker.read_word(index, true, PEAK_OCUC_COUNT as u8)?;
 
-        // Set PMBus command codes 0xD0 and 0xD1 to 0x8000 (disable VMon)
+        // Set the appropriate device-specific PMBus command codes to input
+        // voltage thresholding, by setting the thresholds to a very negative
+        // value. This should ensure that it always thinks the input value is
+        // high enough.
+        //
+        // This is a 16-bit two's-complement register, so 0x8000 is the most
+        // negative value.
         match dev {
             SupportedDevice::ISL68224 => {
                 use pmbus::commands::isl68224::CommandCode;
@@ -1757,6 +1785,25 @@ fn rendmp_phase_check<'a>(
                 let reg = (0xEA5B + rail * 0x80) as u16;
                 worker.read_dma(addr, reg)?;
             }
+            SupportedDevice::RAA229620A => {
+                use pmbus::commands::raa229620a::CommandCode;
+                worker.write_word(
+                    index,
+                    true,
+                    CommandCode::VIN_ON as u8,
+                    0x8000,
+                )?;
+                worker.write_word(
+                    index,
+                    true,
+                    CommandCode::VIN_OFF as u8,
+                    0x8000,
+                )?;
+
+                // TODO: we do this undocumented read of 0xEA5B on the '618.
+                let reg = (0xEA5B + rail * 0x80) as u16;
+                worker.read_dma(addr, reg)?;
+            }
         }
 
         worker.read_dma(addr, disable_fault_reg + rail as u16)?;
@@ -1849,6 +1896,26 @@ fn rendmp_phase_check<'a>(
                     bail!("failed to set VIN_OFF for {rail}: {e}",);
                 }
 
+                // Clear bit 0 of DMA register EA5B and write it back
+                // (the name part_fast_add comes from Power Navigator)
+                let mut part_fast_add = match next()? {
+                    Ok(v) => v.expect_read_dma()?,
+                    Err(e) => {
+                        bail!("worker.failed to read EA5B for rail {rail}: {e}")
+                    }
+                };
+                part_fast_add &= !1; // clear bit 0
+                let reg = (0xEA5B + rail * 0x80) as u16;
+                worker.write_dma(addr, reg, part_fast_add)?;
+            }
+            SupportedDevice::RAA229620A => {
+                if let Err(e) = next()? {
+                    bail!("failed to set VIN_ON for {rail}: {e}",);
+                }
+                if let Err(e) = next()? {
+                    bail!("failed to set VIN_OFF for {rail}: {e}",);
+                }
+
                 // Clear bit 0 of DMA register EA5B and write it back
                 // (the name part_fast_add comes from Power Navigator)
                 let mut part_fast_add = match next()? {
@@ -1919,6 +1986,12 @@ fn rendmp_phase_check<'a>(
                     bail!("failed to modify EA5B for rail {rail}: {e}")
                 }
             },
+            SupportedDevice::RAA229620A => match next()? {
+                Ok(v) => v.expect_write_dma()?,
+                Err(e) => {
+                    bail!("failed to modify EA5B for rail {rail}: {e}")
+                }
+            },
             SupportedDevice::ISL68224 => {
                 // no changes were made specifically for the ISL68224
             }
@@ -2079,6 +2152,7 @@ fn rendmp_phase_check<'a>(
         };
         let device = match dev {
             SupportedDevice::RAA229618 => pmbus::Device::Raa229618,
+            SupportedDevice::RAA229620A => pmbus::Device::Raa229620A,
             SupportedDevice::ISL68224 => pmbus::Device::Isl68224,
         };