dut_power: make GPIOs open drain

This improves EMI performance of the TAC a tiny bit, by not driving the
pins on the flat flex using the somewhat noisy VCC_IO power supply.
Signals on the flat flex are prone to coupling to one another due to
missing GND reference plane.
We _think_ we see this kind of noise on the IOBus lines, which are are
present on the flat-flex, as well as on the external IOBus connector.

Signed-off-by: Leonard Göhrs <l.goehrs@pengutronix.de>

Author: hnez

src/digital_io/gpio/demo_mode.rs

@@ -15,6 +15,8 @@
 // with this program; if not, write to the Free Software Foundation, Inc.,
 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
+use std::ops::BitOr;
+
 use anyhow::Result;
 use async_std::task::block_on;
 
@@ -60,9 +62,30 @@ impl LineHandle {
     }
 }
 
-#[allow(clippy::upper_case_acronyms)]
+#[allow(clippy::upper_case_acronyms, non_camel_case_types)]
+#[derive(Clone, Copy)]
 pub enum LineRequestFlags {
     OUTPUT,
+    OPEN_DRAIN,
+}
+
+impl BitOr for LineRequestFlags {
+    type Output = Self;
+
+    fn bitor(self, rhs: Self) -> Self::Output {
+        match (self, rhs) {
+            (Self::OPEN_DRAIN, res) | (res, Self::OPEN_DRAIN) => res,
+            _ => unimplemented!(),
+        }
+    }
+}
+
+pub struct ChipDecoy;
+
+impl ChipDecoy {
+    pub fn label(&self) -> &'static str {
+        "demo_mode"
+    }
 }
 
 pub struct FindDecoy {
@@ -79,6 +102,10 @@ impl FindDecoy {
 
         Ok(line_handle)
     }
+
+    pub fn chip(&self) -> ChipDecoy {
+        ChipDecoy
+    }
 }
 
 pub fn find_line(name: &str) -> Option<FindDecoy> {

src/digital_io/gpio/test.rs

@@ -16,6 +16,7 @@
 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 use std::iter::Iterator;
+use std::ops::BitOr;
 use std::sync::atomic::{AtomicU8, Ordering};
 use std::thread::sleep;
 use std::time::Duration;
@@ -63,9 +64,30 @@ impl Iterator for LineEventHandle {
     }
 }
 
-#[allow(clippy::upper_case_acronyms)]
+#[allow(clippy::upper_case_acronyms, non_camel_case_types)]
+#[derive(Clone, Copy)]
 pub enum LineRequestFlags {
     OUTPUT,
+    OPEN_DRAIN,
+}
+
+impl BitOr for LineRequestFlags {
+    type Output = Self;
+
+    fn bitor(self, rhs: Self) -> Self::Output {
+        match (self, rhs) {
+            (Self::OPEN_DRAIN, res) | (res, Self::OPEN_DRAIN) => res,
+            _ => unimplemented!(),
+        }
+    }
+}
+
+pub struct ChipDecoy;
+
+impl ChipDecoy {
+    pub fn label(&self) -> &'static str {
+        "test"
+    }
 }
 
 pub struct FindDecoy {
@@ -83,6 +105,10 @@ impl FindDecoy {
         })
     }
 
+    pub fn chip(&self) -> ChipDecoy {
+        ChipDecoy
+    }
+
     pub fn stub_get(&self) -> u8 {
         self.val.load(Ordering::Relaxed)
     }

src/dut_power.rs

@@ -19,7 +19,7 @@ use std::sync::atomic::{AtomicU32, AtomicU8, Ordering};
 use std::thread;
 use std::time::{Duration, Instant};
 
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 use async_std::channel::bounded;
 use async_std::prelude::*;
 use async_std::sync::{Arc, Weak};
@@ -286,17 +286,23 @@ impl DutPwrThread {
         pwr_curr: AdcChannel,
         pwr_led: Arc<Topic<BlinkPattern>>,
     ) -> Result<Self> {
-        let pwr_line = find_line("DUT_PWR_EN").unwrap().request(
-            LineRequestFlags::OUTPUT,
-            1 - PWR_LINE_ASSERTED,
-            "tacd",
-        )?;
-
-        let discharge_line = find_line("DUT_PWR_DISCH").unwrap().request(
-            LineRequestFlags::OUTPUT,
-            DISCHARGE_LINE_ASSERTED,
-            "tacd",
-        )?;
+        let pwr_line = find_line("DUT_PWR_EN")
+            .ok_or_else(|| anyhow!("Could not find GPIO line DUT_PWR_EN"))?;
+        let discharge_line = find_line("DUT_PWR_DISCH")
+            .ok_or_else(|| anyhow!("Could not find GPIO line DUT_PWR_DISCH"))?;
+
+        // Early TACs have a i2c port expander on the power board.
+        // This port expander is output only and can not be configured as
+        // open drain.
+        // The outputs on later TACs should however be driven open drain
+        // for EMI reasons.
+        let flags = match pwr_line.chip().label() {
+            "pca9570" => LineRequestFlags::OUTPUT,
+            _ => LineRequestFlags::OUTPUT | LineRequestFlags::OPEN_DRAIN,
+        };
+
+        let pwr_line = pwr_line.request(flags, 1 - PWR_LINE_ASSERTED, "tacd")?;
+        let discharge_line = discharge_line.request(flags, DISCHARGE_LINE_ASSERTED, "tacd")?;
 
         // The realtime priority must be set up inside the tread, but
         // the operation may fail, in which case we want new() to fail