platform: move get_id_info from platform.rs to public

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

Author: Richardhongyu

rust/kernel/platform.rs

@@ -17,6 +17,7 @@ use crate::{
     types::PointerWrapper,
     ThisModule,
 };
+use macros::get_id_info;
 
 /// A registration of a platform driver.
 pub type Registration<T> = driver::Registration<Adapter<T>>;
@@ -61,33 +62,7 @@ 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() }
-    }
+    get_id_info!();
 
     extern "C" fn probe_callback(pdev: *mut bindings::platform_device) -> core::ffi::c_int {
         from_kernel_result! {

rust/macros/get_id_info.rs

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: GPL-2.0
+
+use proc_macro::{TokenStream, TokenTree};
+
+pub(crate) fn get_id_info(ts: TokenStream) -> TokenStream {
+    "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() }}
+    }}"
+    .parse()
+    .expect("Error parsing formatted string into token stream.")
+}

rust/macros/lib.rs

@@ -3,6 +3,7 @@
 //! Crate for all kernel procedural macros.
 
 mod concat_idents;
+mod get_id_info;
 mod helpers;
 mod module;
 mod vtable;
@@ -188,3 +189,48 @@ 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 }
+///     }
+/// }
+///
+/// pub struct Foo<T: Driver>(T);
+///
+/// impl<T: Driver> Adapter<T> {
+///     // Implements a get_id_info function
+///     get_id_info!()
+///
+/// }
+/// ```
+#[proc_macro]
+pub fn get_id_info(ts: TokenStream) -> TokenStream {
+    get_id_info::get_id_info(ts)
+}