Blog

// rust/kernel/platform.rs
macro_rules! module_platform_driver {
    ($($f:tt)*) => {
        $crate::module_driver!(<T>, $crate::platform::Adapter<T>, { $($f)* });
    };
}

// SPDX-License-Identifier: GPL-2.0

//! Device-tree bound Rust platform driver sample.

use kernel::{
    device::Core,
    io::{mem::IoMem, Io},
    of, platform,
    prelude::*,
    str::CString,
    sync::aref::ARef,
};

/// PL031 레지스터 오프셋.
const RTC_DR: usize = 0x000; // Data Register: 현재 시각(epoch seconds)
const RTC_CR: usize = 0x00c; // Control Register

/// ioremap할 레지스터 영역 크기.
const REG_SIZE: usize = 0x1000;

/// compatible 항목마다 드라이버에 넘길 private 데이터.
struct DeviceInfo {
    variant: &'static CStr,
}

/// 드라이버 그 자체. 상태는 담지 않는다.
struct RustDtDemo;

/// probe()가 만들어 커널에 넘기는 디바이스 인스턴스 상태.
struct Instance<'a> {
    pdev: ARef<platform::Device>,
    io: IoMem<'a, REG_SIZE>,
    label: CString,
    probed_at: u32,
}

kernel::of_device_table!(
    OF_TABLE,
    MODULE_OF_TABLE,
    <RustDtDemo as platform::Driver>::IdInfo,
    [(
        of::DeviceId::new(c"blog,rust-dt-demo"),
        DeviceInfo { variant: c"demo-v1" }
    )]
);

impl platform::Driver for RustDtDemo {
    type IdInfo = DeviceInfo;
    type Data<'bound> = Instance<'bound>;
    const OF_ID_TABLE: Option<of::IdTable<Self::IdInfo>> = Some(&OF_TABLE);
    // ...
}

rust-demo@9010000 {
	reg = <0x00 0x9010000 0x00 0x1000>;
	compatible = "blog,rust-dt-demo";
	blog,label = "pl031-rtc";
	blog,sample-count = <0x2a>;
	blog,debug;
};

fn probe<'bound>(
    pdev: &'bound platform::Device<Core<'_>>,
    info: Option<&'bound Self::IdInfo>,
) -> impl PinInit<Self::Data<'bound>, Error> + 'bound {
    let dev = pdev.as_ref();
    let info = info.ok_or(ENODEV)?;
    dev_info!(dev, "probe: variant={:?}\n", info.variant);

    // 1) 디바이스 트리 속성 읽기
    let fwnode = dev.fwnode().ok_or(ENODEV)?;
    let label: CString = fwnode.property_read(c"blog,label").required_by(dev)?;
    let count: u32 = fwnode.property_read(c"blog,sample-count").required_by(dev)?;
    let debug = fwnode.property_read_bool(c"blog,debug");
    dev_info!(
        dev,
        "of properties: label={label:?} sample-count={count} debug={debug}\n"
    );

    // 2) reg 리소스 확인 후 ioremap
    let res = pdev.resource_by_index(0).ok_or(ENODEV)?;
    dev_info!(
        dev,
        "reg resource: start={:#x} size={:#x}\n",
        res.start(),
        res.size()
    );
    let io = pdev
        .io_request_by_index(0)
        .ok_or(ENODEV)?
        .iomap_sized::<REG_SIZE>()?;

    // 3) 실제 MMIO 레지스터 읽기
    let cr = io.try_read32(RTC_CR)?;
    let probed_at = io.try_read32(RTC_DR)?;
    dev_info!(dev, "mmio: CR={cr:#010x} DR={probed_at} (epoch seconds)\n");

    Ok(Instance {
        pdev: pdev.into(),
        io,
        label,
        probed_at,
    })
}

fn unbind<'bound>(dev: &'bound platform::Device<Core<'_>>, this: Pin<&Self::Data<'bound>>) {
    // 아직 디바이스에 접근할 수 있는 시점이다.
    match this.io.try_read32(RTC_DR) {
        Ok(now) => dev_info!(
            dev.as_ref(),
            "unbind: {} seconds since probe\n",
            now.wrapping_sub(this.probed_at)
        ),
        Err(e) => dev_err!(dev.as_ref(), "unbind: read failed: {e:?}\n"),
    }
}

impl Drop for Instance<'_> {
    fn drop(&mut self) {
        // iounmap과 release_mem_region은 여기서 자동으로 일어난다.
        dev_info!(self.pdev, "drop: releasing '{:?}'\n", self.label);
    }
}

# 툴체인 (커널이 요구하는 정확한 버전을 scripts/min-tool-version.sh로 확인)
rustup toolchain install 1.85.0 --profile minimal
rustup component add rust-src --toolchain 1.85.0
cargo install --locked --version 0.71.1 bindgen-cli

git clone --depth 1 https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
cd linux
export ARCH=arm64 LLVM=1
make rustavailable
make defconfig
scripts/config --enable RUST --enable SAMPLES --enable SAMPLES_RUST \
  --module SAMPLE_RUST_DT_DEMO --enable MODULE_UNLOAD
make olddefconfig
make -j$(nproc) Image modules

qemu-system-aarch64 -machine virt,dumpdtb=virt.dtb -cpu cortex-a57 -m 512 -nographic
dtc -I dtb -O dts -o virt.dts virt.dtb
# pl031@9010000 노드를 위의 rust-demo@9010000 으로 교체
dtc -I dts -O dtb -o virt-demo.dtb virt-demo.dts

#!/bin/sh
/bin/busybox --install -s /bin
mount -t proc none /proc
mount -t sysfs none /sys

echo "### platform device present before insmod:"
ls -d /sys/bus/platform/devices/*rust-demo* 2>/dev/null || echo "  (none)"
echo "### driver dir before insmod:"
ls -d /sys/bus/platform/drivers/rust_dt_demo 2>/dev/null || echo "  (none)"
echo "### insmod"
insmod /rust_dt_demo.ko
echo "### bound devices:"
ls -l /sys/bus/platform/drivers/rust_dt_demo/ | grep -v total
echo "### of_node compatible:"
cat /sys/bus/platform/devices/9010000.rust-demo/of_node/compatible; echo
echo "### guest date:"
date +%s
echo "### rmmod after 3s"
sleep 3
rmmod rust_dt_demo
poweroff -f

qemu-system-aarch64 -machine virt -cpu cortex-a57 -m 512 -nographic \
  -kernel arch/arm64/boot/Image \
  -dtb virt-demo.dtb \
  -initrd initramfs.cpio.gz \
  -append "console=ttyAMA0 rdinit=/init loglevel=7"