[PATCH] rust: drm: tyr: use read_poll_timeout

[PATCH] rust: drm: tyr: use read_poll_timeout

[Deborah Brouwer]

The L2 power-on sequence and soft reset in Tyr previously relied on fixed
sleeps followed by a single register check, since polling helpers were not
available in Rust at the time.

Now that read_poll_timeout() is available, poll the relevant registers
until the hardware reports readiness or a timeout is reached.

This avoids unnecessary delays on start-up.

Signed-off-by: Deborah Brouwer <deborah.brouwer@collabora.com>
---
 drivers/gpu/drm/tyr/driver.rs | 18 +++++++++---------
 drivers/gpu/drm/tyr/gpu.rs    | 16 +++++++++-------
 2 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/drivers/gpu/drm/tyr/driver.rs b/drivers/gpu/drm/tyr/driver.rs
index f0da58932702..60d01e3f101b 100644
--- a/drivers/gpu/drm/tyr/driver.rs
+++ b/drivers/gpu/drm/tyr/driver.rs
@@ -8,6 +8,7 @@
 use kernel::devres::Devres;
 use kernel::drm;
 use kernel::drm::ioctl;
+use kernel::io::poll;
 use kernel::new_mutex;
 use kernel::of;
 use kernel::platform;
@@ -67,19 +68,18 @@ unsafe impl Sync for TyrData {}
 fn issue_soft_reset(dev: &Device<Bound>, iomem: &Devres<IoMem>) -> Result {
     regs::GPU_CMD.write(dev, iomem, regs::GPU_CMD_SOFT_RESET)?;
 
-    // TODO: We cannot poll, as there is no support in Rust currently, so we
-    // sleep. Change this when read_poll_timeout() is implemented in Rust.
-    kernel::time::delay::fsleep(time::Delta::from_millis(100));
-
-    if regs::GPU_IRQ_RAWSTAT.read(dev, iomem)? & regs::GPU_IRQ_RAWSTAT_RESET_COMPLETED == 0 {
-        dev_err!(dev, "GPU reset failed with errno\n");
+    if let Err(e) = poll::read_poll_timeout(
+        || regs::GPU_IRQ_RAWSTAT.read(dev, iomem),
+        |status| *status & regs::GPU_IRQ_RAWSTAT_RESET_COMPLETED != 0,
+        time::Delta::from_millis(1),
+        time::Delta::from_millis(100),
+    ) {
         dev_err!(
             dev,
-            "GPU_INT_RAWSTAT is {}\n",
+            "GPU reset failed, GPU_IRQ_RAWSTAT is {}\n",
             regs::GPU_IRQ_RAWSTAT.read(dev, iomem)?
         );
-
-        return Err(EIO);
+        return Err(e);
     }
 
     Ok(())
diff --git a/drivers/gpu/drm/tyr/gpu.rs b/drivers/gpu/drm/tyr/gpu.rs
index 6c582910dd5d..2ec56f763cc6 100644
--- a/drivers/gpu/drm/tyr/gpu.rs
+++ b/drivers/gpu/drm/tyr/gpu.rs
@@ -4,9 +4,10 @@
 use kernel::device::Bound;
 use kernel::device::Device;
 use kernel::devres::Devres;
+use kernel::io::poll;
 use kernel::platform;
 use kernel::prelude::*;
-use kernel::time;
+use kernel::time::Delta;
 use kernel::transmute::AsBytes;
 
 use crate::driver::IoMem;
@@ -206,13 +207,14 @@ fn from(value: u32) -> Self {
 pub(crate) fn l2_power_on(dev: &Device<Bound>, iomem: &Devres<IoMem>) -> Result {
     regs::L2_PWRON_LO.write(dev, iomem, 1)?;
 
-    // TODO: We cannot poll, as there is no support in Rust currently, so we
-    // sleep. Change this when read_poll_timeout() is implemented in Rust.
-    kernel::time::delay::fsleep(time::Delta::from_millis(100));
-
-    if regs::L2_READY_LO.read(dev, iomem)? != 1 {
+    if let Err(e) = poll::read_poll_timeout(
+        || regs::L2_READY_LO.read(dev, iomem),
+        |status| *status == 1,
+        Delta::from_millis(1),
+        Delta::from_millis(100),
+    ) {
         dev_err!(dev, "Failed to power on the GPU\n");
-        return Err(EIO);
+        return Err(e);
     }
 
     Ok(())
-- 
2.52.0

Re: [PATCH] rust: drm: tyr: use read_poll_timeout

[Alice Ryhl]

On Thu, Jan 15, 2026 at 10:24 PM Deborah Brouwer
<deborah.brouwer@collabora.com> wrote:
>
> The L2 power-on sequence and soft reset in Tyr previously relied on fixed
> sleeps followed by a single register check, since polling helpers were not
> available in Rust at the time.
>
> Now that read_poll_timeout() is available, poll the relevant registers
> until the hardware reports readiness or a timeout is reached.
>
> This avoids unnecessary delays on start-up.
>
> Signed-off-by: Deborah Brouwer <deborah.brouwer@collabora.com>

Reviewed-by: Alice Ryhl <aliceryhl@google.com>

Re: [PATCH] rust: drm: tyr: use read_poll_timeout

[Gary Guo]

On Thu Jan 15, 2026 at 9:23 PM GMT, Deborah Brouwer wrote:
> The L2 power-on sequence and soft reset in Tyr previously relied on fixed
> sleeps followed by a single register check, since polling helpers were not
> available in Rust at the time.
>
> Now that read_poll_timeout() is available, poll the relevant registers
> until the hardware reports readiness or a timeout is reached.
>
> This avoids unnecessary delays on start-up.
>
> Signed-off-by: Deborah Brouwer <deborah.brouwer@collabora.com>
> ---
>  drivers/gpu/drm/tyr/driver.rs | 18 +++++++++---------
>  drivers/gpu/drm/tyr/gpu.rs    | 16 +++++++++-------
>  2 files changed, 18 insertions(+), 16 deletions(-)
>
> diff --git a/drivers/gpu/drm/tyr/driver.rs b/drivers/gpu/drm/tyr/driver.rs
> index f0da58932702..60d01e3f101b 100644
> --- a/drivers/gpu/drm/tyr/driver.rs
> +++ b/drivers/gpu/drm/tyr/driver.rs
> @@ -8,6 +8,7 @@
>  use kernel::devres::Devres;
>  use kernel::drm;
>  use kernel::drm::ioctl;
> +use kernel::io::poll;
>  use kernel::new_mutex;
>  use kernel::of;
>  use kernel::platform;
> @@ -67,19 +68,18 @@ unsafe impl Sync for TyrData {}
>  fn issue_soft_reset(dev: &Device<Bound>, iomem: &Devres<IoMem>) -> Result {
>      regs::GPU_CMD.write(dev, iomem, regs::GPU_CMD_SOFT_RESET)?;
>  
> -    // TODO: We cannot poll, as there is no support in Rust currently, so we
> -    // sleep. Change this when read_poll_timeout() is implemented in Rust.
> -    kernel::time::delay::fsleep(time::Delta::from_millis(100));
> -
> -    if regs::GPU_IRQ_RAWSTAT.read(dev, iomem)? & regs::GPU_IRQ_RAWSTAT_RESET_COMPLETED == 0 {
> -        dev_err!(dev, "GPU reset failed with errno\n");
> +    if let Err(e) = poll::read_poll_timeout(
> +        || regs::GPU_IRQ_RAWSTAT.read(dev, iomem),
> +        |status| *status & regs::GPU_IRQ_RAWSTAT_RESET_COMPLETED != 0,
> +        time::Delta::from_millis(1),
> +        time::Delta::from_millis(100),
> +    ) {
>          dev_err!(
>              dev,
> -            "GPU_INT_RAWSTAT is {}\n",
> +            "GPU reset failed, GPU_IRQ_RAWSTAT is {}\n",
>              regs::GPU_IRQ_RAWSTAT.read(dev, iomem)?
>          );
> -
> -        return Err(EIO);
> +        return Err(e);
>      }
>  
>      Ok(())
> diff --git a/drivers/gpu/drm/tyr/gpu.rs b/drivers/gpu/drm/tyr/gpu.rs
> index 6c582910dd5d..2ec56f763cc6 100644
> --- a/drivers/gpu/drm/tyr/gpu.rs
> +++ b/drivers/gpu/drm/tyr/gpu.rs
> @@ -4,9 +4,10 @@
>  use kernel::device::Bound;
>  use kernel::device::Device;
>  use kernel::devres::Devres;
> +use kernel::io::poll;
>  use kernel::platform;
>  use kernel::prelude::*;
> -use kernel::time;
> +use kernel::time::Delta;
>  use kernel::transmute::AsBytes;
>  
>  use crate::driver::IoMem;
> @@ -206,13 +207,14 @@ fn from(value: u32) -> Self {
>  pub(crate) fn l2_power_on(dev: &Device<Bound>, iomem: &Devres<IoMem>) -> Result {
>      regs::L2_PWRON_LO.write(dev, iomem, 1)?;
>  
> -    // TODO: We cannot poll, as there is no support in Rust currently, so we
> -    // sleep. Change this when read_poll_timeout() is implemented in Rust.
> -    kernel::time::delay::fsleep(time::Delta::from_millis(100));
> -
> -    if regs::L2_READY_LO.read(dev, iomem)? != 1 {
> +    if let Err(e) = poll::read_poll_timeout(
> +        || regs::L2_READY_LO.read(dev, iomem),
> +        |status| *status == 1,
> +        Delta::from_millis(1),
> +        Delta::from_millis(100),
> +    ) {

This can be

    poll::read_poll_timeout(...).inspect_err(|_| dev_err!(...))?;

Best,
Gary

>          dev_err!(dev, "Failed to power on the GPU\n");
> -        return Err(EIO);
> +        return Err(e);
>      }
>  
>      Ok(())