mirror of
git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2025-09-04 20:19:47 +08:00
7b948a2af6
As by now, pci::Device is implemented as:
#[derive(Clone)]
pub struct Device(ARef<device::Device>);
This may be convenient, but has the implication that drivers can call
device methods that require a mutable reference concurrently at any
point of time.
Instead define pci::Device as
pub struct Device<Ctx: DeviceContext = Normal>(
Opaque<bindings::pci_dev>,
PhantomData<Ctx>,
);
and manually implement the AlwaysRefCounted trait.
With this we can implement methods that should only be called from
bus callbacks (such as probe()) for pci::Device<Core>. Consequently, we
make this type accessible in bus callbacks only.
Arbitrary references taken by the driver are still of type
ARef<pci::Device> and hence don't provide access to methods that are
reserved for bus callbacks.
Fixes: 1bd8b6b2c5 ("rust: pci: add basic PCI device / driver abstractions")
Reviewed-by: Benno Lossin <benno.lossin@proton.me>
Signed-off-by: Danilo Krummrich <dakr@kernel.org>
Acked-by: Boqun Feng <boqun.feng@gmail.com>
Link: https://lore.kernel.org/r/20250314160932.100165-4-dakr@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
111 lines
2.6 KiB
Rust
111 lines
2.6 KiB
Rust
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
//! Rust PCI driver sample (based on QEMU's `pci-testdev`).
|
|
//!
|
|
//! To make this driver probe, QEMU must be run with `-device pci-testdev`.
|
|
|
|
use kernel::{bindings, c_str, device::Core, devres::Devres, pci, prelude::*, types::ARef};
|
|
|
|
struct Regs;
|
|
|
|
impl Regs {
|
|
const TEST: usize = 0x0;
|
|
const OFFSET: usize = 0x4;
|
|
const DATA: usize = 0x8;
|
|
const COUNT: usize = 0xC;
|
|
const END: usize = 0x10;
|
|
}
|
|
|
|
type Bar0 = pci::Bar<{ Regs::END }>;
|
|
|
|
#[derive(Debug)]
|
|
struct TestIndex(u8);
|
|
|
|
impl TestIndex {
|
|
const NO_EVENTFD: Self = Self(0);
|
|
}
|
|
|
|
struct SampleDriver {
|
|
pdev: ARef<pci::Device>,
|
|
bar: Devres<Bar0>,
|
|
}
|
|
|
|
kernel::pci_device_table!(
|
|
PCI_TABLE,
|
|
MODULE_PCI_TABLE,
|
|
<SampleDriver as pci::Driver>::IdInfo,
|
|
[(
|
|
pci::DeviceId::from_id(bindings::PCI_VENDOR_ID_REDHAT, 0x5),
|
|
TestIndex::NO_EVENTFD
|
|
)]
|
|
);
|
|
|
|
impl SampleDriver {
|
|
fn testdev(index: &TestIndex, bar: &Bar0) -> Result<u32> {
|
|
// Select the test.
|
|
bar.write8(index.0, Regs::TEST);
|
|
|
|
let offset = u32::from_le(bar.read32(Regs::OFFSET)) as usize;
|
|
let data = bar.read8(Regs::DATA);
|
|
|
|
// Write `data` to `offset` to increase `count` by one.
|
|
//
|
|
// Note that we need `try_write8`, since `offset` can't be checked at compile-time.
|
|
bar.try_write8(data, offset)?;
|
|
|
|
Ok(bar.read32(Regs::COUNT))
|
|
}
|
|
}
|
|
|
|
impl pci::Driver for SampleDriver {
|
|
type IdInfo = TestIndex;
|
|
|
|
const ID_TABLE: pci::IdTable<Self::IdInfo> = &PCI_TABLE;
|
|
|
|
fn probe(pdev: &pci::Device<Core>, info: &Self::IdInfo) -> Result<Pin<KBox<Self>>> {
|
|
dev_dbg!(
|
|
pdev.as_ref(),
|
|
"Probe Rust PCI driver sample (PCI ID: 0x{:x}, 0x{:x}).\n",
|
|
pdev.vendor_id(),
|
|
pdev.device_id()
|
|
);
|
|
|
|
pdev.enable_device_mem()?;
|
|
pdev.set_master();
|
|
|
|
let bar = pdev.iomap_region_sized::<{ Regs::END }>(0, c_str!("rust_driver_pci"))?;
|
|
|
|
let drvdata = KBox::new(
|
|
Self {
|
|
pdev: pdev.into(),
|
|
bar,
|
|
},
|
|
GFP_KERNEL,
|
|
)?;
|
|
|
|
let bar = drvdata.bar.try_access().ok_or(ENXIO)?;
|
|
|
|
dev_info!(
|
|
pdev.as_ref(),
|
|
"pci-testdev data-match count: {}\n",
|
|
Self::testdev(info, &bar)?
|
|
);
|
|
|
|
Ok(drvdata.into())
|
|
}
|
|
}
|
|
|
|
impl Drop for SampleDriver {
|
|
fn drop(&mut self) {
|
|
dev_dbg!(self.pdev.as_ref(), "Remove Rust PCI driver sample.\n");
|
|
}
|
|
}
|
|
|
|
kernel::module_pci_driver! {
|
|
type: SampleDriver,
|
|
name: "rust_driver_pci",
|
|
author: "Danilo Krummrich",
|
|
description: "Rust PCI driver",
|
|
license: "GPL v2",
|
|
}
|