Commit 9901adda authored by Abdiel Janulgue's avatar Abdiel Janulgue Committed by Miguel Ojeda
Browse files

samples: rust: add Rust dma test sample driver 



Add a simple driver to exercise the basics of the Rust DMA
coherent allocator bindings.

Suggested-by: default avatarDanilo Krummrich <dakr@kernel.org>
Signed-off-by: default avatarAbdiel Janulgue <abdiel.janulgue@gmail.com>
Acked-by: default avatarDanilo Krummrich <dakr@kernel.org>
Link: https://lore.kernel.org/r/20250317185345.2608976-4-abdiel.janulgue@gmail.com


[ Renamed Kconfig symbol and moved it up. Migrated to the new
  `authors` key in `module!`. Fixed module name in description
  and typo in commit message. - Miguel ]
Signed-off-by: default avatarMiguel Ojeda <ojeda@kernel.org>
parent ad2907b4

samples/rust/Kconfig

+11 −0
Original line number Diff line number Diff line
@@ -40,6 +40,17 @@ config SAMPLE_RUST_PRINT 


	  If unsure, say N.



config SAMPLE_RUST_DMA

	tristate "DMA Test Driver"

	depends on PCI

	help

	  This option builds the Rust DMA Test driver sample.



	  To compile this as a module, choose M here:

	  the module will be called rust_dma.



	  If unsure, say N.



config SAMPLE_RUST_DRIVER_PCI

	tristate "PCI Driver"

	depends on PCI

samples/rust/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -4,6 +4,7 @@ ccflags-y += -I$(src) # needed for trace events 
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_DRIVER_PCI)		+= rust_driver_pci.o

obj-$(CONFIG_SAMPLE_RUST_DRIVER_PLATFORM)	+= rust_driver_platform.o

obj-$(CONFIG_SAMPLE_RUST_DRIVER_FAUX)		+= rust_driver_faux.o

samples/rust/rust_dma.rs

0 → 100644
+97 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0



//! Rust DMA api test (based on QEMU's `pci-testdev`).

//!

//! To make this driver probe, QEMU must be run with `-device pci-testdev`.



use kernel::{bindings, dma::CoherentAllocation, pci, prelude::*};



struct DmaSampleDriver {

    pdev: pci::Device,

    ca: CoherentAllocation<MyStruct>,

}



const TEST_VALUES: [(u32, u32); 5] = [

    (0xa, 0xb),

    (0xc, 0xd),

    (0xe, 0xf),

    (0xab, 0xba),

    (0xcd, 0xef),

];



struct MyStruct {

    h: u32,

    b: u32,

}



impl MyStruct {

    fn new(h: u32, b: u32) -> Self {

        Self { h, b }

    }

}

// SAFETY: All bit patterns are acceptable values for `MyStruct`.

unsafe impl kernel::transmute::AsBytes for MyStruct {}

// SAFETY: Instances of `MyStruct` have no uninitialized portions.

unsafe impl kernel::transmute::FromBytes for MyStruct {}



kernel::pci_device_table!(

    PCI_TABLE,

    MODULE_PCI_TABLE,

    <DmaSampleDriver as pci::Driver>::IdInfo,

    [(

        pci::DeviceId::from_id(bindings::PCI_VENDOR_ID_REDHAT, 0x5),

        ()

    )]

);



impl pci::Driver for DmaSampleDriver {

    type IdInfo = ();

    const ID_TABLE: pci::IdTable<Self::IdInfo> = &PCI_TABLE;



    fn probe(pdev: &mut pci::Device, _info: &Self::IdInfo) -> Result<Pin<KBox<Self>>> {

        dev_info!(pdev.as_ref(), "Probe DMA test driver.\n");



        let ca: CoherentAllocation<MyStruct> =

            CoherentAllocation::alloc_coherent(pdev.as_ref(), TEST_VALUES.len(), GFP_KERNEL)?;



        || -> Result {

            for (i, value) in TEST_VALUES.into_iter().enumerate() {

                kernel::dma_write!(ca[i] = MyStruct::new(value.0, value.1));

            }



            Ok(())

        }()?;



        let drvdata = KBox::new(

            Self {

                pdev: pdev.clone(),

                ca,

            },

            GFP_KERNEL,

        )?;



        Ok(drvdata.into())

    }

}



impl Drop for DmaSampleDriver {

    fn drop(&mut self) {

        dev_info!(self.pdev.as_ref(), "Unload DMA test driver.\n");



        let _ = || -> Result {

            for (i, value) in TEST_VALUES.into_iter().enumerate() {

                assert_eq!(kernel::dma_read!(self.ca[i].h), value.0);

                assert_eq!(kernel::dma_read!(self.ca[i].b), value.1);

            }

            Ok(())

        }();

    }

}



kernel::module_pci_driver! {

    type: DmaSampleDriver,

    name: "rust_dma",

    authors: ["Abdiel Janulgue"],

    description: "Rust DMA test",

    license: "GPL v2",

}