adc: iio: hardware: use iio buffering for the powerboard ADC

This means the STM32/baseboard ADC and the powerboard ADC can share
most of their setup routine.
The main difference is that the powerboard ADC uses a software trigger
(iio-trig-hrtimer) instead of a hardware timer like the STM32 ADC does.

The software trigger has to first be created via the configs,
making new_powerboard() a bit different from new_stm32().

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

Author: hnez

src/adc/iio/hardware.rs

@@ -16,11 +16,13 @@
 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 use std::convert::{TryFrom, TryInto};
+use std::fs::create_dir;
 use std::io::Read;
+use std::path::Path;
 use std::sync::atomic::{AtomicU16, AtomicU64, Ordering};
 use std::sync::Mutex;
 use std::thread;
-use std::thread::{sleep, JoinHandle};
+use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
 
 use anyhow::{anyhow, Context, Error, Result};
@@ -102,6 +104,8 @@ const CHANNELS_PWR: &[ChannelDesc] = &[
     },
 ];
 
+const TRIGGER_HR_PWR_DIR: &str = "/sys/kernel/config/iio/triggers/hrtimer/tacd-pwr";
+
 const TIMESTAMP_ERROR: u64 = u64::MAX;
 
 #[derive(Clone, Copy)]
@@ -243,43 +247,50 @@ pub struct IioThread {
 }
 
 impl IioThread {
-    fn adc_setup_stm32() -> Result<(Vec<Channel>, Buffer)> {
+    fn adc_setup(
+        adc_name: &str,
+        trigger_name: &str,
+        sample_rate: i64,
+        channel_descs: &[ChannelDesc],
+        buffer_len: usize,
+    ) -> Result<(Vec<Channel>, Buffer)> {
         let ctx = industrial_io::Context::new()?;
 
         debug!("IIO devices:");
         for dev in ctx.devices() {
             debug!("  * {}", &dev.name().unwrap_or_default());
         }
 
-        let stm32_adc = ctx
-            .find_device("48003000.adc:adc@0")
-            .ok_or(anyhow!("Could not find STM32 ADC"))?;
+        let adc = ctx
+            .find_device(adc_name)
+            .ok_or(anyhow!("Could not find ADC: {}", adc_name))?;
 
-        if let Err(err) = stm32_adc.attr_write_bool("buffer/enable", false) {
-            warn!("Failed to disable STM32 ADC buffer: {}", err);
+        if let Err(err) = adc.attr_write_bool("buffer/enable", false) {
+            warn!("Failed to disable {} ADC buffer: {}", adc_name, err);
         }
 
-        let stm32_channels: Vec<Channel> = CHANNELS_STM32
+        let channels: Vec<Channel> = channel_descs
             .iter()
             .map(|ChannelDesc { kernel_name, .. }| {
-                let ch = stm32_adc
+                let ch = adc
                     .find_channel(kernel_name, false)
-                    .unwrap_or_else(|| panic!("Failed to open iio channel {}", kernel_name));
+                    .unwrap_or_else(|| panic!("Failed to open kernel channel {}", kernel_name));
 
                 ch.enable();
                 ch
             })
             .collect();
 
         let trig = ctx
-            .find_device("tim4_trgo")
-            .ok_or(anyhow!("Could not find STM32 Timer 4 trigger"))?;
-        trig.attr_write_int("sampling_frequency", 1024)?;
+            .find_device(trigger_name)
+            .ok_or(anyhow!("Could not find IIO trigger: {}", trigger_name))?;
+
+        trig.attr_write_int("sampling_frequency", sample_rate)?;
 
-        stm32_adc.set_trigger(&trig)?;
+        adc.set_trigger(&trig)?;
         ctx.set_timeout_ms(1000)?;
 
-        let stm32_buf = stm32_adc.create_buffer(128, false)?;
+        let buf = adc.create_buffer(buffer_len, false)?;
 
         set_thread_priority_and_policy(
             thread_native_id(),
@@ -288,10 +299,17 @@ impl IioThread {
         )
         .map_err(|e| anyhow!("Failed to set realtime thread priority: {e:?}"))?;
 
-        Ok((stm32_channels, stm32_buf))
+        Ok((channels, buf))
     }
 
-    pub async fn new_stm32() -> Result<Arc<Self>> {
+    async fn new(
+        thread_name: &str,
+        adc_name: &'static str,
+        trigger_name: &'static str,
+        sample_rate: i64,
+        channel_descs: &'static [ChannelDesc],
+        buffer_len: usize,
+    ) -> Result<Arc<Self>> {
         // Some of the adc thread setup can only happen _in_ the adc thread,
         // like setting the priority or some iio setup, as not all structs
         // are Send.
@@ -303,16 +321,23 @@ impl IioThread {
 
         // Spawn a high priority thread that updates the atomic values in `thread`.
         let join = thread::Builder::new()
-            .name("tacd stm32 iio".to_string())
+            .name(format!("tacd {thread_name} iio"))
             .spawn(move || {
-                let (thread, channels, mut buf) = match Self::adc_setup_stm32() {
+                let adc_setup_res = Self::adc_setup(
+                    adc_name,
+                    trigger_name,
+                    sample_rate,
+                    channel_descs,
+                    buffer_len,
+                );
+                let (thread, channels, mut buf) = match adc_setup_res {
                     Ok((channels, buf)) => {
                         let thread = Arc::new(Self {
                             ref_instant: Instant::now(),
                             timestamp: AtomicU64::new(TIMESTAMP_ERROR),
                             values: channels.iter().map(|_| AtomicU16::new(0)).collect(),
                             join: Mutex::new(None),
-                            channel_descs: CHANNELS_STM32,
+                            channel_descs,
                         });
 
                         (thread, channels, buf)
@@ -332,7 +357,7 @@ impl IioThread {
                     if let Err(e) = buf.refill() {
                         thread.timestamp.store(TIMESTAMP_ERROR, Ordering::Relaxed);
 
-                        error!("Failed to refill stm32 ADC buffer: {}", e);
+                        error!("Failed to refill {} ADC buffer: {}", adc_name, e);
 
                         // If the ADC has not yet produced any values we still have the
                         // queue at hand that signals readiness to the main thread.
@@ -377,127 +402,26 @@ impl IioThread {
         Ok(thread)
     }
 
-    fn adc_setup_powerboard() -> Result<Vec<Channel>> {
-        let ctx = industrial_io::Context::new()?;
-
-        debug!("IIO devices:");
-        for dev in ctx.devices() {
-            debug!("  * {}", &dev.name().unwrap_or_default());
-        }
-
-        let pwr_adc = ctx
-            .find_device("lmp92064")
-            .ok_or(anyhow!("Could not find Powerboard ADC"))?;
-
-        ctx.set_timeout_ms(1000)?;
-
-        let pwr_channels: Vec<Channel> = CHANNELS_PWR
-            .iter()
-            .map(|ChannelDesc { kernel_name, .. }| {
-                pwr_adc
-                    .find_channel(kernel_name, false)
-                    .unwrap_or_else(|| panic!("Failed to open iio channel {}", kernel_name))
-            })
-            .collect();
-
-        set_thread_priority_and_policy(
-            thread_native_id(),
-            ThreadPriority::Crossplatform(ThreadPriorityValue::try_from(10).unwrap()),
-            ThreadSchedulePolicy::Realtime(RealtimeThreadSchedulePolicy::Fifo),
+    pub async fn new_stm32() -> Result<Arc<Self>> {
+        Self::new(
+            "stm32",
+            "48003000.adc:adc@0",
+            "tim4_trgo",
+            1024,
+            CHANNELS_STM32,
+            128,
         )
-        .map_err(|e| anyhow!("Failed to set realtime thread priority: {e:?}"))?;
-
-        Ok(pwr_channels)
+        .await
     }
 
     pub async fn new_powerboard() -> Result<Arc<Self>> {
-        // Some of the adc thread setup can only happen _in_ the adc thread,
-        // like setting the priority or some iio setup, as not all structs
-        // are Send.
-        // We do however not want to return from new() before we know that the
-        // setup was sucessful.
-        // This is why we create Self inside the thread and send it back
-        // to the calling thread via a queue.
-        let (thread_res_tx, mut thread_res_rx) = bounded(1);
-
-        // Spawn a high priority thread that updates the atomic values in `thread`.
-        let join = thread::Builder::new()
-            .name("tacd powerboard iio".to_string())
-            .spawn(move || {
-                let (thread, channels) = match Self::adc_setup_powerboard() {
-                    Ok(channels) => {
-                        let thread = Arc::new(Self {
-                            ref_instant: Instant::now(),
-                            timestamp: AtomicU64::new(TIMESTAMP_ERROR),
-                            values: channels.iter().map(|_| AtomicU16::new(0)).collect(),
-                            join: Mutex::new(None),
-                            channel_descs: CHANNELS_PWR,
-                        });
+        let hr_trigger_path = Path::new(TRIGGER_HR_PWR_DIR);
 
-                        (thread, channels)
-                    }
-                    Err(e) => {
-                        thread_res_tx.try_send(Err(e)).unwrap();
-                        return;
-                    }
-                };
-
-                let thread_weak = Arc::downgrade(&thread);
-                let mut signal_ready = Some((thread, thread_res_tx));
-
-                // Stop running as soon as the last reference to this Arc<IioThread>
-                // is dropped (e.g. the weak reference can no longer be upgraded).
-                while let Some(thread) = thread_weak.upgrade() {
-                    // Use the sysfs based interface to get the values from the
-                    // power board ADC at a slow sampling rate.
-                    let voltage = channels[0].attr_read_int("raw");
-                    let current = channels[1].attr_read_int("raw");
-
-                    let (voltage, current) = match (voltage, current) {
-                        (Ok(v), Ok(c)) => (v, c),
-                        (Err(e), _) | (_, Err(e)) => {
-                            thread.timestamp.store(TIMESTAMP_ERROR, Ordering::Relaxed);
-
-                            error!("Failed to read Powerboard ADC: {}", e);
-
-                            // If the ADC has not yet produced any values we still have the
-                            // queue at hand that signals readiness to the main thread.
-                            // This gives us a chance to return an Err from new().
-                            // If the queue was already used just print an error instead.
-                            if let Some((_, tx)) = signal_ready.take() {
-                                tx.try_send(Err(Error::new(e))).unwrap();
-                            }
-
-                            break;
-                        }
-                    };
-
-                    thread.values[0].store(voltage as u16, Ordering::Relaxed);
-                    thread.values[1].store(current as u16, Ordering::Relaxed);
-
-                    let ts: u64 = Instant::now()
-                        .checked_duration_since(thread.ref_instant)
-                        .unwrap()
-                        .as_nanos()
-                        .try_into()
-                        .unwrap();
-
-                    thread.timestamp.store(ts, Ordering::Release);
-
-                    // Now that we know that the ADC actually works and we have
-                    // initial values: return a handle to it.
-                    if let Some((content, tx)) = signal_ready.take() {
-                        tx.try_send(Ok(content)).unwrap();
-                    }
-
-                    sleep(Duration::from_millis(50));
-                }
-            })?;
-
-        let thread = thread_res_rx.next().await.unwrap()?;
-        *thread.join.lock().unwrap() = Some(join);
+        if !hr_trigger_path.is_dir() {
+            create_dir(hr_trigger_path).unwrap();
+        }
 
-        Ok(thread)
+        Self::new("powerboard", "lmp92064", "tacd-pwr", 20, CHANNELS_PWR, 1).await
     }
 
     /// Use the channel names defined at the top of the file to get a reference