Extend the `Adapter` trait to support ACPI device identification.

This mirrors the existing Open Firmware (OF) support (`of_id_table`) and
enables Rust drivers to match and retrieve ACPI-specific device data
when `CONFIG_ACPI` is enabled.

To avoid breaking compilation, a stub implementation of `acpi_id_table()`
is added to the Platform adapter; the full implementation will be provided
in a subsequent patch.

Signed-off-by: Igor Korotin <igor.korotin.linux@gmail.com>
---
 rust/bindings/bindings_helper.h |  1 +
 rust/kernel/driver.rs           | 39 ++++++++++++++++++++++++++++++++-
 rust/kernel/platform.rs         |  6 ++++-
 3 files changed, 44 insertions(+), 2 deletions(-)

diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h
index ab37e1d35c70..002d84f06b42 100644
--- a/rust/bindings/bindings_helper.h
+++ b/rust/bindings/bindings_helper.h
@@ -6,6 +6,7 @@
  * Sorted alphabetically.
  */
 
+#include <linux/acpi.h>
 #include <kunit/test.h>
 #include <linux/blk-mq.h>
 #include <linux/blk_types.h>
diff --git a/rust/kernel/driver.rs b/rust/kernel/driver.rs
index ec9166cedfa7..638f1d270af8 100644
--- a/rust/kernel/driver.rs
+++ b/rust/kernel/driver.rs
@@ -6,7 +6,7 @@
 //! register using the [`Registration`] class.
 
 use crate::error::{Error, Result};
-use crate::{device, of, str::CStr, try_pin_init, types::Opaque, ThisModule};
+use crate::{acpi, device, of, str::CStr, try_pin_init, types::Opaque, ThisModule};
 use core::pin::Pin;
 use pin_init::{pin_data, pinned_drop, PinInit};
 
@@ -141,6 +141,38 @@ pub trait Adapter {
     /// The type holding driver private data about each device id supported by the driver.
     type IdInfo: 'static;
 
+    /// The [`acpi::IdTable`] of the corresponding driver
+    fn acpi_id_table() -> Option<acpi::IdTable<Self::IdInfo>>;
+
+    /// Returns the driver's private data from the matching entry in the [`acpi::IdTable`], if any.
+    ///
+    /// If this returns `None`, it means there is no match with an entry in the [`acpi::IdTable`].
+    #[cfg(CONFIG_ACPI)]
+    fn acpi_id_info(dev: &device::Device) -> Option<&'static Self::IdInfo> {
+        let table = Self::acpi_id_table()?;
+
+        // SAFETY:
+        // - `table` has static lifetime, hence it's valid for read,
+        // - `dev` is guaranteed to be valid while it's alive, and so is `pdev.as_ref().as_raw()`.
+        let raw_id = unsafe { bindings::acpi_match_device(table.as_ptr(), dev.as_raw()) };
+
+        if raw_id.is_null() {
+            None
+        } else {
+            // SAFETY: `DeviceId` is a `#[repr(transparent)` wrapper of `struct of_device_id` and
+            // does not add additional invariants, so it's safe to transmute.
+            let id = unsafe { &*raw_id.cast::<acpi::DeviceId>() };
+
+            Some(table.info(<acpi::DeviceId as crate::device_id::RawDeviceId>::index(id)))
+        }
+    }
+
+    #[cfg(not(CONFIG_ACPI))]
+    #[allow(missing_docs)]
+    fn acpi_id_info(_dev: &device::Device) -> Option<&'static Self::IdInfo> {
+        None
+    }
+
     /// The [`of::IdTable`] of the corresponding driver.
     fn of_id_table() -> Option<of::IdTable<Self::IdInfo>>;
 
@@ -178,6 +210,11 @@ fn of_id_info(_dev: &device::Device) -> Option<&'static Self::IdInfo> {
     /// If this returns `None`, it means that there is no match in any of the ID tables directly
     /// associated with a [`device::Device`].
     fn id_info(dev: &device::Device) -> Option<&'static Self::IdInfo> {
