platform: move get_id_info from platform.rs to public

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

Author: Richardhongyu

rust/kernel/driver.rs

@@ -440,3 +440,76 @@ macro_rules! module_driver {
         }
     }
 }
+
+/// 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
+///     crate::get_id_info!()
+///
+/// }
+/// ```
+#[macro_export]
+macro_rules! get_id_info {
+    () => {
+        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() }
+        }
+    };
+}

rust/kernel/platform.rs

@@ -61,33 +61,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() }
-    }
+    crate::get_id_info!();
 
     extern "C" fn probe_callback(pdev: *mut bindings::platform_device) -> core::ffi::c_int {
         from_kernel_result! {