platform: move get_id_info from platform.rs to public

Signed-off-by: Li Hongyu <[email protected]>

Author: Richardhongyu

rust/kernel/platform.rs

@@ -17,11 +17,13 @@ use crate::{
     types::PointerWrapper,
     ThisModule,
 };
+use macros::GetIdInfo;
 
 /// A registration of a platform driver.
 pub type Registration<T> = driver::Registration<Adapter<T>>;
 
 /// An adapter for the registration of platform drivers.
+#[derive(GetIdInfo)]
 pub struct Adapter<T: Driver>(T);
 
 impl<T: Driver> driver::DriverOps for Adapter<T> {
@@ -61,34 +63,6 @@ impl<T: Driver> driver::DriverOps for Adapter<T> {
 }
 
 impl<T: Driver> Adapter<T> {
-    fn get_id_info(dev: &Device) -> Option<&'static T::IdInfo> {
-        let table = T::OF_DEVICE_ID_TABLE?;
-
-        // SAFETY: `table` has static lifetime, so it is valid for read. `dev` is guaranteed to be
-        // valid while it's alive, so is the raw device returned by it.
-        let id = unsafe { bindings::of_match_device(table.as_ref(), dev.raw_device()) };
-        if id.is_null() {
-            return None;
-        }
-
-        // SAFETY: `id` is a pointer within the static table, so it's always valid.
-        let offset = unsafe { (*id).data };
-        if offset.is_null() {
-            return None;
-        }
-
-        // SAFETY: The offset comes from a previous call to `offset_from` in `IdArray::new`, which
-        // guarantees that the resulting pointer is within the table.
-        let ptr = unsafe {
-            id.cast::<u8>()
-                .offset(offset as _)
-                .cast::<Option<T::IdInfo>>()
-        };
-
-        // SAFETY: The id table has a static lifetime, so `ptr` is guaranteed to be valid for read.
-        unsafe { (&*ptr).as_ref() }
-    }
-
     extern "C" fn probe_callback(pdev: *mut bindings::platform_device) -> core::ffi::c_int {
         from_kernel_result! {
             // SAFETY: `pdev` is valid by the contract with the C code. `dev` is alive only for the

rust/macros/lib.rs

@@ -5,6 +5,7 @@
 mod concat_idents;
 mod helpers;
 mod module;
+mod of_id;
 mod vtable;
 
 use proc_macro::TokenStream;
@@ -188,3 +189,44 @@ pub fn vtable(attr: TokenStream, ts: TokenStream) -> TokenStream {
 pub fn concat_idents(ts: TokenStream) -> TokenStream {
     concat_idents::concat_idents(ts)
 }
+
+/// Implements a get_id_info function for drivers.
+///
+/// Some linux drivers, e.g. Platform drivers, need to get info from of_id. This macro helps implements the get_id_info
+/// function for those drivers.
+///
+/// # Examples
+///
+/// ```ignore
+/// use crate::{
+///     bindings,
+///     device::{self, RawDevice},
+///     driver,
+///     of,
+/// };
+///
+/// pub trait Driver {
+///     type IdInfo: 'static = ();
+///     const OF_DEVICE_ID_TABLE: Option<driver::IdTable<'static, of::DeviceId, Self::IdInfo>> = None;
+/// }
+///
+/// pub struct Device {
+///     ptr: *mut bindings::bar_device,
+/// }
+///
+/// // SAFETY: The device returned by `raw_device` is the raw bar device.
+/// unsafe impl device::RawDevice for Device {
+///     fn raw_device(&self) -> *mut bindings::device {
+///         // SAFETY: By the type invariants, we know that `self.ptr` is non-null and valid.
+///         unsafe { &mut (*self.ptr).dev }
+///     }
+/// }
+///
+/// // Implements a `#[GetIdInfo]` function
+/// #[derive(GetIdInfo)]
+/// pub struct Foo<T: Driver>(T);
+/// ```
+#[proc_macro_derive(GetIdInfo)]
+pub fn derive_get_id_info(ts: TokenStream) -> TokenStream {
+    of_id::derive_get_id_info(ts)
+}

rust/macros/of_id.rs

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-2.0
+
+use proc_macro::{TokenStream, TokenTree};
+
+pub(crate) fn derive_get_id_info(ts: TokenStream) -> TokenStream {
+    let tokens: Vec<_> = ts.into_iter().collect();
+    let mut type_name = String::from("Struct");
+
+    tokens
+        .iter()
+        .find_map(|token| match token {
+            TokenTree::Ident(ident) => match ident.to_string().as_str() {
+                "struct" => Some(1),
+                _ => None,
+            },
+            _ => None,
+        })
+        .expect("#[GetIdInfo] should be applied to a struct");
+
+    let mut content = tokens.into_iter();
+    while let Some(token) = content.next() {
+        match token {
+            TokenTree::Ident(ident) if ident.to_string() == "struct" => {
+                match content.next() {
+                    Some(TokenTree::Ident(ident)) => type_name = ident.to_string(),
+                    // This will never happend.
+                    _ => (),
+                };
+            }
+            _ => (),
+        }
+    }
+
+    println!("value {:?}", type_name);
+
+    format!(
+        "
+            impl<T: Driver> {name}<T> {{
+                fn get_id_info(dev: &Device) -> Option<&'static T::IdInfo> {{
+                    let table = T::OF_DEVICE_ID_TABLE?;
+
+                    // SAFETY: `table` has static lifetime, so it is valid for read. `dev` is guaranteed to be
+                    // valid while it's alive, so is the raw device returned by it.
+                    let id = unsafe {{ bindings::of_match_device(table.as_ref(), dev.raw_device()) }};
+                    if id.is_null() {{
+                        return None;
+                    }}
+
+                    // SAFETY: `id` is a pointer within the static table, so it's always valid.
+                    let offset = unsafe {{ (*id).data }};
+                    if offset.is_null() {{
+                        return None;
+                    }}
+
+                    // SAFETY: The offset comes from a previous call to `offset_from` in `IdArray::new`, which
+                    // guarantees that the resulting pointer is within the table.
+                    let ptr = unsafe {{
+                        id.cast::<u8>()
+                            .offset(offset as _)
+                            .cast::<Option<T::IdInfo>>()
+                    }};
+
+                    // SAFETY: The id table has a static lifetime, so `ptr` is guaranteed to be valid for read.
+                    unsafe {{ (&*ptr).as_ref() }}
+                }}
+            }}
+        ",
+        name = type_name,
+    ).parse().expect("Error parsing formatted string into token stream.")
+}