[PATCH v2 08/31] gpu: nova-core: add optional ucodes firmware loading

[John Hubbard <jhubbard@nvidia.com>]

The new GSP firmware takes an optional ucodes image, a bindata blob of
microcode that GSP-RM loads at runtime. Open RM fetches it for every
chip family except GB10Y and fails firmware load without it, so the
driver will require it too once it boots the new firmware. The helper
added here reports a missing metadata file rather than failing, and
leaves that policy to its caller.

Load the ucodes metadata with the existing TLV request helper, and give
the TLV parser a method for the payload convention it uses: a FILE
basename together with its SIZE. A FILE tag may only name a basename in
the metadata file's own directory, so one holding a path separator or
naming a special directory is rejected. The GSP firmware image is named
the same way, so both go through the same method. Nothing calls this
until the driver switches to the new firmware.

Assisted-by: Cursor:claude-opus-5
Reviewed-by: Timur Tabi <ttabi@nvidia.com>
Signed-off-by: John Hubbard <jhubbard@nvidia.com>
---
 drivers/gpu/nova-core/firmware.rs         |  8 ++++-
 drivers/gpu/nova-core/firmware/bindata.rs | 39 +++++++++++++++++++++++
 drivers/gpu/nova-core/firmware/gsp.rs     | 14 ++------
 drivers/gpu/nova-core/firmware/tlv.rs     | 37 +++++++++++++++++++++
 4 files changed, 86 insertions(+), 12 deletions(-)
 create mode 100644 drivers/gpu/nova-core/firmware/bindata.rs

diff --git a/drivers/gpu/nova-core/firmware.rs b/drivers/gpu/nova-core/firmware.rs
index 34657004568c..dfd41364cc77 100644
--- a/drivers/gpu/nova-core/firmware.rs
+++ b/drivers/gpu/nova-core/firmware.rs
@@ -22,6 +22,7 @@
     num::IntoSafeCast, //
 };
 
+pub(crate) mod bindata;
 pub(crate) mod booter;
 pub(crate) mod fsp;
 pub(crate) mod fwsec;
@@ -348,7 +349,12 @@ const fn make_entry_chipset(self, chipset: gpu::Chipset) -> Self {
         let mut this = self
             .make_entry_file(name, "gsp_bootloader.tlv")
             .make_entry_file(name, "gsp.tlv")
-            .make_entry_file(name, "gsp.bin");
+            .make_entry_file(name, "gsp.bin")
+            .make_entry_file(name, "ucodes.tlv")
+            // `ucodes.tlv` may name another safe basename in its FILE tag, but module firmware
+            // metadata cannot describe a runtime-selected filename. Advertise the conventional
+            // filename used by the distributed metadata.
+            .make_entry_file(name, "ucodes.bin");
 
         // Add the firmware files specific to the GSP boot method of `chipset`.
         let boot_files = boot_firmware_files(chipset);
diff --git a/drivers/gpu/nova-core/firmware/bindata.rs b/drivers/gpu/nova-core/firmware/bindata.rs
new file mode 100644
index 000000000000..5bc35f8819ea
--- /dev/null
+++ b/drivers/gpu/nova-core/firmware/bindata.rs
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-2.0
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+
+//! GSP bindata firmware loading.
+
+use kernel::{
+    device,
+    prelude::*, //
+};
+
+use crate::{
+    firmware::tlv::{
+        request_tlv,
+        Tlv, //
+    },
+    gpu::Chipset,
+};
+
+/// Requests the optional `ucodes` bindata metadata and loads its payload.
+///
+/// A missing metadata file is reported as [`None`] so that the eventual caller can decide whether
+/// ucodes are optional for its boot path. Once the metadata has been found, all parse and payload
+/// loading errors, including a missing referenced file, are returned as errors.
+#[expect(dead_code)]
+pub(crate) fn request_ucodes_firmware(
+    dev: &device::Device,
+    chipset: Chipset,
+) -> Result<Option<VVec<u8>>> {
+    let firmware = match request_tlv(dev, chipset, "ucodes") {
+        Ok(firmware) => firmware,
+        Err(e) if e == ENOENT => return Ok(None),
+        Err(e) => return Err(e),
+    };
+
+    let tlv = Tlv::new(firmware.data())?;
+    let (_, ucodes) = tlv.load_file(dev, chipset)?;
+
+    Ok(Some(ucodes))
+}
diff --git a/drivers/gpu/nova-core/firmware/gsp.rs b/drivers/gpu/nova-core/firmware/gsp.rs
index 48c73a676ecb..754df6849e43 100644
--- a/drivers/gpu/nova-core/firmware/gsp.rs
+++ b/drivers/gpu/nova-core/firmware/gsp.rs
@@ -6,7 +6,6 @@
         Coherent,
         DmaAddress, //
     },
