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.0On 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))
}
}
© 2016 - 2025 Red Hat, Inc.