Add a generic iomem abstraction to safely read and write ioremapped
regions. This abstraction requires a previously acquired IoRequest
instance. This makes it so that both the resource and the device match,
or, in other words, that the resource is indeed a valid resource for a
given bound device.

A subsequent patch will add the ability to retrieve IoRequest instances
from platform devices.

The reads and writes are done through IoRaw, and are thus checked either
at compile-time, if the size of the region is known at that point, or at
runtime otherwise.

Non-exclusive access to the underlying memory region is made possible to
cater to cases where overlapped regions are unavoidable.

Signed-off-by: Daniel Almeida <daniel.almeida@collabora.com>
---
 rust/helpers/io.c     |   5 +
 rust/kernel/io.rs     |   1 +
 rust/kernel/io/mem.rs | 274 ++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 280 insertions(+)

diff --git a/rust/helpers/io.c b/rust/helpers/io.c
index 404776cf6717c8570c7600a24712ce6e4623d3c6..c475913c69e647b1042e8e7d66b9148d892947a1 100644
--- a/rust/helpers/io.c
+++ b/rust/helpers/io.c
@@ -8,6 +8,11 @@ void __iomem *rust_helper_ioremap(phys_addr_t offset, size_t size)
 	return ioremap(offset, size);
 }
 
+void __iomem *rust_helper_ioremap_np(phys_addr_t offset, size_t size)
+{
+	return ioremap_np(offset, size);
+}
+
 void rust_helper_iounmap(void __iomem *addr)
 {
 	iounmap(addr);
diff --git a/rust/kernel/io.rs b/rust/kernel/io.rs
index 7b70d5b5477e57d6d0f24bcd26bd8b0071721bc0..b7fc759f8b5d3c3ac6f33f5a66e9f619c58b7405 100644
--- a/rust/kernel/io.rs
+++ b/rust/kernel/io.rs
@@ -7,6 +7,7 @@
 use crate::error::{code::EINVAL, Result};
 use crate::{bindings, build_assert};
 
+pub mod mem;
 pub mod resource;
 
 pub use resource::Resource;
diff --git a/rust/kernel/io/mem.rs b/rust/kernel/io/mem.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b047b9a73ae535bb221b2aea48d875a66a3fbc13
--- /dev/null
+++ b/rust/kernel/io/mem.rs
@@ -0,0 +1,274 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Generic memory-mapped IO.
+
+use core::ops::Deref;
+
+use crate::device::Bound;
+use crate::device::Device;
+use crate::devres::Devres;
+use crate::io;
+use crate::io::resource::Region;
+use crate::io::resource::Resource;
+use crate::io::Io;
+use crate::io::IoRaw;
+use crate::prelude::*;
+
+/// An IO request for a specific device and resource.
+pub struct IoRequest<'a> {
+    device: &'a Device<Bound>,
+    resource: &'a Resource,
+}
+
+impl<'a> IoRequest<'a> {
+    /// Creates a new [`IoRequest`] instance.
+    ///
+    /// # Safety
+    ///
+    /// Callers must ensure that `resource` is valid for `device` during the
+    /// lifetime `'a`.
+    pub(crate) unsafe fn new(device: &'a Device<Bound>, resource: &'a Resource) -> Self {
+        IoRequest { device, resource }
+    }
+
+    /// Maps an [`IoRequest`] where the size is known at compile time.
+    ///
+    /// This uses the
+    /// [`ioremap()`](https://docs.kernel.org/driver-api/device-io.html#getting-access-to-the-device)
+    /// C API.
+    ///
+    /// # Examples
+    ///
+    /// The following example uses a [`platform::Device`] for illustration
+    /// purposes.
+    ///
+    /// ```no_run
+    /// # use kernel::{bindings, c_str, platform, of, device::Core};
+    /// # struct SampleDriver;
+    ///
+    /// impl platform::Driver for SampleDriver {
+    ///    # type IdInfo = ();
+    ///    # const OF_ID_TABLE: Option<of::IdTable<Self::IdInfo>> = None;
+    ///
+    ///    fn probe(
+    ///       pdev: &platform::Device<Core>,
+    ///       info: Option<&Self::IdInfo>,
+    ///    ) -> Result<Pin<KBox<Self>>> {
+    ///       let offset = 0; // Some offset.
+    ///
+    ///       // If the size is known at compile time, use [`Self::iomap_sized`].
+    ///       //
+    ///       // No runtime checks will apply when reading and writing.
+    ///       let request = pdev.request_io_by_index(0).ok_or(ENODEV)?;
+    ///       let iomem = request.iomap_sized::<42>()?;
+    ///       let iomem = KBox::pin_init(iomem, GFP_KERNEL)?;
+    ///
+    ///       let io = iomem.access(pdev.as_ref())?;
+    ///
+    ///       // Read and write a 32-bit value at `offset`.
+    ///       let data = io.read32_relaxed(offset);
+    ///
+    ///       io.write32_relaxed(data, offset);
+    ///
+    ///       # Ok(KBox::new(SampleDriver, GFP_KERNEL)?.into())
+    ///     }
+    /// }
+    /// ```
+    pub fn iomap_sized<const SIZE: usize>(
+        self,
+    ) -> Result<impl PinInit<Devres<IoMem<SIZE>>, Error> + 'a> {
+        IoMem::new(self)
+    }
+
+    /// Same as [`Self::iomap_sized`] but with exclusive access to the
+    /// underlying region.
+    ///
+    /// This uses the
+    /// [`ioremap()`](https://docs.kernel.org/driver-api/device-io.html#getting-access-to-the-device)
+    /// C API.
+    pub fn iomap_exclusive_sized<const SIZE: usize>(
+        self,
+    ) -> Result<impl PinInit<Devres<ExclusiveIoMem<SIZE>>, Error> + 'a> {
+        ExclusiveIoMem::new(self)
+    }
+
+    /// Maps an [`IoRequest`] where the size is not known at compile time,
+    ///
+    /// This uses the
+    /// [`ioremap()`](https://docs.kernel.org/driver-api/device-io.html#getting-access-to-the-device)
+    /// C API.
+    ///
+    /// # Examples
+    ///
+    /// The following example uses a [`platform::Device`] for illustration
+    /// purposes.
+    ///
+    /// ```no_run
+    /// # use kernel::{bindings, c_str, platform, of, device::Core};
+    /// # struct SampleDriver;
+    ///
+    /// impl platform::Driver for SampleDriver {
+    ///    # type IdInfo = ();
+    ///    # const OF_ID_TABLE: Option<of::IdTable<Self::IdInfo>> = None;
+    ///
+    ///    fn probe(
+    ///       pdev: &platform::Device<Core>,
+    ///       info: Option<&Self::IdInfo>,
+    ///    ) -> Result<Pin<KBox<Self>>> {
+    ///       let offset = 0; // Some offset.
+    ///
+    ///       // Unlike [`Self::iomap_sized`], here the size of the memory region
+    ///       // is not known at compile time, so only the `try_read*` and `try_write*`
+    ///       // family of functions should be used, leading to runtime checks on every
+    ///       // access.
+    ///       let request = pdev.request_io_by_index(0).ok_or(ENODEV)?;
+    ///       let iomem = request.iomap()?;
+    ///       let iomem = KBox::pin_init(iomem, GFP_KERNEL)?;
+    ///
+    ///       let io = iomem.access(pdev.as_ref())?;
+    ///
+    ///       let data = io.try_read32_relaxed(offset)?;
+    ///
+    ///       io.try_write32_relaxed(data, offset)?;
+    ///
+    ///       # Ok(KBox::new(SampleDriver, GFP_KERNEL)?.into())
+    ///     }
+    /// }
+    /// ```
+    pub fn iomap(self) -> Result<impl PinInit<Devres<IoMem<0>>, Error> + 'a> {
+        Self::iomap_sized::<0>(self)
+    }
+
+    /// Same as [`Self::iomap`] but with exclusive access to the underlying
+    /// region.
+    pub fn iomap_exclusive(self) -> Result<impl PinInit<Devres<ExclusiveIoMem<0>>, Error> + 'a> {
+        Self::iomap_exclusive_sized::<0>(self)
+    }
+}
+
+/// An exclusive memory-mapped IO region.
+///
+/// # Invariants
+///
+/// - [`ExclusiveIoMem`] has exclusive access to the underlying [`IoMem`].
+#[pin_data]
+pub struct ExclusiveIoMem<const SIZE: usize> {
+    /// The underlying `IoMem` instance.
+    iomem: IoMem<SIZE>,
+
+    /// The region abstraction. This represents exclusive access to the
+    /// range represented by the underlying `iomem`.
+    ///
+    /// This field is needed for ownership of the region.
+    _region: Region,
+}
+
+impl<const SIZE: usize> ExclusiveIoMem<SIZE> {
+    /// Creates a new `ExclusiveIoMem` instance.
+    fn ioremap(resource: &Resource) -> Result<Self> {
+        let start = resource.start();
+        let size = resource.size();
+        let name = resource.name();
+
+        let region = resource
+            .request_region(start, size, name, io::resource::flags::IORESOURCE_MEM)
+            .ok_or(EBUSY)?;
+
+        let iomem = IoMem::ioremap(resource)?;
+
+        let iomem = ExclusiveIoMem {
+            iomem,
+            _region: region,
+        };
+
+        Ok(iomem)
+    }
+
+    /// Creates a new `ExclusiveIoMem` instance from a previously acquired [`IoRequest`].
+    pub fn new<'a>(io_request: IoRequest<'a>) -> Result<impl PinInit<Devres<Self>, Error> + 'a> {
+        let iomem = Self::ioremap(io_request.resource)?;
+        let devres = Devres::new(io_request.device, iomem);
+
+        Ok(devres)
+    }
+}
+
+impl<const SIZE: usize> Deref for ExclusiveIoMem<SIZE> {
+    type Target = Io<SIZE>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.iomem
+    }
+}
+
+/// A generic memory-mapped IO region.
+///
+/// Accesses to the underlying region is checked either at compile time, if the
+/// region's size is known at that point, or at runtime otherwise.
+///
+/// # Invariants
+///
+/// [`IoMem`] always holds an [`IoRaw`] instance that holds a valid pointer to the
+/// start of the I/O memory mapped region.
+pub struct IoMem<const SIZE: usize = 0> {
+    io: IoRaw<SIZE>,
+}
+
+impl<const SIZE: usize> IoMem<SIZE> {
+    fn ioremap(resource: &Resource) -> Result<Self> {
+        let size = resource.size();
+        if size == 0 {
+            return Err(EINVAL);
+        }
+
+        let res_start = resource.start();
+
+        let addr = if resource
+            .flags()
+            .contains(io::resource::flags::IORESOURCE_MEM_NONPOSTED)
+        {
+            // SAFETY:
+            // - `res_start` and `size` are read from a presumably valid `struct resource`.
+            // - `size` is known not to be zero at this point.
+            unsafe { bindings::ioremap_np(res_start, size as usize) }
+        } else {
+            // SAFETY:
+            // - `res_start` and `size` are read from a presumably valid `struct resource`.
+            // - `size` is known not to be zero at this point.
+            unsafe { bindings::ioremap(res_start, size as usize) }
+        };
+
+        if addr.is_null() {
+            return Err(ENOMEM);
+        }
+
+        let io = IoRaw::new(addr as usize, size as usize)?;
+        let io = IoMem { io };
+
+        Ok(io)
+    }
+
+    /// Creates a new `IoMem` instance from a previously acquired [`IoRequest`].
+    pub fn new<'a>(io_request: IoRequest<'a>) -> Result<impl PinInit<Devres<Self>, Error> + 'a> {
+        let io = Self::ioremap(io_request.resource)?;
+        let devres = Devres::new(io_request.device, io);
+
+        Ok(devres)
+    }
+}
+
+impl<const SIZE: usize> Drop for IoMem<SIZE> {
+    fn drop(&mut self) {
+        // SAFETY: Safe as by the invariant of `Io`.
+        unsafe { bindings::iounmap(self.io.addr() as *mut core::ffi::c_void) }
+    }
+}
+
+impl<const SIZE: usize> Deref for IoMem<SIZE> {
+    type Target = Io<SIZE>;
+
+    fn deref(&self) -> &Self::Target {
+        // SAFETY: Safe as by the invariant of `IoMem`.
+        unsafe { Io::from_raw(&self.io) }
+    }
+}

