Transition Nova Core to TLV firmware images
Subsystems (11)
v7 cover Transition Nova Core to TLV firmware images
This patch set transitions nova-core to use the new "TLV" firmware image files, instead of the ones that Nouveau uses.
A prerequisite patch "rust: error: add remaining error codes" is required to compile. [1]
The current r570.144 images are a mix of binary headers and ELF files that are cumbersome to parse in Rust. There's a significant amount of code that just reads in a struct, extracts some offset, and uses it to find another struct, only to have nova-core use just a few fields.
The new format uses a sequence of tag/length/value fields that can be iterated over. The script that generates the TLV files, extract-firmware-nova.py, does the extra work to find the specific metadata needed by Nova and packages each one separately.
The TLV versions of r570.144 can be found here:
https://github.com/ttabi/linux-firmware-nova
along with instructions on how to install them. We are not planning on submitting these images to linux-firmware. Rather, if this patchset is accepted upstream, I expect the small handful of people who are actually working on Nova to grab and install these images, which needs to be done only once.
There are still opportunities for improvement. For example, I would like to get rid of more GPU-specific code, especially the GA100 quirks.
Note that there are plans to relocate these images into a different /lib/firmware subdirectory, to further isolate them from the images that Nouveau uses.
[1] https://lore.kernel.org/rust-for-linux/[email protected]/
v7:
1) Removed errant os_code_offset change in booter
2) Removed stray assert! in gsp.rs
3) Fixed tlv.rst (three -> four)
Timur Tabi (8):
rust: alloc: add Vec::zeroed method
rust: firmware: add request_into_buf()
gpu: nova-core: add TLV parser for firmware files
gpu: nova-core: transition booter to TLV images
gpu: nova-core: transition gsp to TLV images
gpu: nova-core: transition gen_bootloader to TLV images
gpu: nova-core: transition fsp to TLV images
gpu: nova-core: update firmware module info for TLV images
Documentation/gpu/nova/core/tlv.rst | 184 ++++++++++ Documentation/gpu/nova/index.rst | 1 + drivers/gpu/nova-core/firmware.rs | 295 +--------------- drivers/gpu/nova-core/firmware/booter.rs | 329 +++--------------- drivers/gpu/nova-core/firmware/fsp.rs | 88 +++-- .../nova-core/firmware/fwsec/bootloader.rs | 75 +--- drivers/gpu/nova-core/firmware/gsp.rs | 59 +--- drivers/gpu/nova-core/firmware/riscv.rs | 75 +--- drivers/gpu/nova-core/firmware/tlv.rs | 265 ++++++++++++++ drivers/gpu/nova-core/fsp.rs | 11 +- drivers/gpu/nova-core/gsp/boot.rs | 7 +- drivers/gpu/nova-core/gsp/hal.rs | 8 +- drivers/gpu/nova-core/gsp/hal/tu102.rs | 13 +- rust/kernel/alloc/kvec.rs | 27 ++ rust/kernel/firmware.rs | 48 ++- 15 files changed, 697 insertions(+), 788 deletions(-) create mode 100644 Documentation/gpu/nova/core/tlv.rst create mode 100644 drivers/gpu/nova-core/firmware/tlv.rs
base-commit: 44e7e7f7cffb10a93bb88e7cb59b7b8b3e2deb1c
prerequisite-patch-id: 92c2d027299f0bc35d20918668f6874712d12f28
Signature · 1 line
2.54.0
PATCH v7 1/8 rust: alloc: add Vec::zeroed method
Add a constructor for kernel Vec that allocates a vector of a given length with all elements zero-initialized. Memory is allocated with the __GFP_ZERO flag, matching the existing KBox::zeroed() pattern.
--- rust/kernel/alloc/kvec.rs | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+)
rust/kernel/alloc/kvec.rs +27 -0
@@ -9,6 +9,7 @@ Vmalloc, VmallocPageIter, // }, + flags::__GFP_ZERO, layout::ArrayLayout, AllocError, Allocator,
@@ -51,6 +52,8 @@ }, // }; +use pin_init::Zeroable ; +mod errors;pub use self::errors::{InsertError ,PushError ,RemoveError };
@@ -532,6 +535,30 @@ pub fn with_capacity(capacity: usize, flags: Flags) -> Result<Self, AllocError>Ok (v) } +/// Creates a new [`Vec`] with `n` zero-initialized elements. +/// +/// # Examples +/// +/// ``` +/// let v = KVec::<u32>::zeroed(20, GFP_KERNEL)?; +/// +/// assert!(v.iter().all(|&x| x == 0)); +/// # Ok::<(), Error>(()) +/// ``` +pub fn zeroed (n:usize , flags:Flags ) ->Result <Self ,AllocError > +where +T :Zeroable , + { +let mut v =Self ::with_capacity (n, flags | __GFP_ZERO)?; + +// SAFETY: +// - `n <= capacity - len`: `with_capacity(n)` guarantees capacity >= n, len is 0. +// - All elements in `[0, n)` are initialized: `__GFP_ZERO` zeroes the allocation, +// and `T: Zeroable` guarantees all-zeroes is a valid bit pattern. +unsafe { v.inc_len (n) }; +Ok (v) + } +/// Creates a `Vec<T, A>` from a pointer, a length and a capacity using the allocator `A`. /// /// # Examples
Signature · 1 line
2.54.0
Danilo Krummrich
maintainerRe: [PATCH v7 1/8] rust: alloc: add Vec::zeroed method
Quoted 6 lines · Timur Tabi
Add a constructor for kernel Vec that allocates a vector of a given length with all elements zero-initialized. Memory is allocated with the
__GFP_ZEROflag, matching the existingKBox::zeroed()pattern.Signed-off-by Timur Tabi <[email protected]>Reviewed-by Alexandre Courbot <[email protected]>
Since I provided the code for this patch:
PATCH v7 2/8 rust: firmware: add request_into_buf()
In reply to Timur TabiAdd request_into_buf(), a Rust wrapper around the request_firmware_into_buf() function. This variant loads the firmware image directly into a caller-provided buffer rather than a kernel-allocated one.
--- rust/kernel/firmware.rs | 48 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 46 insertions(+), 2 deletions(-)
rust/kernel/firmware.rs +46 -2
@@ -7,9 +7,9 @@use crate ::{ bindings, device::Device , - error::Error , - error::Result , + error::to_result, ffi, + prelude::*, str::{CStr ,CStrExt as _}, };use core::ptr::NonNull ;
@@ -120,6 +120,50 @@ fn drop(&mut self) { } } +/// Load firmware directly into the caller-provided `buf`. +/// +/// On success the firmware image has been copied into `buf`; the caller accesses the data +/// through `buf` itself. +/// +/// This is intentionally a stand-alone function rather than a `Firmware` constructor. For +/// the `into_buf` path, the firmware data lives in the caller's `buf`, not in a +/// kernel-owned buffer, so returning a `Firmware` would expose `Firmware::data()` as a +/// second handle aliasing `buf` (and `release_firmware()` does not free `buf` anyway). +pub fn request_into_buf (name: &CStr , dev: &Device , buf: &mut [u8 ]) ->Result { +// `as_mut_ptr()` on an empty slice returns a non-NULL pointer to +// memory which the loader does not own. Passing that pointer with `size == 0` +// makes the loader believe that it is buffer it allocated itself, so when +// `release_firmware()` is called, it will vfree the pointer and trigger a +// bug. Reject empty slices to avoid this situation. +if buf.is_empty () { +return Err (EINVAL ); + } + +let mut fw: *mut bindings::firmware = core::ptr::null_mut (); +let pfw: *mut *mut bindings::firmware = &mut fw; +let pfw: *mut *const bindings::firmware = pfw.cast (); + +// SAFETY: `pfw` is a valid pointer to a NULL initialized `bindings::firmware` pointer. +// `name` and `dev` are valid as by their type invariants. `buf` is a valid writable +// buffer of `buf.len()` bytes. +to_result (unsafe { + bindings::request_firmware_into_buf ( + pfw, + name.as_char_ptr (), + dev.as_raw (), + buf.as_mut_ptr ().cast (), + buf.len (), + ) + })?; + +// The firmware bytes are now in `buf`, which the caller owns, so we don't need +// the kernel to hang on to it any more. +// SAFETY: `fw` is a valid pointer returned by `request_firmware_into_buf`. +unsafe { bindings::release_firmware (fw) }; + +Ok (()) +} +// SAFETY: `Firmware` only holds a pointer to a C `struct firmware`, which is safe to be used from // any thread. unsafe impl Send for Firmware {}
Signature · 1 line
2.54.0
A message that is not in the archive (sent off-list or not yet received): [email protected]
Alexandre Courbot
maintainerRe: [PATCH v7 2/8] rust: firmware: add request_into_buf()
Quoted 43 lines · sashiko-bot
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [High]request_into_bufdiscards the actual size of the loaded firmware, exposing the caller to trailing uninitialized or stale data.
- [Low] The wrapper unnecessarily casts a mutable pointer to a const pointer, which is unidiomatic and confusing. ----- Patch [2]: [PATCH v7 2/8] rust: firmware: add
request_into_buf()--- commite3d518ea065bd3aeb4a38939d026df9eef8651b7
Author: Timur Tabi <[email protected]>rust: firmware: add
request_into_buf()Add
request_into_buf(), a Rust wrapper around therequest_firmware_into_buf()function. This variant loads the firmware image directly into a caller-provided buffer rather than a kernel-allocated one.Quoted 4 lines
rust/kernel/firmware.rs +0
-0[ ... ]
Quoted 14 lines
rust/kernel/firmware.rs +10
-0@@ -116,6 +116,50 @@ fn drop(&mut self) { } } +/// Load firmware directly into the caller-provided `buf`. +/// +/// On success the firmware image has been copied into `buf`; the caller accesses the data +/// through `buf` itself. +/// +/// This is intentionally a stand-alone function rather than a `Firmware` constructor. For +/// the `into_buf` path, the firmware data lives in the caller's `buf`, not in a +/// kernel-owned buffer, so returning a `Firmware` would expose `Firmware::data()` as a +/// second handle aliasing `buf` (and `release_firmware()` does not free `buf` anyway). +pub fn request_into_buf (name: &CStr , dev: &Device , buf: &mut [u8 ]) ->Result {[ ... ]
rust/kernel/firmware.rs
Quoted 3 lines
rust/kernel/firmware.rs +3
-0+let mut fw: *mut bindings::firmware = core::ptr::null_mut (); +let pfw: *mut *mut bindings::firmware = &mut fw; +let pfw: *mut *const bindings::firmware = pfw.cast ();
Quoted 7 lines
[Severity: Low]
This isn't a bug, but is it necessary to declare a mutable pointer and then cast it to a pointer-to-const?The FFI function expects a *mut *const
bindings::firmware. Declaring let mut fw: *constbindings::firmware=core::ptr::null(); would produce the correct *mut *const address naturally, without requiring these casts.
Sashiko is correct here, this can be simplified as follows (on apply if no respin is required?):
rust/kernel/firmware.rs +3 -5
@@ -139,16 +139,14 @@ pub fn request_into_buf(name: &CStr, dev: &Device, buf: &mut [u8]) -> Result {return Err (EINVAL ); } -let mut fw: *mut bindings::firmware = core::ptr::null_mut (); -let pfw: *mut *mut bindings::firmware = &mut fw; -let pfw: *mut *const bindings::firmware = pfw.cast (); +let mut fw: *const bindings::firmware = core::ptr::null (); -// SAFETY: `pfw` is a valid pointer to a NULL initialized `bindings::firmware` pointer. +// SAFETY: `&mut fw` is a valid pointer to a NULL initialized `bindings::firmware` pointer. // `name` and `dev` are valid as by their type invariants. `buf` is a valid writable // buffer of `buf.len()` bytes. to_result (unsafe { bindings::request_firmware_into_buf ( - pfw, + &mut fw, name.as_char_ptr (), dev.as_raw (), buf.as_mut_ptr().cast(),
PATCH v7 3/8 gpu: nova-core: add TLV parser for firmware files
In reply to Timur TabiTLV (type, length, value) files are the new image format used by Nova to encapsulate firmware images and their metadata. Unlike the firmware files for previous versions of the firmware, TLV filenames are not versioned, and they have a .tlv suffix.
Add function request_tlv() to load TLV firmware images.
Add the Tlv struct and supporting types for parsing TLV firmware images. TLV files begin with a 4-byte magic header, which must be "NVFW" for Nvidia firmware files. This is followed by a sequence of blocks each containing a 4-byte ASCII tag, a 4-byte little-endian length, and a payload padded to a 4-byte boundary.
Tlv::new() validates the entire image up front, so that the iterator can subsequently yield blocks without fallible parsing.
Also add accessor methods for the various encoded types that will be used by the driver.
--- Documentation/gpu/nova/core/tlv.rst | 184 ++++++++++++++++++ Documentation/gpu/nova/index.rst | 1 + drivers/gpu/nova-core/firmware.rs | 1 + drivers/gpu/nova-core/firmware/tlv.rs | 267 ++++++++++++++++++++++++++ 4 files changed, 453 insertions(+) create mode 100644 Documentation/gpu/nova/core/tlv.rst create mode 100644 drivers/gpu/nova-core/firmware/tlv.rs
Documentation/gpu/nova/core/tlv.rst new file +184 -0
@@ -0,0 +1,184 @@ +.. SPDX-License-Identifier: (GPL-2.0+ OR MIT) + +================================== +TLV Tags in Nova Firmware Images +================================== + +Nova firmware images use a Type-Length-Value (TLV) format to encapsulate +firmware components and metadata. The TLV file begins with a 4-byte "magic" +header that contains the string "NVFW". Following the header is a sequence of +TLV blocks. + +Each block consists of a 4-byte tag of ASCII characters, a 4-byte length +encoded as a little-endian unsigned integer, and a sequence of bytes, the size +of which is equal to the length rounded up to the next multiple of 4. + +The driver code that reads the TLV and uses its contents is called the parser. +It is the responsibility of the parser to handle missing or malformed tags, +lengths, and values in the TLV. + +:: + + +------+------+------+------+ + | 'N' | 'V' | 'F' | 'W' | Magic header + +------+------+------+------+ + | Tag (4 bytes, ASCII) | TLV block 0 + +---------------------------+ + | Length (4 bytes, LE) | + +---------------------------+ + | | + | Value (length bytes, | + | padded to 4-byte align) | + | | + +---------------------------+ + | Tag (4 bytes, ASCII) | TLV block 1 + +---------------------------+ + | Length (4 bytes, LE) | + +---------------------------+ + | | + | Value (length bytes, | + | padded to 4-byte align) | + | | + +---------------------------+ + | ... | More TLV blocks + +---------------------------+ + +Tags and Length +=============== +TLV tags are always four-character words, with all letters being upper case. +Duplicate tags are not allowed. + +A TLV file may contain additional tags not described in this document. + +Values +====== +Values are one of four types. The type is not encoded in the format; rather, +the parser expects a given tag to have a value of a given type. + +1) Integers, encoded in 32-bit or 64-bit little-endian format. +2) Strings, encoded as-is and required to be only printable ASCII characters + and without a null terminator. +3) An array of bytes, for binary data. +4) Boolean, encoded as single byte, with a value of 0 for False or 1 for True. + +Common Tags +=========== +These tags are shared across firmware types and carry the same meaning +wherever they appear. Unlike the firmware-specific tags below, a common tag +is reserved: its meaning is fixed and may never be redefined for a particular +firmware type. + +``VERS`` (string) + Human-readable firmware version string. Present in all TLV files. + +A TLV image must contain either a single ``BLOB`` tag (firmware embedded +inline) or a ``SIZE``/``FILE`` pair (firmware stored in a separate file). + +``BLOB`` (bytes) + If the firmware microcode binary is stored in the TLV, this tag contains + the actual firmware image bytes. + +``FILE`` (string) + If the firmware binary is stored as a separate file, this tag contains the + name of that file, which is required to be in the same directory as the TLV, + so no paths are allowed in the filename. This tag is always paired with + ``SIZE``, so as to allow the driver to pre-allocate the buffer before + loading the file. + +``SIZE`` (u32) + Total size in bytes of the firmware image to be loaded from the companion + file named by ``FILE``. This tag is mandatory if ``FILE`` exists, so the + size of the firmware image must be known when the TLV is created. If the + firmware image is updated and its size changes, then the TLV must be + updated with it. + +GSP Firmware Tags +================= +``SIGN`` (bytes) + Cryptographic signature for the GSP firmware. + +``BLID`` (string) + The build ID, extracted from the ".note.gnu.build-id" section. + +Booter Firmware Tags +==================== +``DAOF`` (u32) - ``os_data_offset`` + OS data section offset within the firmware image (absolute byte offset). + Maps to the DMEM load source. + +``DASZ`` (u32) - ``os_data_size`` + OS data section size in bytes. + +``CDOF`` (u32) - ``os_code_offset`` + OS code section offset within the firmware image (absolute byte offset). + Maps to the non-secure IMEM load source. + +``CDSZ`` (u32) - ``os_code_size`` + OS code section size in bytes. + +``PLOC`` (u32) - ``patch_loc`` + Signature patch location -- byte offset within the firmware image where the + selected signature should be written. + +``FUSE`` (u32) - ``fuse_version`` + Fuse version of the firmware, used with the hardware fuse register to + select the correct signature index. + +``ENID`` (u32) - ``engine_id`` + Engine ID mask identifying the falcon engine this firmware targets. + +``UCID`` (u32) - ``ucode_id`` + Microcode ID used together with the engine ID to query hardware signature + fuse registers. + +``A0CO`` (u32) - ``app0_code_offset`` + App0 code offset -- start of the secure code region within the firmware + image. Used as the IMEM secure section source. + +``A0CS`` (u32) - ``app0_code_size`` + App0 code size in bytes. + +``NSIG`` (u32) - ``num_sigs`` + Number of signatures included in the ``SIGN`` tag. + +``SIGN`` (bytes) + Concatenated array of firmware signatures. The size of each signature is + the total length of the ``SIGN`` value divided by ``NSIG``. The correct + signature is selected using the fuse-version-derived index. + +Generic Bootloader Tags +======================= +``CDSZ`` (u32) - ``code_size`` + Size in bytes of the bootloader code to copy from the ``BLOB`` tag and + PIO-load into falcon IMEM. + +``STRT`` (u32) - ``start_tag`` + Start tag identifying the IMEM block where execution begins. The falcon + boot address is derived as ``start_tag << 8``. + +GSP Bootloader Tags +=================== +``CDOF`` (u32) - ``code_offset`` + Offset within the firmware image at which the code section starts. + +``DAOF`` (u32) - ``data_offset`` + Offset within the firmware image at which the data section starts. + +``MFOF`` (u32) - ``manifest_offset`` + Offset within the firmware image at which the manifest starts. + +``APPV`` (u32) - ``app_version`` + Application version of the firmware. + +FMC Firmware Tags +================= +``HASH`` (bytes) + SHA-384 hash of the FMC firmware, exactly 48 bytes long. + +``PKEY`` (bytes) + Public key used to verify the FMC firmware. At most 384 bytes (RSA-3072), + but may be shorter. + +``SIGN`` (bytes) + Signature of the FMC firmware. At most 384 bytes (RSA-3072), but may + be shorter.
Documentation/gpu/nova/index.rst +1 -0
@@ -33,3 +33,4 @@ vGPU manager VFIO driver and the nova-drm driver. core/fsp core/fwsec core/falcon + core/tlv
drivers/gpu/nova-core/firmware.rs +1 -0
@@ -33,6 +33,7 @@pub (crate )mod fwsec;pub (crate )mod gsp;pub (crate )mod riscv; +pub (crate )mod tlv;pub (crate )const FIRMWARE_VERSION : &str ="570.144" ;
drivers/gpu/nova-core/firmware/tlv.rs new file +267 -0
267 lines not on this page · raw message
Signature · 1 line
2.54.0
Danilo Krummrich
maintainerRe: [PATCH v7 3/8] gpu: nova-core: add TLV parser for firmware files
@Miguel: One consideration for you below.
Quoted 11 lines · Timur Tabi
drivers/gpu/nova-core/firmware/tlv.rs new file +11
-0+impl <'a>Tlv <'a> { +const MAGIC : &'static [u8 ;4 ] =b"NVFW" ; + +/// Parses `data` as a TLV firmware image, returning [`EINVAL`] if the image is malformed. +pub (crate )fn new (data: &'a [u8 ]) ->Result <Self > { +// Verify that the magic bytes exist and are the correct value +let magic_len =Self ::MAGIC .len (); +if data + .get (..magic_len) + .is_none_or (|magic| magic !=Self ::MAGIC ) + {
drivers/gpu/nova-core/firmware/tlv.rs line 155
Quoted 10 lines
drivers/gpu/nova-core/firmware/tlv.rs new file +10
-0+return Err (EINVAL ); + } + +// The payload is the contiguous sequence of TLV blocks after the magic. +let payload = data.get (magic_len..).ok_or (EINVAL )?; + +if payload.is_empty () { +// Reject empty TLV files +return Err (ENODATA ); + }
This seems redundant, if payload is empty the below loop wouldn't execute and the !has_vers check would return EINVAL. Which seems consistent, since empty data is kinda invalid.
Quoted 32 lines
drivers/gpu/nova-core/firmware/tlv.rs new file +32
-0+ +// The spec says every TLV must have a VERS tag. +let mut has_vers =false ; + +let mut rest = payload; +while !rest.is_empty () { +// Validate and extract the header (type, length). +let Some (header):Option <TlvBlockHeader > = rest + .get (..TlvBlockHeader ::SIZE ) + .and_then (TlvBlockHeader ::parse) +else { +return Err (EINVAL ); + }; + + has_vers |= header.tag == *b"VERS" ; + +// The `length` field of a TLV block contains the actual byte length of the +// value, but each TLV block is aligned to a 4-byte boundary. +let Some (stored_size) = header.length.checked_next_multiple_of (4 )else { +return Err (EINVAL ); + }; + +let length =TlvBlockHeader ::SIZE + .checked_add (stored_size) + .ok_or (EINVAL )?; + + rest = rest.split_at_checked (length).ok_or (EINVAL )?.1 ; + } + +if !has_vers { +return Err (EINVAL ); + }
[...]
drivers/gpu/nova-core/firmware/tlv.rs line 206
Quoted 3 lines
drivers/gpu/nova-core/firmware/tlv.rs new file +3
-0+fn find (&self, tag: &[u8 ;4 ]) ->Result <TlvBlock <'a>> { + self.iter ().find (|b| b.tag == *tag).ok_or (EINVAL ) + }
NIT: Do we really know the tag is invalid just because it wasn't found?
drivers/gpu/nova-core/firmware/tlv.rs line 215
Quoted 8 lines
drivers/gpu/nova-core/firmware/tlv.rs new file +8
-0+/// Return a slice of bytes. Returns ENODATA if the value is empty. +pub (crate )fn get_bytes (&self, tag: &[u8 ;4 ]) ->Result <&'a [u8 ]> { +let tlv = self.find (tag)?; + +// Treat empty value as an error, to avoid trying to parse nothing. +if tlv.value.is_empty () { +return Err (ENODATA ); + }
This one seems resonable; but we don't have the error code in place. The commit message says the series depends on [1], but this likely goes through the Rust tree.
Either we just add this single error code in a separate patch or Miguel provides a signed tag for [1].
Since this is a perfectly trivial conflict, I'd go for the former.
Miguel, let me know if you want to provide a signed tag, otherwise it would be good if Timur (or myself) could send a patch for ENODATA only.
@Timur: In any case, no need to resend the series for this or the other two nits in this reply.
Thanks,
Danilo
Danilo Krummrich
maintainerRe: [PATCH v7 3/8] gpu: nova-core: add TLV parser for firmware files
Quoted 88 lines · Danilo Krummrich
@Miguel: One consideration for you below.
Quoted 11 lines · Timur Tabi
drivers/gpu/nova-core/firmware/tlv.rs new file +11
-0+impl <'a>Tlv <'a> { +const MAGIC : &'static [u8 ;4 ] =b"NVFW" ; + +/// Parses `data` as a TLV firmware image, returning [`EINVAL`] if the image is malformed. +pub (crate )fn new (data: &'a [u8 ]) ->Result <Self > { +// Verify that the magic bytes exist and are the correct value +let magic_len =Self ::MAGIC .len (); +if data + .get (..magic_len) + .is_none_or (|magic| magic !=Self ::MAGIC ) + {drivers/gpu/nova-core/firmware/tlv.rs line 155
Quoted 10 lines
drivers/gpu/nova-core/firmware/tlv.rs new file +10
-0+return Err (EINVAL ); + } + +// The payload is the contiguous sequence of TLV blocks after the magic. +let payload = data.get (magic_len..).ok_or (EINVAL )?; + +if payload.is_empty () { +// Reject empty TLV files +return Err (ENODATA ); + }This seems redundant, if payload is empty the below loop wouldn't execute and the !has_vers check would return EINVAL. Which seems consistent, since empty data is kinda invalid.
Quoted 32 lines
drivers/gpu/nova-core/firmware/tlv.rs new file +32
-0+ +// The spec says every TLV must have a VERS tag. +let mut has_vers =false ; + +let mut rest = payload; +while !rest.is_empty () { +// Validate and extract the header (type, length). +let Some (header):Option <TlvBlockHeader > = rest + .get (..TlvBlockHeader ::SIZE ) + .and_then (TlvBlockHeader ::parse) +else { +return Err (EINVAL ); + }; + + has_vers |= header.tag == *b"VERS" ; + +// The `length` field of a TLV block contains the actual byte length of the +// value, but each TLV block is aligned to a 4-byte boundary. +let Some (stored_size) = header.length.checked_next_multiple_of (4 )else { +return Err (EINVAL ); + }; + +let length =TlvBlockHeader ::SIZE + .checked_add (stored_size) + .ok_or (EINVAL )?; + + rest = rest.split_at_checked (length).ok_or (EINVAL )?.1 ; + } + +if !has_vers { +return Err (EINVAL ); + }[...]
drivers/gpu/nova-core/firmware/tlv.rs line 206
Quoted 3 lines
drivers/gpu/nova-core/firmware/tlv.rs new file +3
-0+fn find (&self, tag: &[u8 ;4 ]) ->Result <TlvBlock <'a>> { + self.iter ().find (|b| b.tag == *tag).ok_or (EINVAL ) + }NIT: Do we really know the tag is invalid just because it wasn't found?
drivers/gpu/nova-core/firmware/tlv.rs line 215
Quoted 8 lines
drivers/gpu/nova-core/firmware/tlv.rs new file +8
-0+/// Return a slice of bytes. Returns ENODATA if the value is empty. +pub (crate )fn get_bytes (&self, tag: &[u8 ;4 ]) ->Result <&'a [u8 ]> { +let tlv = self.find (tag)?; + +// Treat empty value as an error, to avoid trying to parse nothing. +if tlv.value.is_empty () { +return Err (ENODATA ); + }This one seems resonable; but we don't have the error code in place. The commit message says the series depends on [1], but this likely goes through the Rust tree.
Either we just add this single error code in a separate patch or Miguel provides a signed tag for [1].
Since this is a perfectly trivial conflict, I'd go for the former.
Quoted 8 lines
Miguel, let me know if you want to provide a signed tag, otherwise it would be good if Timur (or myself) could send a patch for ENODATA only.
@Timur: In any case, no need to resend the series for this or the other two nits in this reply.
Thanks,
Danilo
Re: [PATCH v7 3/8] gpu: nova-core: add TLV parser for firmware files
In reply to Danilo KrummrichQuoted 21 lines · Danilo Krummrich
@Miguel: One consideration for you below.
Quoted 18 lines · Timur Tabi
drivers/gpu/nova-core/firmware/tlv.rs new file +4
-0+impl <'a>Tlv <'a> { + const MAGIC: &'static [u8; 4] = b"NVFW"; + + /// Parses `data` as a TLV firmware image, returning [`EINVAL`] if the image ismalformed.
+ pub(crate) fnnew(data: &'a [u8])-> Result<Self> {
+ // Verify that the magic bytes exist and are the correct value + letmagic_len=Self::MAGIC.len();
+ if data
+ .get(..magic_len)
+ .is_none_or(|magic| magic !=Self::MAGIC)
+ {
+ return Err(EINVAL);
+ }drivers/gpu/nova-core/firmware/tlv.rs new file +4
-0+ + // The payload is the contiguous sequence of TLV blocks after the magic. + let payload = data.get(magic_len..).ok_or(EINVAL)?; +
Quoted 8 lines
Quoted 4 lines
+ if
payload.is_empty(){
+ // Reject empty TLV files
+ return Err(ENODATA);
+ }This seems redundant, if payload is empty the below loop wouldn't execute and the !has_vers check would return EINVAL. Which seems consistent, since empty data is kinda invalid.
I frequently struggle to find the right error code in kernel code, especially for situations where some data structure is not quite right.
Quoted 34 lines
Quoted 31 lines
+ // The spec says every TLV must have a VERS tag. + let mut
has_vers= false;drivers/gpu/nova-core/firmware/tlv.rs new file +29
-0+ + let mut rest = payload; + while !rest.is_empty() { + // Validate and extract the header (type, length). + let Some(header): Option<TlvBlockHeader> = rest + .get(..TlvBlockHeader::SIZE) + .and_then(TlvBlockHeader::parse) + else { + return Err(EINVAL); + }; + + has_vers |= header.tag == *b"VERS"; + + // The `length` field of a TLV block contains the actual byte length of the + // value, but each TLV block is aligned to a 4-byte boundary. + let Some(stored_size) = header.length.checked_next_multiple_of(4) else { + return Err(EINVAL); + }; + + let length = TlvBlockHeader::SIZE + .checked_add(stored_size) + .ok_or(EINVAL)?; + + rest = rest.split_at_checked(length).ok_or(EINVAL)?.1; + } + + if !has_vers { + return Err(EINVAL); + }[...]
Quoted 5 lines
Quoted 3 lines
+ fn
find(&self, tag: &[u8; 4])-> Result<TlvBlock<'a>> { + self.iter().find(|b| b.tag == *tag).ok_or(EINVAL) + }NIT: Do we really know the tag is invalid just because it wasn't found?
Well, maybe this is where we should return ENODATA?
I am expecting future Nova code to handle tags that may be legitimately absent, so maybe having it return ENODATA if the tag is missing, and EINVAL in all other situations is better.
Quoted 9 lines
Quoted 8 lines
+ /// Return a slice of bytes. Returns ENODATA if the value is empty. + pub(crate) fn
get_bytes(&self, tag: &[u8; 4])-> Result<&'a [u8]> { + let tlv =self.find(tag)?;
+
+ // Treat empty value as an error, to avoid trying to parse nothing. + iftlv.value.is_empty(){
+ return Err(ENODATA);
+ }
Quoted 3 lines
This one seems resonable; but we don't have the error code in place. The commit message says the series depends on [1], but this likely goes through the Rust tree.
Can't you just pick it up from the Rust tree and put it in drm-rust-next?
Quoted 4 lines
Either we just add this single error code in a separate patch or Miguel provides a signed tag for [1].
Since this is a perfectly trivial conflict, I'd go for the former.
The latter seems simpler to me, and would avoid an annoying merge conflict.
Danilo Krummrich
maintainerRe: [PATCH v7 3/8] gpu: nova-core: add TLV parser for firmware files
Quoted 11 lines · Timur Tabi
Quoted 8 lines · Danilo Krummrich
@Miguel: One consideration for you below.
Quoted 3 lines · Timur Tabi
+ fn
find(&self, tag: &[u8; 4])-> Result<TlvBlock<'a>> { + self.iter().find(|b| b.tag == *tag).ok_or(EINVAL) + }NIT: Do we really know the tag is invalid just because it wasn't found?
Well, maybe this is where we should return ENODATA?
Or maybe just ENOENT.
Quoted 2 lines
I am expecting future Nova code to handle tags that may be legitimately absent, so maybe having it return ENODATA if the tag is missing, and EINVAL in all other situations is better.
In this case it makes sense to differenciate; AFAIC this can be a follow-up patch.
Quoted 9 lines
Quoted 9 lines
Quoted 8 lines
+ /// Return a slice of bytes. Returns ENODATA if the value is empty. + pub(crate) fn
get_bytes(&self, tag: &[u8; 4])-> Result<&'a [u8]> { + let tlv =self.find(tag)?;
+
+ // Treat empty value as an error, to avoid trying to parse nothing. + iftlv.value.is_empty(){
+ return Err(ENODATA);
+ }
Quoted 5 lines
Quoted 3 lines
This one seems resonable; but we don't have the error code in place. The commit message says the series depends on [1], but this likely goes through the Rust tree.
Can't you just pick it up from the Rust tree and put it in drm-rust-next?
This is what I refer to below as "signed tag".
Some background on this: We can't have patches as duplicate commits going to Linus. So in order for me to pull from the Rust tree, it has to guarantee to not change its histroy (which it does not). Besides that, we don't want all the commits from another tree, but just a specific one. The normal process for this is to put the commit on a separate branch based on a commit base, e.g. some -rc, typically -rc1. Then we can create a signed tag from this that can be merged into both (or multiple) trees, so the commit only exists exactly once.
However, this kind of logistics typically only makes sense for features, etc. In order to avoid a trivial conflict, it is usually overkill. Which is also why I said I'd go for the former.
Quoted 6 lines
Quoted 4 lines
Either we just add this single error code in a separate patch or Miguel provides a signed tag for [1].
Since this is a perfectly trivial conflict, I'd go for the former.
The latter seems simpler to me, and would avoid an annoying merge conflict.
Re: [PATCH v7 3/8] gpu: nova-core: add TLV parser for firmware files
Quoted 10 lines · Danilo Krummrich
Quoted 1 line
Well, maybe this is where we should return ENODATA?
Or maybe just ENOENT.
Quoted 3 lines
I am expecting future Nova code to handle tags that may be legitimately absent, so maybe having
it return ENODATA if the tag is missing, and EINVAL in all other situations is better.In this case it makes sense to differenciate; AFAIC this can be a follow-up patch.
...
Quoted 10 lines
This is what I refer to below as "signed tag".
Some background on this: We can't have patches as duplicate commits going to Linus. So in order for me to pull from the Rust tree, it has to guarantee to not change its histroy (which it does not). Besides that, we don't want all the commits from another tree, but just a specific one. The normal process for this is to put the commit on a separate branch based on a commit base, e.g. some -rc, typically -rc1. Then we can create a signed tag from this that can be merged into both (or multiple) trees, so the commit only exists exactly once.
Quoted 3 lines
However, this kind of logistics typically only makes sense for features, etc. In order to avoid a trivial conflict, it is usually overkill. Which is also why I said I'd go for the former.
How about this: replace all ENODATA with EINVAL in this patch for now, and then after drm-rust- next pulls in my error.rs change from the Rust tree, I replace some of those EINVAL with ENOENT or ENODATA.
PATCH v7 4/8 gpu: nova-core: transition booter to TLV images
In reply to Timur TabiSwitch the booter firmware loader from the legacy binary format to the TLV format. This change requires the new TLV versions of the r570.144 firmware images.
The new TLV format has all of the metadata needed by Nova encoded as separate tags, eliminating the need to parse legacy firmware headers such as HsHeaderV2 and HsSignatureParams. All of the structs and code for parsing those headers is therefore deleted.
--- drivers/gpu/nova-core/firmware.rs | 15 +- drivers/gpu/nova-core/firmware/booter.rs | 329 ++++------------------- drivers/gpu/nova-core/firmware/tlv.rs | 2 - drivers/gpu/nova-core/gsp/hal/tu102.rs | 13 +- 4 files changed, 62 insertions(+), 297 deletions(-)
drivers/gpu/nova-core/firmware.rs +1 -14
@@ -22,10 +22,7 @@ }, gpu, gsp::boot_firmware_files, - num::{ -FromSafeCast , -IntoSafeCast ,// - }, + num::IntoSafeCast, // };pub (crate )mod booter;
@@ -389,16 +386,6 @@ fn new(fw: &'a firmware::Firmware) -> Result<Self> { .map(|hdr| Self { hdr, fw }) .ok_or (EINVAL ) } - -/// Returns the data payload of the firmware, or `None` if the data range is out of bounds of -/// the firmware image. -fn data (&self) ->Option <&[u8 ]> { -let fw_start = usize::from_safe_cast (self.hdr.data_offset); -let fw_size = usize::from_safe_cast (self.hdr.data_size); -let fw_end = fw_start.checked_add (fw_size)?; - - self.fw.get (fw_start..fw_end) - } }pub (crate )struct ModInfoBuilder <const N :usize >(firmware::ModInfoBuilder <N >);
drivers/gpu/nova-core/firmware/booter.rs +57 -272
389 lines not on this page · raw message
drivers/gpu/nova-core/firmware/tlv.rs +0 -2
@@ -14,7 +14,6 @@ };/// Requests the GPU firmware TLV `name` suitable for `chipset`. -#[expect(dead_code)] pub (crate )fn request_tlv ( dev: &device::Device , chipset: gpu::Chipset,
@@ -131,7 +130,6 @@ pub(crate) struct Tlv<'a> { data: &'a [u8], } -#[expect(dead_code)] impl <'a>Tlv <'a> {const MAGIC : &'static [u8 ;4 ] =b"NVFW" ;
drivers/gpu/nova-core/gsp/hal/tu102.rs +4 -9
@@ -31,8 +31,7 @@ FwsecCommand, FwsecFirmware, // }, - gsp::GspFirmware, - FIRMWARE_VERSION, // + gsp::GspFirmware, // }, gpu::Chipset, gsp::{
@@ -237,7 +236,6 @@ fn build_unload_bundle( dev, BooterKind::Unloader, chipset, - FIRMWARE_VERSION, sec2_falcon, )?, },
@@ -296,14 +294,11 @@ fn boot("Using SEC2 to load and run the booter_load firmware...\n" ); -BooterFirmware ::new ( +BooterFirmware ::new (dev,BooterKind ::Loader , chipset, sec2_falcon)?.run ( dev, -BooterKind ::Loader , - chipset, -FIRMWARE_VERSION , sec2_falcon, - )? - .run (dev, sec2_falcon, wpr_meta)?; + wpr_meta, + )?;Ok (unload_guard.dismiss ()) }
Signature · 1 line
2.54.0
PATCH v7 5/8 gpu: nova-core: transition gsp to TLV images
In reply to Timur TabiSwitch the GSP firmware loader from the legacy binary format to the TLV format. This change requires the new TLV versions of the r570.144 firmware images.
Unlike the other TLV firmware images, gsp.tlv contains a pointer to the actual GSP firmware file instead of its contents. This allows each small gsp.tlv file to contain the distinct metadata for each GPU while still allowing the very large gsp.bin to be shared by all GPUs.
One key piece of metadata is the signature. The legacy GSP firmware image is an ELF file that contains multiple sections that needed to be parsed, and the driver needed to determine which section is relevant for the GPU. Instead, gsp.tlv contains the pre-processed metadata, so all the driver needs to do is to extract it.
--- drivers/gpu/nova-core/firmware.rs | 23 -------- drivers/gpu/nova-core/firmware/gsp.rs | 59 +++++++------------ drivers/gpu/nova-core/firmware/riscv.rs | 75 ++++++------------------- drivers/gpu/nova-core/gsp/boot.rs | 7 +-- 4 files changed, 38 insertions(+), 126 deletions(-)
drivers/gpu/nova-core/firmware.rs +0 -23
@@ -365,29 +365,6 @@ struct BinHdr {// SAFETY: all bit patterns are valid for this type, and it doesn't use interior mutability. unsafe impl FromBytes for BinHdr {} -// A firmware blob starting with a `BinHdr`. -struct BinFirmware <'a> { - hdr:BinHdr , - fw: &'a [u8 ], -} - -impl <'a>BinFirmware <'a> { -/// Interpret `fw` as a firmware image starting with a [`BinHdr`], and returns the -/// corresponding [`BinFirmware`] that can be used to extract its payload. -fn new (fw: &'a firmware::Firmware ) ->Result <Self > { -const BIN_MAGIC :u32 =0x10de ; -let fw = fw.data (); - - fw.get (0 ..size_of ::<BinHdr >()) -// Extract header. - .and_then (BinHdr ::from_bytes_copy) -// Validate header. - .filter (|hdr| hdr.bin_magic ==BIN_MAGIC ) - .map (|hdr|Self { hdr, fw }) - .ok_or (EINVAL ) - } -} -pub (crate )struct ModInfoBuilder <const N :usize >(firmware::ModInfoBuilder <N >);impl <const N :usize >ModInfoBuilder <N > {
drivers/gpu/nova-core/firmware/gsp.rs +19 -40
99 lines not on this page · raw message
drivers/gpu/nova-core/firmware/riscv.rs +17 -58
94 lines not on this page · raw message
drivers/gpu/nova-core/gsp/boot.rs +2 -5
@@ -17,10 +17,7 @@ Falcon, // }, fb::FbLayout, - firmware::{ - gsp::GspFirmware, - FIRMWARE_VERSION, // - }, + firmware::gsp::GspFirmware, gsp::{ cmdq::Cmdq, commands,
@@ -48,7 +45,7 @@ pub(crate) fn boot(let dev = pdev.as_ref ();let hal =super ::hal::gsp_hal (chipset); -let gsp_fw =KBox ::pin_init (GspFirmware ::new (dev, chipset,FIRMWARE_VERSION ),GFP_KERNEL )?; +let gsp_fw =KBox ::pin_init (GspFirmware ::new (dev, chipset),GFP_KERNEL )?;let fb_layout =FbLayout ::new (chipset, bar, &gsp_fw, ctx.vgpu.state ())?;dev_dbg! (dev,"{:#x?}\n" , fb_layout);
Signature · 1 line
2.54.0
PATCH v7 6/8 gpu: nova-core: transition gen_bootloader to TLV images
In reply to Timur TabiSwitch the generic bootloader firmware loader from the legacy binary format to the TLV format. This change requires the new TLV versions of the r570.144 firmware images.
--- drivers/gpu/nova-core/firmware.rs | 24 +----- .../nova-core/firmware/fwsec/bootloader.rs | 75 +++++-------------- 2 files changed, 20 insertions(+), 79 deletions(-)
drivers/gpu/nova-core/firmware.rs +1 -23
@@ -11,8 +11,7 @@ device, firmware, prelude::*, - str::CString, - transmute::FromBytes, // + str::CString, // };use crate ::{
@@ -344,27 +343,6 @@ fn no_patch_signature(self) -> FirmwareObject<F, Signed> { } } -/// Header common to most firmware files. -#[repr( C )] -#[derive( Debug , Clone )] -struct BinHdr { -/// Magic number, must be `0x10de`. - bin_magic:u32 , -/// Version of the header. - bin_ver:u32 , -/// Size in bytes of the binary (to be ignored). - bin_size:u32 , -/// Offset of the start of the application-specific header. - header_offset:u32 , -/// Offset of the start of the data payload. - data_offset:u32 , -/// Size in bytes of the data payload. - data_size:u32 , -} - -// SAFETY: all bit patterns are valid for this type, and it doesn't use interior mutability. -unsafe impl FromBytes for BinHdr {} -pub (crate )struct ModInfoBuilder <const N :usize >(firmware::ModInfoBuilder <N >);impl <const N :usize >ModInfoBuilder <N > {
drivers/gpu/nova-core/firmware/fwsec/bootloader.rs +19 -56
118 lines not on this page · raw message
Signature · 1 line
2.54.0
PATCH v7 7/8 gpu: nova-core: transition fsp to TLV images
In reply to Timur TabiSwitch the FSP firmware loaders from the legacy ELF32 format to the new TLV format. This change requires the new TLV versions of the r570.144 firmware images.
Because we are no longer loading ELF images, we can also delete the ELF parser.
Also remove function request_firmware() as this was the last user.
--- drivers/gpu/nova-core/firmware.rs | 222 +------------------------- drivers/gpu/nova-core/firmware/fsp.rs | 88 +++++----- drivers/gpu/nova-core/fsp.rs | 11 +- 3 files changed, 46 insertions(+), 275 deletions(-)
drivers/gpu/nova-core/firmware.rs +1 -221
@@ -8,10 +8,8 @@use core::ops::Deref ;use kernel::{ - device, firmware, - prelude::*, - str::CString ,// + prelude::*,// };use crate ::{
@@ -33,19 +31,6 @@pub (crate )const FIRMWARE_VERSION : &str ="570.144" ; -/// Requests the GPU firmware `name` suitable for `chipset`, with version `ver`. -fn request_firmware ( - dev: &device::Device , - chipset: gpu::Chipset , - name: &str , - ver: &str , -) ->Result <firmware::Firmware > { -let chip_name = chipset.name (); - -CString ::try_from_fmt (fmt! ("nvidia/{chip_name}/gsp/{name}-{ver}.bin" )) - .and_then (|path| firmware::Firmware ::request (&path, dev)) -} -/// Structure used to describe some firmwares, notably FWSEC-FRTS. #[repr( C )] #[derive( Debug , Clone , FromBytes )]
@@ -393,208 +378,3 @@ pub(crate) const fn create( this.0 } } - -/// Ad-hoc and temporary module to extract sections from ELF images. -/// -/// Some firmware images are currently packaged as ELF files, where sections names are used as keys -/// to specific and related bits of data. Future firmware versions are scheduled to move away from -/// that scheme before nova-core becomes stable, which means this module will eventually be -/// removed. -mod elf { -use kernel::{ - bindings, - prelude::*, - transmute::FromBytes ,// - }; - -/// Trait to abstract over ELF header differences. -trait ElfHeader :FromBytes { -fn shnum (&self) ->u16 ; -fn shoff (&self) ->u64 ; -fn shstrndx (&self) ->u16 ; - } - -/// Trait to abstract over ELF section-header differences. -trait ElfSectionHeader :FromBytes { -fn name (&self) ->u32 ; -fn offset (&self) ->u64 ; -fn size (&self) ->u64 ; - } - -/// Trait describing a matching ELF header and section-header format. -trait ElfFormat { -type Header :ElfHeader ; -type SectionHeader :ElfSectionHeader ; - } - -/// Newtype to provide a [`FromBytes`] implementation. -#[repr(transparent)] -struct Elf64Hdr (bindings::elf64_hdr ); -// SAFETY: all bit patterns are valid for this type, and it doesn't use interior mutability. -unsafe impl FromBytes for Elf64Hdr {} - -impl ElfHeader for Elf64Hdr { -fn shnum (&self) ->u16 { - self.0 .e_shnum - } - -fn shoff (&self) ->u64 { - self.0 .e_shoff - } - -fn shstrndx (&self) ->u16 { - self.0 .e_shstrndx - } - } - -#[repr(transparent)] -struct Elf64SHdr (bindings::elf64_shdr ); -// SAFETY: all bit patterns are valid for this type, and it doesn't use interior mutability. -unsafe impl FromBytes for Elf64SHdr {} - -impl ElfSectionHeader for Elf64SHdr { -fn name (&self) ->u32 { - self.0 .sh_name - } - -fn offset (&self) ->u64 { - self.0 .sh_offset - } - -fn size (&self) ->u64 { - self.0 .sh_size - } - } - -struct Elf64Format ; - -impl ElfFormat for Elf64Format { -type Header =Elf64Hdr ; -type SectionHeader =Elf64SHdr ; - } - -/// Newtype to provide [`FromBytes`] and [`ElfHeader`] implementations for ELF32. -#[repr(transparent)] -struct Elf32Hdr (bindings::elf32_hdr ); -// SAFETY: all bit patterns are valid for this type, and it doesn't use interior mutability. -unsafe impl FromBytes for Elf32Hdr {} - -impl ElfHeader for Elf32Hdr { -fn shnum (&self) ->u16 { - self.0 .e_shnum - } - -fn shoff (&self) ->u64 { - u64::from (self.0 .e_shoff) - } - -fn shstrndx (&self) ->u16 { - self.0 .e_shstrndx - } - } - -/// Newtype to provide [`FromBytes`] and [`ElfSectionHeader`] implementations for ELF32. -#[repr(transparent)] -struct Elf32SHdr (bindings::elf32_shdr ); -// SAFETY: all bit patterns are valid for this type, and it doesn't use interior mutability. -unsafe impl FromBytes for Elf32SHdr {} - -impl ElfSectionHeader for Elf32SHdr { -fn name (&self) ->u32 { - self.0 .sh_name - } - -fn offset (&self) ->u64 { - u64::from (self.0 .sh_offset) - } - -fn size (&self) ->u64 { - u64::from (self.0 .sh_size) - } - } - -struct Elf32Format ; - -impl ElfFormat for Elf32Format { -type Header =Elf32Hdr ; -type SectionHeader =Elf32SHdr ; - } - -/// Returns a NULL-terminated string from the ELF image at `offset`. -fn elf_str (elf: &[u8 ], offset:u64 ) ->Option <&str > { -let idx = usize::try_from (offset).ok ()?; -let bytes = elf.get (idx..)?; -CStr ::from_bytes_until_nul (bytes).ok ()?.to_str ().ok () - } - -fn elf_section_generic <'a,F >(elf: &'a [u8 ], name: &str ) ->Option <&'a [u8 ]> -where -F :ElfFormat , - { -let hdr =F ::Header ::from_bytes (elf.get (0 ..size_of ::<F ::Header >())?)?; - -let shdr_num = usize::from (hdr.shnum ()); -let shdr_start = usize::try_from (hdr.shoff ()).ok ()?; -let shdr_end = shdr_num - .checked_mul (size_of ::<F ::SectionHeader >()) - .and_then (|v| v.checked_add (shdr_start))?; - -// Get all the section headers as an iterator over byte chunks. -let shdr_bytes = elf.get (shdr_start..shdr_end)?; -let mut shdr_iter = shdr_bytes.chunks_exact (size_of ::<F ::SectionHeader >()); - -// Get the strings table. -let strhdr = shdr_iter - .clone () - .nth (usize::from (hdr.shstrndx ())) - .and_then (F ::SectionHeader ::from_bytes)?; - -// Find the section which name matches `name` and return it. - shdr_iter.find_map (|sh_bytes| { -let sh =F ::SectionHeader ::from_bytes (sh_bytes)?; -let name_offset = strhdr.offset ().checked_add (u64::from (sh.name ()))?; -let section_name =elf_str (elf, name_offset)?; - -if section_name != name { -return None ; - } - -let start = usize::try_from (sh.offset ()).ok ()?; -let end = usize::try_from (sh.size ()) - .ok () - .and_then (|sz| start.checked_add (sz))?; - - elf.get (start..end) - }) - } - -/// Extract the section with name `name` from the ELF64 image `elf`. -fn elf64_section <'a>(elf: &'a [u8 ], name: &str ) ->Option <&'a [u8 ]> { -elf_section_generic ::<Elf64Format >(elf, name) - } - -/// Extract the section with name `name` from the ELF32 image `elf`. -fn elf32_section <'a>(elf: &'a [u8 ], name: &str ) ->Option <&'a [u8 ]> { -elf_section_generic ::<Elf32Format >(elf, name) - } - -/// Automatically detects ELF32 vs ELF64 based on the ELF header. -pub (super )fn elf_section <'a>(elf: &'a [u8 ], name: &str ) ->Option <&'a [u8 ]> { -// ELF identification: a 4-byte magic followed by a class byte (32- vs 64-bit). -const ELFMAG : &[u8 ] =b"\x7fELF" ; -const SELFMAG :usize =ELFMAG .len (); -const EI_CLASS :usize =4 ; -const ELFCLASS32 :u8 =1 ; -const ELFCLASS64 :u8 =2 ; - -if elf.get (0 ..SELFMAG ) !=Some (ELFMAG ) { -return None ; - } - -match *elf.get (EI_CLASS )? { -ELFCLASS32 =>elf32_section (elf, name), -ELFCLASS64 =>elf64_section (elf, name), - _ =>None , - } - } -}
drivers/gpu/nova-core/firmware/fsp.rs +41 -47
143 lines not on this page · raw message
drivers/gpu/nova-core/fsp.rs +4 -7
@@ -32,12 +32,9 @@ Falcon, // }, fb::FbLayout, - firmware::{ - fsp::{ - FmcSignatures, - FspFirmware, // - }, - FIRMWARE_VERSION, // + firmware::fsp::{ + FmcSignatures, + FspFirmware, // }, gpu::Chipset, gsp::{
@@ -413,7 +410,7 @@ fn wait_secure_boot(const FSP_SECURE_BOOT_TIMEOUT_MS :i64 =5000 ;let falcon =Falcon ::<FspEngine >::new (dev, chipset, bar)?; -let fsp_fw =FspFirmware ::new (dev, chipset,FIRMWARE_VERSION )?; +let fsp_fw =FspFirmware ::new (dev, chipset)?;read_poll_timeout ( || Ok(hal.fsp_boot_status(bar)),
Signature · 1 line
2.54.0
PATCH v7 8/8 gpu: nova-core: update firmware module info for TLV images
In reply to Timur TabiNow that nova-core loads the TLV firmware images, update the firmware module info to specify those files.
Also remove FIRMWARE_VERSION as it is no longer used.
--- drivers/gpu/nova-core/firmware.rs | 12 ++++-------- drivers/gpu/nova-core/gsp/hal.rs | 8 ++++---- 2 files changed, 8 insertions(+), 12 deletions(-)
drivers/gpu/nova-core/firmware.rs +4 -8
@@ -29,8 +29,6 @@pub (crate )mod riscv;pub (crate )mod tlv; -pub (crate )const FIRMWARE_VERSION : &str ="570.144" ; -/// Structure used to describe some firmwares, notably FWSEC-FRTS. #[repr( C )] #[derive( Debug , Clone , FromBytes )]
@@ -338,10 +336,7 @@ const fn make_entry_file(self, chipset: &str, fw: &str) -> Self { .push("nvidia/") .push (chipset) .push ("/gsp/" ) - .push (fw) - .push ("-" ) - .push (FIRMWARE_VERSION ) - .push(".bin"), + .push(fw), ) }
@@ -350,8 +345,9 @@ const fn make_entry_chipset(self, chipset: gpu::Chipset) -> Self {// GSP firmware files are always present. let mut this = self - .make_entry_file (name,"bootloader" ) - .make_entry_file (name,"gsp" ); + .make_entry_file (name,"gsp_bootloader.tlv" ) + .make_entry_file (name,"gsp.tlv" ) + .make_entry_file (name,"gsp.bin" );// Add the firmware files specific to the GSP boot method of `chipset`. let boot_files =boot_firmware_files (chipset);
drivers/gpu/nova-core/gsp/hal.rs +4 -4
@@ -67,16 +67,16 @@ fn post_boot(pub (crate )const fn boot_firmware_files (chipset:Chipset ) -> &'static [&'staticstr ] {match chipset.arch () {// Turing chipsets boot the GSP via the SEC2 Booter, and require the FWSEC bootloader. -Architecture ::Turing => &["booter_load" ,"booter_unload" ,"gen_bootloader" ], +Architecture ::Turing => &["booter_load.tlv" ,"booter_unload.tlv" ,"gen_bootloader.tlv" ],// GA100 also requires the FWSEC bootloader. Architecture ::Ampere if matches! (chipset,Chipset ::GA100 ) => { - &["booter_load" ,"booter_unload" ,"gen_bootloader" ] + &["booter_load.tlv" ,"booter_unload.tlv" ,"gen_bootloader.tlv" ] }// Other Ampere chipsets, as well as Ada chipsets, run FWSEC directly. -Architecture ::Ampere |Architecture ::Ada => &["booter_load" ,"booter_unload" ], +Architecture ::Ampere |Architecture ::Ada => &["booter_load.tlv" ,"booter_unload.tlv" ],// Hopper and later chipsets boot the GSP via the FMC image loaded by FSP. Architecture ::Hopper |Architecture ::BlackwellGB10x |Architecture ::BlackwellGB20x => { - &["fmc" ] + &["fmc.tlv" ] } } }
Signature · 1 line
2.54.0
Quoted 26 lines · Timur Tabi
This patch set transitions nova-core to use the new "TLV" firmware image files, instead of the ones that Nouveau uses.
A prerequisite patch "rust: error: add remaining error codes" is required to compile. [1]
The current r570.144 images are a mix of binary headers and ELF files that are cumbersome to parse in Rust. There's a significant amount of code that just reads in a struct, extracts some offset, and uses it to find another struct, only to have nova-core use just a few fields.
The new format uses a sequence of tag/length/value fields that can be iterated over. The script that generates the TLV files,
extract-firmware-nova.py, does the extra work to find the specific metadata needed by Nova and packages each one separately.The TLV versions of r570.144 can be found here:
https://github.com/ttabi/linux-firmware-nova
along with instructions on how to install them. We are not planning on submitting these images to linux-firmware. Rather, if this patchset is accepted upstream, I expect the small handful of people who are actually working on Nova to grab and install these images, which needs to be done only once.
Quoted 8 lines
There are still opportunities for improvement. For example, I would like to get rid of more GPU-specific code, especially the GA100 quirks.
Note that there are plans to relocate these images into a different
/lib/firmwaresubdirectory, to further isolate them from the images that Nouveau uses.[1] https://lore.kernel.org/rust-for-linux/[email protected]/
Gave the series a run on tu106, ga107 and gb203, all successfully. Each patch also builds nicely without warnings or formatting issues.
Since this also touches core Rust parts, it is preferable that Danilo merges it, so for the series:
(note that [1] is also needed)
Quoted 1 line · Timur Tabi
[PATCH v7 0/8] Transition Nova Core to TLV firmware images
Applied, thanks!
Branch: drm-rust-next
Tree: https://gitlab.freedesktop.org/drm/rust/kernel.git
[1/8] rust: alloc: add Vec::zeroed method
commit: 60782beb112e
[2/8] rust: firmware: add request_into_buf()
commit: e6c2c6265521
[ Declare fw as *const to match the FFI out-parameter type and pass
&raw mut directly, removing the redundant cast chain. - Danilo ]
[3/8] gpu: nova-core: add TLV parser for firmware files
commit: 33f40117c0c5
[ Drop unnecessary payload.is_empty() check in Tlv::new(), use EINVAL
instead of ENODATA in Tlv::get_bytes() and add a corresponding TODO comment. - Danilo ]
[4/8] gpu: nova-core: transition booter to TLV images
commit: ad5157827522
[5/8] gpu: nova-core: transition gsp to TLV images
commit: ccdcefb71acd
[6/8] gpu: nova-core: transition gen_bootloader to TLV images
commit: ebc053cf0b4c
[7/8] gpu: nova-core: transition fsp to TLV images
commit: 08994a0f2936
[8/8] gpu: nova-core: update firmware module info for TLV images
commit: 7923d0bc8edeThe patches will appear in the next linux-next integration (typically within 24 hours on weekdays).
The patches are queued up for the upcoming merge window for the next major kernel release.