Nouveau - Sep 2025 - [PATCH v5 02/12] gpu: nova-core: move GSP boot code to a dedicated method

Right now the GSP boot code is very incomplete and limited to running
FRTS, so having it in `Gpu::new` is not a big constraint.

However, this will change as we add more steps of the GSP boot process,
and not all GPU families follow the same procedure, so having these
steps in a dedicated method is the logical construct.

Relatedly, booting the GSP typically happens only once in the GPU reset
cycle. Most of the data created to complete this step (notably firmware
loaded from user-space) is needed only temporarily and can be discarded
once the GSP is booted; it then makes all the more sense to store these
as local variables of a dedicated method, instead of inside the `Gpu`
structure where they are kept as long as the GPU is bound, using dozens
of megabytes of host memory.

Thus, introduce a `start_gsp` static method on the `Gpu` struct, which
is called by `Gpu::new` to initialize the GSP and obtain its runtime
data. The GSP runtime data is currently an empty placeholder, but this
will change in a subsequent patch.

Signed-off-by: Alexandre Courbot <acourbot at nvidia.com>
---
 drivers/gpu/nova-core/gpu.rs | 43 +++++++++++++++++++++++++++++++++----------
 1 file changed, 33 insertions(+), 10 deletions(-)

diff --git a/drivers/gpu/nova-core/gpu.rs b/drivers/gpu/nova-core/gpu.rs
index
a0878ecdc18bc9e9d975b9ab9c85dd7ab9c3d995..c8f876698b2e5da1d4250af377163a3f07a5ded0
100644
--- a/drivers/gpu/nova-core/gpu.rs
+++ b/drivers/gpu/nova-core/gpu.rs
@@ -172,14 +172,13 @@ pub(crate) struct Gpu {
     /// System memory page required for flushing all pending GPU-side memory
writes done through
     /// PCIE into system memory, via sysmembar (A GPU-initiated HW
memory-barrier operation).
     sysmem_flush: SysmemFlush,
+    /// GSP runtime data - temporarily a empty placeholder.
+    gsp: (),
 }
 
 impl Gpu {
     /// Helper function to load and run the FWSEC-FRTS firmware and confirm
that it has properly
     /// created the WPR2 region.
-    ///
-    /// TODO: this needs to be moved into a larger type responsible for booting
the whole GSP
-    /// (`GspBooter`?).
     fn run_fwsec_frts(
         dev: &device::Device<device::Bound>,
         falcon: &Falcon<Gsp>,
@@ -254,6 +253,33 @@ fn run_fwsec_frts(
         }
     }
 
+    /// Attempt to start the GSP.
+    ///
+    /// This is a GPU-dependent and complex procedure that involves loading
firmware files from
+    /// user-space, patching them with signatures, and building
firmware-specific intricate data
+    /// structures that the GSP will use at runtime.
+    ///
+    /// Upon return, the GSP is up and running, and its runtime object given as
return value.
+    pub(crate) fn start_gsp(
+        pdev: &pci::Device<device::Bound>,
+        bar: &Bar0,
+        chipset: Chipset,
+        gsp_falcon: &Falcon<Gsp>,
+        _sec2_falcon: &Falcon<Sec2>,
+    ) -> Result<()> {
+        let dev = pdev.as_ref();
+
+        let bios = Vbios::new(dev, bar)?;
+
+        let fb_layout = FbLayout::new(chipset, bar)?;
+        dev_dbg!(dev, "{:#x?}\n", fb_layout);
+
+        Self::run_fwsec_frts(dev, gsp_falcon, bar, &bios, &fb_layout)?;
+
+        // Return an empty placeholder for now, to be replaced with the GSP
runtime data.
+        Ok(())
+    }
+
     pub(crate) fn new(
         pdev: &pci::Device<device::Bound>,
         devres_bar: Arc<Devres<Bar0>>,
@@ -284,20 +310,17 @@ pub(crate) fn new(
         )?;
         gsp_falcon.clear_swgen0_intr(bar);
 
-        let _sec2_falcon = Falcon::<Sec2>::new(pdev.as_ref(),
spec.chipset, bar, true)?;
+        let sec2_falcon = Falcon::<Sec2>::new(pdev.as_ref(),
spec.chipset, bar, true)?;
 
-        let fb_layout = FbLayout::new(spec.chipset, bar)?;
-        dev_dbg!(pdev.as_ref(), "{:#x?}\n", fb_layout);
-
-        let bios = Vbios::new(pdev.as_ref(), bar)?;
-
-        Self::run_fwsec_frts(pdev.as_ref(), &gsp_falcon, bar, &bios,
&fb_layout)?;
+        #[allow(clippy::let_unit_value)]
+        let gsp = Self::start_gsp(pdev, bar, spec.chipset, &gsp_falcon,
&sec2_falcon)?;
 
         Ok(pin_init!(Self {
             spec,
             bar: devres_bar,
             fw,
             sysmem_flush,
+            gsp,
         }))
     }
 

-- 
2.51.0

On 9/11/25 1:04 PM, Alexandre Courbot wrote:
> +    /// Attempt to start the GSP.
> +    ///
> +    /// This is a GPU-dependent and complex procedure that involves
loading firmware files from
> +    /// user-space, patching them with signatures, and building
firmware-specific intricate data
> +    /// structures that the GSP will use at runtime.
> +    ///
> +    /// Upon return, the GSP is up and running, and its runtime object
given as return value.
> +    pub(crate) fn start_gsp(
> +        pdev: &pci::Device<device::Bound>,
> +        bar: &Bar0,
> +        chipset: Chipset,
> +        gsp_falcon: &Falcon<Gsp>,
> +        _sec2_falcon: &Falcon<Sec2>,
> +    ) -> Result<()> {> +        let dev = pdev.as_ref();
> +
> +        let bios = Vbios::new(dev, bar)?;
> +
> +        let fb_layout = FbLayout::new(chipset, bar)?;
> +        dev_dbg!(dev, "{:#x?}\n", fb_layout);
> +
> +        Self::run_fwsec_frts(dev, gsp_falcon, bar, &bios,
&fb_layout)?;
> +
> +        // Return an empty placeholder for now, to be replaced with the
GSP runtime data.
> +        Ok(())
> +    }
I'd rather create the Gsp structure already, move the code to Gsp::new() and
return an impl PinInit<Self, Error>. If you don't want to store any of
the
object instances you create above yet, you can just stuff all the code into an
initializer code block, as you do in the next patch with
gfw::wait_gfw_boot_completion().