rust: iomem: add try_memcpy_fromio method for IoMem<T>

This patch adds only runtime-checked bindings version of
`memcpy_fromio()` function prefixed with `try_` similarly
to read/write methods of `IoMem<T>` that is `readx` and `try_readx`.

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

Author: Maciej Falkowski

rust/helpers.c

@@ -181,6 +181,13 @@ void rust_helper_writeq_relaxed(u64 value, volatile void __iomem *addr)
 }
 EXPORT_SYMBOL_GPL(rust_helper_writeq_relaxed);
 #endif
+
+void rust_helper_memcpy_fromio(void *to, const volatile void __iomem *from, long count)
+{
+	memcpy_fromio(to, from, count);
+}
+EXPORT_SYMBOL_GPL(rust_helper_memcpy_fromio);
+
 void rust_helper___spin_lock_init(spinlock_t *lock, const char *name,
 				  struct lock_class_key *key)
 {

rust/kernel/io_mem.rs

@@ -177,6 +177,47 @@ impl<const SIZE: usize> IoMem<SIZE> {
         crate::build_assert!(Self::offset_ok::<T>(offset), "IoMem offset overflow");
     }
 
+    /// Copy memory block from an i/o memory into a buffer.
+    ///
+    /// # Examples
+    /// ```
+    /// # use kernel::prelude::*;
+    /// use kernel::io_mem::{self, IoMem, Resource};
+    ///
+    /// fn test(res: Resource) -> Result {
+    ///     // Create an i/o memory block of at least 100 bytes.
+    ///     let mem = unsafe { IoMem::<100>::try_new(res) }?;
+    ///
+    ///     let mut buffer: [i8; 32] = [0; 32];
+    ///
+    ///     // Memcpy 16 bytes from offset 10 of i/o memory block into the buffer.
+    ///     mem.try_memcpy_fromio(&mut buffer, 10, 16)?;
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    pub fn try_memcpy_fromio(&self, from: &mut [i8], offset: usize, count: usize) -> Result {
+        if !IoMem::<SIZE>::offset_ok::<u8>(offset) {
+            return Err(Error::EINVAL);
+        }
+
+        // Check if memory block can be copied from i/o region
+        // and also whether it will fit into data buffer.
+        if count > from.len() || count > SIZE - offset {
+            return Err(Error::EINVAL);
+        }
+
+        let ptr = self.ptr.wrapping_add(offset);
+
+        // SAFETY:
+        //   - The type invariants guarantee that `ptr` is a valid pointer.
+        //   - The `offset_ok` check returns an error if `offset` would make the write
+        //     go out of bounds (including the type size).
+        //   - the sizes of from/to bufferso are asserted whether they match `count` above.
+        unsafe { bindings::memcpy_fromio(from.as_mut_ptr() as _, ptr as _, count as _) };
+        Ok(())
+    }
+
     define_read!(readb, try_readb, u8);
     define_read!(readw, try_readw, u16);
     define_read!(readl, try_readl, u32);