* [PATCH 1/2] drm/tyr: move reset work to platform driver data
2026-08-23 10:50 [PATCH 0/2] drm/tyr: unplug the GPU when reset fails Onur Özkan
@ 2026-08-23 10:50 ` Onur Özkan
2026-08-24 17:27 ` Daniel Almeida
2026-08-23 10:50 ` [PATCH 2/2] drm/tyr: unplug the GPU when reset fails Onur Özkan
1 sibling, 1 reply; 6+ messages in thread
From: Onur Özkan @ 2026-08-23 10:50 UTC (permalink / raw)
To: linux-kernel, rust-for-linux, dri-devel
Cc: dakr, aliceryhl, daniel.almeida, airlied, simona, ojeda, boqun,
gary, bjorn3_gh, lossin, a.hindborg, tmgross, Onur Özkan
Move ResetHandle out of DRM registration data and store it as the first
field of platform driver data. This makes platform teardown drain queued
or running reset work before dropping the DRM registration and the
resources it owns.
Signed-off-by: Onur Özkan <work@onurozkan.dev>
---
drivers/gpu/drm/tyr/driver.rs | 172 ++++++++++++++++++++++--------------------
1 file changed, 89 insertions(+), 83 deletions(-)
diff --git a/drivers/gpu/drm/tyr/driver.rs b/drivers/gpu/drm/tyr/driver.rs
index c326192f8af2..92ed0de0b4e4 100644
--- a/drivers/gpu/drm/tyr/driver.rs
+++ b/drivers/gpu/drm/tyr/driver.rs
@@ -51,8 +51,13 @@
#[pin_data(PinnedDrop)]
pub(crate) struct TyrPlatformDriverData<'bound> {
- _device: ARef<TyrDrmDevice>,
+ // `ResetHandle::drop()` drains queued/running works and this must happen
+ // before clocks/regulators are dropped. So keep this field before them to
+ // ensure the correct drop order.
+ #[pin]
+ _reset: reset::ResetHandle<'bound>,
_reg: drm::Registration<'bound, TyrDrmDriver>,
+ _device: ARef<TyrDrmDevice>,
}
/// Resources kept alive by the DRM registration.
@@ -61,12 +66,6 @@ pub(crate) struct TyrDrmRegistrationData<'bound> {
/// Parent platform device.
pub(crate) pdev: &'bound platform::Device<Bound>,
- // `ResetHandle::drop()` drains queued/running works and this must happen
- // before clocks/regulators are dropped. So keep this field before them to
- // ensure the correct drop order.
- #[pin]
- pub(crate) reset: reset::ResetHandle<'bound>,
-
/// Firmware sections.
pub(crate) fw: Arc<Firmware<'bound>>,
@@ -101,82 +100,89 @@ fn probe<'bound>(
pdev: &'bound platform::Device<Core<'_>>,
_info: Option<&'bound Self::IdInfo>,
) -> impl PinInit<Self::Data<'bound>, Error> + 'bound {
- let core_clk = Clk::get(pdev.as_ref(), Some(c"core"))?;
- let stacks_clk = OptionalClk::get(pdev.as_ref(), Some(c"stacks"))?;
- let coregroup_clk = OptionalClk::get(pdev.as_ref(), Some(c"coregroup"))?;
-
- core_clk.prepare_enable()?;
- stacks_clk.prepare_enable()?;
- coregroup_clk.prepare_enable()?;
-
- let mali_regulator = Regulator::<regulator::Enabled>::get(pdev.as_ref(), c"mali")?;
- let sram_regulator = Regulator::<regulator::Enabled>::get(pdev.as_ref(), c"sram")?;
-
- let request = pdev.io_request_by_index(0).ok_or(ENODEV)?;
-
- let hw = Arc::pin_init(
- reset::HwGate::new(request.iomap_sized::<SZ_2M>()?),
- GFP_KERNEL,
- )?;
-
- reset::run_reset(pdev.as_ref(), &hw)?;
-
- let gpu_info = {
- let hw_guard = hw.access();
- let gpu_info = GpuInfo::new(hw_guard.iomem());
- gpu_info.log(pdev.as_ref());
- gpu_info
- };
-
- let pa_bits = MMU_FEATURES::from_raw(gpu_info.mmu_features)
- .pa_bits()
- .get();
- // SAFETY: No concurrent DMA allocations or mappings can be made because
- // the device is still being probed and therefore isn't being used by
- // other threads of execution.
- unsafe { pdev.dma_set_mask_and_coherent(DmaMask::try_new(pa_bits)?)? };
-
- let unreg_dev = drm::UnregisteredDevice::<TyrDrmDriver>::new(pdev, Ok(()))?;
-
- let mmu = Mmu::new(hw.clone(), &gpu_info)?;
-
- let firmware = Firmware::new(pdev, hw.clone(), &unreg_dev, mmu.as_arc_borrow(), &gpu_info)?;
-
- firmware.boot()?;
- firmware.enable_global_interface(&gpu_info, &core_clk)?;
-
- let reg_data = try_pin_init!(TyrDrmRegistrationData {
- pdev,
- // SAFETY: `ResetHandle` is stored in registration data created with `new_with_lt`
- // and is dropped before the borrowed device and MMIO references expire.
- reset <- unsafe { reset::ResetHandle::new(pdev, hw.clone())? },
- fw: firmware,
- clks <- new_mutex!(Clocks {
- core: core_clk,
- stacks: stacks_clk,
- coregroup: coregroup_clk,
- }),
- regulators <- new_mutex!(Regulators {
- _mali: mali_regulator,
- _sram: sram_regulator,
- }),
- gpu_info,
- });
-
- // SAFETY: `reg` is stored in the platform driver data and is not leaked or
- // forgotten, so it is dropped before the `'bound` registration data can become
- // invalid.
- let reg = unsafe { drm::Registration::new_with_lt(pdev.as_ref(), unreg_dev, reg_data, 0)? };
-
- let driver = TyrPlatformDriverData {
- _device: reg.device().into(),
- _reg: reg,
- };
-
- // We need this to be dev_info!() because dev_dbg!() does not work at
- // all in Rust for now, and we need to see whether probe succeeded.
- dev_info!(pdev, "Tyr initialized correctly.\n");
- Ok(driver)
+ pin_init::pin_init_scope(move || {
+ let core_clk = Clk::get(pdev.as_ref(), Some(c"core"))?;
+ let stacks_clk = OptionalClk::get(pdev.as_ref(), Some(c"stacks"))?;
+ let coregroup_clk = OptionalClk::get(pdev.as_ref(), Some(c"coregroup"))?;
+
+ core_clk.prepare_enable()?;
+ stacks_clk.prepare_enable()?;
+ coregroup_clk.prepare_enable()?;
+
+ let mali_regulator = Regulator::<regulator::Enabled>::get(pdev.as_ref(), c"mali")?;
+ let sram_regulator = Regulator::<regulator::Enabled>::get(pdev.as_ref(), c"sram")?;
+
+ let request = pdev.io_request_by_index(0).ok_or(ENODEV)?;
+
+ let hw = Arc::pin_init(
+ reset::HwGate::new(request.iomap_sized::<SZ_2M>()?),
+ GFP_KERNEL,
+ )?;
+
+ reset::run_reset(pdev.as_ref(), &hw)?;
+
+ let gpu_info = {
+ let hw_guard = hw.access();
+ let gpu_info = GpuInfo::new(hw_guard.iomem());
+ gpu_info.log(pdev.as_ref());
+ gpu_info
+ };
+
+ let pa_bits = MMU_FEATURES::from_raw(gpu_info.mmu_features)
+ .pa_bits()
+ .get();
+ // SAFETY: No concurrent DMA allocations or mappings can be made because
+ // the device is still being probed and therefore isn't being used by
+ // other threads of execution.
+ unsafe { pdev.dma_set_mask_and_coherent(DmaMask::try_new(pa_bits)?)? };
+
+ let unreg_dev = drm::UnregisteredDevice::<TyrDrmDriver>::new(pdev, Ok(()))?;
+
+ let mmu = Mmu::new(hw.clone(), &gpu_info)?;
+
+ let firmware =
+ Firmware::new(pdev, hw.clone(), &unreg_dev, mmu.as_arc_borrow(), &gpu_info)?;
+
+ firmware.boot()?;
+ firmware.enable_global_interface(&gpu_info, &core_clk)?;
+
+ let reg_data = try_pin_init!(TyrDrmRegistrationData {
+ pdev,
+ fw: firmware,
+ clks <- new_mutex!(Clocks {
+ core: core_clk,
+ stacks: stacks_clk,
+ coregroup: coregroup_clk,
+ }),
+ regulators <- new_mutex!(Regulators {
+ _mali: mali_regulator,
+ _sram: sram_regulator,
+ }),
+ gpu_info,
+ });
+
+ // SAFETY: `reg` is stored in the platform driver data and is not leaked or
+ // forgotten, so it is dropped before the `'bound` registration data can become
+ // invalid.
+ let reg =
+ unsafe { drm::Registration::new_with_lt(pdev.as_ref(), unreg_dev, reg_data, 0)? };
+ let device = reg.device().into();
+
+ let driver = try_pin_init!(TyrPlatformDriverData {
+ // SAFETY: `ResetHandle` is stored in platform driver data and is
+ // dropped before the borrowed device and MMIO references expire.
+ _reset <- unsafe { reset::ResetHandle::new(pdev, hw)? },
+ _reg: reg,
+ _device: device,
+ _: {
+ // We need this to be dev_info!() because dev_dbg!() does not work at
+ // all in Rust for now, and we need to see whether probe succeeded.
+ dev_info!(pdev, "Tyr initialized correctly.\n");
+ },
+ });
+
+ Ok(driver)
+ })
}
}
--
2.51.2
^ permalink raw reply [flat|nested] 6+ messages in thread* [PATCH 2/2] drm/tyr: unplug the GPU when reset fails
2026-08-23 10:50 [PATCH 0/2] drm/tyr: unplug the GPU when reset fails Onur Özkan
2026-08-23 10:50 ` [PATCH 1/2] drm/tyr: move reset work to platform driver data Onur Özkan
@ 2026-08-23 10:50 ` Onur Özkan
2026-08-26 14:05 ` Daniel Almeida
1 sibling, 1 reply; 6+ messages in thread
From: Onur Özkan @ 2026-08-23 10:50 UTC (permalink / raw)
To: linux-kernel, rust-for-linux, dri-devel
Cc: dakr, aliceryhl, daniel.almeida, airlied, simona, ojeda, boqun,
gary, bjorn3_gh, lossin, a.hindborg, tmgross, Onur Özkan
Wrap the DRM registration in Arc<Revocable<_>> and share it with the
reset controller. If a reset fails, stop reset scheduling and revoke
the registration. Dropping the registration calls drm_dev_unplug()
which prevents new DRM critical sections and waits for existing ones
before the registration data is released.
Signed-off-by: Onur Özkan <work@onurozkan.dev>
---
drivers/gpu/drm/tyr/driver.rs | 12 +++++++-----
drivers/gpu/drm/tyr/reset.rs | 32 +++++++++++++++++++++-----------
2 files changed, 28 insertions(+), 16 deletions(-)
diff --git a/drivers/gpu/drm/tyr/driver.rs b/drivers/gpu/drm/tyr/driver.rs
index 92ed0de0b4e4..03ad00a89420 100644
--- a/drivers/gpu/drm/tyr/driver.rs
+++ b/drivers/gpu/drm/tyr/driver.rs
@@ -22,6 +22,7 @@
prelude::*,
regulator,
regulator::Regulator,
+ revocable::Revocable,
sizes::SZ_2M,
sync::{
aref::ARef,
@@ -56,7 +57,7 @@ pub(crate) struct TyrPlatformDriverData<'bound> {
// ensure the correct drop order.
#[pin]
_reset: reset::ResetHandle<'bound>,
- _reg: drm::Registration<'bound, TyrDrmDriver>,
+ _reg: Arc<Revocable<drm::Registration<'bound, TyrDrmDriver>>>,
_device: ARef<TyrDrmDevice>,
}
@@ -161,17 +162,18 @@ fn probe<'bound>(
gpu_info,
});
- // SAFETY: `reg` is stored in the platform driver data and is not leaked or
- // forgotten, so it is dropped before the `'bound` registration data can become
- // invalid.
+ // SAFETY: `reg` is wrapped in a `Revocable` owned by the platform driver
+ // data and its reset handle. Neither is leaked or forgotten, so `reg` is
+ // dropped before the `'bound` registration data can become invalid.
let reg =
unsafe { drm::Registration::new_with_lt(pdev.as_ref(), unreg_dev, reg_data, 0)? };
let device = reg.device().into();
+ let reg = Arc::pin_init(Revocable::new(reg), GFP_KERNEL)?;
let driver = try_pin_init!(TyrPlatformDriverData {
// SAFETY: `ResetHandle` is stored in platform driver data and is
// dropped before the borrowed device and MMIO references expire.
- _reset <- unsafe { reset::ResetHandle::new(pdev, hw)? },
+ _reset <- unsafe { reset::ResetHandle::new(pdev, hw, reg.clone())? },
_reg: reg,
_device: device,
_: {
diff --git a/drivers/gpu/drm/tyr/reset.rs b/drivers/gpu/drm/tyr/reset.rs
index 1abcd25877d3..50690daec31a 100644
--- a/drivers/gpu/drm/tyr/reset.rs
+++ b/drivers/gpu/drm/tyr/reset.rs
@@ -28,12 +28,14 @@
Bound,
Device, //
},
+ drm,
io::{
poll,
Io, //
},
platform,
prelude::*,
+ revocable::Revocable,
sync::{
atomic::{
Atomic,
@@ -53,7 +55,10 @@
};
use crate::{
- driver::IoMem,
+ driver::{
+ IoMem,
+ TyrDrmDriver, //
+ },
gpu,
regs::gpu_control::*, //
};
@@ -87,6 +92,8 @@ struct Controller<'ctrl> {
state: Atomic<ResetState>,
/// Shared gate that coordinates hardware access with GPU reset.
hw: Arc<HwGate<'ctrl>>,
+ /// DRM registration revoked when a reset fails.
+ registration: Arc<Revocable<drm::Registration<'ctrl, TyrDrmDriver>>>,
}
impl<'ctrl> ScopedWorkItem for Controller<'ctrl> {
@@ -100,11 +107,13 @@ impl<'ctrl> Controller<'ctrl> {
fn new(
pdev: &'ctrl platform::Device<Bound>,
hw: Arc<HwGate<'ctrl>>,
+ registration: Arc<Revocable<drm::Registration<'ctrl, TyrDrmDriver>>>,
) -> impl PinInit<Self, Error> {
try_pin_init!(Self {
pdev,
state: Atomic::new(ResetState::Idle),
hw,
+ registration,
})
}
@@ -119,8 +128,8 @@ fn try_transition(&self, from: ResetState, to: ResetState) -> bool {
/// If the pending reset cannot be claimed, the worker returns immediately.
///
/// It first claims [`ResetState::Pending`], then waits for earlier hardware
- /// accesses to complete before issuing the reset and returning the worker
- /// state to [`ResetState::Idle`].
+ /// accesses to complete before issuing the reset. A successful reset returns
+ /// the worker state to [`ResetState::Idle`]; a failure unplugs the DRM device.
///
/// Panthor reference:
/// - drivers/gpu/drm/panthor/panthor_device.c::panthor_device_reset_work()
@@ -134,16 +143,13 @@ fn reset_work(&self) {
let reset_result = run_reset(self.pdev.as_ref(), &self.hw);
if let Err(e) = reset_result {
- dev_err!(self.pdev, "GPU reset failed: {:?}\n", e);
-
- // TODO: Unplug the GPU.
- // There is no API for unplugging the GPU and this is unreachable
- // for now since there are no hardware users for reset API.
+ dev_err!(self.pdev, "GPU reset failed, unplugging the GPU: {:?}\n", e);
+ let _ = self.try_transition(ResetState::InProgress, ResetState::ShuttingDown);
+ self.registration.revoke();
} else {
dev_dbg!(self.pdev, "GPU reset completed.\n");
+ let _ = self.try_transition(ResetState::InProgress, ResetState::Idle);
}
-
- let _ = self.try_transition(ResetState::InProgress, ResetState::Idle);
}
}
@@ -168,9 +174,13 @@ impl<'reset> ResetHandle<'reset> {
pub(crate) unsafe fn new(
pdev: &'reset platform::Device<Bound>,
hw: Arc<HwGate<'reset>>,
+ registration: Arc<Revocable<drm::Registration<'reset, TyrDrmDriver>>>,
) -> Result<impl PinInit<Self, Error>> {
Ok(try_pin_init!(Self {
- controller <- kernel::new_scoped_work!("tyr::reset", Controller::new(pdev, hw)),
+ controller <- kernel::new_scoped_work!(
+ "tyr::reset",
+ Controller::new(pdev, hw, registration)
+ ),
// SAFETY: The caller guarantees the handle is dropped.
wq: unsafe { ScopedQueue::new(c"tyr-reset-wq")? },
}))
--
2.51.2
^ permalink raw reply [flat|nested] 6+ messages in thread