diff --git a/drivers/char/hw_random/Kconfig b/drivers/char/hw_random/Kconfig index 87cebb34aeccdad84d581343250dd4ea57cc2e57..5c8f1b8e1d5dde824f9c92d804307f6aa5d3011b 100644 --- a/drivers/char/hw_random/Kconfig +++ b/drivers/char/hw_random/Kconfig @@ -438,6 +438,18 @@ config HW_RANDOM_CAVIUM If unsure, say Y. +config HW_RANDOM_CAVIUM_RUST + tristate "Rust implementation of Cavium ThunderX Random Number Generator" + depends on RUST && HW_RANDOM && PCI && ARCH_THUNDER + help + This driver provides alternative Rust-based kernel-side support + for the Random Number Generator hardware found on Cavium SoCs. + + To compile this driver as a module, choose M here: the + module will be called cavium_rng_rust. + + If unsure, say N. + config HW_RANDOM_MTK tristate "Mediatek Random Number Generator support" depends on HW_RANDOM diff --git a/drivers/char/hw_random/Makefile b/drivers/char/hw_random/Makefile index d24ec71627af3182973212b5b78f5a1b10c22457..e7caacfe0e1ad1482416ab0f9aad0cff08602c8d 100644 --- a/drivers/char/hw_random/Makefile +++ b/drivers/char/hw_random/Makefile @@ -39,6 +39,7 @@ obj-$(CONFIG_HW_RANDOM_STM32) += stm32-rng.o obj-$(CONFIG_HW_RANDOM_PIC32) += pic32-rng.o obj-$(CONFIG_HW_RANDOM_MESON) += meson-rng.o obj-$(CONFIG_HW_RANDOM_CAVIUM) += cavium-rng.o cavium-rng-vf.o +obj-$(CONFIG_HW_RANDOM_CAVIUM_RUST) += cavium_rng_rust.o obj-$(CONFIG_HW_RANDOM_MTK) += mtk-rng.o obj-$(CONFIG_HW_RANDOM_S390) += s390-trng.o obj-$(CONFIG_HW_RANDOM_KEYSTONE) += ks-sa-rng.o diff --git a/drivers/char/hw_random/cavium_rng_rust.rs b/drivers/char/hw_random/cavium_rng_rust.rs new file mode 100644 index 0000000000000000000000000000000000000000..3766fd5a1af3dbe0efee8a15cc69efd87ca6c309 --- /dev/null +++ b/drivers/char/hw_random/cavium_rng_rust.rs @@ -0,0 +1,100 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Broadcom CAVIUM Random Number Generator support. + +use kernel::{ + bindings, define_pci_id_table, device, file, file::File, io_buffer::IoBufferWriter, + io_mem::IoMem, miscdev, module_pci_driver, pci, prelude::*, sync::Ref, +}; + +module_pci_driver! { + type: RngDriver, + name: b"cavium_rng_rust", + author: b"Rust for Linux Contributors", + description: b"Cavium Random Number Generator (RNG) driver", + license: b"GPL v2", +} + +const THUNDERX_RNM_ENT_EN: u64 = 0x1; +const THUNDERX_RNM_RNG_EN: u64 = 0x2; +const CAVIUM_SIZE: usize = 0x1000; + +struct RngDevice; + +impl file::Operations for RngDevice { + kernel::declare_file_operations!(); + + fn open(_open_data: &(), _file: &File) -> Result { + Ok(()) + } + + fn read(_: (), _: &File, data: &mut impl IoBufferWriter, offset: u64) -> Result { + // Succeed if the caller doesn't provide a buffer or if not at the start. + if data.is_empty() || offset != 0 { + return Ok(0); + } + + data.write(&0_u32)?; + Ok(4) + } +} + +struct CAVIUMResources { + base: IoMem, +} + +struct CAVIUMData { + dev: device::Device, +} + +type DeviceData = device::Data, CAVIUMResources, CAVIUMData>; + +struct RngDriver; +impl pci::Driver for RngDriver { + type Data = Ref; + + define_pci_id_table! {u32, [ + (pci::DeviceId::new(bindings::PCI_VENDOR_ID_CAVIUM, 0xa018), None), + ]} + + fn probe(dev: &mut pci::Device, _id_info: Option<&Self::IdInfo>) -> Result { + let res = dev.take_resource().ok_or(ENXIO)?; + + let res = CAVIUMResources { + // SAFETY: This device doesn't support DMA. + base: unsafe { IoMem::try_new(res)? }, + }; + res.base + .writeq(THUNDERX_RNM_ENT_EN | THUNDERX_RNM_RNG_EN, 0); + + let ret = dev.pci_enable_sriov(1); + match ret { + Ok(_o) => (), + Err(_e) => { + dev_err!(dev, "Error initializing RNG virtual function.\n",); + res.base.writeq(0, 0); + return Err(_e); + } + } + + let cdata = CAVIUMData { + dev: device::Device::from_dev(dev), + }; + + let mut data = kernel::new_device_data!( + miscdev::Registration::new(), + res, + cdata, + "CAVIUM::Registrations" + )?; + + let data = Ref::::from(data); + + data.registrations() + .ok_or(ENXIO)? + .as_pinned_mut() + .register(fmt!("rust_cavium"), ())?; + + Ok(data.into()) + } +} diff --git a/rust/helpers.c b/rust/helpers.c index ead3a64f700c73ef73fd7a58a49b109e392f8b5c..cfb54a0207d8fbc7d966f20cb8ff79b48eedae0a 100644 --- a/rust/helpers.c +++ b/rust/helpers.c @@ -32,6 +32,7 @@ #include #include #include +#include #include #include #include @@ -620,6 +621,18 @@ unsigned int rust_helper_NF_QUEUE_NR(unsigned int n) } EXPORT_SYMBOL_GPL(rust_helper_NF_QUEUE_NR); +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); + /* * 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 diff --git a/rust/kernel/amba.rs b/rust/kernel/amba.rs index 61eedcd21ca4314081affecee4413077d6aba536..12ffbfe24faac80dd0e8c28e7eb14d26b37ee08f 100644 --- a/rust/kernel/amba.rs +++ b/rust/kernel/amba.rs @@ -133,7 +133,7 @@ unsafe extern "C" fn probe_callback( } } -unsafe extern "C" fn remove_callback(adev: *mut bindings::amba_device) -> i32 { +unsafe extern "C" fn remove_callback(adev: *mut bindings::amba_device) { // SAFETY: `adev` is valid by the contract with the C code. let ptr = unsafe { bindings::amba_get_drvdata(adev) }; // SAFETY: The value returned by `amba_get_drvdata` was stored by a previous call to @@ -142,7 +142,6 @@ unsafe extern "C" fn remove_callback(adev: *mut bindings::amba_device let data = unsafe { T::Data::from_pointer(ptr) }; T::remove(&data); ::device_remove(&data); - 0 } /// An Amba device. diff --git a/rust/kernel/bindings_helper.h b/rust/kernel/bindings_helper.h index 73100fa139ebb5b527139aa68bd1baabea640a13..3bab72c8eced7720a06c3cc5f294b4e93a3adf26 100644 --- a/rust/kernel/bindings_helper.h +++ b/rust/kernel/bindings_helper.h @@ -27,6 +27,7 @@ #include #include #include +#include #include #include #include diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index 3e01c30de6704a98d98dba2e4b8286f3c7360f80..6c11382a03f7f09e0a155c3be577266d4c00af2c 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -60,6 +60,8 @@ pub mod mm; #[cfg(CONFIG_NET)] pub mod net; pub mod pages; +#[cfg(CONFIG_PCI)] +pub mod pci; pub mod power; pub mod revocable; pub mod security; diff --git a/rust/kernel/net.rs b/rust/kernel/net.rs index be766acca7d9f2561397211710b4cad80f5ef747..76e5369009667a9ed06ee37aa29a2953db27df71 100644 --- a/rust/kernel/net.rs +++ b/rust/kernel/net.rs @@ -107,11 +107,7 @@ unsafe impl AlwaysRefCounted for SkBuff { unsafe fn dec_ref(obj: core::ptr::NonNull) { // SAFETY: The safety requirements guarantee that the refcount is nonzero. - unsafe { - bindings::__kfree_skb( - obj.cast().as_ptr() - ) - }; + unsafe { bindings::__kfree_skb(obj.cast().as_ptr()) }; } } diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs new file mode 100644 index 0000000000000000000000000000000000000000..35af37bf78d6deeaf003c123809abe78707cb66a --- /dev/null +++ b/rust/kernel/pci.rs @@ -0,0 +1,290 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! PCI devices and drivers. +//! +//! C header: [`include/linux/pci.h`](../../../../include/linux/pci.h) + +#![allow(dead_code)] + +use crate::{ + bindings, c_types, device, driver, + error::{from_kernel_result, Result}, + io_mem::Resource, + str::CStr, + to_result, + types::PointerWrapper, + ThisModule, +}; + +/// An adapter for the registration of PCI drivers. +pub struct Adapter(T); + +impl driver::DriverOps for Adapter { + 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_ref(); + 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 Adapter { + extern "C" fn probe_callback( + pdev: *mut bindings::pci_dev, + id: *const bindings::pci_device_id, + ) -> c_types::c_int { + from_kernel_result! { + let mut dev = unsafe { Device::from_ptr(pdev) }; + + // SAFETY: `id` is a pointer within the static table, so it's always valid. + let offset = unsafe {(*id).driver_data}; + // 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 info = { + let ptr = unsafe {id.cast::().offset(offset as _).cast::>()}; + unsafe {(&*ptr).as_ref()} + }; + let data = T::probe(&mut dev, info)?; + unsafe { bindings::pci_set_drvdata(pdev, data.into_pointer() 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_pointer(ptr) }; + T::remove(&data); + ::device_remove(&data); + } +} + +/// Abstraction for bindings::pci_device_id. +#[derive(Clone, Copy)] +pub struct DeviceId { + /// Vendor ID + pub vendor: u32, + /// Device ID + pub device: u32, + /// Subsystem vendor ID + pub subvendor: u32, + /// Subsystem device ID + pub subdevice: u32, + /// Device class and subclass + pub class: u32, + /// Limit which sub-fields of the class + pub class_mask: u32, +} + +impl DeviceId { + const PCI_ANY_ID: u32 = !0; + + /// PCI_DEVICE macro. + pub const fn new(vendor: u32, device: u32) -> Self { + Self { + vendor, + device, + subvendor: DeviceId::PCI_ANY_ID, + subdevice: DeviceId::PCI_ANY_ID, + class: 0, + class_mask: 0, + } + } + + /// PCI_DEVICE_CLASS macro. + pub const fn with_class(class: u32, class_mask: u32) -> Self { + Self { + vendor: DeviceId::PCI_ANY_ID, + device: DeviceId::PCI_ANY_ID, + subvendor: DeviceId::PCI_ANY_ID, + subdevice: DeviceId::PCI_ANY_ID, + class, + class_mask, + } + } +} + +// SAFETY: `ZERO` is all zeroed-out and `to_rawid` stores `offset` in `pci_device_id::driver_data`. +unsafe impl const driver::RawDeviceId for DeviceId { + type RawType = bindings::pci_device_id; + + const ZERO: Self::RawType = bindings::pci_device_id { + vendor: 0, + device: 0, + subvendor: 0, + subdevice: 0, + class: 0, + class_mask: 0, + driver_data: 0, + }; + + fn to_rawid(&self, offset: isize) -> Self::RawType { + bindings::pci_device_id { + vendor: self.vendor, + device: self.device, + subvendor: self.subvendor, + subdevice: self.subdevice, + class: self.class, + class_mask: self.class_mask, + driver_data: offset as _, + } + } +} + +/// Define a const pci device id table +/// +/// # Examples +/// +/// ```ignore +/// # use kernel::{pci, define_pci_id_table}; +/// # +/// struct MyDriver; +/// impl pci::Driver for MyDriver { +/// // [...] +/// # fn probe(_dev: &mut pci::Device, _id_info: Option<&Self::IdInfo>) -> Result { +/// # Ok(()) +/// # } +/// # define_pci_id_table! {u32, [ +/// # (pci::DeviceId::new(0x010800, 0xffffff), None), +/// # (pci::DeviceId::with_class(0x010802, 0xfffff), Some(0x10)), +/// # ]} +/// } +/// ``` +#[macro_export] +macro_rules! define_pci_id_table { + ($data_type:ty, $($t:tt)*) => { + type IdInfo = $data_type; + const PCI_ID_TABLE: $crate::driver::IdTable<'static, $crate::pci::DeviceId, $data_type> = { + $crate::define_id_array!(ARRAY, $crate::pci::DeviceId, $data_type, $($t)* ); + ARRAY.as_table() + }; + }; +} + +/// 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 `PointerWrapper`. We guarantee to + /// never move the underlying wrapped data structure. This allows + type Data: PointerWrapper + Send + Sync + driver::DeviceRemoval = (); + + /// The type holding information about each device id supported by the driver. + type IdInfo: 'static = (); + + /// The table of device ids supported by the driver. + const PCI_ID_TABLE: driver::IdTable<'static, DeviceId, Self::IdInfo>; + + /// 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, id: Option<&Self::IdInfo>) -> Result; + + /// 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, + res: Option, +} + +impl Device { + /// Creates a new device from the given pointer. + /// + /// # Safety + /// + /// `ptr` must be non-null and valid. It must remain valid for the lifetime of the returned + /// instance. + unsafe fn from_ptr(ptr: *mut bindings::pci_dev) -> Self { + // SAFETY: The safety requirements of the function ensure that `ptr` is valid. + let dev = unsafe { &mut *ptr }; + // INVARIANT: The safety requirements of the function ensure the lifetime invariant. + Self { + ptr, + res: Resource::new(dev.resource[0].start, dev.resource[0].end), + } + } + + /// Returns the io mem resource associated with the device, if there is one. + /// + /// Ownership of the resource is transferred to the caller, so subsequent calls to this + /// function will return [`None`]. + pub fn take_resource(&mut self) -> Option { + self.res.take() + } + + pub fn pci_enable_sriov(&self, nr_virtfn: i32) -> Result { + to_result(|| + // SAFETY: The existence of the shared references mean `self.0`is valid. + unsafe{bindings::pci_enable_sriov(self.ptr, nr_virtfn)}) + } + + fn pci_disable_sriov(&self) { + // SAFETY: The existence of the shared references mean `self.0`is valid. + unsafe { bindings::pci_disable_sriov(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 } + } +} + +/// Declares a kernel module that exposes a single pci driver. +/// +/// # Examples +/// +/// ```ignore +/// # use kernel::{pci, define_pci_id_table, module_pci_driver}; +/// # +/// struct MyDriver; +/// impl pci::Driver for MyDriver { +/// // [...] +/// # fn probe(_dev: &mut pci::Device, _id_info: Option<&Self::IdInfo>) -> Result { +/// # Ok(()) +/// # } +/// # define_pci_id_table! {u32, [ +/// # (pci::DeviceId::new(0x177d, 0xa018), None), +/// # ]} +/// } +/// +/// module_pci_driver! { +/// type: MyDriver, +/// name: b"module_name", +/// author: b"Author name", +/// license: b"GPL", +/// } +/// ``` +#[macro_export] +macro_rules! module_pci_driver { + ($($f:tt)*) => { + $crate::module_driver!(, $crate::pci::Adapter, { $($f)* }); + }; +}