-- 
2.50.0

On Fri, Jul 04, 2025 at 01:25:27PM -0300, Daniel Almeida wrote:
> Add a generic iomem abstraction to safely read and write ioremapped
> regions. This abstraction requires a previously acquired IoRequest
> instance. This makes it so that both the resource and the device match,
> or, in other words, that the resource is indeed a valid resource for a
> given bound device.
> 
> A subsequent patch will add the ability to retrieve IoRequest instances
> from platform devices.
> 
> The reads and writes are done through IoRaw, and are thus checked either
> at compile-time, if the size of the region is known at that point, or at
> runtime otherwise.
> 
> Non-exclusive access to the underlying memory region is made possible to
> cater to cases where overlapped regions are unavoidable.
> 
> Signed-off-by: Daniel Almeida <daniel.almeida@collabora.com>

> +    /// ```no_run
> +    /// # use kernel::{bindings, c_str, platform, of, device::Core};
> +    /// # struct SampleDriver;
> +    ///
> +    /// impl platform::Driver for SampleDriver {
> +    ///    # type IdInfo = ();
> +    ///    # const OF_ID_TABLE: Option<of::IdTable<Self::IdInfo>> = None;
> +    ///
> +    ///    fn probe(

When using # to hide lines from the example, it's useful to think about
what's left. The rendered docs will have a weird empty newline at the
beginning and before `fn probe`.

