665 lines · 21.0 KB · Rust
RawDownload
// SPDX-License-Identifier: GPL-2.0// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. //! Contains structures and functions dedicated to the parsing, building and patching of firmwares//! to be loaded into a given execution unit. use core::marker::PhantomData;use core::ops::Deref; use kernel::{    device,    firmware,    prelude::*,    str::CString,    transmute::FromBytes, //}; use crate::{    falcon::{        FalconDmaLoadTarget,        FalconFirmware, //    },    gpu,    num::{        FromSafeCast,        IntoSafeCast, //    },}; pub(crate) mod booter;pub(crate) mod fsp;pub(crate) mod fwsec;pub(crate) mod gsp;pub(crate) mod riscv; 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)]pub(crate) struct FalconUCodeDescV2 {    /// Header defined by 'NV_BIT_FALCON_UCODE_DESC_HEADER_VDESC*' in OpenRM.    hdr: u32,    /// Stored size of the ucode after the header, compressed or uncompressed    stored_size: u32,    /// Uncompressed size of the ucode.  If store_size == uncompressed_size, then the ucode    /// is not compressed.    pub(crate) uncompressed_size: u32,    /// Code entry point    pub(crate) virtual_entry: u32,    /// Offset after the code segment at which the Application Interface Table headers are located.    pub(crate) interface_offset: u32,    /// Base address at which to load the code segment into 'IMEM'.    pub(crate) imem_phys_base: u32,    /// Size in bytes of the code to copy into 'IMEM' (includes both secure and non-secure    /// segments).    pub(crate) imem_load_size: u32,    /// Virtual 'IMEM' address (i.e. 'tag') at which the code should start.    pub(crate) imem_virt_base: u32,    /// Virtual address of secure IMEM segment.    pub(crate) imem_sec_base: u32,    /// Size of secure IMEM segment.    pub(crate) imem_sec_size: u32,    /// Offset into stored (uncompressed) image at which DMEM begins.    pub(crate) dmem_offset: u32,    /// Base address at which to load the data segment into 'DMEM'.    pub(crate) dmem_phys_base: u32,    /// Size in bytes of the data to copy into 'DMEM'.    pub(crate) dmem_load_size: u32,    /// "Alternate" Size of data to load into IMEM.    pub(crate) alt_imem_load_size: u32,    /// "Alternate" Size of data to load into DMEM.    pub(crate) alt_dmem_load_size: u32,} /// Structure used to describe some firmwares, notably FWSEC-FRTS.#[repr(C)]#[derive(Debug, Clone)]pub(crate) struct FalconUCodeDescV3 {    /// Header defined by `NV_BIT_FALCON_UCODE_DESC_HEADER_VDESC*` in OpenRM.    hdr: u32,    /// Stored size of the ucode after the header.    stored_size: u32,    /// Offset in `DMEM` at which the signature is expected to be found.    pub(crate) pkc_data_offset: u32,    /// Offset after the code segment at which the app headers are located.    pub(crate) interface_offset: u32,    /// Base address at which to load the code segment into `IMEM`.    pub(crate) imem_phys_base: u32,    /// Size in bytes of the code to copy into `IMEM`.    pub(crate) imem_load_size: u32,    /// Virtual `IMEM` address (i.e. `tag`) at which the code should start.    pub(crate) imem_virt_base: u32,    /// Base address at which to load the data segment into `DMEM`.    pub(crate) dmem_phys_base: u32,    /// Size in bytes of the data to copy into `DMEM`.    pub(crate) dmem_load_size: u32,    /// Mask of the falcon engines on which this firmware can run.    pub(crate) engine_id_mask: u16,    /// ID of the ucode used to infer a fuse register to validate the signature.    pub(crate) ucode_id: u8,    /// Number of signatures in this firmware.    pub(crate) signature_count: u8,    /// Versions of the signatures, used to infer a valid signature to use.    pub(crate) signature_versions: u16,    _reserved: u16,} // SAFETY: all bit patterns are valid for this type, and it doesn't use// interior mutability.unsafe impl FromBytes for FalconUCodeDescV3 {} /// Enum wrapping the different versions of Falcon microcode descriptors.////// This allows handling both V2 and V3 descriptor formats through a/// unified type, providing version-agnostic access to firmware metadata/// via the [`FalconUCodeDescriptor`] trait.#[derive(Debug, Clone)]pub(crate) enum FalconUCodeDesc {    V2(FalconUCodeDescV2),    V3(FalconUCodeDescV3),} impl Deref for FalconUCodeDesc {    type Target = dyn FalconUCodeDescriptor;     fn deref(&self) -> &Self::Target {        match self {            FalconUCodeDesc::V2(v2) => v2,            FalconUCodeDesc::V3(v3) => v3,        }    }} /// Trait providing a common interface for accessing Falcon microcode descriptor fields.////// This trait abstracts over the different descriptor versions ([`FalconUCodeDescV2`] and/// [`FalconUCodeDescV3`]), allowing code to work with firmware metadata without needing to/// know the specific descriptor version. Fields not present return zero.pub(crate) trait FalconUCodeDescriptor {    fn hdr(&self) -> u32;    fn imem_load_size(&self) -> u32;    fn interface_offset(&self) -> u32;    fn dmem_load_size(&self) -> u32;    fn pkc_data_offset(&self) -> u32;    fn engine_id_mask(&self) -> u16;    fn ucode_id(&self) -> u8;    fn signature_count(&self) -> u8;    fn signature_versions(&self) -> u16;     /// Returns the size in bytes of the header.    fn size(&self) -> usize {        let hdr = self.hdr();         const HDR_SIZE_SHIFT: u32 = 16;        const HDR_SIZE_MASK: u32 = 0xffff0000;        ((hdr & HDR_SIZE_MASK) >> HDR_SIZE_SHIFT).into_safe_cast()    }     fn imem_sec_load_params(&self) -> FalconDmaLoadTarget;    fn imem_ns_load_params(&self) -> Option<FalconDmaLoadTarget>;    fn dmem_load_params(&self) -> FalconDmaLoadTarget;} impl FalconUCodeDescriptor for FalconUCodeDescV2 {    fn hdr(&self) -> u32 {        self.hdr    }    fn imem_load_size(&self) -> u32 {        self.imem_load_size    }    fn interface_offset(&self) -> u32 {        self.interface_offset    }    fn dmem_load_size(&self) -> u32 {        self.dmem_load_size    }    fn pkc_data_offset(&self) -> u32 {        0    }    fn engine_id_mask(&self) -> u16 {        0    }    fn ucode_id(&self) -> u8 {        0    }    fn signature_count(&self) -> u8 {        0    }    fn signature_versions(&self) -> u16 {        0    }     fn imem_sec_load_params(&self) -> FalconDmaLoadTarget {        // `imem_sec_base` is the *virtual* start address of the secure IMEM segment, so subtract        // `imem_virt_base` to get its physical offset.        let imem_sec_start = self.imem_sec_base.saturating_sub(self.imem_virt_base);         FalconDmaLoadTarget {            src_start: imem_sec_start,            dst_start: self.imem_phys_base.saturating_add(imem_sec_start),            len: self.imem_sec_size,        }    }     fn imem_ns_load_params(&self) -> Option<FalconDmaLoadTarget> {        Some(FalconDmaLoadTarget {            // Non-secure code always starts at offset 0.            src_start: 0,            dst_start: self.imem_phys_base,            // `imem_load_size` includes the size of the secure segment, so subtract it to            // get the correct amount of data to copy.            len: self.imem_load_size.saturating_sub(self.imem_sec_size),        })    }     fn dmem_load_params(&self) -> FalconDmaLoadTarget {        FalconDmaLoadTarget {            src_start: self.dmem_offset,            dst_start: self.dmem_phys_base,            len: self.dmem_load_size,        }    }} impl FalconUCodeDescriptor for FalconUCodeDescV3 {    fn hdr(&self) -> u32 {        self.hdr    }    fn imem_load_size(&self) -> u32 {        self.imem_load_size    }    fn interface_offset(&self) -> u32 {        self.interface_offset    }    fn dmem_load_size(&self) -> u32 {        self.dmem_load_size    }    fn pkc_data_offset(&self) -> u32 {        self.pkc_data_offset    }    fn engine_id_mask(&self) -> u16 {        self.engine_id_mask    }    fn ucode_id(&self) -> u8 {        self.ucode_id    }    fn signature_count(&self) -> u8 {        self.signature_count    }    fn signature_versions(&self) -> u16 {        self.signature_versions    }     fn imem_sec_load_params(&self) -> FalconDmaLoadTarget {        FalconDmaLoadTarget {            // IMEM segment always starts at offset 0.            src_start: 0,            dst_start: self.imem_phys_base,            len: self.imem_load_size,        }    }     fn imem_ns_load_params(&self) -> Option<FalconDmaLoadTarget> {        // Not used on V3 platforms        None    }     fn dmem_load_params(&self) -> FalconDmaLoadTarget {        FalconDmaLoadTarget {            // DMEM segment starts right after the IMEM one.            src_start: self.imem_load_size,            dst_start: self.dmem_phys_base,            len: self.dmem_load_size,        }    }} /// Trait implemented by types defining the signed state of a firmware.trait SignedState {} /// Type indicating that the firmware must be signed before it can be used.struct Unsigned;impl SignedState for Unsigned {} /// Type indicating that the firmware is signed and ready to be loaded.struct Signed;impl SignedState for Signed {} /// Microcode to be loaded into a specific falcon.////// This is module-local and meant for sub-modules to use internally.////// After construction, a firmware is [`Unsigned`], and must generally be patched with a signature/// before it can be loaded (with an exception for development hardware). The/// [`Self::patch_signature`] and [`Self::no_patch_signature`] methods are used to transition the/// firmware to its [`Signed`] state.// TODO: Consider replacing this with a coherent memory object once `CoherentAllocation` supports// temporary CPU-exclusive access to the object without unsafe methods.struct FirmwareObject<F: FalconFirmware, S: SignedState>(KVVec<u8>, PhantomData<(F, S)>); /// Trait for signatures to be patched directly into a given firmware.////// This is module-local and meant for sub-modules to use internally.trait FirmwareSignature<F: FalconFirmware>: AsRef<[u8]> {} impl<F: FalconFirmware> FirmwareObject<F, Unsigned> {    /// Patches the firmware at offset `signature_start` with `signature`.    fn patch_signature<S: FirmwareSignature<F>>(        mut self,        signature: &S,        signature_start: usize,    ) -> Result<FirmwareObject<F, Signed>> {        let signature_bytes = signature.as_ref();        let signature_end = signature_start            .checked_add(signature_bytes.len())            .ok_or(EOVERFLOW)?;        let dst = self            .0            .get_mut(signature_start..signature_end)            .ok_or(EINVAL)?;         // PANIC: `dst` and `signature_bytes` have the same length.        dst.copy_from_slice(signature_bytes);         Ok(FirmwareObject(self.0, PhantomData))    }     /// Mark the firmware as signed without patching it.    ///    /// This method is used to explicitly confirm that we do not need to sign the firmware, while    /// allowing us to continue as if it was. This is typically only needed for development    /// hardware.    fn no_patch_signature(self) -> FirmwareObject<F, Signed> {        FirmwareObject(self.0, PhantomData)    }} /// 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 {} // 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)    }     /// 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>); impl<const N: usize> ModInfoBuilder<N> {    const fn make_entry_file(self, chipset: &str, fw: &str) -> Self {        ModInfoBuilder(            self.0                .new_entry()                .push("nvidia/")                .push(chipset)                .push("/gsp/")                .push(fw)                .push("-")                .push(FIRMWARE_VERSION)                .push(".bin"),        )    }     const fn make_entry_chipset(self, chipset: gpu::Chipset) -> Self {        let name = chipset.name();         let this = self            .make_entry_file(name, "booter_load")            .make_entry_file(name, "booter_unload")            .make_entry_file(name, "bootloader")            .make_entry_file(name, "gsp");         let this = if chipset.needs_fwsec_bootloader() {            this.make_entry_file(name, "gen_bootloader")        } else {            this        };         if chipset.uses_fsp() {            this.make_entry_file(name, "fmc")        } else {            this        }    }     pub(crate) const fn create(        module_name: &'static core::ffi::CStr,    ) -> firmware::ModInfoBuilder<N> {        let mut this = Self(firmware::ModInfoBuilder::new(module_name));        let mut i = 0;         while i < gpu::Chipset::ALL.len() {            this = this.make_entry_chipset(gpu::Chipset::ALL[i]);            i += 1;        }         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 core::mem::size_of;     use kernel::{        bindings,        str::CStr,        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 {} 

Lines 1–500 of 665.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t