mirror of
https://github.com/torvalds/linux.git
synced 2025-10-31 00:28:52 +02:00
1b8ac37677
Change Device::vendor_id() to return a Vendor type, and change DeviceId::from_id() to accept a Vendor type. Use the new pci::Vendor in the various Rust for Linux callers who were previously using bindings::PCI_VENDOR_ID_*. Doing so also allows removing "use kernel::bindings" entirely from most of the affected files here. Also, mark vendor_id() as inline. Cc: Danilo Krummrich <dakr@kernel.org> Cc: Elle Rhumsaa <elle@weathered-steel.dev> Reviewed-by: Alexandre Courbot <acourbot@nvidia.com> Signed-off-by: John Hubbard <jhubbard@nvidia.com> Link: https://lore.kernel.org/r/20250829223632.144030-6-jhubbard@nvidia.com [ Replace "as a validated vendor" with "as [`Vendor`]". - Danilo ] Signed-off-by: Danilo Krummrich <dakr@kernel.org>
117 lines
3.1 KiB
Rust
117 lines
3.1 KiB
Rust
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
//! Rust auxiliary driver sample (based on a PCI driver for QEMU's `pci-testdev`).
|
|
//!
|
|
//! To make this driver probe, QEMU must be run with `-device pci-testdev`.
|
|
|
|
use kernel::{
|
|
auxiliary, c_str, device::Core, driver, error::Error, pci, prelude::*, InPlaceModule,
|
|
};
|
|
|
|
use pin_init::PinInit;
|
|
|
|
const MODULE_NAME: &CStr = <LocalModule as kernel::ModuleMetadata>::NAME;
|
|
const AUXILIARY_NAME: &CStr = c_str!("auxiliary");
|
|
|
|
struct AuxiliaryDriver;
|
|
|
|
kernel::auxiliary_device_table!(
|
|
AUX_TABLE,
|
|
MODULE_AUX_TABLE,
|
|
<AuxiliaryDriver as auxiliary::Driver>::IdInfo,
|
|
[(auxiliary::DeviceId::new(MODULE_NAME, AUXILIARY_NAME), ())]
|
|
);
|
|
|
|
impl auxiliary::Driver for AuxiliaryDriver {
|
|
type IdInfo = ();
|
|
|
|
const ID_TABLE: auxiliary::IdTable<Self::IdInfo> = &AUX_TABLE;
|
|
|
|
fn probe(adev: &auxiliary::Device<Core>, _info: &Self::IdInfo) -> Result<Pin<KBox<Self>>> {
|
|
dev_info!(
|
|
adev.as_ref(),
|
|
"Probing auxiliary driver for auxiliary device with id={}\n",
|
|
adev.id()
|
|
);
|
|
|
|
ParentDriver::connect(adev)?;
|
|
|
|
let this = KBox::new(Self, GFP_KERNEL)?;
|
|
|
|
Ok(this.into())
|
|
}
|
|
}
|
|
|
|
struct ParentDriver {
|
|
_reg: [auxiliary::Registration; 2],
|
|
}
|
|
|
|
kernel::pci_device_table!(
|
|
PCI_TABLE,
|
|
MODULE_PCI_TABLE,
|
|
<ParentDriver as pci::Driver>::IdInfo,
|
|
[(pci::DeviceId::from_id(pci::Vendor::REDHAT, 0x5), ())]
|
|
);
|
|
|
|
impl pci::Driver for ParentDriver {
|
|
type IdInfo = ();
|
|
|
|
const ID_TABLE: pci::IdTable<Self::IdInfo> = &PCI_TABLE;
|
|
|
|
fn probe(pdev: &pci::Device<Core>, _info: &Self::IdInfo) -> Result<Pin<KBox<Self>>> {
|
|
let this = KBox::new(
|
|
Self {
|
|
_reg: [
|
|
auxiliary::Registration::new(pdev.as_ref(), AUXILIARY_NAME, 0, MODULE_NAME)?,
|
|
auxiliary::Registration::new(pdev.as_ref(), AUXILIARY_NAME, 1, MODULE_NAME)?,
|
|
],
|
|
},
|
|
GFP_KERNEL,
|
|
)?;
|
|
|
|
Ok(this.into())
|
|
}
|
|
}
|
|
|
|
impl ParentDriver {
|
|
fn connect(adev: &auxiliary::Device) -> Result<()> {
|
|
let parent = adev.parent().ok_or(EINVAL)?;
|
|
let pdev: &pci::Device = parent.try_into()?;
|
|
|
|
let vendor = pdev.vendor_id();
|
|
dev_info!(
|
|
adev.as_ref(),
|
|
"Connect auxiliary {} with parent: VendorID={}, DeviceID={:#x}\n",
|
|
adev.id(),
|
|
vendor,
|
|
pdev.device_id()
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[pin_data]
|
|
struct SampleModule {
|
|
#[pin]
|
|
_pci_driver: driver::Registration<pci::Adapter<ParentDriver>>,
|
|
#[pin]
|
|
_aux_driver: driver::Registration<auxiliary::Adapter<AuxiliaryDriver>>,
|
|
}
|
|
|
|
impl InPlaceModule for SampleModule {
|
|
fn init(module: &'static kernel::ThisModule) -> impl PinInit<Self, Error> {
|
|
try_pin_init!(Self {
|
|
_pci_driver <- driver::Registration::new(MODULE_NAME, module),
|
|
_aux_driver <- driver::Registration::new(MODULE_NAME, module),
|
|
})
|
|
}
|
|
}
|
|
|
|
module! {
|
|
type: SampleModule,
|
|
name: "rust_driver_auxiliary",
|
|
authors: ["Danilo Krummrich"],
|
|
description: "Rust auxiliary driver",
|
|
license: "GPL v2",
|
|
}
|