+        let id = Self::acpi_id_info(dev);
+        if id.is_some() {
+            return id;
+        }
+
         let id = Self::of_id_info(dev);
         if id.is_some() {
             return id;
diff --git a/rust/kernel/platform.rs b/rust/kernel/platform.rs
index 4917cb34e2fe..dd77934937d3 100644
--- a/rust/kernel/platform.rs
+++ b/rust/kernel/platform.rs
@@ -5,7 +5,7 @@
 //! C header: [`include/linux/platform_device.h`](srctree/include/linux/platform_device.h)
 
 use crate::{
-    bindings, device, driver,
+    acpi, bindings, device, driver,
     error::{to_result, Result},
     of,
     prelude::*,
@@ -95,6 +95,10 @@ impl<T: Driver + 'static> driver::Adapter for Adapter<T> {
     fn of_id_table() -> Option<of::IdTable<Self::IdInfo>> {
         T::OF_ID_TABLE
     }
+
+    fn acpi_id_table() -> Option<acpi::IdTable<Self::IdInfo>> {
+        None
+    }
 }
 
 /// Declares a kernel module that exposes a single platform driver.
-- 
2.43.0

On Fri Jun 6, 2025 at 7:08 PM CEST, Igor Korotin wrote:
> @@ -141,6 +141,38 @@ pub trait Adapter {
>      /// The type holding driver private data about each device id supported by the driver.
>      type IdInfo: 'static;
>  
> +    /// The [`acpi::IdTable`] of the corresponding driver
> +    fn acpi_id_table() -> Option<acpi::IdTable<Self::IdInfo>>;
> +
> +    /// Returns the driver's private data from the matching entry in the [`acpi::IdTable`], if any.
> +    ///
> +    /// If this returns `None`, it means there is no match with an entry in the [`acpi::IdTable`].
> +    #[cfg(CONFIG_ACPI)]
> +    fn acpi_id_info(dev: &device::Device) -> Option<&'static Self::IdInfo> {
> +        let table = Self::acpi_id_table()?;
> +
> +        // SAFETY:
> +        // - `table` has static lifetime, hence it's valid for read,
> +        // - `dev` is guaranteed to be valid while it's alive, and so is `pdev.as_ref().as_raw()`.
> +        let raw_id = unsafe { bindings::acpi_match_device(table.as_ptr(), dev.as_raw()) };
> +
> +        if raw_id.is_null() {
> +            None
> +        } else {
> +            // SAFETY: `DeviceId` is a `#[repr(transparent)` wrapper of `struct of_device_id` and
> +            // does not add additional invariants, so it's safe to transmute.
> +            let id = unsafe { &*raw_id.cast::<acpi::DeviceId>() };
> +
> +            Some(table.info(<acpi::DeviceId as crate::device_id::RawDeviceId>::index(id)))
> +        }
> +    }
> +
> +    #[cfg(not(CONFIG_ACPI))]
> +    #[allow(missing_docs)]

I think we should change this to one single definition and do

    if cfg!(not(CONFIG_ACPI)) {
        return None;
    }
    /* body from above */

In a single function instead.

> +    fn acpi_id_info(_dev: &device::Device) -> Option<&'static Self::IdInfo> {
> +        None
> +    }
> +
>      /// The [`of::IdTable`] of the corresponding driver.
>      fn of_id_table() -> Option<of::IdTable<Self::IdInfo>>;
>  
> @@ -178,6 +210,11 @@ fn of_id_info(_dev: &device::Device) -> Option<&'static Self::IdInfo> {
>      /// If this returns `None`, it means that there is no match in any of the ID tables directly
>      /// associated with a [`device::Device`].
>      fn id_info(dev: &device::Device) -> Option<&'static Self::IdInfo> {
> +        let id = Self::acpi_id_info(dev);
> +        if id.is_some() {
> +            return id;
> +        }

Is a driver only going to have one id_info? Or is there some kind of
precedence?