-    firmware,
     prelude::*,
     str::CString,
 };
@@ -20,8 +19,7 @@
             Tlv,
         },
     },
-    gpu::Chipset,
-    num::FromSafeCast,
+    gpu::Chipset, //
 };
 
 /// GSP firmware with 3-level radix page tables for the GSP bootloader.
@@ -59,19 +57,13 @@ pub(crate) fn new<'a>(
                 fw_version.to_str().unwrap_or("unknown")
             );
 
-            let size = usize::from_safe_cast(tlv.get_u32(b"SIZE")?);
-            let mut fw_vvec = VVec::zeroed(size, GFP_KERNEL).map_err(|_| ENOMEM)?;
-
-            let chip_name = chipset.name();
-            let file = tlv.get_string(b"FILE")?;
-            let filename = CString::try_from_fmt(fmt!("nvidia/{chip_name}/gsp/{file}"))?;
-            firmware::request_into_buf(&filename, dev, fw_vvec.as_mut_slice())?;
+            let (fw_path, fw_vvec) = tlv.load_file(dev, chipset)?;
 
             let signatures = Coherent::from_slice(dev, tlv.get_bytes(b"SIGN")?, GFP_KERNEL)?;
 
             Ok(try_pin_init!(Self {
                 radix3 <- Radix3::new(dev, fw_vvec),
-                fw_path: filename,
+                fw_path,
                 fw_version,
                 signatures,
                 bootloader: {
diff --git a/drivers/gpu/nova-core/firmware/tlv.rs b/drivers/gpu/nova-core/firmware/tlv.rs
index 7b879f13a61e..e4b003f20088 100644
--- a/drivers/gpu/nova-core/firmware/tlv.rs
+++ b/drivers/gpu/nova-core/firmware/tlv.rs
@@ -198,6 +198,43 @@ fn iter(&self) -> TlvIter<'_, 'a> {
         self.iter().find(|b| b.tag == *tag).ok_or(EINVAL)
     }
 
+    /// Loads the file that this TLV references.
+    ///
+    /// A TLV that names its payload rather than carrying it inline holds a `FILE` basename and
+    /// the payload's `SIZE`. The basename is resolved against the metadata file's own directory,
+    /// so an empty name, `.`, `..`, or a name holding a `/` is rejected.
+    ///
+    /// On success, returns the firmware path that was requested and a [`VVec`] holding `SIZE`
+    /// bytes of file contents.
+    ///
+    /// Returns `EINVAL` if either tag is absent or the basename is rejected, and `ENODATA` if
+    /// `SIZE` is zero.
+    pub(crate) fn load_file(
+        &self,
+        dev: &device::Device,
+        chipset: gpu::Chipset,
+    ) -> Result<(CString, VVec<u8>)> {
+        let file = self.get_string(b"FILE")?;
+
+        // FILE is a basename relative to the TLV's directory, not an arbitrary firmware path.
+        if file.is_empty() || matches!(file, "." | "..") || file.contains('/') {
+            return Err(EINVAL);
+        }
+
+        let chip_name = chipset.name();
+        let path = CString::try_from_fmt(fmt!("nvidia/{chip_name}/gsp/{file}"))?;
+
+        let size = usize::from_safe_cast(self.get_u32(b"SIZE")?);
+        if size == 0 {
+            return Err(ENODATA);
+        }
+
+        let mut data = VVec::zeroed(size, GFP_KERNEL).map_err(|_| ENOMEM)?;
+        firmware::request_into_buf(&path, dev, data.as_mut_slice())?;
+
+        Ok((path, data))
+    }
+
     /// Return a slice of bytes.
     ///
     /// Returns `EINVAL` if the value is empty.
-- 
2.55.0