So I would either remove those newlines or just not hide those lines.

> +    /// Same as [`Self::iomap_sized`] but with exclusive access to the
> +    /// underlying region.
> +    ///
> +    /// This uses the
> +    /// [`ioremap()`](https://docs.kernel.org/driver-api/device-io.html#getting-access-to-the-device)
> +    /// C API.

I would probably format this like this:

/// This uses the [`ioremap()`] C API.
///
/// [`ioremap()`]: https://docs.kernel.org/driver-api/device-io.html#getting-access-to-the-device

> +/// An exclusive memory-mapped IO region.
> +///
> +/// # Invariants
> +///
> +/// - [`ExclusiveIoMem`] has exclusive access to the underlying [`IoMem`].
> +#[pin_data]
> +pub struct ExclusiveIoMem<const SIZE: usize> {

You don't need #[pin_data] if there aren't any pinned fields.

> +    /// The underlying `IoMem` instance.
> +    iomem: IoMem<SIZE>,
> +
> +    /// The region abstraction. This represents exclusive access to the
> +    /// range represented by the underlying `iomem`.
> +    ///
> +    /// This field is needed for ownership of the region.
> +    _region: Region,
> +}
> [..]
> +impl<const SIZE: usize> IoMem<SIZE> {
> +    fn ioremap(resource: &Resource) -> Result<Self> {
> +        let size = resource.size();
> +        if size == 0 {
> +            return Err(EINVAL);
> +        }
> +
> +        let res_start = resource.start();
> +
> +        let addr = if resource
> +            .flags()
> +            .contains(io::resource::flags::IORESOURCE_MEM_NONPOSTED)
> +        {
> +            // SAFETY:
> +            // - `res_start` and `size` are read from a presumably valid `struct resource`.
> +            // - `size` is known not to be zero at this point.
> +            unsafe { bindings::ioremap_np(res_start, size as usize) }

Here you cast from ResourceSize to usize. Are you sure that is correct?
I thought those types could be different.

> +impl<const SIZE: usize> Drop for IoMem<SIZE> {
> +    fn drop(&mut self) {
> +        // SAFETY: Safe as by the invariant of `Io`.
> +        unsafe { bindings::iounmap(self.io.addr() as *mut core::ffi::c_void) }

Just c_void.

Alice

Hi Alice,

>> +impl<const SIZE: usize> IoMem<SIZE> {
>> +    fn ioremap(resource: &Resource) -> Result<Self> {
>> +        let size = resource.size();
>> +        if size == 0 {
>> +            return Err(EINVAL);
>> +        }
>> +
>> +        let res_start = resource.start();
>> +
>> +        let addr = if resource
>> +            .flags()
>> +            .contains(io::resource::flags::IORESOURCE_MEM_NONPOSTED)
>> +        {
>> +            // SAFETY:
>> +            // - `res_start` and `size` are read from a presumably valid `struct resource`.
>> +            // - `size` is known not to be zero at this point.
>> +            unsafe { bindings::ioremap_np(res_start, size as usize) }
> 
> Here you cast from ResourceSize to usize. Are you sure that is correct?
> I thought those types could be different.

This seems to what C is doing as well, i.e.:

static void __iomem *__devm_ioremap(struct device *dev, resource_size_t offset,
				    resource_size_t size, <---------
				    enum devm_ioremap_type type)
{

        […]

	case DEVM_IOREMAP_NP:
		addr = ioremap_np(offset, size);
		break;
	}


Where:

`static inline void __iomem *ioremap_np(phys_addr_t offset, size_t size)`

IOW: this stems from the mix and match of types used the C API itself.

What do you suggest here? Maybe a try_into() then?

— Daniel

On Thu, Jul 10, 2025 at 10:58:13AM -0300, Daniel Almeida wrote:
> Hi Alice,
> 
> >> +impl<const SIZE: usize> IoMem<SIZE> {
> >> +    fn ioremap(resource: &Resource) -> Result<Self> {
> >> +        let size = resource.size();
> >> +        if size == 0 {
> >> +            return Err(EINVAL);
> >> +        }
> >> +
> >> +        let res_start = resource.start();
> >> +
> >> +        let addr = if resource
> >> +            .flags()
> >> +            .contains(io::resource::flags::IORESOURCE_MEM_NONPOSTED)
> >> +        {
> >> +            // SAFETY:
> >> +            // - `res_start` and `size` are read from a presumably valid `struct resource`.
> >> +            // - `size` is known not to be zero at this point.
> >> +            unsafe { bindings::ioremap_np(res_start, size as usize) }
> > 
> > Here you cast from ResourceSize to usize. Are you sure that is correct?
> > I thought those types could be different.
> 
> This seems to what C is doing as well, i.e.:
> 
> static void __iomem *__devm_ioremap(struct device *dev, resource_size_t offset,
> 				    resource_size_t size, <---------
> 				    enum devm_ioremap_type type)
> {
> 
>         […]
> 
> 	case DEVM_IOREMAP_NP:
> 		addr = ioremap_np(offset, size);
> 		break;
> 	}
> 
> 
> Where:
> 
> `static inline void __iomem *ioremap_np(phys_addr_t offset, size_t size)`
> 
> IOW: this stems from the mix and match of types used the C API itself.
> 
> What do you suggest here? Maybe a try_into() then?

What a mess. It looks like there aren't any 32-bit architectures that
define ioremap_np. This means that sometimes this cast will be lossy,
but in those cases the function body just returns NULL and doesn't read
the size.

I would probably cast to an underscore instead of explicitly mentioning
the target type and make a comment about it.

Alice

Alice,

> On 14 Jul 2025, at 08:51, Alice Ryhl <aliceryhl@google.com> wrote:
> 
> On Thu, Jul 10, 2025 at 10:58:13AM -0300, Daniel Almeida wrote:
>> Hi Alice,
>> 
>>>> +impl<const SIZE: usize> IoMem<SIZE> {
>>>> +    fn ioremap(resource: &Resource) -> Result<Self> {
>>>> +        let size = resource.size();
>>>> +        if size == 0 {
>>>> +            return Err(EINVAL);
>>>> +        }
>>>> +
>>>> +        let res_start = resource.start();
>>>> +
>>>> +        let addr = if resource
>>>> +            .flags()
>>>> +            .contains(io::resource::flags::IORESOURCE_MEM_NONPOSTED)
>>>> +        {
>>>> +            // SAFETY:
>>>> +            // - `res_start` and `size` are read from a presumably valid `struct resource`.
>>>> +            // - `size` is known not to be zero at this point.
>>>> +            unsafe { bindings::ioremap_np(res_start, size as usize) }
>>> 
>>> Here you cast from ResourceSize to usize. Are you sure that is correct?
>>> I thought those types could be different.
>> 
>> This seems to what C is doing as well, i.e.:
>> 
>> static void __iomem *__devm_ioremap(struct device *dev, resource_size_t offset,
>>     resource_size_t size, <---------
>>     enum devm_ioremap_type type)
>> {
>> 
>>        […]
>> 
>> case DEVM_IOREMAP_NP:
>> addr = ioremap_np(offset, size);
>> break;
>> }
>> 
>> 
>> Where:
>> 
>> `static inline void __iomem *ioremap_np(phys_addr_t offset, size_t size)`
>> 
>> IOW: this stems from the mix and match of types used the C API itself.
>> 
>> What do you suggest here? Maybe a try_into() then?
> 
> What a mess. It looks like there aren't any 32-bit architectures that
> define ioremap_np. This means that sometimes this cast will be lossy,
> but in those cases the function body just returns NULL and doesn't read
> the size.
> 
> I would probably cast to an underscore instead of explicitly mentioning
> the target type and make a comment about it.
> 
> Alice

You replied here but v13 was already out [0]. Can we shift the dicussion
there? I ended up using try_into(), but feel free to suggest the cast to _
+ the TODO if you still feel like this is the right approach.


-- Daniel

[0] https://lore.kernel.org/rust-for-linux/20250711-topics-tyr-platform_iomem-v13-0-06328b514db3@collabora.com/

On Mon Jul 14, 2025 at 1:51 PM CEST, Alice Ryhl wrote:
> On Thu, Jul 10, 2025 at 10:58:13AM -0300, Daniel Almeida wrote:
>> Hi Alice,
>> 
>> >> +impl<const SIZE: usize> IoMem<SIZE> {
>> >> +    fn ioremap(resource: &Resource) -> Result<Self> {
>> >> +        let size = resource.size();
>> >> +        if size == 0 {
>> >> +            return Err(EINVAL);
>> >> +        }
>> >> +
>> >> +        let res_start = resource.start();
>> >> +
>> >> +        let addr = if resource
>> >> +            .flags()
>> >> +            .contains(io::resource::flags::IORESOURCE_MEM_NONPOSTED)
>> >> +        {
>> >> +            // SAFETY:
>> >> +            // - `res_start` and `size` are read from a presumably valid `struct resource`.
>> >> +            // - `size` is known not to be zero at this point.
>> >> +            unsafe { bindings::ioremap_np(res_start, size as usize) }
>> > 
>> > Here you cast from ResourceSize to usize. Are you sure that is correct?
>> > I thought those types could be different.
>> 
>> This seems to what C is doing as well, i.e.:
>> 
>> static void __iomem *__devm_ioremap(struct device *dev, resource_size_t offset,
>> 				    resource_size_t size, <---------
>> 				    enum devm_ioremap_type type)
>> {
>> 
>>         […]
>> 
>> 	case DEVM_IOREMAP_NP:
>> 		addr = ioremap_np(offset, size);
>> 		break;
>> 	}
>> 
>> 
>> Where:
>> 
>> `static inline void __iomem *ioremap_np(phys_addr_t offset, size_t size)`
>> 
>> IOW: this stems from the mix and match of types used the C API itself.
>> 
>> What do you suggest here? Maybe a try_into() then?
>
> What a mess.

Yeah, it mixes up types describing CPU word width and bus address width. :(

> It looks like there aren't any 32-bit architectures that
> define ioremap_np. This means that sometimes this cast will be lossy,
> but in those cases the function body just returns NULL and doesn't read
> the size.
>
> I would probably cast to an underscore instead of explicitly mentioning
> the target type and make a comment about it.

I think fixing up the C side would be even nicer, but for the scope of this
series that's fine. The comment should mention that, ultimately, we want to fix
up the C side type wise.

On Fri, Jul 04, 2025 at 01:25:27PM -0300, Daniel Almeida wrote:

This looks good now, one comment below.

> +    /// Creates a new `IoMem` instance from a previously acquired [`IoRequest`].
> +    pub fn new<'a>(io_request: IoRequest<'a>) -> Result<impl PinInit<Devres<Self>, Error> + 'a> {
> +        let io = Self::ioremap(io_request.resource)?;
> +        let devres = Devres::new(io_request.device, io);
> +
> +        Ok(devres)
> +    }

This method should not return `Result<impl PinInit<Devres<Self>, Error> + 'a>`,
but just `impl PinInit<Devres<Self>, Error> + 'a`.

Here's the full diff of the changes needed. :)

diff --git a/rust/kernel/io/mem.rs b/rust/kernel/io/mem.rs
index b047b9a73ae5..cb0805ef0860 100644
--- a/rust/kernel/io/mem.rs
+++ b/rust/kernel/io/mem.rs
@@ -60,7 +60,7 @@ pub(crate) unsafe fn new(device: &'a Device<Bound>, resource: &'a Resource) -> S
     ///       //
     ///       // No runtime checks will apply when reading and writing.
     ///       let request = pdev.request_io_by_index(0).ok_or(ENODEV)?;
-    ///       let iomem = request.iomap_sized::<42>()?;
+    ///       let iomem = request.iomap_sized::<42>();
     ///       let iomem = KBox::pin_init(iomem, GFP_KERNEL)?;
     ///
     ///       let io = iomem.access(pdev.as_ref())?;
@@ -74,9 +74,7 @@ pub(crate) unsafe fn new(device: &'a Device<Bound>, resource: &'a Resource) -> S
     ///     }
     /// }
     /// ```
-    pub fn iomap_sized<const SIZE: usize>(
-        self,
-    ) -> Result<impl PinInit<Devres<IoMem<SIZE>>, Error> + 'a> {
+    pub fn iomap_sized<const SIZE: usize>(self) -> impl PinInit<Devres<IoMem<SIZE>>, Error> + 'a {
         IoMem::new(self)
     }

@@ -88,7 +86,7 @@ pub fn iomap_sized<const SIZE: usize>(
     /// C API.
     pub fn iomap_exclusive_sized<const SIZE: usize>(
         self,
-    ) -> Result<impl PinInit<Devres<ExclusiveIoMem<SIZE>>, Error> + 'a> {
+    ) -> impl PinInit<Devres<ExclusiveIoMem<SIZE>>, Error> + 'a {
         ExclusiveIoMem::new(self)
     }

@@ -122,7 +120,7 @@ pub fn iomap_exclusive_sized<const SIZE: usize>(
     ///       // family of functions should be used, leading to runtime checks on every
     ///       // access.
     ///       let request = pdev.request_io_by_index(0).ok_or(ENODEV)?;
-    ///       let iomem = request.iomap()?;
+    ///       let iomem = request.iomap();
     ///       let iomem = KBox::pin_init(iomem, GFP_KERNEL)?;
     ///
     ///       let io = iomem.access(pdev.as_ref())?;
@@ -135,13 +133,13 @@ pub fn iomap_exclusive_sized<const SIZE: usize>(
     ///     }
     /// }
     /// ```
-    pub fn iomap(self) -> Result<impl PinInit<Devres<IoMem<0>>, Error> + 'a> {
+    pub fn iomap(self) -> impl PinInit<Devres<IoMem<0>>, Error> + 'a {
         Self::iomap_sized::<0>(self)
     }

     /// Same as [`Self::iomap`] but with exclusive access to the underlying
     /// region.
-    pub fn iomap_exclusive(self) -> Result<impl PinInit<Devres<ExclusiveIoMem<0>>, Error> + 'a> {
+    pub fn iomap_exclusive(self) -> impl PinInit<Devres<ExclusiveIoMem<0>>, Error> + 'a {
         Self::iomap_exclusive_sized::<0>(self)
     }
 }
@@ -185,11 +183,11 @@ fn ioremap(resource: &Resource) -> Result<Self> {
     }

     /// Creates a new `ExclusiveIoMem` instance from a previously acquired [`IoRequest`].
-    pub fn new<'a>(io_request: IoRequest<'a>) -> Result<impl PinInit<Devres<Self>, Error> + 'a> {
-        let iomem = Self::ioremap(io_request.resource)?;
-        let devres = Devres::new(io_request.device, iomem);
+    pub fn new<'a>(io_request: IoRequest<'a>) -> impl PinInit<Devres<Self>, Error> + 'a {
+        let dev = io_request.device;
+        let res = io_request.resource;

-        Ok(devres)
+        Devres::new(dev, Self::ioremap(res))
     }
 }

@@ -249,11 +247,11 @@ fn ioremap(resource: &Resource) -> Result<Self> {
     }

     /// Creates a new `IoMem` instance from a previously acquired [`IoRequest`].
-    pub fn new<'a>(io_request: IoRequest<'a>) -> Result<impl PinInit<Devres<Self>, Error> + 'a> {
-        let io = Self::ioremap(io_request.resource)?;
-        let devres = Devres::new(io_request.device, io);
+    pub fn new<'a>(io_request: IoRequest<'a>) -> impl PinInit<Devres<Self>, Error> + 'a {
+        let dev = io_request.device;
+        let res = io_request.resource;

-        Ok(devres)
+        Devres::new(dev, Self::ioremap(res))
     }
 }