rust: add initial PCI support

Added minimum abstration APIs for PCI.

---

Original-author: FUJITA Tomonori <[email protected]>

Modified to apply to this tree.

Author: fujita

rust/Makefile

@@ -14,6 +14,7 @@ RUST_HELPERS := \
 	err \
 	kunit \
 	mutex \
+	pci \
 	rcu \
 	refcount \
 	signal \

rust/bindings/bindings_helper.h

@@ -12,6 +12,7 @@
 #include <linux/ethtool.h>
 #include <linux/jiffies.h>
 #include <linux/mdio.h>
+#include <linux/pci.h>
 #include <linux/phy.h>
 #include <linux/refcount.h>
 #include <linux/sched.h>

rust/helpers/pci.c

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/pci.h>
+
+void rust_helper_pci_set_drvdata(struct pci_dev *pdev, void *data)
+{
+	pci_set_drvdata(pdev, data);
+}
+EXPORT_SYMBOL_GPL(rust_helper_pci_set_drvdata);
+
+void *rust_helper_pci_get_drvdata(struct pci_dev *pdev)
+{
+	return pci_get_drvdata(pdev);
+}
+EXPORT_SYMBOL_GPL(rust_helper_pci_get_drvdata);

rust/kernel/lib.rs

@@ -13,6 +13,7 @@
 
 #![no_std]
 #![feature(allocator_api)]
+#![feature(associated_type_defaults)]
 #![feature(coerce_unsized)]
 #![feature(const_refs_to_cell)]
 #![feature(dispatch_from_dyn)]
@@ -58,6 +59,8 @@ pub mod workqueue;
 #[doc(hidden)]
 pub use bindings;
 pub use macros;
+#[cfg(CONFIG_PCI)]
+pub mod pci;
 pub use uapi;
 
 #[doc(hidden)]

rust/kernel/pci.rs

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! PCI devices and drivers.
+//!
+//! C header: [`include/linux/pci.h`](../../../../include/linux/pci.h)
+
+use crate::{
+    bindings, device, driver,
+    error::{from_result, to_result, Result},
+    str::CStr,
+    types::ForeignOwnable,
+    ThisModule,
+};
+
+/// An adapter for the registration of PCI drivers.
+pub struct Adapter<T: Driver>(T);
+
+impl<T: Driver> driver::DriverOps for Adapter<T> {
+    type RegType = bindings::pci_driver;
+
+    unsafe fn register(
+        reg: *mut bindings::pci_driver,
+        name: &'static CStr,
+        module: &'static ThisModule,
+    ) -> Result {
+        let pdrv: &mut bindings::pci_driver = unsafe { &mut *reg };
+
+        pdrv.name = name.as_char_ptr();
+        pdrv.probe = Some(Self::probe_callback);
+        pdrv.remove = Some(Self::remove_callback);
+        pdrv.id_table = T::PCI_ID_TABLE.as_ptr();
+        to_result(unsafe { bindings::__pci_register_driver(reg, module.0, name.as_char_ptr()) })
+    }
+
+    unsafe fn unregister(reg: *mut bindings::pci_driver) {
+        unsafe { bindings::pci_unregister_driver(reg) }
+    }
+}
+
+impl<T: Driver> Adapter<T> {
+    extern "C" fn probe_callback(
+        pdev: *mut bindings::pci_dev,
+        _id: *const bindings::pci_device_id,
+    ) -> core::ffi::c_int {
+        from_result(|| {
+            let mut dev = unsafe { Device::from_ptr(pdev) };
+            let data = T::probe(&mut dev)?;
+            unsafe { bindings::pci_set_drvdata(pdev, data.into_foreign() as _) };
+            Ok(0)
+        })
+    }
+
+    extern "C" fn remove_callback(pdev: *mut bindings::pci_dev) {
+        let ptr = unsafe { bindings::pci_get_drvdata(pdev) };
+        let data = unsafe { T::Data::from_foreign(ptr) };
+        T::remove(&data);
+        <T::Data as driver::DeviceRemoval>::device_remove(&data);
+    }
+}
+
+/// A PCI driver
+pub trait Driver {
+    /// Data stored on device by driver.
+    ///
+    /// Corresponds to the data set or retrieved via the kernel's
+    /// `pci_{set,get}_drvdata()` functions.
+    ///
+    /// Require that `Data` implements `ForeignOwnable`. We guarantee to
+    /// never move the underlying wrapped data structure. This allows
+    type Data: ForeignOwnable + Send + Sync + driver::DeviceRemoval = ();
+
+    /// The table of device ids supported by the driver.
+    const PCI_ID_TABLE: &'static [bindings::pci_device_id];
+
+    /// PCI driver probe.
+    ///
+    /// Called when a new platform device is added or discovered.
+    /// Implementers should attempt to initialize the device here.
+    fn probe(dev: &mut Device) -> Result<Self::Data>;
+
+    /// PCI driver remove.
+    ///
+    /// Called when a platform device is removed.
+    /// Implementers should prepare the device for complete removal here.
+    fn remove(_data: &Self::Data);
+}
+
+/// A PCI device.
+///
+/// # Invariants
+///
+/// The field `ptr` is non-null and valid for the lifetime of the object.
+pub struct Device {
+    ptr: *mut bindings::pci_dev,
+}
+
+impl Device {
+    unsafe fn from_ptr(ptr: *mut bindings::pci_dev) -> Self {
+        Self { ptr }
+    }
+}
+
+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 }
+    }
+}