---
Cheers,
Benno

On Sun, Jun 08, 2025 at 09:54:30AM +0200, Benno Lossin wrote:
> On Fri Jun 6, 2025 at 7:08 PM CEST, Igor Korotin wrote:
> > @@ -141,6 +141,38 @@ pub trait Adapter {
> >      /// The type holding driver private data about each device id supported by the driver.
> >      type IdInfo: 'static;
> >  
> > +    /// The [`acpi::IdTable`] of the corresponding driver
> > +    fn acpi_id_table() -> Option<acpi::IdTable<Self::IdInfo>>;
> > +
> > +    /// Returns the driver's private data from the matching entry in the [`acpi::IdTable`], if any.
> > +    ///
> > +    /// If this returns `None`, it means there is no match with an entry in the [`acpi::IdTable`].
> > +    #[cfg(CONFIG_ACPI)]
> > +    fn acpi_id_info(dev: &device::Device) -> Option<&'static Self::IdInfo> {
> > +        let table = Self::acpi_id_table()?;
> > +
> > +        // SAFETY:
> > +        // - `table` has static lifetime, hence it's valid for read,
> > +        // - `dev` is guaranteed to be valid while it's alive, and so is `pdev.as_ref().as_raw()`.
> > +        let raw_id = unsafe { bindings::acpi_match_device(table.as_ptr(), dev.as_raw()) };
> > +
> > +        if raw_id.is_null() {
> > +            None
> > +        } else {
> > +            // SAFETY: `DeviceId` is a `#[repr(transparent)` wrapper of `struct of_device_id` and
> > +            // does not add additional invariants, so it's safe to transmute.
> > +            let id = unsafe { &*raw_id.cast::<acpi::DeviceId>() };
> > +
> > +            Some(table.info(<acpi::DeviceId as crate::device_id::RawDeviceId>::index(id)))
> > +        }
> > +    }
> > +
> > +    #[cfg(not(CONFIG_ACPI))]
> > +    #[allow(missing_docs)]
> 
> I think we should change this to one single definition and do
> 
>     if cfg!(not(CONFIG_ACPI)) {
>         return None;
>     }
>     /* body from above */
> 
> In a single function instead.

Generally, that's fine, but in this case I'd rather keep it as it is for
consistency with the rest of the file.

> > +    fn acpi_id_info(_dev: &device::Device) -> Option<&'static Self::IdInfo> {
> > +        None
> > +    }
> > +
> >      /// The [`of::IdTable`] of the corresponding driver.
> >      fn of_id_table() -> Option<of::IdTable<Self::IdInfo>>;
> >  
> > @@ -178,6 +210,11 @@ fn of_id_info(_dev: &device::Device) -> Option<&'static Self::IdInfo> {
> >      /// If this returns `None`, it means that there is no match in any of the ID tables directly
> >      /// associated with a [`device::Device`].
> >      fn id_info(dev: &device::Device) -> Option<&'static Self::IdInfo> {
> > +        let id = Self::acpi_id_info(dev);
> > +        if id.is_some() {
> > +            return id;
> > +        }
> 
> Is a driver only going to have one id_info? Or is there some kind of
> precedence?

A driver potentially has lots of them, but the device is only matching a single
entry in one of the driver's ID tables and hence a single ID info.

