rust: Add soc_device support (057d44b0) · Commits · git / linux-net

MAINTAINERS

+1 −0

Original line number	Diff line number	Diff line
		@@ -7700,6 +7700,7 @@ F: rust/kernel/devres.rs
		F: rust/kernel/driver.rs
		F: rust/kernel/faux.rs
		F: rust/kernel/platform.rs
		F: rust/kernel/soc.rs
		F: samples/rust/rust_debugfs.rs
		F: samples/rust/rust_debugfs_scoped.rs
		F: samples/rust/rust_driver_platform.rs

rust/bindings/bindings_helper.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -80,6 +80,7 @@
		#include <linux/sched.h>
		#include <linux/security.h>
		#include <linux/slab.h>
		#include <linux/sys_soc.h>
		#include <linux/task_work.h>
		#include <linux/tracepoint.h>
		#include <linux/usb.h>

rust/kernel/lib.rs

+2 −0

Original line number	Diff line number	Diff line
		@@ -138,6 +138,8 @@
		pub mod seq_file;
		pub mod sizes;
		pub mod slice;
		#[cfg(CONFIG_SOC_BUS)]
		pub mod soc;
		mod static_assert;
		#[doc(hidden)]
		pub mod std_vendor;

rust/kernel/soc.rs

0 → 100644

+135 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0

		// Copyright (C) 2025 Google LLC.

		//! SoC Driver Abstraction.
		//!
		//! C header: [`include/linux/sys_soc.h`](srctree/include/linux/sys_soc.h)

		use crate::{
		bindings,
		error,
		prelude::*,
		str::CString,
		types::Opaque, //
		};
		use core::ptr::NonNull;

		/// Attributes for a SoC device.
		///
		/// These are both exported to userspace under /sys/devices/socX and provided to other drivers to
		/// match against via `soc_device_match` (not yet available in Rust) to enable quirks or
		/// device-specific support where necessary.
		///
		/// All fields are freeform - they have no specific formatting, just defined meanings.
		/// For example, the [`machine`](`Attributes::machine`) field could be "DB8500" or
		/// "Qualcomm Technologies, Inc. SM8560 HDK", but regardless it should identify a board or product.
		pub struct Attributes {
		/// Should generally be a board ID or product ID. Examples
		/// include DB8500 (ST-Ericsson) or "Qualcomm Technologies, inc. SM8560 HDK".
		///
		/// If this field is not populated, the SoC infrastructure will try to populate it from
		/// `/model` in the device tree.
		pub machine: Option<CString>,
		/// The broader class this SoC belongs to. Examples include ux500
		/// (for DB8500) or Snapdragon (for SM8650).
		///
		/// On chips with ARM firmware supporting SMCCC v1.2+, this may be a JEDEC JEP106 manufacturer
		/// identification.
		pub family: Option<CString>,
		/// The manufacturing revision of the part. Frequently this is MAJOR.MINOR, but not always.
		pub revision: Option<CString>,
		/// Serial Number - uniquely identifies a specific SoC. If present, should be unique (buying a
		/// replacement part should change it if present). This field cannot be matched on and is
		/// solely present to export through /sys.
		pub serial_number: Option<CString>,
		/// SoC ID - identifies a specific SoC kind in question, sometimes more specifically than
		/// `machine` if the same SoC is used in multiple products. Some devices use this to specify a
		/// SoC name, e.g. "I.MX??", and others just print an ID number (e.g. Tegra and Qualcomm).
		///
		/// On chips with ARM firmware supporting SMCCC v1.2+, this may be a JEDEC JEP106 manufacturer
		/// identification (the family value) followed by a colon and then a 4-digit ID value.
		pub soc_id: Option<CString>,
		}

		struct BuiltAttributes {
		// While `inner` has pointers to `_backing`, it is to the interior of the `CStrings`, not
		// `backing` itself, so it does not need to be pinned.
		_backing: Attributes,
		// `Opaque` makes us `!Unpin`, as the registration holds a pointer to `inner` when used.
		inner: Opaque<bindings::soc_device_attribute>,
		}

		fn cstring_to_c(mcs: &Option<CString>) -> *const kernel::ffi::c_char {
		mcs.as_ref()
		.map(\|cs\| cs.as_char_ptr())
		.unwrap_or(core::ptr::null())
		}

		impl BuiltAttributes {
		fn as_mut_ptr(&self) -> *mut bindings::soc_device_attribute {
		self.inner.get()
		}
		}

		impl Attributes {
		fn build(self) -> BuiltAttributes {
		BuiltAttributes {
		inner: Opaque::new(bindings::soc_device_attribute {
		machine: cstring_to_c(&self.machine),
		family: cstring_to_c(&self.family),
		revision: cstring_to_c(&self.revision),
		serial_number: cstring_to_c(&self.serial_number),
		soc_id: cstring_to_c(&self.soc_id),
		data: core::ptr::null(),
		custom_attr_group: core::ptr::null(),
		}),
		_backing: self,
		}
		}
		}

		#[pin_data(PinnedDrop)]
		/// Registration handle for your soc_dev. If you let it go out of scope, your soc_dev will be
		/// unregistered.
		pub struct Registration {
		#[pin]
		attr: BuiltAttributes,
		soc_dev: NonNull<bindings::soc_device>,
		}

		// SAFETY: We provide no operations through `&Registration`.
		unsafe impl Sync for Registration {}

		// SAFETY: All pointers are normal allocations, not thread-specific.
		unsafe impl Send for Registration {}

		#[pinned_drop]
		impl PinnedDrop for Registration {
		fn drop(self: Pin<&mut Self>) {
		// SAFETY: Device always contains a live pointer to a soc_device that can be unregistered
		unsafe { bindings::soc_device_unregister(self.soc_dev.as_ptr()) }
		}
		}

		impl Registration {
		/// Register a new SoC device
		pub fn new(attr: Attributes) -> impl PinInit<Self, Error> {
		try_pin_init!(Self {
		attr: attr.build(),
		soc_dev: {
		// SAFETY:
		// * The struct provided through attr is backed by pinned data next to it,
		// so as long as attr lives, the strings pointed to by the struct will too.
		// * `attr` is pinned, so the pinned data won't move.
		// * If it returns a device, and so others may try to read this data, by
		// caller invariant, `attr` won't be released until the device is.
		let raw_soc = error::from_err_ptr(unsafe {
		bindings::soc_device_register(attr.as_mut_ptr())
		})?;

		NonNull::new(raw_soc).ok_or(EINVAL)?
		},
		}? Error)
		}
		}