Add a new `rust_device_i2c` sample, showing how to create I2C device
on a certain `I2CAdapterRef` using `I2cBoardInfo`. Demonstrates
automatic unregister of such I2C device when driver is unloaded

Signed-off-by: Igor Korotin <igor.korotin.linux@gmail.com>
---
 MAINTAINERS                     |  1 +
 samples/rust/Kconfig            | 13 +++++++++
 samples/rust/Makefile           |  1 +
 samples/rust/rust_device_i2c.rs | 50 +++++++++++++++++++++++++++++++++
 4 files changed, 65 insertions(+)
 create mode 100644 samples/rust/rust_device_i2c.rs

diff --git a/MAINTAINERS b/MAINTAINERS
index 82b469b8ecb9..23bab3c8e1ef 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -11365,6 +11365,7 @@ F:	include/uapi/linux/i2c-*.h
 F:	include/uapi/linux/i2c.h
 F:	rust/helpers/i2c.c
 F:	rust/kernel/i2c.rs
+F:	samples/rust/rust_device_i2c.rs
 F:	samples/rust/rust_driver_i2c.rs
 
 I2C SUBSYSTEM HOST DRIVERS
diff --git a/samples/rust/Kconfig b/samples/rust/Kconfig
index 55aeb12cd7f7..394618aaf5ef 100644
--- a/samples/rust/Kconfig
+++ b/samples/rust/Kconfig
@@ -62,6 +62,18 @@ config SAMPLE_RUST_DMA
 
 	  If unsure, say N.
 
+config SAMPLE_RUST_DEVICE_I2C
+	tristate "Manual I2C Device"
+	depends on I2C && I2C_CHARDEV
+	help
+	  This option builds the Rust I2C device manual creation
+	  sample.
+
+	  To compile this as a module, choose M here:
+	  the module will be called rust_device_i2c.
+
+	  If unsure, say N.
+
 config SAMPLE_RUST_DRIVER_I2C
 	tristate "I2C Driver"
 	depends on I2C
@@ -124,3 +136,4 @@ config SAMPLE_RUST_HOSTPROGS
 	  If unsure, say N.
 
 endif # SAMPLES_RUST
+
diff --git a/samples/rust/Makefile b/samples/rust/Makefile
index 141d8f078248..ee830da1a9d2 100644
--- a/samples/rust/Makefile
+++ b/samples/rust/Makefile
@@ -5,6 +5,7 @@ obj-$(CONFIG_SAMPLE_RUST_MINIMAL)		+= rust_minimal.o
 obj-$(CONFIG_SAMPLE_RUST_MISC_DEVICE)		+= rust_misc_device.o
 obj-$(CONFIG_SAMPLE_RUST_PRINT)			+= rust_print.o
 obj-$(CONFIG_SAMPLE_RUST_DMA)			+= rust_dma.o
+obj-$(CONFIG_SAMPLE_RUST_DEVICE_I2C)		+= rust_device_i2c.o
 obj-$(CONFIG_SAMPLE_RUST_DRIVER_I2C)		+= rust_driver_i2c.o
 obj-$(CONFIG_SAMPLE_RUST_DRIVER_PCI)		+= rust_driver_pci.o
 obj-$(CONFIG_SAMPLE_RUST_DRIVER_PLATFORM)	+= rust_driver_platform.o
diff --git a/samples/rust/rust_device_i2c.rs b/samples/rust/rust_device_i2c.rs
new file mode 100644
index 000000000000..a056736b1b97
--- /dev/null
+++ b/samples/rust/rust_device_i2c.rs
@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Rust I2C DeviceOwned usage sample.
+//!
+//! This sample driver manually creates i2c_client using I2C board info
+//! and pointer to I2C Adapter structure.
+//!
+//! For reproduction of the scenario one should compile kernel with i2c-dev and i2c-stub
+//! modules enabled. f
+
+use kernel::{c_str, device::Core, i2c, prelude::*};
+
+struct SampleDriver {
+    _owned: i2c::DeviceOwned<Core>,
+}
+
+// SAFETY: SampleDriver contains only one field `owned: DeviceOwned<Core>`,
+// which is initialized in `init()` and dropped on module unload.
+// There is no interior mutability or concurrent access to its contents
+// (all I²C operations happen in single-threaded init/drop contexts),
+// so it is safe to share &SampleDriver across threads.
+unsafe impl Sync for SampleDriver {}
+
+const BOARD_INFO: i2c::I2cBoardInfo = i2c::I2cBoardInfo::new(c_str!("rust_driver_i2c"), 0x30);
+
+impl kernel::Module for SampleDriver {
+    fn init(_module: &'static ThisModule) -> Result<Self> {
+        pr_debug!("Probe Rust I2C device sample.\n");
+
+        let adapter = i2c::I2cAdapterRef::get(0).ok_or(EINVAL)?;
+
+        let device = i2c::DeviceOwned::<Core>::new(&adapter, &BOARD_INFO).ok_or(EINVAL)?;
+
+        Ok(Self { _owned: device })
+    }
+}
+
+impl Drop for SampleDriver {
+    fn drop(&mut self) {
+        pr_debug!("Drop Rust I2C device sample.\n");
+    }
+}
+
+kernel::prelude::module! {
+    type:SampleDriver,
+    name:"rust_device_i2c",
+    authors:["Igor Korotin"],
+    description:"Rust I2C device manual creation driver ",
+    license:"GPL v2",
+}
-- 
2.43.0

On Fri, Jul 04, 2025 at 04:43:41PM +0100, Igor Korotin wrote:
> +struct SampleDriver {
> +    _owned: i2c::DeviceOwned<Core>,
> +}
> +
> +const BOARD_INFO: i2c::I2cBoardInfo = i2c::I2cBoardInfo::new(c_str!("rust_driver_i2c"), 0x30);
> +
> +impl kernel::Module for SampleDriver {
> +    fn init(_module: &'static ThisModule) -> Result<Self> {
> +        pr_debug!("Probe Rust I2C device sample.\n");
> +
> +        let adapter = i2c::I2cAdapterRef::get(0).ok_or(EINVAL)?;
> +
> +        let device = i2c::DeviceOwned::<Core>::new(&adapter, &BOARD_INFO).ok_or(EINVAL)?;

This can't be device::Core, since the scope of device is not limited to I2C bus
callback. Also, device::Core dereferences to device::Bound, and device is also
not limited to scope where it can be guaranteed that the device is actually
bound.

It could be device::Normal, but as mentioned in the other thread, you're
thinking this too complicated. You really want t simple i2c::Registration type,
just like auxiliary::Registration. Please take a look at that instead.

> +        Ok(Self { _owned: device })
> +    }
> +}