On Sun Jun 8, 2025 at 12:48 PM CEST, Danilo Krummrich wrote:
> On Sun, Jun 08, 2025 at 09:54:30AM +0200, Benno Lossin wrote:
>> On Fri Jun 6, 2025 at 7:08 PM CEST, Igor Korotin wrote:
>> > @@ -141,6 +141,38 @@ pub trait Adapter {
>> >      /// The type holding driver private data about each device id supported by the driver.
>> >      type IdInfo: 'static;
>> >  
>> > +    /// The [`acpi::IdTable`] of the corresponding driver
>> > +    fn acpi_id_table() -> Option<acpi::IdTable<Self::IdInfo>>;
>> > +
>> > +    /// Returns the driver's private data from the matching entry in the [`acpi::IdTable`], if any.
>> > +    ///
>> > +    /// If this returns `None`, it means there is no match with an entry in the [`acpi::IdTable`].
>> > +    #[cfg(CONFIG_ACPI)]
>> > +    fn acpi_id_info(dev: &device::Device) -> Option<&'static Self::IdInfo> {
>> > +        let table = Self::acpi_id_table()?;
>> > +
>> > +        // SAFETY:
>> > +        // - `table` has static lifetime, hence it's valid for read,
>> > +        // - `dev` is guaranteed to be valid while it's alive, and so is `pdev.as_ref().as_raw()`.
>> > +        let raw_id = unsafe { bindings::acpi_match_device(table.as_ptr(), dev.as_raw()) };
>> > +
>> > +        if raw_id.is_null() {
>> > +            None
>> > +        } else {
>> > +            // SAFETY: `DeviceId` is a `#[repr(transparent)` wrapper of `struct of_device_id` and
>> > +            // does not add additional invariants, so it's safe to transmute.
>> > +            let id = unsafe { &*raw_id.cast::<acpi::DeviceId>() };
>> > +
>> > +            Some(table.info(<acpi::DeviceId as crate::device_id::RawDeviceId>::index(id)))
>> > +        }
>> > +    }
>> > +
>> > +    #[cfg(not(CONFIG_ACPI))]
>> > +    #[allow(missing_docs)]
>> 
>> I think we should change this to one single definition and do
>> 
>>     if cfg!(not(CONFIG_ACPI)) {
>>         return None;
>>     }
>>     /* body from above */
>> 
>> In a single function instead.
>
> Generally, that's fine, but in this case I'd rather keep it as it is for
> consistency with the rest of the file.

Then let's also change the OF bindings in this file to that style :)

>> > +    fn acpi_id_info(_dev: &device::Device) -> Option<&'static Self::IdInfo> {
>> > +        None
>> > +    }
>> > +
>> >      /// The [`of::IdTable`] of the corresponding driver.
>> >      fn of_id_table() -> Option<of::IdTable<Self::IdInfo>>;
>> >  
>> > @@ -178,6 +210,11 @@ fn of_id_info(_dev: &device::Device) -> Option<&'static Self::IdInfo> {
>> >      /// If this returns `None`, it means that there is no match in any of the ID tables directly
>> >      /// associated with a [`device::Device`].
>> >      fn id_info(dev: &device::Device) -> Option<&'static Self::IdInfo> {
>> > +        let id = Self::acpi_id_info(dev);
>> > +        if id.is_some() {
>> > +            return id;
>> > +        }
>> 
>> Is a driver only going to have one id_info? Or is there some kind of
>> precedence?
>
> A driver potentially has lots of them, but the device is only matching a single
> entry in one of the driver's ID tables and hence a single ID info.

Ah so if `of_id_info` and `acpi_id_info` return `Some(_)`, then both
values are the same?

---
Cheers,
Benno

