rust: convert platform to use driver

A platform driver is now defined by implementing a trait, very much like
`amba`. There is also a module macro used that can used if a module is
just a platform driver. Lastly, drivers can specify additional data with
each supported id (to be passed back to them on `probe`).

Signed-off-by: Wedson Almeida Filho <wedsonaf@google.com>

Author: wedsonaf

drivers/char/hw_random/bcm2835_rng_rust.rs

@@ -6,12 +6,12 @@
 #![feature(allocator_api, global_asm)]
 
 use kernel::{
-    c_str, file::File, file_operations::FileOperations, io_buffer::IoBufferWriter, miscdev,
-    of::ConstOfMatchTable, platform, platform::PlatformDriver, prelude::*,
+    c_str, device, file::File, file_operations::FileOperations, io_buffer::IoBufferWriter, miscdev,
+    module_platform_driver, of, platform, prelude::*, sync::Ref,
 };
 
-module! {
-    type: RngModule,
+module_platform_driver! {
+    type: RngDriver,
     name: b"bcm2835_rng_rust",
     author: b"Rust for Linux Contributors",
     description: b"BCM2835 Random Number Generator (RNG) driver",
@@ -38,35 +38,29 @@ impl FileOperations for RngDevice {
     }
 }
 
-struct RngDriver;
-
-impl PlatformDriver for RngDriver {
-    type DrvData = Pin<Box<miscdev::Registration<RngDevice>>>;
-
-    fn probe(device_id: i32) -> Result<Self::DrvData> {
-        pr_info!("probing discovered hwrng with id {}\n", device_id);
-        let drv_data = miscdev::Registration::new_pinned(c_str!("rust_hwrng"), None, ())?;
-        Ok(drv_data)
-    }
+type DeviceData = device::Data<miscdev::Registration<RngDevice>, (), ()>;
 
-    fn remove(device_id: i32, _drv_data: Self::DrvData) -> Result {
-        pr_info!("removing hwrng with id {}\n", device_id);
-        Ok(())
-    }
-}
-
-struct RngModule {
-    _pdev: Pin<Box<platform::Registration>>,
-}
-
-impl KernelModule for RngModule {
-    fn init(name: &'static CStr, module: &'static ThisModule) -> Result<Self> {
-        const OF_MATCH_TBL: ConstOfMatchTable<1> =
-            ConstOfMatchTable::new_const([c_str!("brcm,bcm2835-rng")]);
-
-        let pdev =
-            platform::Registration::new_pinned::<RngDriver>(name, Some(&OF_MATCH_TBL), module)?;
-
-        Ok(RngModule { _pdev: pdev })
+struct RngDriver;
+impl platform::Driver for RngDriver {
+    type Data = Ref<DeviceData>;
+
+    kernel::define_of_id_table! {(), [
+        (of::DeviceId::Compatible(b"brcm,bcm2835-rng"), None),
+    ]}
+
+    fn probe(dev: &mut platform::Device, _id_info: Option<&Self::IdInfo>) -> Result<Self::Data> {
+        pr_info!("probing discovered hwrng with id {}\n", dev.id());
+        let data = kernel::new_device_data!(
+            miscdev::Registration::new(),
+            (),
+            (),
+            "BCM2835::Registrations"
+        )?;
+
+        data.registrations()
+            .ok_or(Error::ENXIO)?
+            .as_pinned_mut()
+            .register(c_str!("rust_hwrng"), None, ())?;
+        Ok(data.into())
     }
 }

rust/helpers.c

@@ -17,6 +17,7 @@
 #include <linux/irqchip/chained_irq.h>
 #include <linux/irqdomain.h>
 #include <linux/amba/bus.h>
+#include <linux/of_device.h>
 
 __noreturn void rust_helper_BUG(void)
 {
@@ -477,6 +478,13 @@ void rust_helper_put_cred(const struct cred *cred) {
 }
 EXPORT_SYMBOL_GPL(rust_helper_put_cred);
 
+const struct of_device_id *rust_helper_of_match_device(
+		const struct of_device_id *matches, const struct device *dev)
+{
+	return of_match_device(matches, dev);
+}
+EXPORT_SYMBOL_GPL(rust_helper_of_match_device);
+
 /* We use bindgen's --size_t-is-usize option to bind the C size_t type
  * as the Rust usize type, so we can use it in contexts where Rust
  * expects a usize like slice (array) indices. usize is defined to be

rust/kernel/of.rs

@@ -4,98 +4,60 @@
 //!
 //! C header: [`include/linux/of_*.h`](../../../../include/linux/of_*.h)
 
-use crate::{bindings, c_types, str::CStr};
+use crate::{bindings, driver, str::BStr};
 
-use core::ops::Deref;
-use core::ptr;
+/// An open firmware device id.
+#[derive(Clone, Copy)]
+pub enum DeviceId {
+    /// An open firmware device id where only a compatible string is specified.
+    Compatible(&'static BStr),
+}
 
-/// A kernel Open Firmware / devicetree match table.
-///
-/// Can only exist as an `&OfMatchTable` reference (akin to `&str` or
-/// `&Path` in Rust std).
+/// Defines a const open firmware device id table that also carries per-entry data/context/info.
 ///
-/// # Invariants
+/// The name of the const is `OF_DEVICE_ID_TABLE`, which is what buses are expected to name their
+/// open firmware tables.
 ///
-/// The inner reference points to a sentinel-terminated C array.
-#[repr(transparent)]
-pub struct OfMatchTable(bindings::of_device_id);
-
-impl OfMatchTable {
-    /// Returns the table as a reference to a static lifetime, sentinel-terminated C array.
-    ///
-    /// This is suitable to be coerced into the kernel's `of_match_table` field.
-    pub fn as_ptr(&'static self) -> &'static bindings::of_device_id {
-        // The inner reference points to a sentinel-terminated C array, as per
-        // the type invariant.
-        &self.0
-    }
-}
-
-/// An Open Firmware Match Table that can be constructed at build time.
+/// # Examples
 ///
-/// # Invariants
+/// ```
+/// # use kernel::define_of_id_table;
+/// use kernel::of;
 ///
-/// `sentinel` always contains zeroes.
-#[repr(C)]
-pub struct ConstOfMatchTable<const N: usize> {
-    table: [bindings::of_device_id; N],
-    sentinel: bindings::of_device_id,
+/// define_of_id_table! {u32, [
+///     (of::DeviceId::Compatible(b"test-device1,test-device2"), Some(0xff)),
+///     (of::DeviceId::Compatible(b"test-device3"), None),
+/// ]};
+/// ```
+#[macro_export]
+macro_rules! define_of_id_table {
+    ($data_type:ty, $($t:tt)*) => {
+        $crate::define_id_table!(OF_DEVICE_ID_TABLE, $crate::of::DeviceId, $data_type, $($t)*);
+    };
 }
 
-impl<const N: usize> ConstOfMatchTable<N> {
-    /// Creates a new Open Firmware Match Table from a list of compatible strings.
-    pub const fn new_const(compatibles: [&'static CStr; N]) -> Self {
-        let mut table = [Self::zeroed_of_device_id(); N];
-        let mut i = 0;
-        while i < N {
-            table[i] = Self::new_of_device_id(compatibles[i]);
-            i += 1;
-        }
-        Self {
-            table,
-            // INVARIANTS: we zero the sentinel here, and never change it
-            // anywhere. Therefore it always contains zeroes.
-            sentinel: Self::zeroed_of_device_id(),
-        }
-    }
-
-    const fn zeroed_of_device_id() -> bindings::of_device_id {
-        bindings::of_device_id {
-            name: [0; 32],
-            type_: [0; 32],
-            compatible: [0; 128],
-            data: ptr::null(),
-        }
-    }
-
-    const fn new_of_device_id(compatible: &'static CStr) -> bindings::of_device_id {
-        let mut id = Self::zeroed_of_device_id();
-        let compatible = compatible.as_bytes_with_nul();
+// SAFETY: `ZERO` is all zeroed-out and `to_rawid` stores `offset` in `of_device_id::data`.
+unsafe impl const driver::RawDeviceId for DeviceId {
+    type RawType = bindings::of_device_id;
+    const ZERO: Self::RawType = bindings::of_device_id {
+        name: [0; 32],
+        type_: [0; 32],
+        compatible: [0; 128],
+        data: core::ptr::null(),
+    };
+
+    fn to_rawid(&self, offset: isize) -> Self::RawType {
+        let DeviceId::Compatible(compatible) = self;
+        let mut id = Self::ZERO;
         let mut i = 0;
         while i < compatible.len() {
-            // If `compatible` does not fit in `id.compatible`, an
-            // "index out of bounds" build time error will be triggered.
-            id.compatible[i] = compatible[i] as c_types::c_char;
+            // If `compatible` does not fit in `id.compatible`, an "index out of bounds" build time
+            // error will be triggered.
+            id.compatible[i] = compatible[i] as _;
             i += 1;
         }
+        id.compatible[i] = b'\0' as _;
+        id.data = offset as _;
         id
     }
 }
-
-impl<const N: usize> Deref for ConstOfMatchTable<N> {
-    type Target = OfMatchTable;
-
-    fn deref(&self) -> &OfMatchTable {
-        // INVARIANTS: `head` points to a sentinel-terminated C array,
-        // as per the `ConstOfMatchTable` type invariant, therefore
-        // `&OfMatchTable`'s inner reference will point to a sentinel-terminated C array.
-        let head = &self.table[0] as *const bindings::of_device_id as *const OfMatchTable;
-
-        // SAFETY: The returned reference must remain valid for the lifetime of `self`.
-        // The raw pointer `head` points to memory inside `self`. So the reference created
-        // from this raw pointer has the same lifetime as `self`.
-        // Therefore this reference remains valid for the lifetime of `self`, and
-        // is safe to return.
-        unsafe { &*head }
-    }
-}