rust: iopoll: add iopoll bindings

Signed-off-by: Maciej Falkowski <[email protected]>

Author: Maciej Falkowski

rust/helpers.c

@@ -3,6 +3,9 @@
 #include <linux/bug.h>
 #include <linux/build_bug.h>
 #include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/ktime.h>
+#include <linux/kernel.h>
 #include <linux/uaccess.h>
 #include <linux/sched/signal.h>
 #include <linux/gfp.h>
@@ -23,6 +26,26 @@ __noreturn void rust_helper_BUG(void)
 	BUG();
 }
 
+void rust_helper_usleep_range(unsigned long min, unsigned long max)
+{
+	usleep_range(min, max);
+}
+
+void rust_helper_might_sleep(void)
+{
+	might_sleep();
+}
+
+int rust_helper_ktime_compare(const ktime_t cmp1, const ktime_t cmp2)
+{
+	return ktime_compare(cmp1, cmp2);
+}
+
+ktime_t rust_helper_ktime_add_us(const ktime_t kt, const u64 usec)
+{
+	return ktime_add_us(kt, usec);
+}
+
 int rust_helper_clk_prepare_enable(struct clk *clk)
 {
 	return clk_prepare_enable(clk);

rust/kernel/io_mem.rs

@@ -7,7 +7,7 @@
 #![allow(dead_code)]
 
 use crate::{
-    bindings
+    bindings, iopoll,
     platdev::{self, PlatformDevice},
     Error, Result,
 };
@@ -131,6 +131,32 @@ macro_rules! define_write {
     };
 }
 
+macro_rules! define_readx_poll_timeout {
+    ($(#[$attr:meta])* $fname:ident, $callback_name:ident, $type_name:ty) => {
+        /// Polls IO data from the given offset known, at compile time.
+        ///
+        /// The IO data is polled until it matches specific condition or fails
+        /// at timeout.
+        ///
+        /// If the offset is not known at compile time, the build will fail.
+        $(#[$attr])*
+        pub fn $fname<F: Fn(&$type_name) -> bool>(
+            &self,
+            offset: usize,
+            cond: F,
+            sleep_us: u32,
+            timeout_us: u64,
+        ) -> Result<$type_name> {
+            Self::check_offset::<$type_name>(offset);
+            let ptr = self.ptr.wrapping_add(offset);
+            // SAFETY: The type invariants guarantee that `ptr` is a valid pointer. The check above
+            // guarantees that the code won't build if `offset` makes the read go out of bounds
+            // (including the type size).
+            unsafe { iopoll::readx_poll_timeout(bindings::$callback_name, cond, sleep_us, timeout_us, ptr as _) }
+        }
+    };
+}
+
 impl<const SIZE: usize> IoMem<SIZE> {
     /// Tries to create a new instance of a memory block.
     ///
@@ -189,6 +215,16 @@ impl<const SIZE: usize> IoMem<SIZE> {
         crate::build_assert!(Self::offset_ok::<T>(offset), "IoMem offset overflow");
     }
 
+    define_readx_poll_timeout!(readb_poll_timeout, readb, u8);
+    define_readx_poll_timeout!(readw_poll_timeout, readw, u16);
+    define_readx_poll_timeout!(readl_poll_timeout, readl, u32);
+    define_readx_poll_timeout!(
+        #[cfg(CONFIG_64BIT)]
+        readq_poll_timeout,
+        readq,
+        u64
+    );
+
     define_read!(readb, try_readb, u8);
     define_read!(readw, try_readw, u16);
     define_read!(readl, try_readl, u32);

rust/kernel/iopoll.rs

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Helper routines for polling IO addresses.
+//!
+//! C header: [`include/linux/iopoll.h`](../../../../include/linux/iopoll.h)
+
+use core::mem::MaybeUninit;
+
+use crate::{
+    bindings, c_types,
+    error::{Error, Result},
+    might_sleep_if,
+};
+
+/// Periodically poll an address until a condition is met or a timeout occurs.
+///
+/// # Safety
+///
+/// `addr` must be non-null pointer valid io address.
+pub unsafe fn read_poll_timeout<T, F: Fn(&T) -> bool>(
+    op: unsafe extern "C" fn(*const c_types::c_void) -> T,
+    cond: F,
+    sleep_us: u32,
+    timeout_us: u64,
+    sleep_before_read: bool,
+    addr: *const c_types::c_void,
+) -> Result<T> {
+    // SAFETY: FFI call.
+    let timeout = unsafe { bindings::ktime_add_us(bindings::ktime_get(), timeout_us) };
+    might_sleep_if!(sleep_us != 0);
+
+    if sleep_before_read && sleep_us != 0 {
+        // SAFETY: FFI call.
+        unsafe { bindings::usleep_range((sleep_us >> 2) + 1, sleep_us) };
+    }
+
+    let mut val = MaybeUninit::<T>::uninit();
+
+    loop {
+        unsafe { val.as_mut_ptr().write(op(addr)) };
+        if cond(unsafe { &*val.as_mut_ptr() }) {
+            break;
+        }
+
+        // SAFETY: FFI call.
+        if timeout_us != 0 && unsafe { bindings::ktime_compare(bindings::ktime_get(), timeout) } > 0
+        {
+            unsafe { val.as_mut_ptr().write(op(addr)) };
+            break;
+        }
+
+        if sleep_us != 0 {
+            // SAFETY: FFI call.
+            unsafe { bindings::usleep_range((sleep_us >> 2) + 1, sleep_us) };
+        }
+    }
+
+    if cond(unsafe { &*val.as_mut_ptr() }) {
+        // SAFETY: variable is properly initialized as there is at least one write to it at loop.
+        Ok(unsafe { val.assume_init() })
+    } else {
+        Err(Error::ETIMEDOUT)
+    }
+}
+
+/// # Safety
+///
+/// `addr` must be non-null pointer valid io address.
+pub unsafe fn readx_poll_timeout<T, F: Fn(&T) -> bool>(
+    op: unsafe extern "C" fn(*const c_types::c_void) -> T,
+    cond: F,
+    sleep_us: u32,
+    timeout_us: u64,
+    addr: *const c_types::c_void,
+) -> Result<T> {
+    // SAFETY: `addr` is valid by the safety contract.
+    unsafe { read_poll_timeout(op, cond, sleep_us, timeout_us, false, addr) }
+}

rust/kernel/lib.rs

@@ -55,6 +55,7 @@ pub mod file;
 pub mod file_operations;
 pub mod gpio;
 pub mod hw_random;
+pub mod iopoll;
 pub mod irq;
 pub mod miscdev;
 pub mod pages;
@@ -177,6 +178,17 @@ impl<'a> Drop for KParamGuard<'a> {
     }
 }
 
+#[macro_export]
+macro_rules! might_sleep_if {
+    ($cond:expr) => {
+        if $cond {
+            unsafe {
+                bindings::might_sleep();
+            }
+        }
+    };
+}
+
 /// Calculates the offset of a field from the beginning of the struct it belongs to.
 ///
 /// # Example