On Sun, Jun 08, 2025 at 01:46:17PM +0200, Benno Lossin wrote:
> On Sun Jun 8, 2025 at 12:48 PM CEST, Danilo Krummrich wrote:
> > On Sun, Jun 08, 2025 at 09:54:30AM +0200, Benno Lossin wrote:
> >> On Fri Jun 6, 2025 at 7:08 PM CEST, Igor Korotin wrote:
> >> > @@ -141,6 +141,38 @@ pub trait Adapter {
> >> >      /// The type holding driver private data about each device id supported by the driver.
> >> >      type IdInfo: 'static;
> >> >  
> >> > +    /// The [`acpi::IdTable`] of the corresponding driver
> >> > +    fn acpi_id_table() -> Option<acpi::IdTable<Self::IdInfo>>;
> >> > +
> >> > +    /// Returns the driver's private data from the matching entry in the [`acpi::IdTable`], if any.
> >> > +    ///
> >> > +    /// If this returns `None`, it means there is no match with an entry in the [`acpi::IdTable`].
> >> > +    #[cfg(CONFIG_ACPI)]
> >> > +    fn acpi_id_info(dev: &device::Device) -> Option<&'static Self::IdInfo> {
> >> > +        let table = Self::acpi_id_table()?;
> >> > +
> >> > +        // SAFETY:
> >> > +        // - `table` has static lifetime, hence it's valid for read,
> >> > +        // - `dev` is guaranteed to be valid while it's alive, and so is `pdev.as_ref().as_raw()`.
> >> > +        let raw_id = unsafe { bindings::acpi_match_device(table.as_ptr(), dev.as_raw()) };
> >> > +
> >> > +        if raw_id.is_null() {
> >> > +            None
> >> > +        } else {
> >> > +            // SAFETY: `DeviceId` is a `#[repr(transparent)` wrapper of `struct of_device_id` and
> >> > +            // does not add additional invariants, so it's safe to transmute.
> >> > +            let id = unsafe { &*raw_id.cast::<acpi::DeviceId>() };
> >> > +
> >> > +            Some(table.info(<acpi::DeviceId as crate::device_id::RawDeviceId>::index(id)))
> >> > +        }
> >> > +    }
> >> > +
> >> > +    #[cfg(not(CONFIG_ACPI))]
> >> > +    #[allow(missing_docs)]
> >> 
> >> I think we should change this to one single definition and do
> >> 
> >>     if cfg!(not(CONFIG_ACPI)) {
> >>         return None;
> >>     }
> >>     /* body from above */
> >> 
> >> In a single function instead.
> >
> > Generally, that's fine, but in this case I'd rather keep it as it is for
> > consistency with the rest of the file.
> 
> Then let's also change the OF bindings in this file to that style :)

Fine for me.

@Igor: If you do so, please do it in a seaparate patch.

> >> > +    fn acpi_id_info(_dev: &device::Device) -> Option<&'static Self::IdInfo> {
> >> > +        None
> >> > +    }
> >> > +
> >> >      /// The [`of::IdTable`] of the corresponding driver.
> >> >      fn of_id_table() -> Option<of::IdTable<Self::IdInfo>>;
> >> >  
> >> > @@ -178,6 +210,11 @@ fn of_id_info(_dev: &device::Device) -> Option<&'static Self::IdInfo> {
> >> >      /// If this returns `None`, it means that there is no match in any of the ID tables directly
> >> >      /// associated with a [`device::Device`].
> >> >      fn id_info(dev: &device::Device) -> Option<&'static Self::IdInfo> {
> >> > +        let id = Self::acpi_id_info(dev);
> >> > +        if id.is_some() {
> >> > +            return id;
> >> > +        }
> >> 
> >> Is a driver only going to have one id_info? Or is there some kind of
> >> precedence?
> >
> > A driver potentially has lots of them, but the device is only matching a single
> > entry in one of the driver's ID tables and hence a single ID info.
> 
> Ah so if `of_id_info` and `acpi_id_info` return `Some(_)`, then both
> values are the same?

No, if one of them returns Some(_), the other one will always return None. Or
phrased differently, the first match will always be the only match.

