adc: determine ADC lines based on hardware generation

The ADC channels 0 and 1 on the STM32MP1 are a bit special,
in that they are not muxable as GPIOs but connected directly to the
ADC peripheral.
This has cause us a bit of trouble in the past, because these pins
seem to leak current (like all other channels did until the transition
into ADC standby was fixed by unmuxing the ADC pins beforehand).
We could once again try to fix the issue with these pins,
but that could also turn out to be impossible to do (since the pins
can not be muxed away).
This is why we have instead decided to just not use these pins on
generation 3 (and likely later) hardware and use other pins instead.

This means we have to detect which ADC pins we should use based on
if we are running on Gen 1 / Gen 2 or Gen 3.

Signed-off-by: Leonard Göhrs <[email protected]>

Author: hnez

src/adc.rs

@@ -23,6 +23,7 @@ use async_std::task::sleep;
 
 use crate::broker::{BrokerBuilder, Topic};
 use crate::measurement::{Measurement, Timestamp};
+use crate::system::HardwareGeneration;
 use crate::watched_tasks::WatchedTasksBuilder;
 
 const HISTORY_LENGTH: usize = 200;
@@ -78,8 +79,12 @@ pub struct Adc {
 }
 
 impl Adc {
-    pub async fn new(bb: &mut BrokerBuilder, wtb: &mut WatchedTasksBuilder) -> Result<Self> {
-        let stm32_thread = IioThread::new_stm32(wtb).await?;
+    pub async fn new(
+        bb: &mut BrokerBuilder,
+        wtb: &mut WatchedTasksBuilder,
+        hardware_generation: HardwareGeneration,
+    ) -> Result<Self> {
+        let stm32_thread = IioThread::new_stm32(wtb, hardware_generation).await?;
         let powerboard_thread = IioThread::new_powerboard(wtb).await?;
 
         let adc = Self {

src/adc/iio/demo_mode.rs

@@ -160,7 +160,7 @@ pub struct IioThread {
 }
 
 impl IioThread {
-    pub async fn new_stm32<W>(_wtb: &W) -> Result<Arc<Self>> {
+    pub async fn new_stm32<W, G>(_wtb: &W, _hardware_generation: G) -> Result<Arc<Self>> {
         let mut demo_magic = block_on(DEMO_MAGIC_STM32.lock());
 
         // Only ever set up a single demo_mode "IioThread" per ADC

src/adc/iio/hardware.rs

@@ -32,6 +32,7 @@ use log::{debug, error, warn};
 use thread_priority::*;
 
 use crate::measurement::{Measurement, Timestamp};
+use crate::system::HardwareGeneration;
 use crate::watched_tasks::WatchedTasksBuilder;
 
 struct ChannelDesc {
@@ -43,7 +44,7 @@ struct ChannelDesc {
 // Hard coded list of channels using the internal STM32MP1 ADC.
 // Consists of the IIO channel name, the location of the calibration data
 // in the device tree and an internal name for the channel.
-const CHANNELS_STM32: &[ChannelDesc] = &[
+const CHANNELS_STM32_GEN1_GEN2: &[ChannelDesc] = &[
     ChannelDesc {
         kernel_name: "voltage13",
         calibration_path: "baseboard-factory-data/usb-host-curr",
@@ -86,6 +87,49 @@ const CHANNELS_STM32: &[ChannelDesc] = &[
     },
 ];
 
+const CHANNELS_STM32_GEN3: &[ChannelDesc] = &[
+    ChannelDesc {
+        kernel_name: "voltage13",
+        calibration_path: "baseboard-factory-data/usb-host-curr",
+        name: "usb-host-curr",
+    },
+    ChannelDesc {
+        kernel_name: "voltage15",
+        calibration_path: "baseboard-factory-data/usb-host1-curr",
+        name: "usb-host1-curr",
+    },
+    ChannelDesc {
+        kernel_name: "voltage18",
+        calibration_path: "baseboard-factory-data/usb-host2-curr",
+        name: "usb-host2-curr",
+    },
+    ChannelDesc {
+        kernel_name: "voltage14",
+        calibration_path: "baseboard-factory-data/usb-host3-curr",
+        name: "usb-host3-curr",
+    },
+    ChannelDesc {
+        kernel_name: "voltage2",
+        calibration_path: "baseboard-factory-data/out0-volt",
+        name: "out0-volt",
+    },
+    ChannelDesc {
+        kernel_name: "voltage10",
+        calibration_path: "baseboard-factory-data/out1-volt",
+        name: "out1-volt",
+    },
+    ChannelDesc {
+        kernel_name: "voltage5",
+        calibration_path: "baseboard-factory-data/iobus-curr",
+        name: "iobus-curr",
+    },
+    ChannelDesc {
+        kernel_name: "voltage9",
+        calibration_path: "baseboard-factory-data/iobus-volt",
+        name: "iobus-volt",
+    },
+];
+
 // The same as for the STM32MP1 channels but for the discrete ADC on the power
 // board.
 const CHANNELS_PWR: &[ChannelDesc] = &[
@@ -431,14 +475,22 @@ impl IioThread {
         Ok(thread)
     }
 
-    pub async fn new_stm32(wtb: &mut WatchedTasksBuilder) -> Result<Arc<Self>> {
+    pub async fn new_stm32(
+        wtb: &mut WatchedTasksBuilder,
+        hardware_generation: HardwareGeneration,
+    ) -> Result<Arc<Self>> {
+        let channels = match hardware_generation {
+            HardwareGeneration::Gen1 | HardwareGeneration::Gen2 => CHANNELS_STM32_GEN1_GEN2,
+            HardwareGeneration::Gen3 => CHANNELS_STM32_GEN3,
+        };
+
         Self::new(
             wtb,
             "adc-stm32",
             "48003000.adc:adc@0",
             "tim4_trgo",
             80,
-            CHANNELS_STM32,
+            channels,
             4,
         )
         .await

src/adc/iio/test.rs

@@ -107,7 +107,7 @@ pub struct IioThread {
 }
 
 impl IioThread {
-    pub async fn new_stm32<W>(_wtb: &W) -> Result<Arc<Self>> {
+    pub async fn new_stm32<W, G>(_wtb: &W, _hardware_generation: G) -> Result<Arc<Self>> {
         let mut channels = Vec::new();
 
         for name in CHANNELS_STM32 {

src/digital_io/gpio/demo_mode.rs

@@ -32,7 +32,7 @@ impl LineHandle {
         // It is just a hack to let adc/iio/demo_mode.rs
         // communicate with this function so that toggling an output
         // has an effect on the measured values.
-        let iio_thread_stm32 = block_on(IioThread::new_stm32(&())).unwrap();
+        let iio_thread_stm32 = block_on(IioThread::new_stm32(&(), ())).unwrap();
         let iio_thread_pwr = block_on(IioThread::new_powerboard(&())).unwrap();
 
         match self.name.as_str() {

src/dut_power.rs

@@ -631,7 +631,7 @@ mod tests {
 
         let (adc, dut_pwr, led) = {
             let mut bb = BrokerBuilder::new();
-            let adc = block_on(Adc::new(&mut bb, &mut wtb)).unwrap();
+            let adc = block_on(Adc::new(&mut bb, &mut wtb, hardware_generation)).unwrap();
             let led = Topic::anonymous(None);
 
             let dut_pwr = block_on(DutPwrThread::new(
@@ -792,7 +792,7 @@ mod tests {
 
         let (adc, dut_pwr) = {
             let mut bb = BrokerBuilder::new();
-            let adc = block_on(Adc::new(&mut bb, &mut wtb)).unwrap();
+            let adc = block_on(Adc::new(&mut bb, &mut wtb, hardware_generation)).unwrap();
             let led = Topic::anonymous(None);
 
             let dut_pwr = block_on(DutPwrThread::new(

src/main.rs

@@ -75,7 +75,7 @@ async fn init(screenshooter: ScreenShooter) -> Result<(Ui, WatchedTasksBuilder)>
     // Expose hardware on the TAC via the broker framework.
     let backlight = Backlight::new(&mut bb, &mut wtb)?;
     let led = Led::new(&mut bb, &mut wtb)?;
-    let adc = Adc::new(&mut bb, &mut wtb).await?;
+    let adc = Adc::new(&mut bb, &mut wtb, hardware_generation).await?;
     let dut_pwr = DutPwrThread::new(
         &mut bb,
         &mut wtb,

src/regulators.rs

@@ -32,7 +32,7 @@ mod reg {
 
     pub fn regulator_set(name: &str, state: bool) -> Result<()> {
         if name == "output_iobus_12v" {
-            let iio_thread = block_on(IioThread::new_stm32(&())).unwrap();
+            let iio_thread = block_on(IioThread::new_stm32(&(), ())).unwrap();
 
             iio_thread
                 .clone()

src/usb_hub.rs

@@ -94,7 +94,7 @@ mod rw {
 
         for (path_tail, iio_channel) in DISABLE_CHANNELS {
             if path.ends_with(path_tail) {
-                let iio_thread = block_on(IioThread::new_stm32(&())).unwrap();
+                let iio_thread = block_on(IioThread::new_stm32(&(), ())).unwrap();
 
                 iio_thread
                     .get_channel(iio_channel)