On Sun, Jun 8, 2025 at 12:50 PM Danilo Krummrich <dakr@kernel.org> wrote:
>
> On Sun, Jun 08, 2025 at 01:46:17PM +0200, Benno Lossin wrote:
> > On Sun Jun 8, 2025 at 12:48 PM CEST, Danilo Krummrich wrote:
> > > On Sun, Jun 08, 2025 at 09:54:30AM +0200, Benno Lossin wrote:
> > >> On Fri Jun 6, 2025 at 7:08 PM CEST, Igor Korotin wrote:
> > >> > @@ -141,6 +141,38 @@ pub trait Adapter {
> > >> >      /// The type holding driver private data about each device id supported by the driver.
> > >> >      type IdInfo: 'static;
> > >> >
> > >> > +    /// The [`acpi::IdTable`] of the corresponding driver
> > >> > +    fn acpi_id_table() -> Option<acpi::IdTable<Self::IdInfo>>;
> > >> > +
> > >> > +    /// Returns the driver's private data from the matching entry in the [`acpi::IdTable`], if any.
> > >> > +    ///
> > >> > +    /// If this returns `None`, it means there is no match with an entry in the [`acpi::IdTable`].
> > >> > +    #[cfg(CONFIG_ACPI)]
> > >> > +    fn acpi_id_info(dev: &device::Device) -> Option<&'static Self::IdInfo> {
> > >> > +        let table = Self::acpi_id_table()?;
> > >> > +
> > >> > +        // SAFETY:
> > >> > +        // - `table` has static lifetime, hence it's valid for read,
> > >> > +        // - `dev` is guaranteed to be valid while it's alive, and so is `pdev.as_ref().as_raw()`.
> > >> > +        let raw_id = unsafe { bindings::acpi_match_device(table.as_ptr(), dev.as_raw()) };
> > >> > +
> > >> > +        if raw_id.is_null() {
> > >> > +            None
> > >> > +        } else {
> > >> > +            // SAFETY: `DeviceId` is a `#[repr(transparent)` wrapper of `struct of_device_id` and
> > >> > +            // does not add additional invariants, so it's safe to transmute.
> > >> > +            let id = unsafe { &*raw_id.cast::<acpi::DeviceId>() };
> > >> > +
> > >> > +            Some(table.info(<acpi::DeviceId as crate::device_id::RawDeviceId>::index(id)))
> > >> > +        }
> > >> > +    }
> > >> > +
> > >> > +    #[cfg(not(CONFIG_ACPI))]
> > >> > +    #[allow(missing_docs)]
> > >>
> > >> I think we should change this to one single definition and do
> > >>
> > >>     if cfg!(not(CONFIG_ACPI)) {
> > >>         return None;
> > >>     }
> > >>     /* body from above */
> > >>
> > >> In a single function instead.
> > >
> > > Generally, that's fine, but in this case I'd rather keep it as it is for
> > > consistency with the rest of the file.
> >
> > Then let's also change the OF bindings in this file to that style :)
>
> Fine for me.
>
> @Igor: If you do so, please do it in a seaparate patch.

That's definitely not possible with `if cfg!(not(CONFIG_ACPI))`
because it is a runtime condition and it breaks compilation in case
either `CONFIG_OF` or `CONFIG_ACPI` is not set, the Rust compiler
can't find `of_match_device`/`acpi_match_device` because in that case
they are defined as `static inline` and are not parsed by bindgen.

Alternatively the following pattern works:

    fn foo() {
        #[cfg(not(CONFIG_ACPI))] {
            None
        }

        #[cfg(CONFIG_ACPI)] {
             // some logic.
        }
    }

Also the argument `dev` of `both of_id_info` and `acpi_id_info`  must be
renamed into `_dev` to mark it as unused in case CONFIG_ACPI/CONFIG_OF
is off and the argument is not used.

Let me know if this pattern is acceptable. To my opinion it is not much
different from the original 2 functions conditioned by #[cfg] and
requires some nasty changes.

Thanks
Igor

On Mon Jun 9, 2025 at 3:09 PM CEST, Igor Korotin wrote:
> On Sun, Jun 8, 2025 at 12:50 PM Danilo Krummrich <dakr@kernel.org> wrote:
>> On Sun, Jun 08, 2025 at 01:46:17PM +0200, Benno Lossin wrote:
>> > On Sun Jun 8, 2025 at 12:48 PM CEST, Danilo Krummrich wrote:
>> > > On Sun, Jun 08, 2025 at 09:54:30AM +0200, Benno Lossin wrote:
>> > >> On Fri Jun 6, 2025 at 7:08 PM CEST, Igor Korotin wrote:
>> > >> > @@ -141,6 +141,38 @@ pub trait Adapter {
>> > >> >      /// The type holding driver private data about each device id supported by the driver.
>> > >> >      type IdInfo: 'static;
>> > >> >
>> > >> > +    /// The [`acpi::IdTable`] of the corresponding driver
>> > >> > +    fn acpi_id_table() -> Option<acpi::IdTable<Self::IdInfo>>;
>> > >> > +
>> > >> > +    /// Returns the driver's private data from the matching entry in the [`acpi::IdTable`], if any.
>> > >> > +    ///
>> > >> > +    /// If this returns `None`, it means there is no match with an entry in the [`acpi::IdTable`].
>> > >> > +    #[cfg(CONFIG_ACPI)]
>> > >> > +    fn acpi_id_info(dev: &device::Device) -> Option<&'static Self::IdInfo> {
>> > >> > +        let table = Self::acpi_id_table()?;
>> > >> > +
>> > >> > +        // SAFETY:
>> > >> > +        // - `table` has static lifetime, hence it's valid for read,
>> > >> > +        // - `dev` is guaranteed to be valid while it's alive, and so is `pdev.as_ref().as_raw()`.
>> > >> > +        let raw_id = unsafe { bindings::acpi_match_device(table.as_ptr(), dev.as_raw()) };
>> > >> > +
>> > >> > +        if raw_id.is_null() {
>> > >> > +            None
>> > >> > +        } else {
>> > >> > +            // SAFETY: `DeviceId` is a `#[repr(transparent)` wrapper of `struct of_device_id` and
>> > >> > +            // does not add additional invariants, so it's safe to transmute.
>> > >> > +            let id = unsafe { &*raw_id.cast::<acpi::DeviceId>() };
>> > >> > +
>> > >> > +            Some(table.info(<acpi::DeviceId as crate::device_id::RawDeviceId>::index(id)))
>> > >> > +        }
>> > >> > +    }
>> > >> > +
>> > >> > +    #[cfg(not(CONFIG_ACPI))]
>> > >> > +    #[allow(missing_docs)]
>> > >>
>> > >> I think we should change this to one single definition and do
>> > >>
>> > >>     if cfg!(not(CONFIG_ACPI)) {
>> > >>         return None;
>> > >>     }
>> > >>     /* body from above */
>> > >>
>> > >> In a single function instead.
>> > >
>> > > Generally, that's fine, but in this case I'd rather keep it as it is for
>> > > consistency with the rest of the file.
>> >
>> > Then let's also change the OF bindings in this file to that style :)
>>
>> Fine for me.
>>
>> @Igor: If you do so, please do it in a seaparate patch.
>
> That's definitely not possible with `if cfg!(not(CONFIG_ACPI))`
> because it is a runtime condition and it breaks compilation in case
> either `CONFIG_OF` or `CONFIG_ACPI` is not set, the Rust compiler
> can't find `of_match_device`/`acpi_match_device` because in that case
> they are defined as `static inline` and are not parsed by bindgen.
>
> Alternatively the following pattern works:
>
>     fn foo() {
>         #[cfg(not(CONFIG_ACPI))] {
>             None
>         }
>
>         #[cfg(CONFIG_ACPI)] {
>              // some logic.
>         }
>     }

We might want to add a `cfg_if!` macro that expands to this.

> Also the argument `dev` of `both of_id_info` and `acpi_id_info`  must be
> renamed into `_dev` to mark it as unused in case CONFIG_ACPI/CONFIG_OF
> is off and the argument is not used.

You can add a `let _ = dev;` in the `not` "branch".

---
Cheers,
Benno

On Mon, Jun 9, 2025 at 3:09 PM Igor Korotin
<igor.korotin.linux@gmail.com> wrote:
>
> Let me know if this pattern is acceptable. To my opinion it is not much
> different from the original 2 functions conditioned by #[cfg] and
> requires some nasty changes.

In general, the more local a `cfg` can be made, the better, because we
can share more, e.g. the docs and signature.

But maybe in this case it doesn't work -- what would be the "nasty
changes" required?

Cheers,
Miguel