gpu: nova-core: firmware: Hopper/Blackwell support
Subsystems (5)
v5 cover gpu: nova-core: firmware: Hopper/Blackwell support
Hi,
This is based on today's linux.git. A git branch with this (plus a fix for a CLIPPY warning on a core Rust for Linux issue which I suspect others have already found and fixed) is here:
https://github.com/johnhubbard/linux/tree/nova-core-blackwell-v5
This is quite a large overhaul, multiple passes to fix up a lot of issues found during review, and then I found more while doing the fixes.
Patch 1 is going to be merged separately, but is included here in order to allow people to apply the series.
Patch 2 is going to come from Gary Guo, not here, but is included for the same reason.
The last two patches, 37 and 38, do not need to be part of this series, but are best applied *after* the series, in order to catch all the cases.
There are a also a few rust/ patches that might need/want to get merged separately.
It's been tested on Ampere and Blackwell, one each:
NovaCore 0000:e1:00.0: GPU name: NVIDIA RTX A4000
NovaCore 0000:01:00.0: GPU name: NVIDIA RTX PRO 6000 Blackwell Max-Q
Workstation EditionChanges in v5 (in highly condensed and summarized form):
* Rebased onto linux.git master.
* Split MCTP protocol into its own module and file.
* Many Rust-based improvements: more use of types, especially. Also used Result and Option more.
* Lots of cleanup of comments and print output and error handling.
* Added const_align_up() to rust/ and used it in nova-core. This required enabling a Rust feature: inline_const, as recommended by Miguel Ojeda.
* Refactoring various things, such as Gpu::new() to own Spec creation, and several more such things.
* Fixed three Delta::ZERO busy-polls (patches 21, 24, 31) to use non-zero sleep intervals (after just realizing that it was a bad choice to have zero in there).
* Reduced GH100/GB100 HAL duplication. Made FSP_PKEY_SIZE/FSP_SIG_SIZE consistent across patches. Replaced fragile architecture checks with chipset.arch(). Renamed LIBOS_BLACKWELL.
* Narrowed the scope of some of the #![expect(dead_code)] cases, although that really only matters within the series, not once it is fully applied.
John Hubbard (38):
gpu: nova-core: fix aux device registration for multi-GPU systems
gpu: nova-core: pass pdev directly to dev_* logging macros
gpu: nova-core: print FB sizes, along with ranges
gpu: nova-core: add FbRange.len() and use it in boot.rs
gpu: nova-core: Hopper/Blackwell: basic GPU identification
gpu: nova-core: factor .fwsignature* selection into a new
find_gsp_sigs_section()
gpu: nova-core: use GPU Architecture to simplify HAL selections
gpu: nova-core: apply the one "use" item per line policy to
commands.rs
gpu: nova-core: move GPU init and DMA mask setup into Gpu::new()
gpu: nova-core: set DMA mask width based on GPU architecture
gpu: nova-core: Hopper/Blackwell: skip GFW boot waiting
gpu: nova-core: move firmware image parsing code to firmware.rs
gpu: nova-core: factor out an elf_str() function
gpu: nova-core: don't assume 64-bit firmware images
gpu: nova-core: add support for 32-bit firmware images
gpu: nova-core: add auto-detection of 32-bit, 64-bit firmware images
gpu: nova-core: Hopper/Blackwell: add FMC firmware image, in support
of FSP
gpu: nova-core: Hopper/Blackwell: add FSP falcon engine stub
gpu: nova-core: Hopper/Blackwell: add FSP falcon EMEM operations
gpu: nova-core: Hopper/Blackwell: add FSP message infrastructure
rust: ptr: add const_align_up() and enable inline_const feature
gpu: nova-core: Hopper/Blackwell: calculate reserved FB heap size
gpu: nova-core: add MCTP/NVDM protocol types for firmware
communication
gpu: nova-core: Hopper/Blackwell: add FSP secure boot completion
waiting
gpu: nova-core: Hopper/Blackwell: add FSP message structures
gpu: nova-core: Hopper/Blackwell: add FMC signature extraction
gpu: nova-core: Hopper/Blackwell: add FSP send/receive messaging
gpu: nova-core: Hopper/Blackwell: add FspCotVersion type
gpu: nova-core: Hopper/Blackwell: larger non-WPR heap
gpu: nova-core: Hopper/Blackwell: add FSP Chain of Trust boot
gpu: nova-core: Blackwell: use correct sysmem flush registers
gpu: nova-core: Hopper/Blackwell: larger WPR2 (GSP) heap
gpu: nova-core: refactor SEC2 booter loading into
BooterFirmware::run()
gpu: nova-core: Hopper/Blackwell: add GSP lockdown release polling
gpu: nova-core: Hopper/Blackwell: new location for PCI config mirror
gpu: nova-core: Hopper/Blackwell: integrate FSP boot path into boot()
rust: sizes: add u64 variants of SZ_* constants
gpu: nova-core: use SZ_*_U64 constants from kernel::sizes
drivers/gpu/nova-core/driver.rs | 32 +- drivers/gpu/nova-core/falcon.rs | 1 + drivers/gpu/nova-core/falcon/fsp.rs | 222 ++++++++++ drivers/gpu/nova-core/falcon/hal.rs | 20 +- drivers/gpu/nova-core/fb.rs | 123 ++++-- drivers/gpu/nova-core/fb/hal.rs | 38 +- drivers/gpu/nova-core/fb/hal/ga102.rs | 2 +- drivers/gpu/nova-core/fb/hal/gb100.rs | 75 ++++ drivers/gpu/nova-core/fb/hal/gb202.rs | 62 +++ drivers/gpu/nova-core/fb/hal/gh100.rs | 38 ++ drivers/gpu/nova-core/firmware.rs | 186 ++++++++ drivers/gpu/nova-core/firmware/booter.rs | 35 +- drivers/gpu/nova-core/firmware/fsp.rs | 46 ++ drivers/gpu/nova-core/firmware/gsp.rs | 140 ++---- drivers/gpu/nova-core/fsp.rs | 525 +++++++++++++++++++++++ drivers/gpu/nova-core/gpu.rs | 119 ++++- drivers/gpu/nova-core/gsp/boot.rs | 318 ++++++++++---- drivers/gpu/nova-core/gsp/commands.rs | 8 +- drivers/gpu/nova-core/gsp/fw.rs | 95 ++-- drivers/gpu/nova-core/gsp/fw/commands.rs | 32 +- drivers/gpu/nova-core/mctp.rs | 105 +++++ drivers/gpu/nova-core/nova_core.rs | 2 + drivers/gpu/nova-core/regs.rs | 103 ++++- rust/kernel/ptr.rs | 27 ++ rust/kernel/sizes.rs | 51 +++ scripts/Makefile.build | 2 +- 26 files changed, 2098 insertions(+), 309 deletions(-) create mode 100644 drivers/gpu/nova-core/falcon/fsp.rs create mode 100644 drivers/gpu/nova-core/fb/hal/gb100.rs create mode 100644 drivers/gpu/nova-core/fb/hal/gb202.rs create mode 100644 drivers/gpu/nova-core/fb/hal/gh100.rs create mode 100644 drivers/gpu/nova-core/firmware/fsp.rs create mode 100644 drivers/gpu/nova-core/fsp.rs create mode 100644 drivers/gpu/nova-core/mctp.rs
base-commit: a95f71ad3e2e224277508e006580c333d0a5fe36
prerequisite-patch-id: 1ec0faa352dab8fa7c0f209474b75cd21931340d
Signature · 1 line
2.53.0
PATCH v5 1/38 gpu: nova-core: fix aux device registration for multi-GPU systems
The auxiliary device registration was using a hardcoded ID of 0, which caused probe() to fail on multi-GPU systems with:
sysfs: cannot create duplicate filename '/bus/auxiliary/devices/NovaCore.nova-drm.0'
Fix this by using an atomic counter to generate unique IDs for each GPU's aux device registration. The TODO item to eventually use XArray for recycling aux device IDs is retained, but for now, this works very nicely.
This has the side effect of making debugfs[1] work on multi-GPU systems.
[1] https://lore.kernel.org/[email protected]
--- drivers/gpu/nova-core/driver.rs | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-)
drivers/gpu/nova-core/driver.rs +14 -1
@@ -1,5 +1,10 @@// SPDX-License-Identifier: GPL-2.0 +use core::sync::atomic::{ +AtomicU32 , +Ordering ,// +}; +use kernel::{ auxiliary, device::Core ,
@@ -19,6 +24,9 @@use crate ::gpu::Gpu ; +/// Counter for generating unique auxiliary device IDs. +static AUXILIARY_ID_COUNTER :AtomicU32 =AtomicU32 ::new (0 ); +#[pin_data] pub (crate )struct NovaCore { #[pin]
@@ -85,12 +93,17 @@ fn probe(pdev: &pci::Device<Core>, _info: &Self::IdInfo) -> impl PinInit<Self, E GFP_KERNEL, )?; +// TODO[XARR]: Use XArray for proper ID allocation/recycling. Until then, use a simple +// atomic counter which never recycles IDs. A unique ID is required for multi-GPU +// systems, because without it, probe() would fail for all but the first GPU. +let aux_id =AUXILIARY_ID_COUNTER .fetch_add (1 ,Ordering ::Relaxed ); +Ok (try_pin_init! (Self { gpu <-Gpu ::new (pdev, bar.clone (), bar.access (pdev.as_ref ())?), _reg <- auxiliary::Registration ::new ( pdev.as_ref (),c"nova-drm" , -0 ,// TODO[XARR]: Once it lands, use XArray; for now we don't use the ID. + aux_id,crate ::MODULE_NAME ), }))
Signature · 1 line
2.53.0
Re: [PATCH v5 01/38] gpu: nova-core: fix aux device registration for multi-GPU systems
Quoted 10 lines · John Hubbard
The auxiliary device registration was using a hardcoded ID of 0, which caused
probe()to fail on multi-GPU systems with:sysfs: cannot create duplicate filename '/bus/auxiliary/devices/NovaCore.nova-drm.0'
Fix this by using an atomic counter to generate unique IDs for each GPU's aux device registration. The TODO item to eventually use XArray for recycling aux device IDs is retained, but for now, this works very nicely.
Quoted 6 lines
This has the side effect of making debugfs[1] work on multi-GPU systems.
[1] https://lore.kernel.org/[email protected]
Reviewed-by Gary Guo <[email protected]>Signed-off-by John Hubbard <[email protected]>
Applied to drm-rust-next, thanks!
[ Use LKMM atomics; inline and slightly reword TODO comment. - Danilo ]
Gary Guo
reviewerRe: [PATCH v5 01/38] gpu: nova-core: fix aux device registration for multi-GPU systems
Quoted 13 lines · Danilo Krummrich
Quoted 12 lines · John Hubbard
The auxiliary device registration was using a hardcoded ID of 0, which caused
probe()to fail on multi-GPU systems with:sysfs: cannot create duplicate filename '/bus/auxiliary/devices/NovaCore.nova-drm.0'
Fix this by using an atomic counter to generate unique IDs for each GPU's aux device registration. The TODO item to eventually use XArray for recycling aux device IDs is retained, but for now, this works very nicely.
This has the side effect of making debugfs[1] work on multi-GPU systems.
Quoted 8 lines
Quoted 4 lines
[1] https://lore.kernel.org/[email protected]
Reviewed-by Gary Guo <[email protected]>Signed-off-by John Hubbard <[email protected]>Applied to drm-rust-next, thanks!
[ Use LKMM atomics; inline and slightly reword TODO comment. - Danilo ]
Danilo, can you drop this patch from drm-rust-next?
The patch that is supposed to be queued is
https://lore.kernel.org/rust-for-linux/[email protected]/#t,
which does correctly use LKMM atomics and add comments about possible use of XArray.
In fact, I am not sure why this patch carries my R-b.
Best,
Gary
Gary Guo
reviewerRe: [PATCH v5 01/38] gpu: nova-core: fix aux device registration for multi-GPU systems
Quoted 23 lines · Gary Guo
Quoted 13 lines · Danilo Krummrich
Quoted 12 lines · John Hubbard
The auxiliary device registration was using a hardcoded ID of 0, which caused
probe()to fail on multi-GPU systems with:sysfs: cannot create duplicate filename '/bus/auxiliary/devices/NovaCore.nova-drm.0'
Fix this by using an atomic counter to generate unique IDs for each GPU's aux device registration. The TODO item to eventually use XArray for recycling aux device IDs is retained, but for now, this works very nicely.
This has the side effect of making debugfs[1] work on multi-GPU systems.
Quoted 8 lines
Quoted 4 lines
[1] https://lore.kernel.org/[email protected]
Reviewed-by Gary Guo <[email protected]>Signed-off-by John Hubbard <[email protected]>Applied to drm-rust-next, thanks!
[ Use LKMM atomics; inline and slightly reword TODO comment. - Danilo ]
Quoted 8 lines
Danilo, can you drop this patch from drm-rust-next?
The patch that is supposed to be queued is
https://lore.kernel.org/rust-for-linux/[email protected]/#t,
which does correctly use LKMM atomics and add comments about possible use of XArray.In fact, I am not sure why this patch carries my R-b.
Hmm, actually this patch contains updated comment but somehow have LKMM atomics changed back to Rust atomics. Not sure what happens. Anyhow that patch should be picked instead.
Best,
Gary
Quoted 3 lines
Best,
Gary
Danilo Krummrich
maintainerRe: [PATCH v5 01/38] gpu: nova-core: fix aux device registration for multi-GPU systems
Quoted 31 lines · Gary Guo
Quoted 30 lines · Gary Guo
Quoted 13 lines · Danilo Krummrich
Quoted 12 lines · John Hubbard
The auxiliary device registration was using a hardcoded ID of 0, which caused
probe()to fail on multi-GPU systems with:sysfs: cannot create duplicate filename '/bus/auxiliary/devices/NovaCore.nova-drm.0'
Fix this by using an atomic counter to generate unique IDs for each GPU's aux device registration. The TODO item to eventually use XArray for recycling aux device IDs is retained, but for now, this works very nicely.
This has the side effect of making debugfs[1] work on multi-GPU systems.
Quoted 8 lines
Quoted 4 lines
[1] https://lore.kernel.org/[email protected]
Reviewed-by Gary Guo <[email protected]>Signed-off-by John Hubbard <[email protected]>Applied to drm-rust-next, thanks!
[ Use LKMM atomics; inline and slightly reword TODO comment. - Danilo ]
Danilo, can you drop this patch from drm-rust-next?
The patch that is supposed to be queued is
https://lore.kernel.org/rust-for-linux/[email protected]/#t,
which does correctly use LKMM atomics and add comments about possible use of XArray.
Quoted 5 lines
Quoted 1 line
In fact, I am not sure why this patch carries my R-b.
Hmm, actually this patch contains updated comment but somehow have LKMM atomics changed back to Rust atomics. Not sure what happens. Anyhow that patch should be picked instead.
I picked up the latest version of this patch and fixed up the LKMM atomics, i.e. the result should be correct:
https://gitlab.freedesktop.org/drm/rust/kernel/-/commit/d3f36fa57aa289c43e01da16c928a2cd971ad5dc
Looks like I could have picked v2 instead, as it seems to be identical except that it already uses LKMM atomics.
@John: For the future, please don't send patches in multiple series / ways. I think there was no reason to include the patch in this series in the first place.
Thanks,
Danilo
Re: [PATCH v5 01/38] gpu: nova-core: fix aux device registration for multi-GPU systems
Quoted 4 lines · Danilo Krummrich
Quoted 3 lines · Gary Guo
Quoted 2 lines · Gary Guo
Quoted 1 line · Danilo Krummrich
On 2/21/26 3:09 AM, John Hubbard wrote:
...
Quoted 11 lines
I picked up the latest version of this patch and fixed up the LKMM atomics, i.e. the result should be correct:
https://gitlab.freedesktop.org/drm/rust/kernel/-/commit/d3f36fa57aa289c43e01da16c928a2cd971ad5dc
Looks like I could have picked v2 instead, as it seems to be identical except that it already uses LKMM atomics.
@John: For the future, please don't send patches in multiple series / ways. I think there was no reason to include the patch in this series in the first place.
OK, and sorry about the mix-up! I thought it would be "helpful", but this turned out to be the opposite of that. :)
thanks,
John Hubbard
PATCH v5 2/38 gpu: nova-core: pass pdev directly to dev_* logging macros
In reply to John HubbardThe dev_dbg!, dev_info!, dev_err!, and dev_warn! macros now accept pci::Device directly without requiring an explicit .as_ref() conversion to device::Device, thanks to commit a38cd1fea989 ("rust: device: support dev_printk on all devices").
--- drivers/gpu/nova-core/driver.rs | 2 +- drivers/gpu/nova-core/gpu.rs | 4 ++-- drivers/gpu/nova-core/gsp/boot.rs | 14 +++++++------- 3 files changed, 10 insertions(+), 10 deletions(-)
drivers/gpu/nova-core/driver.rs +1 -1
@@ -78,7 +78,7 @@ impl pci::Driver for NovaCore {fn probe (pdev: &pci::Device <Core >, _info: &Self ::IdInfo ) ->impl PinInit <Self ,Error > { pin_init::pin_init_scope (move || { -dev_dbg! (pdev.as_ref (),"Probe Nova Core GPU driver.\n" ); +dev_dbg! (pdev,"Probe Nova Core GPU driver.\n" ); pdev.enable_device_mem ()?; pdev.set_master ();
drivers/gpu/nova-core/gpu.rs +2 -2
@@ -262,13 +262,13 @@ pub(crate) fn new<'a>( ) -> impl PinInit<Self, Error> + 'a {try_pin_init! (Self { spec:Spec ::new (pdev.as_ref (), bar).inspect (|spec| { -dev_info! (pdev.as_ref (),"NVIDIA ({})\n" , spec); +dev_info! (pdev,"NVIDIA ({})\n" , spec); })?,// We must wait for GFW_BOOT completion before doing any significant setup on the GPU. _: { gfw::wait_gfw_boot_completion (bar) - .inspect_err (|_|dev_err! (pdev.as_ref (),"GFW boot did not complete\n" ))?; + .inspect_err (|_|dev_err! (pdev,"GFW boot did not complete\n" ))?; }, sysmem_flush:SysmemFlush ::register (pdev.as_ref (), bar, spec.chipset)?,
drivers/gpu/nova-core/gsp/boot.rs +7 -7
@@ -171,14 +171,14 @@ pub(crate) fn boot( Some((libos_handle >> 32) as u32), )?;dev_dbg! ( - pdev.as_ref (), + pdev,"GSP MBOX0: {:#x}, MBOX1: {:#x}\n" , mbox0, mbox1 );dev_dbg! ( - pdev.as_ref (), + pdev,"Using SEC2 to load and run the booter_load firmware...\n" );
@@ -191,7 +191,7 @@ pub(crate) fn boot( Some((wpr_handle >> 32) as u32), )?;dev_dbg! ( - pdev.as_ref (), + pdev,"SEC2 MBOX0: {:#x}, MBOX1{:#x}\n" , mbox0, mbox1
@@ -199,7 +199,7 @@ pub(crate) fn boot(if mbox0 !=0 {dev_err! ( - pdev.as_ref (), + pdev,"Booter-load failed with error {:#x}\n" , mbox0 );
@@ -217,7 +217,7 @@ pub(crate) fn boot( )?;dev_dbg! ( - pdev.as_ref (), + pdev,"RISC-V active? {}\n" , gsp_falcon.is_riscv_active (bar), );
@@ -239,8 +239,8 @@ pub(crate) fn boot(// Obtain and display basic GPU information. let info = commands::get_gsp_info (&mut self.cmdq, bar)?;match info.gpu_name () { -Ok (name) =>dev_info! (pdev.as_ref (),"GPU name: {}\n" , name), -Err (e) =>dev_warn! (pdev.as_ref (),"GPU name unavailable: {:?}\n" , e), +Ok (name) =>dev_info! (pdev,"GPU name: {}\n" , name), +Err (e) =>dev_warn! (pdev,"GPU name unavailable: {:?}\n" , e), }Ok (())
Signature · 1 line
2.53.0
PATCH v5 3/38 gpu: nova-core: print FB sizes, along with ranges
In reply to John HubbardFor convenience of the reader: now you can directly see the sizes of each range. It is surprising just how much this helps.
Sample output (using an Ampere GA104):
NovaCore 0000:e1:00.0: FbLayout {
fb: 0x0..0x3ff800000 (16376 MiB),
vga_workspace: 0x3ff700000..0x3ff800000 (1 MiB),
frts: 0x3ff600000..0x3ff700000 (1 MiB),
boot: 0x3ff5fa000..0x3ff600000 (24 KiB),
elf: 0x3fb960000..0x3ff5f9000 (60 MiB),
wpr2_heap: 0x3f3900000..0x3fb900000 (128 MiB),
wpr2: 0x3f3800000..0x3ff700000 (191 MiB),
heap: 0x3f3700000..0x3f3800000 (1 MiB),
vf_partition_count: 0x0,
}--- drivers/gpu/nova-core/fb.rs | 83 +++++++++++++++++++++++++++++-------- 1 file changed, 66 insertions(+), 17 deletions(-)
drivers/gpu/nova-core/fb.rs +66 -17
@@ -1,9 +1,13 @@// SPDX-License-Identifier: GPL-2.0 -use core::ops::Range ; +use core::ops::{ +Deref , +Range ,// +};use kernel::{ device, + fmt, prelude::*, ptr::{Alignable ,
@@ -94,26 +98,71 @@ pub(crate) fn unregister(&self, bar: &Bar0) { } } +pub (crate )struct FbRange (Range <u64 >); + +impl From <Range <u64 >>for FbRange { +fn from (range:Range <u64 >) ->Self { +Self (range) + } +} + +impl Deref for FbRange { +type Target =Range <u64 >; + +fn deref (&self) -> &Self ::Target { + &self.0 + } +} + +impl fmt::Debug for FbRange { +fn fmt (&self, f: &mut fmt::Formatter <'_>) -> fmt::Result { +// Use alternate format ({:#?}) to include size, compact format ({:?}) for just the range. +if f.alternate () { +let size = self.0 .end - self.0 .start; + +if size <usize_as_u64 (SZ_1M ) { +let size_kib = size /usize_as_u64 (SZ_1K ); + f.write_fmt (fmt! ( +"{:#x}..{:#x} ({} KiB)" , + self.0 .start, + self.0 .end, + size_kib + )) + }else { +let size_mib = size /usize_as_u64 (SZ_1M ); + f.write_fmt (fmt! ( +"{:#x}..{:#x} ({} MiB)" , + self.0 .start, + self.0 .end, + size_mib + )) + } + }else { + f.write_fmt (fmt! ("{:#x}..{:#x}" , self.0 .start, self.0 .end)) + } + } +} +/// Layout of the GPU framebuffer memory. /// /// Contains ranges of GPU memory reserved for a given purpose during the GSP boot process. #[derive( Debug )] pub (crate )struct FbLayout {/// Range of the framebuffer. Starts at `0`. -pub (crate ) fb:Range <u64 >, +pub (crate ) fb:FbRange ,/// VGA workspace, small area of reserved memory at the end of the framebuffer. -pub (crate ) vga_workspace:Range <u64 >, +pub (crate ) vga_workspace:FbRange ,/// FRTS range. -pub (crate ) frts:Range <u64 >, +pub (crate ) frts:FbRange ,/// Memory area containing the GSP bootloader image. -pub (crate ) boot:Range <u64 >, +pub (crate ) boot:FbRange ,/// Memory area containing the GSP firmware image. -pub (crate ) elf:Range <u64 >, +pub (crate ) elf:FbRange ,/// WPR2 heap. -pub (crate ) wpr2_heap:Range <u64 >, +pub (crate ) wpr2_heap:FbRange ,/// WPR2 region range, starting with an instance of `GspFwWprMeta`. -pub (crate ) wpr2:Range <u64 >, -pub (crate ) heap:Range <u64 >, +pub (crate ) wpr2:FbRange , +pub (crate ) heap:FbRange ,pub (crate ) vf_partition_count:u8 , }
@@ -125,7 +174,7 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result<let fb = {let fb_size = hal.vidmem_size (bar); -0 ..fb_size +FbRange (0 ..fb_size) };let vga_workspace = {
@@ -152,7 +201,7 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result< } }; - vga_base..fb.end +FbRange (vga_base..fb.end) };let frts = {
@@ -160,7 +209,7 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result<const FRTS_SIZE :u64 =usize_as_u64 (SZ_1M );let frts_base = vga_workspace.start.align_down (FRTS_DOWN_ALIGN ) -FRTS_SIZE ; - frts_base..frts_base +FRTS_SIZE +FbRange (frts_base..frts_base +FRTS_SIZE ) };let boot = {
@@ -168,7 +217,7 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result<let bootloader_size = u64::from_safe_cast (gsp_fw.bootloader.ucode.size ());let bootloader_base = (frts.start - bootloader_size).align_down (BOOTLOADER_DOWN_ALIGN ); - bootloader_base..bootloader_base + bootloader_size +FbRange (bootloader_base..bootloader_base + bootloader_size) };let elf = {
@@ -176,7 +225,7 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result<let elf_size = u64::from_safe_cast (gsp_fw.size);let elf_addr = (boot.start - elf_size).align_down (ELF_DOWN_ALIGN ); - elf_addr..elf_addr + elf_size +FbRange (elf_addr..elf_addr + elf_size) };let wpr2_heap = {
@@ -185,7 +234,7 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result< gsp::LibosParams ::from_chipset (chipset).wpr_heap_size (chipset, fb.end);let wpr2_heap_addr = (elf.start - wpr2_heap_size).align_down (WPR2_HEAP_DOWN_ALIGN ); - wpr2_heap_addr..(elf.start).align_down (WPR2_HEAP_DOWN_ALIGN ) +FbRange (wpr2_heap_addr..(elf.start).align_down (WPR2_HEAP_DOWN_ALIGN )) };let wpr2 = {
@@ -193,13 +242,13 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result<let wpr2_addr = (wpr2_heap.start - u64::from_safe_cast (size_of ::<gsp::GspFwWprMeta >())) .align_down (WPR2_DOWN_ALIGN ); - wpr2_addr..frts.end +FbRange (wpr2_addr..frts.end) };let heap = {const HEAP_SIZE :u64 =usize_as_u64 (SZ_1M ); - wpr2.start -HEAP_SIZE ..wpr2.start +FbRange (wpr2.start -HEAP_SIZE ..wpr2.start) };Ok (Self {
Signature · 1 line
2.53.0
PATCH v5 4/38 gpu: nova-core: add FbRange.len() and use it in boot.rs
In reply to John HubbardA tiny simplification: now that FbLayout uses its own specific FbRange type, add an FbRange.len() method, and use that to (very slightly) simplify the calculation of Frts::frts_size initialization.
--- drivers/gpu/nova-core/fb.rs | 8 +++++++- drivers/gpu/nova-core/gsp/boot.rs | 2 +- 2 files changed, 8 insertions(+), 2 deletions(-)
drivers/gpu/nova-core/fb.rs +7 -1
@@ -100,6 +100,12 @@ pub(crate) fn unregister(&self, bar: &Bar0) {pub (crate )struct FbRange (Range <u64 >); +impl FbRange { +pub (crate )fn len (&self) ->u64 { + self.0 .end - self.0 .start + } +} +impl From <Range <u64 >>for FbRange {fn from (range:Range <u64 >) ->Self {Self (range)
@@ -118,7 +124,7 @@ impl fmt::Debug for FbRange {fn fmt (&self, f: &mut fmt::Formatter <'_>) -> fmt::Result {// Use alternate format ({:#?}) to include size, compact format ({:?}) for just the range. if f.alternate () { -let size = self.0 .end - self.0 .start; +let size = self.len ();if size <usize_as_u64 (SZ_1M ) {let size_kib = size /usize_as_u64 (SZ_1K );
drivers/gpu/nova-core/gsp/boot.rs +1 -1
@@ -70,7 +70,7 @@ fn run_fwsec_frts( bios,FwsecCommand ::Frts { frts_addr: fb_layout.frts.start, - frts_size: fb_layout.frts.end - fb_layout.frts.start, + frts_size: fb_layout.frts.len (), }, )?;
Signature · 1 line
2.53.0
PATCH v5 5/38 gpu: nova-core: Hopper/Blackwell: basic GPU identification
In reply to John HubbardHopper (GH100) and Blackwell identification, including ELF .fwsignature_* items.
--- drivers/gpu/nova-core/falcon/hal.rs | 3 ++- drivers/gpu/nova-core/fb/hal.rs | 5 ++--- drivers/gpu/nova-core/firmware/gsp.rs | 17 +++++++++++++++++ drivers/gpu/nova-core/gpu.rs | 22 ++++++++++++++++++++++ 4 files changed, 43 insertions(+), 4 deletions(-)
drivers/gpu/nova-core/falcon/hal.rs +2 -1
@@ -76,7 +76,8 @@ pub(super) fn falcon_hal<E: FalconEngine + 'static>( TU102 | TU104 | TU106 | TU116 | TU117 => {KBox ::new (tu102::Tu102 ::<E >::new (),GFP_KERNEL )?as KBox <dyn FalconHal <E >> } - GA102 | GA103 | GA104 | GA106 | GA107 | AD102 | AD103 | AD104 | AD106 | AD107 => { + GA102 | GA103 | GA104 | GA106 | GA107 | AD102 | AD103 | AD104 | AD106 | AD107 | GH100 + | GB100 | GB102 | GB202 | GB203 | GB205 | GB206 | GB207 => {KBox ::new (ga102::Ga102 ::<E >::new (),GFP_KERNEL )?as KBox <dyn FalconHal <E >> } _ => return Err(ENOTSUPP),
drivers/gpu/nova-core/fb/hal.rs +2 -3
@@ -34,8 +34,7 @@ pub(super) fn fb_hal(chipset: Chipset) -> &'static dyn FbHal {match chipset {TU102 |TU104 |TU106 |TU117 |TU116 => tu102::TU102_HAL ,GA100 => ga100::GA100_HAL , -GA102 |GA103 |GA104 |GA106 |GA107 |AD102 |AD103 |AD104 |AD106 |AD107 => { - ga102::GA102_HAL - } +GA102 |GA103 |GA104 |GA106 |GA107 |AD102 |AD103 |AD104 |AD106 |AD107 |GH100 + |GB100 |GB102 |GB202 |GB203 |GB205 |GB206 |GB207 => ga102::GA102_HAL , } }
drivers/gpu/nova-core/firmware/gsp.rs +17 -0
@@ -222,6 +222,23 @@ pub(crate) fn new<'a>( Architecture::Ampere if chipset == Chipset::GA100 => ".fwsignature_tu10x", Architecture::Ampere => ".fwsignature_ga10x", Architecture::Ada => ".fwsignature_ad10x", + Architecture::Hopper => ".fwsignature_gh10x", + Architecture::Blackwell => { + // Distinguish between GB10x and GB20x series + match chipset { + // GB10x series: GB100, GB102 + Chipset::GB100 | Chipset::GB102 => ".fwsignature_gb10x", + // GB20x series: GB202, GB203, GB205, GB206, GB207 + Chipset::GB202 + | Chipset::GB203 + | Chipset::GB205 + | Chipset::GB206 + | Chipset::GB207 => ".fwsignature_gb20x", + // It's not possible to get here with a non-Blackwell chipset, but + // Rust doesn't know that. + _ => return Err(ENOTSUPP), + } + } }; elf::elf64_section(firmware.data(), sigs_section)
drivers/gpu/nova-core/gpu.rs +22 -0
@@ -83,12 +83,22 @@ fn try_from(value: u32) -> Result<Self, Self::Error> { GA104 = 0x174, GA106 = 0x176, GA107 = 0x177, +// Hopper + GH100 = 0x180,// Ada AD102 = 0x192, AD103 = 0x193, AD104 = 0x194, AD106 = 0x196, AD107 = 0x197, +// Blackwell + GB100 = 0x1a0, + GB102 = 0x1a2, + GB202 = 0x1b2, + GB203 = 0x1b3, + GB205 = 0x1b5, + GB206 = 0x1b6, + GB207 = 0x1b7, });impl Chipset {
@@ -100,9 +110,17 @@ pub(crate) fn arch(&self) -> Architecture { Self::GA100 | Self::GA102 | Self::GA103 | Self::GA104 | Self::GA106 | Self::GA107 => { Architecture::Ampere } + Self::GH100 => Architecture::Hopper, Self::AD102 | Self::AD103 | Self::AD104 | Self::AD106 | Self::AD107 => { Architecture::Ada } +Self ::GB100 + |Self ::GB102 + |Self ::GB202 + |Self ::GB203 + |Self ::GB205 + |Self ::GB206 + | Self::GB207 => Architecture::Blackwell, } } }
@@ -132,7 +150,9 @@ pub(crate) enum Architecture {#[default] Turing = 0x16, Ampere = 0x17, + Hopper = 0x18, Ada = 0x19, + Blackwell = 0x1b, }impl TryFrom <u8 >for Architecture {
@@ -142,7 +162,9 @@ fn try_from(value: u8) -> Result<Self> {match value {0x16 =>Ok (Self ::Turing ),0x17 =>Ok (Self ::Ampere ), +0x18 =>Ok (Self ::Hopper ),0x19 =>Ok (Self ::Ada ), +0x1b =>Ok (Self ::Blackwell ), _ =>Err (ENODEV ), } }
Signature · 1 line
2.53.0
PATCH v5 6/38 gpu: nova-core: factor .fwsignature* selection into a new find_gsp_sigs_section()
In reply to John HubbardKeep Gsp::new() from getting too cluttered, by factoring out the selection of .fwsignature* items. This will continue to grow as we add GPUs.
--- drivers/gpu/nova-core/firmware/gsp.rs | 60 ++++++++++++++------------- 1 file changed, 31 insertions(+), 29 deletions(-)
drivers/gpu/nova-core/firmware/gsp.rs +31 -29
@@ -146,6 +146,36 @@ pub(crate) struct GspFirmware { }impl GspFirmware { +fn find_gsp_sigs_section (chipset:Chipset ) ->Option <&'staticstr > { +match chipset.arch () { +Architecture ::Turing if matches! (chipset,Chipset ::TU116 |Chipset ::TU117 ) => { +Some (".fwsignature_tu11x" ) + } +Architecture ::Turing =>Some (".fwsignature_tu10x" ), +// GA100 uses the same firmware as Turing +Architecture ::Ampere if chipset ==Chipset ::GA100 =>Some (".fwsignature_tu10x" ), +Architecture ::Ampere =>Some (".fwsignature_ga10x" ), +Architecture ::Ada =>Some (".fwsignature_ad10x" ), +Architecture ::Hopper =>Some (".fwsignature_gh10x" ), +Architecture ::Blackwell => { +// Distinguish between GB10x and GB20x series +match chipset { +// GB10x series: GB100, GB102 +Chipset ::GB100 |Chipset ::GB102 =>Some (".fwsignature_gb10x" ), +// GB20x series: GB202, GB203, GB205, GB206, GB207 +Chipset ::GB202 + |Chipset ::GB203 + |Chipset ::GB205 + |Chipset ::GB206 + |Chipset ::GB207 =>Some (".fwsignature_gb20x" ), +// It's not possible to get here with a non-Blackwell chipset, but Rust doesn't +// know that. + _ =>None , + } + } + } + } +/// Loads the GSP firmware binaries, map them into `dev`'s address-space, and creates the page /// tables expected by the GSP bootloader to load it. pub(crate) fn new<'a>(
@@ -211,35 +241,7 @@ pub(crate) fn new<'a>( }, size, signatures: { - let sigs_section = match chipset.arch() { -Architecture ::Turing -if matches! (chipset,Chipset ::TU116 |Chipset ::TU117 ) => - { -".fwsignature_tu11x" - } -Architecture ::Turing =>".fwsignature_tu10x" , -// GA100 uses the same firmware as Turing -Architecture ::Ampere if chipset ==Chipset ::GA100 =>".fwsignature_tu10x" , -Architecture ::Ampere =>".fwsignature_ga10x" , -Architecture ::Ada =>".fwsignature_ad10x" , -Architecture ::Hopper =>".fwsignature_gh10x" , -Architecture ::Blackwell => { -// Distinguish between GB10x and GB20x series -match chipset { -// GB10x series: GB100, GB102 -Chipset ::GB100 |Chipset ::GB102 =>".fwsignature_gb10x" , -// GB20x series: GB202, GB203, GB205, GB206, GB207 -Chipset ::GB202 - |Chipset ::GB203 - |Chipset ::GB205 - |Chipset ::GB206 - |Chipset ::GB207 =>".fwsignature_gb20x" , -// It's not possible to get here with a non-Blackwell chipset, but -// Rust doesn't know that. - _ =>return Err (ENOTSUPP ), - } - } - }; + let sigs_section = Self::find_gsp_sigs_section(chipset).ok_or(ENOTSUPP)?; elf::elf64_section (firmware.data (), sigs_section) .ok_or (EINVAL )
Signature · 1 line
2.53.0
PATCH v5 7/38 gpu: nova-core: use GPU Architecture to simplify HAL selections
In reply to John HubbardReplace per-chipset match arms with Architecture-based matching in the falcon and FB HAL selection functions. This reduces the number of match arms that need updating when new chipsets are added within an existing architecture.
--- drivers/gpu/nova-core/falcon/hal.rs | 21 +++++++++++++-------- drivers/gpu/nova-core/fb/hal.rs | 17 +++++++++-------- 2 files changed, 22 insertions(+), 16 deletions(-)
drivers/gpu/nova-core/falcon/hal.rs +13 -8
@@ -9,7 +9,10 @@ FalconBromParams, FalconEngine, // }, - gpu::Chipset, + gpu::{ +Architecture , +Chipset ,// + }, };mod ga102;
@@ -70,17 +73,19 @@ fn signature_reg_fuse_version(pub (super )fn falcon_hal <E :FalconEngine + 'static>( chipset:Chipset , ) ->Result <KBox <dyn FalconHal <E >>> { -use Chipset ::*; - -let hal =match chipset { -TU102 |TU104 |TU106 |TU116 |TU117 => { +let hal =match chipset.arch () { +Architecture ::Turing => {KBox ::new (tu102::Tu102 ::<E >::new (),GFP_KERNEL )?as KBox <dyn FalconHal <E >> } -GA102 |GA103 |GA104 |GA106 |GA107 |AD102 |AD103 |AD104 |AD106 |AD107 |GH100 - |GB100 |GB102 |GB202 |GB203 |GB205 |GB206 |GB207 => { +// TODO: support GA100. Its boot sequence is a lot like Turing, except that it handles the +// FRTS steps differently (specifically, it skips FWSEC-FRTS). +Architecture ::Ampere if chipset ==Chipset ::GA100 =>return Err (ENOTSUPP ), +Architecture ::Ampere + |Architecture ::Hopper + |Architecture ::Ada + |Architecture ::Blackwell => {KBox ::new (ga102::Ga102 ::<E >::new (),GFP_KERNEL )?as KBox <dyn FalconHal <E >> } - _ =>return Err (ENOTSUPP ), };Ok (hal)
drivers/gpu/nova-core/fb/hal.rs +9 -8
@@ -4,7 +4,10 @@use crate ::{ driver::Bar0 , - gpu::Chipset ,// + gpu::{ +Architecture , +Chipset ,// + }, };mod ga100;
@@ -29,12 +32,10 @@ pub(crate) trait FbHal {/// Returns the HAL corresponding to `chipset`. pub (super )fn fb_hal (chipset:Chipset ) -> &'staticdyn FbHal { -use Chipset ::*; - -match chipset { -TU102 |TU104 |TU106 |TU117 |TU116 => tu102::TU102_HAL , -GA100 => ga100::GA100_HAL , -GA102 |GA103 |GA104 |GA106 |GA107 |AD102 |AD103 |AD104 |AD106 |AD107 |GH100 - |GB100 |GB102 |GB202 |GB203 |GB205 |GB206 |GB207 => ga102::GA102_HAL , +match chipset.arch () { +Architecture ::Turing => tu102::TU102_HAL , +Architecture ::Ampere if chipset ==Chipset ::GA100 => ga100::GA100_HAL , +Architecture ::Ampere => ga102::GA102_HAL , +Architecture ::Ada |Architecture ::Hopper |Architecture ::Blackwell => ga102::GA102_HAL , } }
Signature · 1 line
2.53.0
PATCH v5 8/38 gpu: nova-core: apply the one "use" item per line policy to commands.rs
In reply to John HubbardAs per [1], we need one "use" item per line, in order to reduce merge conflicts. Furthermore, we need a trailing ", //" in order to tell rustfmt(1) to leave it alone.
This does that for commands.rs, which is the only file in nova-core that has any remaining instances of the old style.
[1] https://docs.kernel.org/rust/coding-guidelines.html#imports
--- drivers/gpu/nova-core/gsp/fw/commands.rs | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-)
drivers/gpu/nova-core/gsp/fw/commands.rs +9 -3
@@ -1,8 +1,14 @@// SPDX-License-Identifier: GPL-2.0 -use kernel::prelude::*; -use kernel::transmute::{AsBytes ,FromBytes }; -use kernel::{device, pci}; +use kernel::{ + device, + pci, + prelude::*, + transmute::{ +AsBytes , +FromBytes ,// + },// +};use crate ::gsp::GSP_PAGE_SIZE ;
Signature · 1 line
2.53.0
PATCH v5 9/38 gpu: nova-core: move GPU init and DMA mask setup into Gpu::new()
In reply to John HubbardMove Spec creation, the dev_info log, and DMA mask setup from the driver's probe() into Gpu::new(), so that all GPU-specific initialization lives in the Gpu constructor.
This restructures Gpu::new() to use pin_init_scope wrapping try_pin_init!, which allows running fallible setup code (Spec::new, dma_set_mask_and_coherent) before the pin-initializer. The parameter type changes from pci::Device<device::Bound> to pci::Device<device::Core> because the DMA call requires the Core device state.
Also makes Chipset::arch() const, adds Spec::chipset() accessor, and makes Spec::new() pub(crate) for use by later patches.
No functional change: the same 47-bit DMA mask is applied.
--- drivers/gpu/nova-core/driver.rs | 15 -------- drivers/gpu/nova-core/gpu.rs | 66 ++++++++++++++++++++++----------- 2 files changed, 44 insertions(+), 37 deletions(-)
drivers/gpu/nova-core/driver.rs +0 -15
@@ -9,8 +9,6 @@ auxiliary, device::Core, devres::Devres, - dma::Device, - dma::DmaMask, pci, pci::{Class ,
@@ -37,14 +35,6 @@ pub(crate) struct NovaCore {const BAR0_SIZE :usize =SZ_16M ; -// For now we only support Ampere which can use up to 47-bit DMA addresses. -// -// TODO: Add an abstraction for this to support newer GPUs which may support -// larger DMA addresses. Limiting these GPUs to smaller address widths won't -// have any adverse affects, unless installed on systems which require larger -// DMA addresses. These systems should be quite rare. -const GPU_DMA_BITS :u32 =47 ; -pub (crate )type Bar0 = pci::Bar <BAR0_SIZE >; kernel::pci_device_table!(
@@ -83,11 +73,6 @@ fn probe(pdev: &pci::Device<Core>, _info: &Self::IdInfo) -> impl PinInit<Self, E pdev.enable_device_mem ()?; pdev.set_master (); -// SAFETY: No concurrent DMA allocations or mappings can be made because -// the device is still being probed and therefore isn't being used by -// other threads of execution. -unsafe { pdev.dma_set_mask_and_coherent (DmaMask ::new ::<GPU_DMA_BITS >())? }; -let bar =Arc ::pin_init ( pdev.iomap_region_sized ::<BAR0_SIZE >(0 ,c"nova-core/bar0" ), GFP_KERNEL,
drivers/gpu/nova-core/gpu.rs +44 -22
112 lines not on this page · raw message
Signature · 1 line
2.53.0
PATCH v5 10/38 gpu: nova-core: set DMA mask width based on GPU architecture
In reply to John HubbardReplace the hardcoded 47-bit DMA mask with per-architecture values. Hopper and Blackwell support 52-bit DMA addresses, while Turing, Ampere, and Ada use 47-bit.
Add Architecture::dma_mask() as a const method with an exhaustive match, so that new architectures will get a compile-time reminder to specify their DMA mask width.
--- drivers/gpu/nova-core/gpu.rs | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-)
drivers/gpu/nova-core/gpu.rs +13 -4
@@ -159,9 +159,18 @@ pub(crate) enum Architecture { Blackwell = 0x1b, } -// TODO: Set the DMA mask per-architecture. Hopper and Blackwell support 52-bit -// DMA addresses. For now, use 47-bit which is correct for Turing, Ampere, and Ada. -const GPU_DMA_BITS :u32 =47 ; +impl Architecture { +/// Returns the DMA mask supported by this architecture. +/// +/// Hopper and Blackwell support 52-bit DMA addresses, while earlier architectures +/// (Turing, Ampere, Ada) support 47-bit DMA addresses. +pub (crate )const fn dma_mask (&self) ->DmaMask { +match self { +Self ::Turing |Self ::Ampere |Self ::Ada =>DmaMask ::new ::<47 >(), +Self ::Hopper |Self ::Blackwell =>DmaMask ::new ::<52 >(), + } + } +}impl TryFrom <u8 >for Architecture {type Error =Error ;
@@ -301,7 +310,7 @@ pub(crate) fn new<'a>(// SAFETY: No concurrent DMA allocations or mappings can be made because // the device is still being probed and therefore isn't being used by // other threads of execution. -unsafe { pdev.dma_set_mask_and_coherent (DmaMask ::new ::<GPU_DMA_BITS >())? }; +unsafe { pdev.dma_set_mask_and_coherent (spec.chipset ().arch ().dma_mask ())? };let chipset = spec.chipset ();
Signature · 1 line
2.53.0
PATCH v5 11/38 gpu: nova-core: Hopper/Blackwell: skip GFW boot waiting
In reply to John HubbardHopper and Blackwell GPUs use FSP-based secure boot and do not require waiting for GFW_BOOT completion. Skip this step for these architectures, and in fact for all future architectures, because we have moved on:
there will not be any future GPUs using the older GFW_BOOT system.
--- drivers/gpu/nova-core/gpu.rs | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-)
drivers/gpu/nova-core/gpu.rs +13 -4
@@ -170,6 +170,15 @@ pub(crate) const fn dma_mask(&self) -> DmaMask { Self::Hopper | Self::Blackwell => DmaMask::new::<52>(), } } + +/// Returns whether the GPU uses GFW_BOOT for firmware loading. +/// +/// Pre-Hopper architectures (Turing, Ampere, Ada) require waiting for GFW_BOOT completion +/// before any significant GPU setup. Hopper and later use the FSP Chain of Trust boot path +/// instead. +pub (crate )const fn needs_gfw_boot (&self) ->bool { +matches! (self,Self ::Turing |Self ::Ampere |Self ::Ada ) + } }impl TryFrom <u8 >for Architecture {
@@ -315,11 +324,11 @@ pub(crate) fn new<'a>(let chipset = spec.chipset (); Ok(try_pin_init!(Self { - // We must wait for GFW_BOOT completion before doing any significant setup - // on the GPU. _: { - gfw::wait_gfw_boot_completion(bar) - .inspect_err(|_| dev_err!(pdev, "GFW boot did not complete\n"))?; + if chipset.arch().needs_gfw_boot() { + gfw::wait_gfw_boot_completion(bar) + .inspect_err(|_| dev_err!(pdev, "GFW boot did not complete\n"))?; + } }, sysmem_flush: SysmemFlush::register(pdev.as_ref(), bar, chipset)?,
Signature · 1 line
2.53.0
PATCH v5 12/38 gpu: nova-core: move firmware image parsing code to firmware.rs
In reply to John HubbardUp until now, only the GSP required parsing of its firmware headers. However, upcoming support for Hopper/Blackwell+ adds another firmware image (FMC), along with another format (ELF32).
Therefore, the current ELF64 section parsing support needs to be moved up a level, so that both of the above can use it.
There are no functional changes. This is pure code movement.
--- drivers/gpu/nova-core/firmware.rs | 88 +++++++++++++++++++++++++ drivers/gpu/nova-core/firmware/gsp.rs | 93 ++------------------------- 2 files changed, 94 insertions(+), 87 deletions(-)
drivers/gpu/nova-core/firmware.rs +88 -0
@@ -437,3 +437,91 @@ 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 core::mem::size_of; + +use kernel::{ + bindings, + str::CStr , + transmute::FromBytes ,// + }; + +/// 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 {} + +#[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 {} + +/// Tries to extract section with name `name` from the ELF64 image `elf`, and returns it. +pub (super )fn elf64_section <'a, 'b>(elf: &'a [u8 ], name: &'bstr ) ->Option <&'a [u8 ]> { +let hdr = &elf + .get (0 ..size_of ::<bindings::elf64_hdr >()) + .and_then (Elf64Hdr ::from_bytes)? + .0 ; + +// Get all the section headers. +let mut shdr = { +let shdr_num = usize::from (hdr.e_shnum); +let shdr_start = usize::try_from (hdr.e_shoff).ok ()?; +let shdr_end = shdr_num + .checked_mul (size_of ::<Elf64SHdr >()) + .and_then (|v| v.checked_add (shdr_start))?; + + elf.get (shdr_start..shdr_end) + .map (|slice| slice.chunks_exact (size_of ::<Elf64SHdr >()))? + }; + +// Get the strings table. +let strhdr = shdr + .clone () + .nth (usize::from (hdr.e_shstrndx)) + .and_then (Elf64SHdr ::from_bytes)?; + +// Find the section which name matches `name` and return it. + shdr.find (|&sh| { +let Some (hdr) =Elf64SHdr ::from_bytes (sh)else { +return false ; + }; + +let Some (name_idx) = strhdr + .0 + .sh_offset + .checked_add (u64::from (hdr.0 .sh_name)) + .and_then (|idx| usize::try_from (idx).ok ()) +else { +return false ; + }; + +// Get the start of the name. + elf.get (name_idx..) + .and_then (|nstr|CStr ::from_bytes_until_nul (nstr).ok ()) +// Convert into str. + .and_then (|c_str| c_str.to_str ().ok ()) +// Check that the name matches. + .map (|str| str == name) + .unwrap_or (false ) + }) +// Return the slice containing the section. + .and_then (|sh| { +let hdr =Elf64SHdr ::from_bytes (sh)?; +let start = usize::try_from (hdr.0 .sh_offset).ok ()?; +let end = usize::try_from (hdr.0 .sh_size) + .ok () + .and_then (|sh_size| start.checked_add (sh_size))?; + + elf.get (start..end) + }) + } +}
drivers/gpu/nova-core/firmware/gsp.rs +6 -87
110 lines not on this page · raw message
Signature · 1 line
2.53.0
PATCH v5 13/38 gpu: nova-core: factor out an elf_str() function
In reply to John HubbardFactor out a chunk of complexity into a new subroutine. This is an incremental step in adding ELF32 support to the existing ELF64 section support, for handling GPU firmware.
--- drivers/gpu/nova-core/firmware.rs | 40 ++++++++++++------------------- 1 file changed, 15 insertions(+), 25 deletions(-)
drivers/gpu/nova-core/firmware.rs +15 -25
@@ -464,6 +464,13 @@ unsafe impl FromBytes for Elf64Hdr {}// SAFETY: all bit patterns are valid for this type, and it doesn't use interior mutability. unsafe impl FromBytes for Elf64SHdr {} +/// 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 () + } +/// Tries to extract section with name `name` from the ELF64 image `elf`, and returns it. pub (super )fn elf64_section <'a, 'b>(elf: &'a [u8 ], name: &'bstr ) ->Option <&'a [u8 ]> {let hdr = &elf
@@ -490,32 +497,15 @@ pub(super) fn elf64_section<'a, 'b>(elf: &'a [u8], name: &'b str) -> Option<&'a .and_then(Elf64SHdr::from_bytes)?;// Find the section which name matches `name` and return it. - shdr.find (|&sh| { -let Some (hdr) =Elf64SHdr ::from_bytes (sh)else { -return false ; - }; - -let Some (name_idx) = strhdr - .0 - .sh_offset - .checked_add (u64::from (hdr.0 .sh_name)) - .and_then (|idx| usize::try_from (idx).ok ()) -else { -return false ; - }; - -// Get the start of the name. - elf.get (name_idx..) - .and_then (|nstr|CStr ::from_bytes_until_nul (nstr).ok ()) -// Convert into str. - .and_then (|c_str| c_str.to_str ().ok ()) -// Check that the name matches. - .map (|str| str == name) - .unwrap_or (false ) - }) -// Return the slice containing the section. - .and_then (|sh| { + shdr.find_map (|sh| {let hdr =Elf64SHdr ::from_bytes (sh)?; +let name_offset = strhdr.0 .sh_offset.checked_add (u64::from (hdr.0 .sh_name))?; +let section_name =elf_str (elf, name_offset)?; + +if section_name != name { +return None ; + } +let start = usize::try_from (hdr.0 .sh_offset).ok ()?;let end = usize::try_from (hdr.0 .sh_size) .ok ()
Signature · 1 line
2.53.0
PATCH v5 14/38 gpu: nova-core: don't assume 64-bit firmware images
In reply to John HubbardAdd ElfHeader and ElfSectionHeader traits to abstract out differences between ELF32 and ELF64. Implement these for ELF64.
This is in preparation for upcoming ELF32 section support, and for auto-selecting ELF32 or ELF64.
--- drivers/gpu/nova-core/firmware.rs | 99 ++++++++++++++++++++++--------- 1 file changed, 72 insertions(+), 27 deletions(-)
drivers/gpu/nova-core/firmware.rs +72 -27
@@ -453,17 +453,60 @@ mod elf { transmute::FromBytes, // }; -/// Newtype to provide a [`FromBytes`] implementation. +/// Trait to abstract over ELF header differences (32-bit vs 64-bit). +trait ElfHeader :FromBytes { +fn shnum (&self) ->u16 ; +fn shoff (&self) ->u64 ; +fn shstrndx (&self) ->u16 ; + } + +/// Trait to abstract over ELF section header differences (32-bit vs 64-bit). +trait ElfSectionHeader :FromBytes { +fn name (&self) ->u32 ; +fn offset (&self) ->u64 ; +fn size (&self) ->u64 ; + } + +/// Newtype to provide [`FromBytes`] and [`ElfHeader`] implementations. #[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 + } + } + +/// Newtype to provide [`FromBytes`] and [`ElfSectionHeader`] implementations. #[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 + } + } +/// 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 ()?;
@@ -471,47 +514,49 @@ fn elf_str(elf: &[u8], offset: u64) -> Option<&str> {CStr ::from_bytes_until_nul (bytes).ok ()?.to_str ().ok () } -/// Tries to extract section with name `name` from the ELF64 image `elf`, and returns it. -pub (super )fn elf64_section <'a, 'b>(elf: &'a [u8 ], name: &'bstr ) ->Option <&'a [u8 ]> { -let hdr = &elf - .get (0 ..size_of ::<bindings::elf64_hdr >()) - .and_then (Elf64Hdr ::from_bytes)? - .0 ; +fn elf_section_generic <'a,H ,S >(elf: &'a [u8 ], name: &str ) ->Option <&'a [u8 ]> +where +H :ElfHeader , +S :ElfSectionHeader , + { +let hdr =H ::from_bytes (elf.get (0 ..size_of ::<H >())?)?; -// Get all the section headers. -let mut shdr = { -let shdr_num = usize::from (hdr.e_shnum); -let shdr_start = usize::try_from (hdr.e_shoff).ok ()?; -let shdr_end = shdr_num - .checked_mul (size_of ::<Elf64SHdr >()) - .and_then (|v| v.checked_add (shdr_start))?; +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 ::<S >()) + .and_then (|v| v.checked_add (shdr_start))?; - elf.get (shdr_start..shdr_end) - .map (|slice| slice.chunks_exact (size_of ::<Elf64SHdr >()))? - }; +// 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 ::<S >());// Get the strings table. -let strhdr = shdr +let strhdr = shdr_iter .clone () - .nth (usize::from (hdr.e_shstrndx)) - .and_then (Elf64SHdr ::from_bytes)?; + .nth (usize::from (hdr.shstrndx ())) + .and_then (S ::from_bytes)?;// Find the section which name matches `name` and return it. - shdr.find_map (|sh| { -let hdr =Elf64SHdr ::from_bytes (sh)?; -let name_offset = strhdr.0 .sh_offset.checked_add (u64::from (hdr.0 .sh_name))?; + shdr_iter.find_map (|sh_bytes| { +let sh =S ::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 (hdr.0 .sh_offset).ok ()?; -let end = usize::try_from (hdr.0 .sh_size) +let start = usize::try_from (sh.offset ()).ok ()?; +let end = usize::try_from (sh.size ()) .ok () - .and_then (|sh_size| start.checked_add (sh_size))?; - + .and_then (|sz| start.checked_add (sz))?; elf.get (start..end) }) } + +/// Extract the section with name `name` from the ELF64 image `elf`. +pub (super )fn elf64_section <'a>(elf: &'a [u8 ], name: &str ) ->Option <&'a [u8 ]> { +elf_section_generic ::<Elf64Hdr ,Elf64SHdr >(elf, name) + } }
Signature · 1 line
2.53.0
PATCH v5 15/38 gpu: nova-core: add support for 32-bit firmware images
In reply to John HubbardAdd ELF32 header and section header newtypes with ElfHeader and ElfSectionHeader trait implementations, mirroring the existing ELF64 support. Add elf32_section() for extracting sections from ELF32 images.
--- drivers/gpu/nova-core/firmware.rs | 46 +++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+)
drivers/gpu/nova-core/firmware.rs +46 -0
@@ -507,6 +507,46 @@ fn size(&self) -> u64 { } } +/// 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) + } + } +/// 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 ()?;
@@ -559,4 +599,10 @@ fn elf_section_generic<'a, H, S>(elf: &'a [u8], name: &str) -> Option<&'a [u8]>pub (super )fn elf64_section <'a>(elf: &'a [u8 ], name: &str ) ->Option <&'a [u8 ]> {elf_section_generic ::<Elf64Hdr ,Elf64SHdr >(elf, name) } + +/// Extract the section with name `name` from the ELF32 image `elf`. +#[expect(dead_code)] +pub (super )fn elf32_section <'a>(elf: &'a [u8 ], name: &str ) ->Option <&'a [u8 ]> { +elf_section_generic ::<Elf32Hdr ,Elf32SHdr >(elf, name) + } }
Signature · 1 line
2.53.0
PATCH v5 16/38 gpu: nova-core: add auto-detection of 32-bit, 64-bit firmware images
In reply to John HubbardAdd elf_section() which automatically detects ELF32 vs ELF64 based on the ELF header's class byte, and dispatches to the appropriate parser. Switch gsp.rs callers from elf64_section() to elf_section(), making both elf32_section() and elf64_section() private.
--- drivers/gpu/nova-core/firmware.rs | 20 +++++++++++++++++--- drivers/gpu/nova-core/firmware/gsp.rs | 4 ++-- 2 files changed, 19 insertions(+), 5 deletions(-)
drivers/gpu/nova-core/firmware.rs +17 -3
@@ -596,13 +596,27 @@ fn elf_section_generic<'a, H, S>(elf: &'a [u8], name: &str) -> Option<&'a [u8]> }/// Extract the section with name `name` from the ELF64 image `elf`. -pub (super )fn elf64_section <'a>(elf: &'a [u8 ], name: &str ) ->Option <&'a [u8 ]> { +fn elf64_section <'a>(elf: &'a [u8 ], name: &str ) ->Option <&'a [u8 ]> {elf_section_generic ::<Elf64Hdr ,Elf64SHdr >(elf, name) }/// Extract the section with name `name` from the ELF32 image `elf`. -#[expect(dead_code)] -pub (super )fn elf32_section <'a>(elf: &'a [u8 ], name: &str ) ->Option <&'a [u8 ]> { +fn elf32_section <'a>(elf: &'a [u8 ], name: &str ) ->Option <&'a [u8 ]> {elf_section_generic ::<Elf32Hdr ,Elf32SHdr >(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 ]> { +// Check ELF magic. +if elf.len () <5 || elf.get (0 ..4 )? !=b"\x7fELF" { +return None ; + } + +// Check ELF class: 1 = 32-bit, 2 = 64-bit. +match elf.get (4 )? { +1 =>elf32_section (elf, name), +2 =>elf64_section (elf, name), + _ =>None , + } + } }
drivers/gpu/nova-core/firmware/gsp.rs +2 -2
@@ -105,7 +105,7 @@ pub(crate) fn new<'a>( pin_init::pin_init_scope (move || {let firmware =super ::request_firmware (dev, chipset,"gsp" , ver)?; -let fw_section = elf::elf64_section (firmware.data (),".fwimage" ).ok_or (EINVAL )?; +let fw_section = elf::elf_section (firmware.data (),".fwimage" ).ok_or (EINVAL )?;let size = fw_section.len ();
@@ -162,7 +162,7 @@ pub(crate) fn new<'a>( signatures: { let sigs_section = Self::find_gsp_sigs_section(chipset).ok_or(ENOTSUPP)?; - elf::elf64_section (firmware.data (), sigs_section) + elf::elf_section (firmware.data (), sigs_section) .ok_or (EINVAL ) .and_then (|data|DmaObject ::from_data (dev, data))? },
Signature · 1 line
2.53.0
PATCH v5 17/38 gpu: nova-core: Hopper/Blackwell: add FMC firmware image, in support of FSP
In reply to John HubbardFSP is a hardware unit that runs FMC firmware. The FMC ELF file is loaded and stored in two forms: the "image" ELF section alone (which FSP uses for boot) and the full ELF (needed later for signature extraction during Chain of Trust verification).
--- drivers/gpu/nova-core/firmware.rs | 1 + drivers/gpu/nova-core/firmware/fsp.rs | 44 +++++++++++++++++++++++++++ 2 files changed, 45 insertions(+) create mode 100644 drivers/gpu/nova-core/firmware/fsp.rs
drivers/gpu/nova-core/firmware.rs +1 -0
@@ -28,6 +28,7 @@ };pub (crate )mod booter; +pub (crate )mod fsp;pub (crate )mod fwsec;pub (crate )mod gsp;pub (crate )mod riscv;
drivers/gpu/nova-core/firmware/fsp.rs new file +44 -0
44 lines not on this page · raw message
Signature · 1 line
2.53.0
PATCH v5 18/38 gpu: nova-core: Hopper/Blackwell: add FSP falcon engine stub
In reply to John HubbardAdd the FSP (Firmware System Processor) falcon engine type that will handle secure boot and Chain of Trust operations on Hopper and Blackwell architectures.
The FSP falcon replaces SEC2's role in the boot sequence for these newer architectures. This initial stub just defines the falcon type and its base address.
--- drivers/gpu/nova-core/falcon.rs | 1 + drivers/gpu/nova-core/falcon/fsp.rs | 30 +++++++++++++++++++++++++++++ 2 files changed, 31 insertions(+) create mode 100644 drivers/gpu/nova-core/falcon/fsp.rs
drivers/gpu/nova-core/falcon.rs +1 -0
@@ -33,6 +33,7 @@ regs::macros::RegisterBase, // }; +pub (crate )mod fsp;pub (crate )mod gsp;mod hal;pub (crate )mod sec2;
drivers/gpu/nova-core/falcon/fsp.rs new file +30 -0
@@ -0,0 +1,30 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! FSP (Firmware System Processor) falcon engine for Hopper/Blackwell GPUs. +//! +//! The FSP falcon handles secure boot and Chain of Trust operations +//! on Hopper and Blackwell architectures, replacing SEC2's role. + +use crate ::{ + falcon::{ +FalconEngine , +PFalcon2Base , +PFalconBase ,// + }, + regs::macros::RegisterBase , +}; + +/// Type specifying the `Fsp` falcon engine. Cannot be instantiated. +pub (crate )struct Fsp (()); + +impl RegisterBase <PFalconBase >for Fsp { +const BASE :usize =0x8f2000 ; +} + +impl RegisterBase <PFalcon2Base >for Fsp { +const BASE :usize =0x8f3000 ; +} + +impl FalconEngine for Fsp { +const ID :Self =Fsp (()); +}
Signature · 1 line
2.53.0
PATCH v5 19/38 gpu: nova-core: Hopper/Blackwell: add FSP falcon EMEM operations
In reply to John HubbardAdd external memory (EMEM) read/write operations to the GPU's FSP falcon engine. These operations use Falcon PIO (Programmed I/O) to communicate with the FSP through indirect memory access.
--- drivers/gpu/nova-core/falcon/fsp.rs | 122 +++++++++++++++++++++++++++- drivers/gpu/nova-core/regs.rs | 12 +++ 2 files changed, 133 insertions(+), 1 deletion(-)
drivers/gpu/nova-core/falcon/fsp.rs +121 -1
@@ -5,13 +5,26 @@//! The FSP falcon handles secure boot and Chain of Trust operations //! on Hopper and Blackwell architectures, replacing SEC2's role. +use kernel::{ + io::{ +Io , +IoCapable ,// + }, + prelude::*,// +}; +use crate ::{ + driver::Bar0 , falcon::{ +Falcon ,FalconEngine ,PFalcon2Base ,PFalconBase ,// }, - regs::macros::RegisterBase , + regs::{ + self, + macros::RegisterBase ,// + }, };/// Type specifying the `Fsp` falcon engine. Cannot be instantiated.
@@ -28,3 +41,110 @@ impl RegisterBase<PFalcon2Base> for Fsp {impl FalconEngine for Fsp {const ID :Self =Fsp (()); } + +/// Maximum addressable EMEM size, derived from the 24-bit offset field +/// in NV_PFALCON_FALCON_EMEM_CTL. +const EMEM_MAX_SIZE :usize =1 <<24 ; + +/// I/O backend for the FSP falcon's external memory (EMEM). +/// +/// Each 32-bit access programs a byte offset via the EMEM_CTL register, +/// then reads or writes through the EMEM_DATA register. +pub (crate )struct Emem <'a> { + bar: &'aBar0 , +} + +impl <'a>Emem <'a> { +fn new (bar: &'aBar0 ) ->Self { +Self { bar } + } +} + +impl IoCapable <u32 >for Emem <'_> {} + +impl Io for Emem <'_> { +fn addr (&self) ->usize { +0 + } + +fn maxsize (&self) ->usize { +EMEM_MAX_SIZE + } + +fn try_read32 (&self, offset:usize ) ->Result <u32 > { +// io_addr validates offset < EMEM_MAX_SIZE (2^24), so the u32 cast is safe. +let offset = self.io_addr ::<u32 >(offset)?as u32 ; + + regs::NV_PFALCON_FALCON_EMEM_CTL ::default () + .set_rd_mode (true ) + .set_offset (offset) + .write (self.bar, &Fsp ::ID ); + +Ok (regs::NV_PFALCON_FALCON_EMEM_DATA ::read (self.bar, &Fsp ::ID ).data ()) + } + +fn try_write32 (&self, value:u32 , offset:usize ) ->Result { +// io_addr validates offset < EMEM_MAX_SIZE (2^24), so the u32 cast is safe. +let offset = self.io_addr ::<u32 >(offset)?as u32 ; + + regs::NV_PFALCON_FALCON_EMEM_CTL ::default () + .set_wr_mode (true ) + .set_offset (offset) + .write (self.bar, &Fsp ::ID ); + + regs::NV_PFALCON_FALCON_EMEM_DATA ::default () + .set_data (value) + .write (self.bar, &Fsp ::ID ); + +Ok (()) + } +} + +impl Falcon <Fsp > { +/// Returns an EMEM I/O accessor for this FSP falcon. +pub (crate )fn emem <'a>(&self, bar: &'aBar0 ) ->Emem <'a> { +Emem ::new (bar) + } + +/// Writes `data` to FSP external memory at byte `offset`. +/// +/// Data is interpreted as little-endian 32-bit words. +/// Returns `EINVAL` if offset or data length is not 4-byte aligned. +#[expect(unused)] +pub (crate )fn write_emem (&self, bar: &Bar0 , offset:u32 , data: &[u8 ]) ->Result { +if offset %4 !=0 || data.len () %4 !=0 { +return Err (EINVAL ); + } + +let emem = self.emem (bar); +let mut off = offsetas usize ; +for chunkin data.chunks_exact (4 ) { +let word = u32::from_le_bytes ([chunk[0 ], chunk[1 ], chunk[2 ], chunk[3 ]]); + emem.try_write32 (word, off)?; + off +=4 ; + } + +Ok (()) + } + +/// Reads FSP external memory at byte `offset` into `data`. +/// +/// Data is stored as little-endian 32-bit words. +/// Returns `EINVAL` if offset or data length is not 4-byte aligned. +#[expect(unused)] +pub (crate )fn read_emem (&self, bar: &Bar0 , offset:u32 , data: &mut [u8 ]) ->Result { +if offset %4 !=0 || data.len () %4 !=0 { +return Err (EINVAL ); + } + +let emem = self.emem (bar); +let mut off = offsetas usize ; +for chunkin data.chunks_exact_mut (4 ) { +let word = emem.try_read32 (off)?; + chunk.copy_from_slice (&word.to_le_bytes ()); + off +=4 ; + } + +Ok (()) + } +}
drivers/gpu/nova-core/regs.rs +12 -0
@@ -431,6 +431,18 @@ pub(crate) fn reset_engine<E: FalconEngine>(bar: &Bar0) { 8:8 br_fetch as bool; }); +// Falcon EMEM PIO registers (used by FSP on Hopper/Blackwell). +// These provide the falcon external memory communication interface. +register! (NV_PFALCON_FALCON_EMEM_CTL @PFalconBase [0x00000ac0 ] { +23 :0 offsetas u32 ;// EMEM byte offset (must be 4-byte aligned) +24 :24 wr_modeas bool ;// Write mode +25 :25 rd_modeas bool ;// Read mode +}); + +register! (NV_PFALCON_FALCON_EMEM_DATA @PFalconBase [0x00000ac4 ] { +31 :0 dataas u32 ;// EMEM data register +}); +// The modules below provide registers that are not identical on all supported chips. They should // only be used in HAL modules.
Signature · 1 line
2.53.0
PATCH v5 20/38 gpu: nova-core: Hopper/Blackwell: add FSP message infrastructure
In reply to John HubbardAdd the FSP messaging infrastructure needed for Chain of Trust communication on Hopper/Blackwell GPUs.
--- drivers/gpu/nova-core/falcon/fsp.rs | 79 ++++++++++++++++++++++++++++- drivers/gpu/nova-core/regs.rs | 48 ++++++++++++++++++ 2 files changed, 125 insertions(+), 2 deletions(-)
drivers/gpu/nova-core/falcon/fsp.rs +77 -2
@@ -110,7 +110,6 @@ pub(crate) fn emem<'a>(&self, bar: &'a Bar0) -> Emem<'a> {/// /// Data is interpreted as little-endian 32-bit words. /// Returns `EINVAL` if offset or data length is not 4-byte aligned. -#[expect(unused)] pub (crate )fn write_emem (&self, bar: &Bar0 , offset:u32 , data: &[u8 ]) ->Result {if offset %4 !=0 || data.len () %4 !=0 {return Err (EINVAL );
@@ -131,7 +130,6 @@ pub(crate) fn write_emem(&self, bar: &Bar0, offset: u32, data: &[u8]) -> Result/// /// Data is stored as little-endian 32-bit words. /// Returns `EINVAL` if offset or data length is not 4-byte aligned. -#[expect(unused)] pub (crate )fn read_emem (&self, bar: &Bar0 , offset:u32 , data: &mut [u8 ]) ->Result {if offset %4 !=0 || data.len () %4 !=0 {return Err (EINVAL );
@@ -147,4 +145,81 @@ pub(crate) fn read_emem(&self, bar: &Bar0, offset: u32, data: &mut [u8]) -> ResuOk (()) } + +/// Poll FSP for incoming data. +/// +/// Returns the size of available data in bytes, or 0 if no data is available. +/// +/// The FSP message queue is not circular - pointers are reset to 0 after each +/// message exchange, so `tail >= head` is always true when data is present. +#[expect(unused)] +pub (crate )fn poll_msgq (&self, bar: &Bar0 ) ->u32 { +let head = regs::NV_PFSP_MSGQ_HEAD ::read (bar).address (); +let tail = regs::NV_PFSP_MSGQ_TAIL ::read (bar).address (); + +if head == tail { +return 0 ; + } + +// TAIL points at last DWORD written, so add 4 to get total size + tail.saturating_sub (head) +4 + } + +/// Send message to FSP. +/// +/// Writes a message to FSP EMEM and updates queue pointers to notify FSP. +/// +/// # Arguments +/// * `bar` - BAR0 memory mapping +/// * `packet` - Message data (must be 4-byte aligned in length) +/// +/// # Returns +/// `Ok(())` on success, `Err(EINVAL)` if packet is empty or not 4-byte aligned +#[expect(unused)] +pub (crate )fn send_msg (&self, bar: &Bar0 , packet: &[u8 ]) ->Result { +if packet.is_empty () { +return Err (EINVAL ); + } + +// Write message to EMEM at offset 0 (validates 4-byte alignment) + self.write_emem (bar,0 , packet)?; + +// Update queue pointers - TAIL points at last DWORD written +let tail_offset = u32::try_from (packet.len () -4 ).map_err (|_|EINVAL )?; + regs::NV_PFSP_QUEUE_TAIL ::default () + .set_address (tail_offset) + .write (bar); + regs::NV_PFSP_QUEUE_HEAD ::default () + .set_address (0 ) + .write (bar); + +Ok (()) + } + +/// Receive message from FSP. +/// +/// Reads a message from FSP EMEM and resets queue pointers. +/// +/// # Arguments +/// * `bar` - BAR0 memory mapping +/// * `buffer` - Buffer to receive message data +/// * `size` - Size of message to read in bytes (from `poll_msgq`) +/// +/// # Returns +/// `Ok(bytes_read)` on success, `Err(EINVAL)` if size is 0, exceeds buffer, or not aligned +#[expect(unused)] +pub (crate )fn recv_msg (&self, bar: &Bar0 , buffer: &mut [u8 ], size:usize ) ->Result <usize > { +if size ==0 || size > buffer.len () { +return Err (EINVAL ); + } + +// Read response from EMEM at offset 0 (validates 4-byte alignment) + self.read_emem (bar,0 , &mut buffer[..size])?; + +// Reset message queue pointers after reading + regs::NV_PFSP_MSGQ_TAIL ::default ().set_address (0 ).write (bar); + regs::NV_PFSP_MSGQ_HEAD ::default ().set_address (0 ).write (bar); + +Ok (size) + } }
drivers/gpu/nova-core/regs.rs +48 -0
60 lines not on this page · raw message
Signature · 1 line
2.53.0
PATCH v5 21/38 rust: ptr: add const_align_up() and enable inline_const feature
In reply to John HubbardAdd const_align_up<ALIGN>() to kernel::ptr as the const-compatible equivalent of Alignable::align_up(). This uses inline_const to validate the alignment at compile time with a clear error message.
Add inline_const to rust_allowed_features in scripts/Makefile.build, following the approach in [1].
[1] https://lore.kernel.org/rust-for-linux/[email protected]/
--- rust/kernel/ptr.rs | 27 +++++++++++++++++++++++++++ scripts/Makefile.build | 2 +- 2 files changed, 28 insertions(+), 1 deletion(-)
rust/kernel/ptr.rs +27 -0
@@ -225,3 +225,30 @@ fn align_up(self, alignment: Alignment) -> Option<Self> { }impl_alignable_uint! (u8 ,u16 ,u32 ,u64 ,usize ); + +/// Aligns `value` up to `ALIGN` at compile time. +/// +/// This is the const-compatible equivalent of [`Alignable::align_up`]. +/// `ALIGN` must be a power of two (enforced at compile time). +/// +/// Panics on overflow, which becomes a compile-time error when called in a +/// const context. +/// +/// # Examples +/// +/// ``` +/// use kernel::ptr::const_align_up; +/// use kernel::sizes::SZ_4K; +/// +/// assert_eq!(const_align_up::<16>(0x4f), 0x50); +/// assert_eq!(const_align_up::<16>(0x40), 0x40); +/// assert_eq!(const_align_up::<SZ_4K>(1), SZ_4K); +/// ``` +#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->usize { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) => v & !(ALIGN -1 ), +None =>panic! ("const_align_up: overflow" ), + } +}
scripts/Makefile.build +1 -1
@@ -319,7 +319,7 @@ $(obj)/%.lst: $(obj)/%.c FORCE # # Please see https://github.com/Rust-for-Linux/linux/issues/2 for details on # the unstable features in use. -rust_allowed_features := asm_const,asm_goto,arbitrary_self_types,lint_reasons,offset_of_nested,raw_ref_op,used_with_arg +rust_allowed_features := asm_const,asm_goto,arbitrary_self_types,inline_const,lint_reasons,offset_of_nested,raw_ref_op,used_with_arg # `--out-dir` is required to avoid temporaries being created by `rustc` in the # current working directory, which may be not accessible in the out-of-tree
Signature · 1 line
2.53.0
Re: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 2 lines · John Hubbard
[1] https://lore.kernel.org/rust-for-linux/[email protected]/
Quoted 1 line
+pub const fn const_align_up<const ALIGN: usize>(value: usize) -> usize {
Ah, I thought you wanted to put this in drivers/gpu/nova-core/num.rs like in the previous version.
If it is here instead, then you shouldn't need the rust_allowed_features change anymore, because we already enable inline_const in the kernel crate.
scripts/Makefile.build
Quoted 1 line
scripts/Makefile.build +0
-0
Having said that, if you do end up needing it elsewhere, then please add the other line added by Gary's patch, i.e.:
+# - Stable since Rust 1.79.0: feature(inline_const).
Thanks!
Cheers,
Miguel
Re: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 11 lines · Miguel Ojeda
Quoted 2 lines · John Hubbard
[1] https://lore.kernel.org/rust-for-linux/[email protected]/
Quoted 1 line
+pub const fn const_align_up<const ALIGN: usize>(value: usize) -> usize {
Ah, I thought you wanted to put this in
drivers/gpu/nova-core/num.rslike in the previous version.
Works for me. I was anticipating that people wanted it in rust/ but I'm perfectly happy to keep it local to nova-core.
Quoted 4 lines
If it is here instead, then you shouldn't need the
rust_allowed_featureschange anymore, because we already enableinline_constin thekernelcrate.
I see.
Quoted 6 lines
scripts/Makefile.build
Quoted 2 lines
scripts/Makefile.build +0
-0Having said that, if you do end up needing it elsewhere, then please add the other line added by Gary's patch, i.e.:
Quoted 6 lines
+# - Stable since Rust 1.79.0: `feature(inline_const)`.Thanks!
Cheers,
Miguel
thanks,
Signature · 1 line
John Hubbard
Re: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 3 lines · John Hubbard
Works for me. I was anticipating that people wanted it in
rust/but I'm perfectly happy to keep it local to nova-core.
Sorry, I didn't mean you necessarily need to move it -- I only meant to point out that if you do, then you don't need the other changes.
Cheers,
Miguel
Alexandre Courbot
maintainerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 7 lines · Miguel Ojeda
Quoted 3 lines · John Hubbard
Works for me. I was anticipating that people wanted it in
rust/but I'm perfectly happy to keep it local to nova-core.Sorry, I didn't mean you necessarily need to move it -- I only meant to point out that if you do, then you don't need the other changes.
FWIW I think it makes more sense to keep it in kernel - even though Nova is the only user for now, this is a useful addition in general.
Gary Guo
reviewerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
In reply to John HubbardQuoted 40 lines · John Hubbard
Add const_align_up<ALIGN>() to
kernel::ptras the const-compatible equivalent ofAlignable::align_up(). This usesinline_constto validate the alignment at compile time with a clear error message.Add
inline_consttorust_allowed_featuresinscripts/Makefile.build, following the approach in [1].[1] https://lore.kernel.org/rust-for-linux/[email protected]/
Suggested-by Danilo Krummrich <[email protected]>Suggested-by Miguel Ojeda <[email protected]>Signed-off-by John Hubbard <[email protected]>--- rust/kernel/ptr.rs | 27 +++++++++++++++++++++++++++ scripts/Makefile.build | 2 +- 2 files changed, 28 insertions(+), 1 deletion(-)rust/kernel/ptr.rs +15
-0@@ -225,3 +225,30 @@ fn align_up(self, alignment: Alignment) -> Option<Self> { }impl_alignable_uint! (u8 ,u16 ,u32 ,u64 ,usize ); + +/// Aligns `value` up to `ALIGN` at compile time. +/// +/// This is the const-compatible equivalent of [`Alignable::align_up`]. +/// `ALIGN` must be a power of two (enforced at compile time). +/// +/// Panics on overflow, which becomes a compile-time error when called in a +/// const context. +/// +/// # Examples +/// +/// ``` +/// use kernel::ptr::const_align_up; +/// use kernel::sizes::SZ_4K; +///
rust/kernel/ptr.rs fn align_up(self, alignment: Alignment) -> Option<Self> { · line 252
Quoted 10 lines
rust/kernel/ptr.rs +10
-0+/// assert_eq!(const_align_up::<16>(0x4f), 0x50); +/// assert_eq!(const_align_up::<16>(0x40), 0x40); +/// assert_eq!(const_align_up::<SZ_4K>(1), SZ_4K); +/// ``` +#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->usize { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) => v & !(ALIGN -1 ), +None =>panic! ("const_align_up: overflow" ),
This is wrong. Either this function is always used in const context, in which case you take ALIGN as normal function parameter and use build_assert and build_error, or this function can be called from runtime and you shouldn't have a panic call here.
Best,
Gary
Quoted 15 lines
rust/kernel/ptr.rs +2
-0+ } +}scripts/Makefile.build +1
-1@@ -319,7 +319,7 @@ $(obj)/%.lst: $(obj)/%.c FORCE # # Please see https://github.com/Rust-for-Linux/linux/issues/2 for details on # the unstable features in use. -rust_allowed_features := asm_const,asm_goto,arbitrary_self_types,lint_reasons,offset_of_nested,raw_ref_op,used_with_arg +rust_allowed_features := asm_const,asm_goto,arbitrary_self_types,inline_const,lint_reasons,offset_of_nested,raw_ref_op,used_with_arg # `--out-dir` is required to avoid temporaries being created by `rustc` in the # current working directory, which may be not accessible in the out-of-tree
Re: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 5 lines · Gary Guo
Quoted 4 lines · John Hubbard
Add const_align_up<ALIGN>() to
kernel::ptras the const-compatible equivalent ofAlignable::align_up(). This usesinline_constto validate the alignment at compile time with a clear error message.
...
Quoted 11 lines
rust/kernel/ptr.rs fn align_up(self, alignment: Alignment) -> Option<Self> { · line 252
Quoted 6 lines
rust/kernel/ptr.rs +6
-0+#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->usize { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) => v & !(ALIGN -1 ), +None =>panic! ("const_align_up: overflow" ),This is wrong. Either this function is always used in const context, in which case you take
ALIGNas normal function parameter and usebuild_assertandbuild_error, or this function can be called from runtime and you shouldn't have a panic call here.
I will have another go at this, and put it in nova-core as per Miguel's comment as well. Thanks for catching this, Gary!
thanks,
Signature · 1 line
John Hubbard
Danilo Krummrich
maintainerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 8 lines · John Hubbard
Quoted 5 lines · Gary Guo
Quoted 4 lines · John Hubbard
Add const_align_up<ALIGN>() to
kernel::ptras the const-compatible equivalent ofAlignable::align_up(). This usesinline_constto validate the alignment at compile time with a clear error message....
Quoted 10 lines
Quoted 10 lines
rust/kernel/ptr.rs fn align_up(self, alignment: Alignment) -> Option<Self> { · line 252
Quoted 6 lines
rust/kernel/ptr.rs +6
-0+#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->usize { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) => v & !(ALIGN -1 ), +None =>panic! ("const_align_up: overflow" ),This is wrong. Either this function is always used in const context, in which case you take
ALIGNas normal function parameter and usebuild_assertandbuild_error, or this function can be called from runtime and you shouldn't have a panic call here.
I think the most common case is that ALIGN is const, but value is not.
What about keeping the function as is (with the panic() replaced with a Result) and also add
#[inline(always)]
pub const fn const_expect<T: Copy>(opt: Result<T>, &'static str) -> T {
match opt {
Ok(v) => v,
Err(_) => panic!(""),
}
}for when it is entirely called from const context, e.g.
pub(crate) const PMU_RESERVED_SIZE: u32 = const_expect(const_align_up::<SZ_128K>(SZ_8M + SZ_16M + SZ_4K), "...");
Quoted 2 lines
I will have another go at this, and put it in nova-core as per Miguel's comment as well.
I think Miguel didn't mean to say it should not be in this file. I think the current place makes sense, let's keep it there.
Gary Guo
reviewerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 25 lines · Danilo Krummrich
Quoted 8 lines · John Hubbard
Quoted 5 lines · Gary Guo
Quoted 4 lines · John Hubbard
Add const_align_up<ALIGN>() to
kernel::ptras the const-compatible equivalent ofAlignable::align_up(). This usesinline_constto validate the alignment at compile time with a clear error message....
Quoted 10 lines
Quoted 10 lines
rust/kernel/ptr.rs fn align_up(self, alignment: Alignment) -> Option<Self> { · line 252
Quoted 6 lines
rust/kernel/ptr.rs +6
-0+#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->usize { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) => v & !(ALIGN -1 ), +None =>panic! ("const_align_up: overflow" ),This is wrong. Either this function is always used in const context, in which case you take
ALIGNas normal function parameter and usebuild_assertandbuild_error, or this function can be called from runtime and you shouldn't have a panic call here.I think the most common case is that ALIGN is const, but value is not.
What about keeping the function as is (with the
panic()replaced with a Result) and also add
Quoted 8 lines
#[inline(always)]
pub const fn const_expect<T: Copy>(opt: Result<T>, &'static str) -> T {
match opt {
Ok(v) => v,
Err(_) => panic!(""),
}
}We already have Alignable::align_up for non-const cases, so this would only be used in const context and I don't see the need of having explicit const_expect?
Best,
Gary
Quoted 10 lines
for when it is entirely called from const context, e.g.
pub(crate) const PMU_RESERVED_SIZE: u32 = const_expect(const_align_up::<SZ_128K>(SZ_8M + SZ_16M + SZ_4K), "...");Quoted 2 lines
I will have another go at this, and put it in nova-core as per Miguel's comment as well.
I think Miguel didn't mean to say it should not be in this file. I think the current place makes sense, let's keep it there.
Danilo Krummrich
maintainerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 35 lines · Gary Guo
Quoted 25 lines · Danilo Krummrich
Quoted 8 lines · John Hubbard
Quoted 5 lines · Gary Guo
Quoted 4 lines · John Hubbard
Add const_align_up<ALIGN>() to
kernel::ptras the const-compatible equivalent ofAlignable::align_up(). This usesinline_constto validate the alignment at compile time with a clear error message....
Quoted 10 lines
Quoted 10 lines
rust/kernel/ptr.rs fn align_up(self, alignment: Alignment) -> Option<Self> { · line 252
Quoted 6 lines
rust/kernel/ptr.rs +6
-0+#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->usize { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) => v & !(ALIGN -1 ), +None =>panic! ("const_align_up: overflow" ),This is wrong. Either this function is always used in const context, in which case you take
ALIGNas normal function parameter and usebuild_assertandbuild_error, or this function can be called from runtime and you shouldn't have a panic call here.I think the most common case is that ALIGN is const, but value is not.
What about keeping the function as is (with the
panic()replaced with a Result) and also addQuoted 8 lines
#[inline(always)] pub const fn const_expect<T: Copy>(opt: Result<T>, &'static str) -> T { match opt { Ok(v) => v, Err(_) => panic!(""), } }
Quoted 2 lines
We already have
Alignable::align_upfor non-const cases, so this would only be used in const context and I don't see the need of having explicitconst_expect?
Fair enough -- unfortunate we can't call this from const context.
Re: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 36 lines · Danilo Krummrich
Quoted 35 lines · Gary Guo
Quoted 33 lines · Danilo Krummrich
Quoted 8 lines · John Hubbard
Quoted 5 lines · Gary Guo
Quoted 4 lines · John Hubbard
Add const_align_up<ALIGN>() to
kernel::ptras the const-compatible equivalent ofAlignable::align_up(). This usesinline_constto validate the alignment at compile time with a clear error message....
Quoted 10 lines
Quoted 10 lines
Review
Quoted 6 lines
(quoted diff) +6
-0+#[inline(always)] +pub const fn const_align_up<const ALIGN: usize>(value: usize) -> usize { + const { assert!(ALIGN.is_power_of_two(), "ALIGN must be a power of two") }; + match value.checked_add(ALIGN - 1) { + Some(v) => v & !(ALIGN - 1), + None => panic!("const_align_up: overflow"),This is wrong. Either this function is always used in const context, in which case you take
ALIGNas normal function parameter and usebuild_assertandbuild_error, or this function can be called from runtime and you shouldn't have a panic call here.I think the most common case is that ALIGN is const, but value is not.
What about keeping the function as is (with the
panic()replaced with a Result) and also add#[inline(always)] pub const fn const_expect<T: Copy>(opt: Result<T>, &'static str) -> T { match opt { Ok(v) => v, Err(_) => panic!(""), } }
Quoted 4 lines
Quoted 2 lines
We already have
Alignable::align_upfor non-const cases, so this would only be used in const context and I don't see the need of having explicitconst_expect?Fair enough -- unfortunate we can't call this from const context.
OK, so after the dust settled on this discussion, I *think* we ended up at this, which I have staged for an upcoming v6. Did I understand you both correctly?
commit 1360a440272976df697140361537c5b697d602e0
Author: John Hubbard <[email protected]> Date: Thu Feb 19 14:44:02 2026 -0800
rust: ptr: add const_align_up()
Add const_align_up<ALIGN>() to kernel::ptr as the const-compatible equivalent of Alignable::align_up(). This uses inline_const to validate the alignment at compile time with a clear error message.
Overflow causes a panic, which becomes a compile-time error in const context. For runtime alignment with fallible overflow handling, callers should use Alignable::align_up() instead.
rust/kernel/ptr.rs +28 -0
@@ -225,3 +225,31 @@ fn align_up(self, alignment: Alignment) -> Option<Self> { }impl_alignable_uint! (u8 ,u16 ,u32 ,u64 ,usize ); + +/// Aligns `value` up to `ALIGN` at compile time. +/// +/// This is the const-compatible equivalent of [`Alignable::align_up`]. +/// `ALIGN` must be a power of two (enforced at compile time). +/// +/// Panics on overflow, which becomes a compile-time error in const context. +/// For runtime alignment with fallible overflow handling, use +/// [`Alignable::align_up`] instead. +/// +/// # Examples +/// +/// ``` +/// use kernel::ptr::const_align_up; +/// use kernel::sizes::SZ_4K; +/// +/// assert_eq!(const_align_up::<16>(0x4f), 0x50); +/// assert_eq!(const_align_up::<16>(0x40), 0x40); +/// assert_eq!(const_align_up::<SZ_4K>(1), SZ_4K); +/// ``` +#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->usize { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) => v & !(ALIGN -1 ), +None =>panic! ("const_align_up: overflow" ), + } +}
<blueforge> linux-github (nova-core-blackwell-v6)$
thanks,
Signature · 1 line
John Hubbard
Gary Guo
reviewerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 90 lines · John Hubbard
Quoted 36 lines · Danilo Krummrich
Quoted 35 lines · Gary Guo
Quoted 33 lines · Danilo Krummrich
Quoted 8 lines · John Hubbard
Quoted 5 lines · Gary Guo
Quoted 4 lines · John Hubbard
Add const_align_up<ALIGN>() to
kernel::ptras the const-compatible equivalent ofAlignable::align_up(). This usesinline_constto validate the alignment at compile time with a clear error message....
Quoted 10 lines
Quoted 10 lines
rust/kernel/ptr.rs fn align_up(self, alignment: Alignment) -> Option<Self> { · line 253
Quoted 6 lines
rust/kernel/ptr.rs +6
-0+#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->usize { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) => v & !(ALIGN -1 ), +None =>panic! ("const_align_up: overflow" ),This is wrong. Either this function is always used in const context, in which case you take
ALIGNas normal function parameter and usebuild_assertandbuild_error, or this function can be called from runtime and you shouldn't have a panic call here.I think the most common case is that ALIGN is const, but value is not.
What about keeping the function as is (with the
panic()replaced with a Result) and also add#[inline(always)] pub const fn const_expect<T: Copy>(opt: Result<T>, &'static str) -> T { match opt { Ok(v) => v, Err(_) => panic!(""), } }Quoted 4 lines
Quoted 2 lines
We already have
Alignable::align_upfor non-const cases, so this would only be used in const context and I don't see the need of having explicitconst_expect?Fair enough -- unfortunate we can't call this from const context.
OK, so after the dust settled on this discussion, I *think* we ended up at this, which I have staged for an upcoming v6. Did I understand you both correctly?
commit
1360a440272976df697140361537c5b697d602e0Author: John Hubbard <[email protected]> Date: Thu Feb 19 14:44:02 2026 -0800rust: ptr: add
const_align_up()Add const_align_up<ALIGN>() to
kernel::ptras the const-compatible equivalent ofAlignable::align_up(). This usesinline_constto validate the alignment at compile time with a clear error message.Overflow causes a panic, which becomes a compile-time error in const context. For runtime alignment with fallible overflow handling, callers should use
Alignable::align_up()instead.Suggested-by Danilo Krummrich <[email protected]>Suggested-by Miguel Ojeda <[email protected]>Signed-off-by John Hubbard <[email protected]>rust/kernel/ptr.rs +18
-0@@ -225,3 +225,31 @@ fn align_up(self, alignment: Alignment) -> Option<Self> { }impl_alignable_uint! (u8 ,u16 ,u32 ,u64 ,usize ); + +/// Aligns `value` up to `ALIGN` at compile time. +/// +/// This is the const-compatible equivalent of [`Alignable::align_up`]. +/// `ALIGN` must be a power of two (enforced at compile time). +/// +/// Panics on overflow, which becomes a compile-time error in const context. +/// For runtime alignment with fallible overflow handling, use +/// [`Alignable::align_up`] instead. +/// +/// # Examples +/// +/// ``` +/// use kernel::ptr::const_align_up; +/// use kernel::sizes::SZ_4K; +/// +/// assert_eq!(const_align_up::<16>(0x4f), 0x50); +/// assert_eq!(const_align_up::<16>(0x40), 0x40);
rust/kernel/ptr.rs fn align_up(self, alignment: Alignment) -> Option<Self> { · line 255
Quoted 10 lines
rust/kernel/ptr.rs +10
-0+/// assert_eq!(const_align_up::<SZ_4K>(1), SZ_4K); +/// ``` +#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->usize { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) => v & !(ALIGN -1 ), +None =>panic! ("const_align_up: overflow" ), + } +}
The implementation doesn't address any of my original comment and all my points still apply.
Best,
Gary
Quoted 4 lines
<blueforge> linux-github (nova-core-blackwell-v6)$
thanks,
Re: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 1 line · Gary Guo
On Wed Mar 4, 2026 at 3:47 AM GMT, John Hubbard wrote:
...
Quoted 3 lines
The implementation doesn't address any of my original comment and all my points still apply.
OK, so that implies that you want to return an Option, I believe, like this?
commit b41512390999f85bcb2a3809c68f392e936b09ab
Author: John Hubbard <[email protected]> Date: Thu Feb 19 14:44:02 2026 -0800
rust: ptr: add const_align_up()
Add const_align_up<ALIGN>() to kernel::ptr as the const-compatible equivalent of Alignable::align_up(). This uses inline_const to validate the alignment at compile time with a clear error message.
rust/kernel/ptr.rs +26 -0
@@ -225,3 +225,29 @@ fn align_up(self, alignment: Alignment) -> Option<Self> { }impl_alignable_uint! (u8 ,u16 ,u32 ,u64 ,usize ); + +/// Aligns `value` up to `ALIGN` at compile time. +/// +/// This is the const-compatible equivalent of [`Alignable::align_up`]. +/// `ALIGN` must be a power of two (enforced at compile time). +/// +/// Returns [`None`] on overflow. +/// +/// # Examples +/// +/// ``` +/// use kernel::ptr::const_align_up; +/// use kernel::sizes::SZ_4K; +/// +/// assert_eq!(const_align_up::<16>(0x4f), Some(0x50)); +/// assert_eq!(const_align_up::<16>(0x40), Some(0x40)); +/// assert_eq!(const_align_up::<SZ_4K>(1), Some(SZ_4K)); +/// ``` +#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->Option <usize > { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) =>Some (v & !(ALIGN -1 )), +None =>None , + } +}
thanks,
Signature · 1 line
John Hubbard
Gary Guo
reviewerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 49 lines · John Hubbard
Quoted 1 line · Gary Guo
On Wed Mar 4, 2026 at 3:47 AM GMT, John Hubbard wrote:
...
Quoted 3 lines
The implementation doesn't address any of my original comment and all my points still apply.
OK, so that implies that you want to return an Option, I believe, like this?
commit
b41512390999f85bcb2a3809c68f392e936b09abAuthor: John Hubbard <[email protected]> Date: Thu Feb 19 14:44:02 2026 -0800rust: ptr: add
const_align_up()Add const_align_up<ALIGN>() to
kernel::ptras the const-compatible equivalent ofAlignable::align_up(). This usesinline_constto validate the alignment at compile time with a clear error message.Suggested-by Danilo Krummrich <[email protected]>Suggested-by Gary Guo <[email protected]>Suggested-by Miguel Ojeda <[email protected]>Signed-off-by John Hubbard <[email protected]>rust/kernel/ptr.rs +16
-0@@ -225,3 +225,29 @@ fn align_up(self, alignment: Alignment) -> Option<Self> { }impl_alignable_uint! (u8 ,u16 ,u32 ,u64 ,usize ); + +/// Aligns `value` up to `ALIGN` at compile time. +/// +/// This is the const-compatible equivalent of [`Alignable::align_up`]. +/// `ALIGN` must be a power of two (enforced at compile time). +/// +/// Returns [`None`] on overflow. +/// +/// # Examples +/// +/// ``` +/// use kernel::ptr::const_align_up; +/// use kernel::sizes::SZ_4K; +/// +/// assert_eq!(const_align_up::<16>(0x4f), Some(0x50)); +/// assert_eq!(const_align_up::<16>(0x40), Some(0x40));
rust/kernel/ptr.rs fn align_up(self, alignment: Alignment) -> Option<Self> { · line 253
Quoted 10 lines
rust/kernel/ptr.rs +10
-0+/// assert_eq!(const_align_up::<SZ_4K>(1), Some(SZ_4K)); +/// ``` +#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->Option <usize > { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) =>Some (v & !(ALIGN -1 )), +None =>None , + } +}
I think your signature should probably just be
pub const fn const_align_up(value: usize, align: Alignment) -> Option<usize> {
... }
Best,
Gary
Quoted 3 lines
thanks,
Re: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 15 lines · Gary Guo
rust/kernel/ptr.rs fn align_up(self, alignment: Alignment) -> Option<Self> { · line 253
Quoted 11 lines · John Hubbard
Quoted 1 line · Gary Guo
On Wed Mar 4, 2026 at 3:47 AM GMT, John Hubbard wrote:
...
rust/kernel/ptr.rs +8
-0+#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->Option <usize > { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) =>Some (v & !(ALIGN -1 )), +None =>None , + } +}I think your signature should probably just be
Quoted 4 lines
pub const fn
const_align_up(value: usize, align: Alignment)-> Option<usize> {... }
OK yes that's a bit nicer. I've done that for v6, thanks!
thanks,
Signature · 1 line
John Hubbard
Alexandre Courbot
maintainerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 16 lines · John Hubbard
Quoted 15 lines · Gary Guo
rust/kernel/ptr.rs fn align_up(self, alignment: Alignment) -> Option<Self> { · line 253
Quoted 11 lines · John Hubbard
Quoted 1 line · Gary Guo
On Wed Mar 4, 2026 at 3:47 AM GMT, John Hubbard wrote:
...
rust/kernel/ptr.rs +8
-0+#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->Option <usize > { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) =>Some (v & !(ALIGN -1 )), +None =>None , + } +}I think your signature should probably just be
Quoted 6 lines
Quoted 4 lines
pub const fn
const_align_up(value: usize, align: Alignment)-> Option<usize> {... }OK yes that's a bit nicer. I've done that for v6, thanks!
Hold on a bit - if we are purposing this new method for use in const contexts, what use do we have for a None return value? By definition we would know both value and align and thus the result is deterministic.
We do have an alignment method for non-const contexts already. Gary's initial comment was:
Quoted 3 lines
Either this function is always used in const context, in which case you take
ALIGNas normal function parameter and usebuild_assertandbuild_error
So why not make both arguments generic in this new method, and fail at build in case of overflow?
Re: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 32 lines · Alexandre Courbot
Quoted 16 lines · John Hubbard
Quoted 15 lines · Gary Guo
Review
Quoted 11 lines · John Hubbard
Quoted 1 line · Gary Guo
On Wed Mar 4, 2026 at 3:47 AM GMT, John Hubbard wrote:
...
(quoted diff) +8
-0+#[inline(always)] +pub const fn const_align_up<const ALIGN: usize>(value: usize) -> Option<usize> { + const { assert!(ALIGN.is_power_of_two(), "ALIGN must be a power of two") }; + match value.checked_add(ALIGN - 1) { + Some(v) => Some(v & !(ALIGN - 1)), + None => None, + } +}I think your signature should probably just be
Quoted 6 lines
Quoted 4 lines
pub const fn
const_align_up(value: usize, align: Alignment)-> Option<usize> {... }OK yes that's a bit nicer. I've done that for v6, thanks!
Hold on a bit - if we are purposing this new method for use in const contexts, what use do we have for a
Nonereturn value? By definition we would know bothvalueandalignand thus the result is deterministic.We do have an alignment method for non-const contexts already. Gary's initial comment was:
Quoted 6 lines
Quoted 3 lines
Either this function is always used in const context, in which case you take
ALIGNas normal function parameter and usebuild_assertandbuild_errorSo why not make both arguments generic in this new method, and fail at build in case of overflow?
At this point, it is completely impossible to write a patch that complies with Gary, Danilo, and Alex. It's all over the map.
Here's what is staged in v6 so far. I don't care anymore what we end up with, but let's pick something:
Author: John Hubbard <[email protected]> Date: Thu Feb 19 14:44:02 2026 -0800
rust: ptr: add const_align_up()
Add const_align_up() to kernel::ptr as the const-compatible equivalent of Alignable::align_up().
rust/kernel/ptr.rs +24 -0
@@ -225,3 +225,27 @@ fn align_up(self, alignment: Alignment) -> Option<Self> { }impl_alignable_uint! (u8 ,u16 ,u32 ,u64 ,usize ); + +/// Aligns `value` up to `align`. +/// +/// This is the const-compatible equivalent of [`Alignable::align_up`]. +/// +/// Returns [`None`] on overflow. +/// +/// # Examples +/// +/// ``` +/// use kernel::ptr::{const_align_up, Alignment}; +/// use kernel::sizes::SZ_4K; +/// +/// assert_eq!(const_align_up(0x4f, Alignment::new::<16>()), Some(0x50)); +/// assert_eq!(const_align_up(0x40, Alignment::new::<16>()), Some(0x40)); +/// assert_eq!(const_align_up(1, Alignment::new::<SZ_4K>()), Some(SZ_4K)); +/// ``` +#[inline(always)] +pub const fn const_align_up (value:usize , align:Alignment ) ->Option <usize > { +match value.checked_add (align.as_usize () -1 ) { +Some (v) =>Some (v & align.mask ()), +None =>None , + } +}
thanks,
Signature · 1 line
John Hubbard
Alexandre Courbot
maintainerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 37 lines · John Hubbard
Quoted 36 lines · Alexandre Courbot
Quoted 16 lines · John Hubbard
Quoted 15 lines · Gary Guo
rust/kernel/ptr.rs fn align_up(self, alignment: Alignment) -> Option<Self> { · line 251
Quoted 11 lines · John Hubbard
Quoted 1 line · Gary Guo
On Wed Mar 4, 2026 at 3:47 AM GMT, John Hubbard wrote:
...
rust/kernel/ptr.rs +8
-0+#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->Option <usize > { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) =>Some (v & !(ALIGN -1 )), +None =>None , + } +}I think your signature should probably just be
Quoted 6 lines
Quoted 4 lines
pub const fn
const_align_up(value: usize, align: Alignment)-> Option<usize> {... }OK yes that's a bit nicer. I've done that for v6, thanks!
Hold on a bit - if we are purposing this new method for use in const contexts, what use do we have for a
Nonereturn value? By definition we would know bothvalueandalignand thus the result is deterministic.We do have an alignment method for non-const contexts already. Gary's initial comment was:
Quoted 3 lines
Either this function is always used in const context, in which case you take
ALIGNas normal function parameter and usebuild_assertandbuild_error
Quoted 5 lines
Quoted 2 lines
So why not make both arguments generic in this new method, and fail at build in case of overflow?
At this point, it is completely impossible to write a patch that complies with Gary, Danilo, and Alex. It's all over the map.
IIUC it is possible. Let's summarize the constraints:
- Gary wants to avoid a panic in case this gets called at runtime,
- Danilo suggested returning a Result that can be discarded in const context (but took that suggestion back as we already have methods for non-const contexts and thus wouldn't bring any benefit),
- I also pointed out that there is not reason to have a failure path for const context and suggested two generic arguments.
So here is what I had in mind, if using a standalone function:
pub const fn const_align_up<const ALIGN: usize, const VALUE: usize>() -> usize {
const { assert!(ALIGN.is_power_of_two(), "ALIGN must be a power of two") };
const {
assert!(
VALUE <= usize::MAX - (ALIGN - 1),
"requested alignment would overflow"
)
};
(VALUE + (ALIGN - 1)) & !(ALIGN - 1)}
const TEST_ALIGN: usize = const_align_up::<256, 10>();
This uses purely const asserts, but you have to work with two usize arguments. The version below looks a bit nicer as it leverages the power-of-two invariant of Alignment:
impl Alignment {
const fn const_align_up(self, value: usize) -> usize {
build_assert!(value <= usize::MAX - !self.mask()); (value + !self.mask()) & self.mask()
}}
const TEST_ALIGN2: usize = Alignment::new::<256>().const_align_up(10);
It has to trade the const asserts for build_assert, which could cause these cryptic error messages if called in a non-const context, so we should document that this is only to be called in const contexts. But otherwise it fits the bill and looks reasonable imho.
Unfortunate that we cannot make it generic against all integer types without const_trait_impl, but generating const_align_usize_up, const_align_u32_up... etc using a macro should be doable if needed.
Oh and if this cannot reach consensus I am ok with just dropping this patch for now and doing something like this in the next one:
const SZ_128K_ALIGN_MASK: usize = Alignment::new::<SZ_128K>().mask();
const PMU_RESERVED_SIZE: usize = SZ_8M + SZ_16M + SZ_4K; // Align to 128K.
const PMU_RESERVED_SIZE_ALIGNED: u32 = num::usize_into_u32::<
{ (PMU_RESERVED_SIZE + !SZ_128K_ALIGN_MASK) & SZ_128K_ALIGN_MASK },Quoted 1 line
();
Gary Guo
reviewerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 65 lines · Alexandre Courbot
Quoted 37 lines · John Hubbard
Quoted 36 lines · Alexandre Courbot
Quoted 16 lines · John Hubbard
Quoted 15 lines · Gary Guo
rust/kernel/ptr.rs fn align_up(self, alignment: Alignment) -> Option<Self> { · line 251
Quoted 11 lines · John Hubbard
Quoted 1 line · Gary Guo
On Wed Mar 4, 2026 at 3:47 AM GMT, John Hubbard wrote:
...
rust/kernel/ptr.rs +8
-0+#[inline(always)] +pub const fn const_align_up <const ALIGN :usize >(value:usize ) ->Option <usize > { +const {assert! (ALIGN .is_power_of_two (),"ALIGN must be a power of two" ) }; +match value.checked_add (ALIGN -1 ) { +Some (v) =>Some (v & !(ALIGN -1 )), +None =>None , + } +}I think your signature should probably just be
Quoted 6 lines
Quoted 4 lines
pub const fn
const_align_up(value: usize, align: Alignment)-> Option<usize> {... }OK yes that's a bit nicer. I've done that for v6, thanks!
Hold on a bit - if we are purposing this new method for use in const contexts, what use do we have for a
Nonereturn value? By definition we would know bothvalueandalignand thus the result is deterministic.We do have an alignment method for non-const contexts already. Gary's initial comment was:
Quoted 3 lines
Either this function is always used in const context, in which case you take
ALIGNas normal function parameter and usebuild_assertandbuild_errorQuoted 5 lines
Quoted 2 lines
So why not make both arguments generic in this new method, and fail at build in case of overflow?
At this point, it is completely impossible to write a patch that complies with Gary, Danilo, and Alex. It's all over the map.
IIUC it is possible. Let's summarize the constraints:
- Gary wants to avoid a panic in case this gets called at runtime,
- Danilo suggested returning a Result that can be discarded in const context (but took that suggestion back as we already have methods for non-const contexts and thus wouldn't bring any benefit),
- I also pointed out that there is not reason to have a failure path for const context and suggested two generic arguments.So here is what I had in mind, if using a standalone function:
pub const fn const_align_up<const ALIGN: usize, const VALUE: usize>() -> usize {
const { assert!(ALIGN.is_power_of_two(), "ALIGN must be a power of two") }; const { assert!( VALUE <= usize::MAX - (ALIGN - 1), "requested alignment would overflow" ) }; (VALUE + (ALIGN - 1)) & !(ALIGN - 1)
Quoted 1 line
}
Eh, no, please don't start put everything into const generics params. These are severely limited in usability, you can only refer to actual constant values, and won't be able to use them in, say, const functions.
If we're going down this route I'd just want
pub const fn const_align_up(align: usize, value: usize) -> usize
and use build asserts inside. If this is only used in const, then using build_assert! is perfectly fine.
I think John just want to express usize.align_up(Alignment) in const context, which we can't do with stable features only right now, hence I sugggested a specific const function that has the same signature as the extension trait method.
Returning a Option isn't an issue in const contexts, you can just use Option::unwrap which is const (might need to enable a feature in 1.78, but it is stable for a while now).
So you just have
const TEST_ALIGN: usize = const_align_up(10, Alignment::new::<256>()).unwrap();
which would become
const TEST_ALIGN: usize = 10.align_up(Alignmnet::new::<256>()).unwrap();
when we have const trait impl.
Quoted 7 lines
const TEST_ALIGN: usize = const_align_up::<256, 10>();This uses purely const asserts, but you have to work with two
usizearguments. The version below looks a bit nicer as it leverages the power-of-two invariant ofAlignment:
Quoted 6 lines
impl Alignment { const fn const_align_up(self, value: usize) -> usize { build_assert!(value <= usize::MAX - !self.mask());(value + !self.mask()) & self.mask() }
This is fine, too, although I think just returning an Option and ask user to unwrap it in const eval is better.
Best,
Gary
Quoted 23 lines
} const TEST_ALIGN2: usize = Alignment::new::<256>().const_align_up(10);It has to trade the const asserts for
build_assert, which could cause these cryptic error messages if called in a non-const context, so we should document that this is only to be called in const contexts. But otherwise it fits the bill and looks reasonable imho.Unfortunate that we cannot make it generic against all integer types without
const_trait_impl, but generatingconst_align_usize_up,const_align_u32_up... etc using a macro should be doable if needed.Oh and if this cannot reach consensus I am ok with just dropping this patch for now and doing something like this in the next one:
const SZ_128K_ALIGN_MASK: usize = Alignment::new::<SZ_128K>().mask();const
PMU_RESERVED_SIZE: usize =SZ_8M+SZ_16M+SZ_4K; // Align to 128K.
constPMU_RESERVED_SIZE_ALIGNED: u32 = num::usize_into_u32::<{ (PMU_RESERVED_SIZE + !SZ_128K_ALIGN_MASK) & SZ_128K_ALIGN_MASK },Quoted 1 line
();
Danilo Krummrich
maintainerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 2 lines · Gary Guo
This is fine, too, although I think just returning an
Optionand ask user to unwrap it in const eval is better.
Well, that was my initial proposal (except that it was Result and const_expect()).
IIRC, you were against this in favor of build_assert!()?
Gary Guo
reviewerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 8 lines · Danilo Krummrich
Quoted 2 lines · Gary Guo
This is fine, too, although I think just returning an
Optionand ask user to unwrap it in const eval is better.Well, that was my initial proposal (except that it was Result and
const_expect()).IIRC, you were against this in favor of build_assert!()?
I think I was just commenting about the API design, and not the idea in general.
My view is that should either completely mimick the non-const API (just with functions so it doesn't need const trait impl), or we should go all the way to build_assert!(). Either is fine.
Best,
Gary
Alexandre Courbot
maintainerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
In reply to Gary GuoQuoted 11 lines · Gary Guo
Quoted 11 lines
const TEST_ALIGN: usize = const_align_up::<256, 10>();This uses purely const asserts, but you have to work with two
usizearguments. The version below looks a bit nicer as it leverages the power-of-two invariant ofAlignment:impl Alignment { const fn const_align_up(self, value: usize) -> usize { build_assert!(value <= usize::MAX - !self.mask());
Quoted 5 lines
Quoted 2 lines
(value + !self.mask()) & self.mask() }This is fine, too, although I think just returning an
Optionand ask user to unwrap it in const eval is better.
Why? Aren't unwraps something we want to avoid?
We already have fallible methods for non-const contexts, so why give another method that essentially behaves the same when we want to use it in scenarios where we know the result will be successful anyway?
Gary Guo
reviewerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 15 lines · Alexandre Courbot
Quoted 14 lines · Gary Guo
Quoted 13 lines
const TEST_ALIGN: usize = const_align_up::<256, 10>();This uses purely const asserts, but you have to work with two
usizearguments. The version below looks a bit nicer as it leverages the power-of-two invariant ofAlignment:impl Alignment { const fn const_align_up(self, value: usize) -> usize { build_assert!(value <= usize::MAX - !self.mask());(value + !self.mask()) & self.mask() }
Quoted 8 lines
Quoted 2 lines
This is fine, too, although I think just returning an
Optionand ask user to unwrap it in const eval is better.Why? Aren't unwraps something we want to avoid?
We already have fallible methods for non-const contexts, so why give another method that essentially behaves the same when we want to use it in scenarios where we know the result will be successful anyway?
Unwrap is only bad when it can panic. It's not an issue for things that is apparently const eval only, e.g. inside const {} or const FOO: Bar = baz.
Best,
Gary
Alexandre Courbot
maintainerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
Quoted 19 lines · Gary Guo
Quoted 18 lines · Alexandre Courbot
Quoted 16 lines · Gary Guo
Quoted 7 lines
const TEST_ALIGN: usize = const_align_up::<256, 10>();This uses purely const asserts, but you have to work with two
usizearguments. The version below looks a bit nicer as it leverages the power-of-two invariant ofAlignment:Quoted 6 lines
impl Alignment { const fn const_align_up(self, value: usize) -> usize { build_assert!(value <= usize::MAX - !self.mask());(value + !self.mask()) & self.mask() }This is fine, too, although I think just returning an
Optionand ask user to unwrap it in const eval is better.
Quoted 8 lines
Quoted 5 lines
Why? Aren't unwraps something we want to avoid?
We already have fallible methods for non-const contexts, so why give another method that essentially behaves the same when we want to use it in scenarios where we know the result will be successful anyway?
Unwrap is only bad when it can panic. It's not an issue for things that is apparently const eval only, e.g. inside
const {}orconst FOO: Bar = baz.
If we go that route we are just providing const versions of the align_up methods of Alignable. Why not, but it looks very redundant to me.
Alice Ryhl
maintainerRe: [PATCH v5 21/38] rust: ptr: add const_align_up() and enable inline_const feature
In reply to John HubbardQuoted 4 lines · John Hubbard
Add const_align_up<ALIGN>() to
kernel::ptras the const-compatible equivalent ofAlignable::align_up(). This usesinline_constto validate the alignment at compile time with a clear error message.
Quoted 8 lines
Add
inline_consttorust_allowed_featuresinscripts/Makefile.build, following the approach in [1].[1] https://lore.kernel.org/rust-for-linux/[email protected]/
Suggested-by Danilo Krummrich <[email protected]>Suggested-by Miguel Ojeda <[email protected]>Signed-off-by John Hubbard <[email protected]>
Note that Rust Binder's ptr_align could use this if you want another user.
Alice
PATCH v5 22/38 gpu: nova-core: Hopper/Blackwell: calculate reserved FB heap size
In reply to John HubbardVarious "reserved" areas of FB (frame buffer: vidmem) have to be calculated, because the GSP booting process needs this information.
PMU_RESERVED_SIZE is computed at compile time using const_align_up(). The total reserved size is computed at runtime using Alignable::align_up because it depends on the heap layout.
--- drivers/gpu/nova-core/fb.rs | 7 ++++++- drivers/gpu/nova-core/gsp/fw.rs | 6 +++++- 2 files changed, 11 insertions(+), 2 deletions(-)
drivers/gpu/nova-core/fb.rs +6 -1
@@ -11,7 +11,8 @@ prelude::*, ptr::{Alignable , -Alignment ,// +Alignment , + const_align_up,// }, sizes::*, sync::aref::ARef, //
@@ -270,3 +271,7 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result< }) } } + +/// PMU reserved size, aligned to 128KB. +pub (crate )const PMU_RESERVED_SIZE :u32 = +const_align_up ::<SZ_128K >(SZ_8M +SZ_16M +SZ_4K )as u32 ;
drivers/gpu/nova-core/gsp/fw.rs +5 -1
@@ -27,7 +27,10 @@ };use crate ::{ - fb::FbLayout , + fb::{ +FbLayout , +PMU_RESERVED_SIZE ,// + }, firmware::gsp::GspFirmware , gpu::Chipset , gsp::{
@@ -183,6 +186,7 @@ pub(crate) fn new(gsp_firmware: &GspFirmware, fb_layout: &FbLayout) -> Self { fbSize: fb_layout.fb.end - fb_layout.fb.start, vgaWorkspaceOffset: fb_layout.vga_workspace.start, vgaWorkspaceSize: fb_layout.vga_workspace.end - fb_layout.vga_workspace.start, + pmuReservedSize: PMU_RESERVED_SIZE, ..Default ::default () }) }
Signature · 1 line
2.53.0
PATCH v5 23/38 gpu: nova-core: add MCTP/NVDM protocol types for firmware communication
In reply to John HubbardAdd the MCTP (Management Component Transport Protocol) and NVDM (NVIDIA Device Management) wire-format types used for communication between the kernel driver and GPU firmware processors.
This includes typed MCTP transport headers, NVDM message headers, and NVDM message type identifiers. Both the FSP boot path and the upcoming GSP RPC message queue share this protocol layer.
--- drivers/gpu/nova-core/mctp.rs | 107 +++++++++++++++++++++++++++++ drivers/gpu/nova-core/nova_core.rs | 1 + 2 files changed, 108 insertions(+) create mode 100644 drivers/gpu/nova-core/mctp.rs
drivers/gpu/nova-core/mctp.rs new file +107 -0
@@ -0,0 +1,107 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! MCTP/NVDM protocol types for NVIDIA GPU firmware communication. +//! +//! MCTP (Management Component Transport Protocol) carries NVDM (NVIDIA +//! Device Management) messages between the kernel driver and GPU firmware +//! processors such as FSP and GSP. + +#![expect(dead_code)] + +/// NVDM message type identifiers carried over MCTP. +#[derive( Debug , Clone , Copy , PartialEq , Eq )] +#[repr( u32 )] +pub (crate )enum NvdmType { +/// Chain of Trust boot message. +Cot =0x14 , +/// FSP command response. +FspResponse =0x15 , +} + +/// MCTP transport header for NVIDIA firmware messages. +/// +/// Bit layout: `[31] SOM | [30] EOM | [29:28] SEQ | [23:16] SEID`. +#[derive( Debug , Clone , Copy )] +pub (crate )struct MctpHeader (u32 ); + +impl MctpHeader { +const SOM_SHIFT :u32 =31 ; +const EOM_SHIFT :u32 =30 ; + +/// Build a single-packet MCTP header (SOM=1, EOM=1, SEQ=0, SEID=0). +pub (crate )const fn single_packet () ->Self { +Self ((1 <<Self ::SOM_SHIFT ) | (1 <<Self ::EOM_SHIFT )) + } + +/// Return the raw packed u32. +pub (crate )const fn raw (self) ->u32 { + self.0 + } + +/// Check if this is a complete single-packet message (SOM=1 and EOM=1). +pub (crate )const fn is_single_packet (self) ->bool { +let som = (self.0 >>Self ::SOM_SHIFT ) &1 ; +let eom = (self.0 >>Self ::EOM_SHIFT ) &1 ; + som ==1 && eom ==1 + } +} + +impl From <u32 >for MctpHeader { +fn from (raw:u32 ) ->Self { +Self (raw) + } +} + +/// MCTP message type for PCI vendor-defined messages. +const MSG_TYPE_VENDOR_PCI :u32 =0x7e ; + +/// NVIDIA PCI vendor ID. +const VENDOR_ID_NV :u32 =0x10de ; + +/// NVIDIA Vendor-Defined Message (NVDM) header over MCTP. +/// +/// Bit layout: `[6:0] msg_type | [23:8] vendor_id | [31:24] nvdm_type`. +#[derive( Debug , Clone , Copy )] +pub (crate )struct NvdmHeader (u32 ); + +impl NvdmHeader { +const MSG_TYPE_MASK :u32 =0x7f ; +const VENDOR_ID_SHIFT :u32 =8 ; +const VENDOR_ID_MASK :u32 =0xffff ; +const TYPE_SHIFT :u32 =24 ; +const TYPE_MASK :u32 =0xff ; + +/// Build an NVDM header for the given message type. +pub (crate )const fn new (nvdm_type:NvdmType ) ->Self { +Self ( +MSG_TYPE_VENDOR_PCI + | (VENDOR_ID_NV <<Self ::VENDOR_ID_SHIFT ) + | ((nvdm_typeas u32 ) <<Self ::TYPE_SHIFT ), + ) + } + +/// Return the raw packed u32. +pub (crate )const fn raw (self) ->u32 { + self.0 + } + +/// Extract the NVDM type field as a raw value. +pub (crate )const fn nvdm_type_raw (self) ->u32 { + (self.0 >>Self ::TYPE_SHIFT ) &Self ::TYPE_MASK + } + +/// Validate this header against the expected NVIDIA NVDM format and type. +pub (crate )const fn validate (self, expected_type:NvdmType ) ->bool { +let msg_type = self.0 &Self ::MSG_TYPE_MASK ; +let vendor_id = (self.0 >>Self ::VENDOR_ID_SHIFT ) &Self ::VENDOR_ID_MASK ; + msg_type ==MSG_TYPE_VENDOR_PCI + && vendor_id ==VENDOR_ID_NV + && self.nvdm_type_raw () == expected_typeas u32 + } +} + +impl From <u32 >for NvdmHeader { +fn from (raw:u32 ) ->Self { +Self (raw) + } +}
drivers/gpu/nova-core/nova_core.rs +1 -0
@@ -13,6 +13,7 @@mod gfw;mod gpu;mod gsp; +mod mctp;mod num;mod regs;mod sbuffer;
Signature · 1 line
2.53.0
PATCH v5 24/38 gpu: nova-core: Hopper/Blackwell: add FSP secure boot completion waiting
In reply to John HubbardAdd the FSP (Firmware System Processor) module for Hopper/Blackwell GPUs. These architectures use a simplified firmware boot sequence:
FMC --> FSP --> GSP, with no SEC2 involvement.
This commit adds the ability to wait for FSP secure boot completion by polling the I2CS thermal scratch register until FSP signals success.
--- drivers/gpu/nova-core/fsp.rs | 141 +++++++++++++++++++++++++++++ drivers/gpu/nova-core/nova_core.rs | 1 + drivers/gpu/nova-core/regs.rs | 12 +-- 3 files changed, 148 insertions(+), 6 deletions(-) create mode 100644 drivers/gpu/nova-core/fsp.rs
drivers/gpu/nova-core/fsp.rs new file +141 -0
@@ -0,0 +1,141 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! FSP (Firmware System Processor) interface for Hopper/Blackwell GPUs. +//! +//! Hopper/Blackwell use a simplified firmware boot sequence: FMC --> FSP --> GSP. +//! Unlike Turing/Ampere/Ada, there is NO SEC2 (Security Engine 2) usage. +//! FSP handles secure boot directly using FMC firmware + Chain of Trust. + +use kernel::{ + device, + io::poll::read_poll_timeout, + prelude::*, + time::Delta , + transmute::{ +AsBytes , +FromBytes ,// + }, +}; + +use crate ::regs; + +/// FSP secure boot completion timeout in milliseconds. +const FSP_SECURE_BOOT_TIMEOUT_MS :i64 =4000 ; + +/// GSP FMC initialization parameters. +#[repr( C )] +#[derive( Debug , Clone , Copy , Default )] +struct GspFmcInitParams { +/// CC initialization "registry keys". + regkeys:u32 , +} + +// SAFETY: GspFmcInitParams is a simple C struct with only primitive types. +unsafe impl AsBytes for GspFmcInitParams {} +// SAFETY: All bit patterns are valid for the primitive fields. +unsafe impl FromBytes for GspFmcInitParams {} + +/// GSP ACR (Authenticated Code RAM) boot parameters. +#[repr( C )] +#[derive( Debug , Clone , Copy , Default )] +struct GspAcrBootGspRmParams { +/// Physical memory aperture through which gspRmDescPa is accessed. + target:u32 , +/// Size in bytes of the GSP-RM descriptor structure. + gsp_rm_desc_size:u32 , +/// Physical offset in the target aperture of the GSP-RM descriptor structure. + gsp_rm_desc_offset:u64 , +/// Physical offset in FB to set the start of the WPR containing GSP-RM. + wpr_carveout_offset:u64 , +/// Size in bytes of the WPR containing GSP-RM. + wpr_carveout_size:u32 , +/// Whether to boot GSP-RM or GSP-Proxy through ACR. + b_is_gsp_rm_boot:u32 , +} + +// SAFETY: GspAcrBootGspRmParams is a simple C struct with only primitive types. +unsafe impl AsBytes for GspAcrBootGspRmParams {} +// SAFETY: All bit patterns are valid for the primitive fields. +unsafe impl FromBytes for GspAcrBootGspRmParams {} + +/// GSP RM boot parameters. +#[repr( C )] +#[derive( Debug , Clone , Copy , Default )] +struct GspRmParams { +/// Physical memory aperture through which bootArgsOffset is accessed. + target:u32 , +/// Physical offset in the memory aperture that will be passed to GSP-RM. + boot_args_offset:u64 , +} + +// SAFETY: GspRmParams is a simple C struct with only primitive types. +unsafe impl AsBytes for GspRmParams {} +// SAFETY: All bit patterns are valid for the primitive fields. +unsafe impl FromBytes for GspRmParams {} + +/// GSP SPDM (Security Protocol and Data Model) parameters. +#[repr( C )] +#[derive( Debug , Clone , Copy , Default )] +struct GspSpdmParams { +/// Physical memory aperture through which all addresses are accessed. + target:u32 , +/// Physical offset in the memory aperture where SPDM payload buffer is stored. + payload_buffer_offset:u64 , +/// Size of the above payload buffer. + payload_buffer_size:u32 , +} + +// SAFETY: GspSpdmParams is a simple C struct with only primitive types. +unsafe impl AsBytes for GspSpdmParams {} +// SAFETY: All bit patterns are valid for the primitive fields. +unsafe impl FromBytes for GspSpdmParams {} + +/// Complete GSP FMC boot parameters passed to FSP. +#[repr( C )] +#[derive( Debug , Clone , Copy , Default )] +pub (crate )struct GspFmcBootParams { + init_params:GspFmcInitParams , + boot_gsp_rm_params:GspAcrBootGspRmParams , + gsp_rm_params:GspRmParams , + gsp_spdm_params:GspSpdmParams , +} + +// SAFETY: GspFmcBootParams is composed of C structs with only primitive types. +unsafe impl AsBytes for GspFmcBootParams {} +// SAFETY: All bit patterns are valid for the primitive fields. +unsafe impl FromBytes for GspFmcBootParams {} + +/// FSP interface for Hopper/Blackwell GPUs. +pub (crate )struct Fsp ; + +impl Fsp { +/// Wait for FSP secure boot completion. +/// +/// Polls the thermal scratch register until FSP signals boot completion +/// or timeout occurs. +#[expect(dead_code)] +pub (crate )fn wait_secure_boot ( + dev: &device::Device <device::Bound >, + bar: &crate ::driver::Bar0 , + arch:crate ::gpu::Architecture , + ) ->Result { +debug_assert! ( + regs::read_fsp_boot_complete_status (bar, arch).is_some (), +"wait_secure_boot called on non-FSP architecture" + ); + +let timeout =Delta ::from_millis (FSP_SECURE_BOOT_TIMEOUT_MS ); + +read_poll_timeout ( + || regs::read_fsp_boot_complete_status (bar, arch).ok_or (ENOTSUPP ), + |&status| status == regs::FSP_BOOT_COMPLETE_SUCCESS , +Delta ::from_millis (10 ), + timeout, + ) + .map_err (|_| { +dev_err! (dev,"FSP secure boot completion timeout\n" ); +ETIMEDOUT + }) + .map (|_| ()) + } +}
drivers/gpu/nova-core/nova_core.rs +1 -0
@@ -10,6 +10,7 @@mod falcon;mod fb;mod firmware; +mod fsp;mod gfw;mod gpu;mod gsp;
drivers/gpu/nova-core/regs.rs +6 -6
@@ -478,17 +478,17 @@ pub(crate) fn fsp_thermal_scratch_reg_addr(arch: Architecture) -> Result<usize> }/// FSP writes this value to indicate successful boot completion. -#[expect(unused)] pub (crate )const FSP_BOOT_COMPLETE_SUCCESS :u32 =0xff ; -// Helper function to read FSP boot completion status from the correct register -#[expect(unused)] +/// Read FSP boot completion status from the architecture-specific thermal scratch register. +/// +/// Returns `None` if the architecture does not have an FSP. pub (crate )fn read_fsp_boot_complete_status ( bar: &crate ::driver::Bar0 , arch:Architecture , -) ->Result <u32 > { -let addr =fsp_thermal_scratch_reg_addr (arch)?; -Ok (bar.read32 (addr)) +) ->Option <u32 > { +let addr =fsp_thermal_scratch_reg_addr (arch).ok ()?; +Some (bar.read32 (addr)) }// The modules below provide registers that are not identical on all supported chips. They should
Signature · 1 line
2.53.0
PATCH v5 25/38 gpu: nova-core: Hopper/Blackwell: add FSP message structures
In reply to John HubbardAdd the NVDM COT payload, FSP message, and FSP response structures needed for FSP Chain of Trust communication. Also add FmcSignatures to hold the hash, public key, and signature extracted from FMC firmware.
--- drivers/gpu/nova-core/firmware.rs | 5 +- drivers/gpu/nova-core/fsp.rs | 78 +++++++++++++++++++++++++++++++ 2 files changed, 82 insertions(+), 1 deletion(-)
drivers/gpu/nova-core/firmware.rs +4 -1
@@ -27,6 +27,9 @@ }, }; +#[expect(unused)] +pub (crate )use elf::elf_section; +pub (crate )mod booter;pub (crate )mod fsp;pub (crate )mod fwsec;
@@ -607,7 +610,7 @@ fn elf32_section<'a>(elf: &'a [u8], name: &str) -> Option<&'a [u8]> { }/// Automatically detects ELF32 vs ELF64 based on the ELF header. -pub (super )fn elf_section <'a>(elf: &'a [u8 ], name: &str ) ->Option <&'a [u8 ]> { +pub (crate )fn elf_section <'a>(elf: &'a [u8 ], name: &str ) ->Option <&'a [u8 ]> {// Check ELF magic. if elf.len () <5 || elf.get (0 ..4 )? !=b"\x7fELF" {return None ;
drivers/gpu/nova-core/fsp.rs +78 -0
84 lines not on this page · raw message
Signature · 1 line
2.53.0
PATCH v5 26/38 gpu: nova-core: Hopper/Blackwell: add FMC signature extraction
In reply to John HubbardAdd extract_fmc_signatures() which extracts SHA-384 hash, RSA public key, and RSA signature from FMC ELF32 firmware sections. These are needed for FSP Chain of Trust verification.
--- drivers/gpu/nova-core/firmware.rs | 1 - drivers/gpu/nova-core/fsp.rs | 61 ++++++++++++++++++++++++++++++- 2 files changed, 60 insertions(+), 2 deletions(-)
drivers/gpu/nova-core/firmware.rs +0 -1
@@ -27,7 +27,6 @@ }, }; -#[expect(unused)] pub (crate )use elf::elf_section;pub (crate )mod booter;
drivers/gpu/nova-core/fsp.rs +60 -1
71 lines not on this page · raw message
Signature · 1 line
2.53.0
PATCH v5 27/38 gpu: nova-core: Hopper/Blackwell: add FSP send/receive messaging
In reply to John HubbardAdd send_sync_fsp() which sends an MCTP/NVDM message to FSP and waits for the response. Response validation uses the typed MctpHeader and NvdmHeader wrappers from the previous commit.
A MessageToFsp trait provides the NVDM type constant for each message struct, so send_sync_fsp() can verify that the response matches the request.
--- drivers/gpu/nova-core/falcon/fsp.rs | 3 - drivers/gpu/nova-core/fsp.rs | 107 +++++++++++++++++++++++++++- 2 files changed, 105 insertions(+), 5 deletions(-)
drivers/gpu/nova-core/falcon/fsp.rs +0 -3
@@ -152,7 +152,6 @@ pub(crate) fn read_emem(&self, bar: &Bar0, offset: u32, data: &mut [u8]) -> Resu/// /// The FSP message queue is not circular - pointers are reset to 0 after each /// message exchange, so `tail >= head` is always true when data is present. -#[expect(unused)] pub (crate )fn poll_msgq (&self, bar: &Bar0 ) ->u32 {let head = regs::NV_PFSP_MSGQ_HEAD ::read (bar).address ();let tail = regs::NV_PFSP_MSGQ_TAIL ::read (bar).address ();
@@ -175,7 +174,6 @@ pub(crate) fn poll_msgq(&self, bar: &Bar0) -> u32 {/// /// # Returns /// `Ok(())` on success, `Err(EINVAL)` if packet is empty or not 4-byte aligned -#[expect(unused)] pub (crate )fn send_msg (&self, bar: &Bar0 , packet: &[u8 ]) ->Result {if packet.is_empty () {return Err (EINVAL );
@@ -207,7 +205,6 @@ pub(crate) fn send_msg(&self, bar: &Bar0, packet: &[u8]) -> Result {/// /// # Returns /// `Ok(bytes_read)` on success, `Err(EINVAL)` if size is 0, exceeds buffer, or not aligned -#[expect(unused)] pub (crate )fn recv_msg (&self, bar: &Bar0 , buffer: &mut [u8 ], size:usize ) ->Result <usize > {if size ==0 || size > buffer.len () {return Err (EINVAL );
drivers/gpu/nova-core/fsp.rs +105 -2
135 lines not on this page · raw message
Signature · 1 line
2.53.0
PATCH v5 28/38 gpu: nova-core: Hopper/Blackwell: add FspCotVersion type
In reply to John HubbardAdd FspCotVersion to represent the FSP Chain of Trust protocol version, and Chipset::fsp_cot_version() which returns the version for each architecture. Hopper uses version 1, Blackwell uses version 2. Non-FSP architectures return None.
--- drivers/gpu/nova-core/fsp.rs | 19 +++++++++++++++++++ drivers/gpu/nova-core/gpu.rs | 14 ++++++++++++++ 2 files changed, 33 insertions(+)
drivers/gpu/nova-core/fsp.rs +19 -0
@@ -25,6 +25,25 @@ NvdmType, // }; +/// FSP Chain of Trust protocol version. +/// +/// Hopper (GH100) uses version 1, Blackwell uses version 2. +#[derive( Debug , Clone , Copy )] +pub (crate )struct FspCotVersion (u16 ); + +impl FspCotVersion { +/// Create a new FSP COT version. +pub (crate )const fn new (version:u16 ) ->Self { +Self (version) + } + +/// Return the raw protocol version number for the wire format. +#[expect(dead_code)] +pub (crate )const fn raw (self) ->u16 { + self.0 + } +} +/// FSP message timeout in milliseconds. const FSP_MSG_TIMEOUT_MS :i64 =2000 ;
drivers/gpu/nova-core/gpu.rs +14 -0
@@ -21,6 +21,7 @@ Falcon, // }, fb::SysmemFlush, + fsp::FspCotVersion, gfw, gsp::Gsp, regs,
@@ -127,6 +128,19 @@ pub(crate) const fn arch(&self) -> Architecture { | Self::GB207 => Architecture::Blackwell, } } + +/// Returns the FSP Chain of Trust (COT) protocol version for this chipset. +/// +/// Hopper (GH100) uses version 1, Blackwell uses version 2. +/// Returns `None` for architectures that do not use FSP. +#[expect(dead_code)] +pub (crate )const fn fsp_cot_version (&self) ->Option <FspCotVersion > { +match self.arch () { +Architecture ::Hopper =>Some (FspCotVersion ::new (1 )), +Architecture ::Blackwell =>Some (FspCotVersion ::new (2 )), + _ =>None , + } + } }// TODO
Signature · 1 line
2.53.0
PATCH v5 29/38 gpu: nova-core: Hopper/Blackwell: larger non-WPR heap
In reply to John HubbardAdd dedicated FB HALs for Hopper (GH100) and Blackwell (GB100) with architecture-specific non-WPR heap sizes. Hopper uses 2 MiB, Blackwell uses 2 MiB + 128 KiB. These are needed for the larger reserved memory regions that Hopper/Blackwell GPUs require.
Also adds the non_wpr_heap_size() method to the FbHal trait, and the total_reserved_size field to FbLayout.
--- drivers/gpu/nova-core/fb.rs | 16 ++++++++--- drivers/gpu/nova-core/fb/hal.rs | 16 ++++++++--- drivers/gpu/nova-core/fb/hal/ga102.rs | 2 +- drivers/gpu/nova-core/fb/hal/gb100.rs | 38 +++++++++++++++++++++++++++ drivers/gpu/nova-core/fb/hal/gh100.rs | 38 +++++++++++++++++++++++++++ 5 files changed, 102 insertions(+), 8 deletions(-) create mode 100644 drivers/gpu/nova-core/fb/hal/gb100.rs create mode 100644 drivers/gpu/nova-core/fb/hal/gh100.rs
drivers/gpu/nova-core/fb.rs +12 -4
@@ -31,7 +31,7 @@ regs, }; -mod hal; +pub (crate )mod hal;/// Type holding the sysmem flush memory page, a page of memory to be written into the /// `NV_PFB_NISO_FLUSH_SYSMEM_ADDR*` registers and used to maintain memory coherency.
@@ -99,6 +99,15 @@ pub(crate) fn unregister(&self, bar: &Bar0) { } } +/// Calculate non-WPR heap size based on chipset architecture. +/// This matches the logic used in FSP for consistency. +pub (crate )fn calc_non_wpr_heap_size (chipset:Chipset ) ->u64 { + hal::fb_hal (chipset) + .non_wpr_heap_size () + .map (u64::from) + .unwrap_or (usize_as_u64 (SZ_1M )) +} +pub (crate )struct FbRange (Range <u64 >);impl FbRange {
@@ -253,9 +262,8 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result< };let heap = { -const HEAP_SIZE :u64 =usize_as_u64 (SZ_1M ); - -FbRange (wpr2.start -HEAP_SIZE ..wpr2.start) +let heap_size =calc_non_wpr_heap_size (chipset); +FbRange (wpr2.start - heap_size..wpr2.start) };Ok (Self {
drivers/gpu/nova-core/fb/hal.rs +13 -3
@@ -12,6 +12,8 @@mod ga100;mod ga102; +mod gb100; +mod gh100;mod tu102;pub (crate )trait FbHal {
@@ -28,14 +30,22 @@ pub(crate) trait FbHal {/// Returns the VRAM size, in bytes. fn vidmem_size (&self, bar: &Bar0 ) ->u64 ; + +/// Returns the non-WPR heap size for GPUs that need large reserved memory. +/// +/// Returns `None` for GPUs that don't need extra reserved memory. +fn non_wpr_heap_size (&self) ->Option <u32 > { +None + } }/// Returns the HAL corresponding to `chipset`. -pub (super )fn fb_hal (chipset:Chipset ) -> &'staticdyn FbHal { +pub (crate )fn fb_hal (chipset:Chipset ) -> &'staticdyn FbHal {match chipset.arch () {Architecture ::Turing => tu102::TU102_HAL ,Architecture ::Ampere if chipset ==Chipset ::GA100 => ga100::GA100_HAL , -Architecture ::Ampere => ga102::GA102_HAL , -Architecture ::Ada |Architecture ::Hopper |Architecture ::Blackwell => ga102::GA102_HAL , +Architecture ::Ampere |Architecture ::Ada => ga102::GA102_HAL , +Architecture ::Hopper => gh100::GH100_HAL , +Architecture ::Blackwell => gb100::GB100_HAL , } }
drivers/gpu/nova-core/fb/hal/ga102.rs +1 -1
@@ -8,7 +8,7 @@ regs, // }; -fn vidmem_size_ga102 (bar: &Bar0 ) ->u64 { +pub (super )fn vidmem_size_ga102 (bar: &Bar0 ) ->u64 { regs::NV_USABLE_FB_SIZE_IN_MB ::read (bar).usable_fb_size () }
drivers/gpu/nova-core/fb/hal/gb100.rs new file +38 -0
@@ -0,0 +1,38 @@ +// SPDX-License-Identifier: GPL-2.0 + +use kernel::prelude::*; + +use crate ::{ + driver::Bar0 , + fb::hal::FbHal ,// +}; + +struct Gb100 ; + +impl FbHal for Gb100 { +fn read_sysmem_flush_page (&self, bar: &Bar0 ) ->u64 { +super ::ga100::read_sysmem_flush_page_ga100 (bar) + } + +fn write_sysmem_flush_page (&self, bar: &Bar0 , addr:u64 ) ->Result { +super ::ga100::write_sysmem_flush_page_ga100 (bar, addr); + +Ok (()) + } + +fn supports_display (&self, bar: &Bar0 ) ->bool { +super ::ga100::display_enabled_ga100 (bar) + } + +fn vidmem_size (&self, bar: &Bar0 ) ->u64 { +super ::ga102::vidmem_size_ga102 (bar) + } + +fn non_wpr_heap_size (&self) ->Option <u32 > { +// 2 MiB + 128 KiB non-WPR heap for Blackwell (see Open RM: kgspCalculateFbLayout_GB100). +Some (0x220000 ) + } +} + +const GB100 :Gb100 =Gb100 ; +pub (super )const GB100_HAL : &dyn FbHal = &GB100 ;
drivers/gpu/nova-core/fb/hal/gh100.rs new file +38 -0
@@ -0,0 +1,38 @@ +// SPDX-License-Identifier: GPL-2.0 + +use kernel::prelude::*; + +use crate ::{ + driver::Bar0 , + fb::hal::FbHal ,// +}; + +struct Gh100 ; + +impl FbHal for Gh100 { +fn read_sysmem_flush_page (&self, bar: &Bar0 ) ->u64 { +super ::ga100::read_sysmem_flush_page_ga100 (bar) + } + +fn write_sysmem_flush_page (&self, bar: &Bar0 , addr:u64 ) ->Result { +super ::ga100::write_sysmem_flush_page_ga100 (bar, addr); + +Ok (()) + } + +fn supports_display (&self, bar: &Bar0 ) ->bool { +super ::ga100::display_enabled_ga100 (bar) + } + +fn vidmem_size (&self, bar: &Bar0 ) ->u64 { +super ::ga102::vidmem_size_ga102 (bar) + } + +fn non_wpr_heap_size (&self) ->Option <u32 > { +// 2 MiB non-WPR heap for Hopper (see Open RM: kgspCalculateFbLayout_GH100). +Some (0x200000 ) + } +} + +const GH100 :Gh100 =Gh100 ; +pub (super )const GH100_HAL : &dyn FbHal = &GH100 ;
Signature · 1 line
2.53.0
PATCH v5 30/38 gpu: nova-core: Hopper/Blackwell: add FSP Chain of Trust boot
In reply to John HubbardAdd boot_fmc() which builds and sends the Chain of Trust message to FSP, and FmcBootArgs which bundles the DMA-coherent boot parameters that FSP reads at boot time. The FspFirmware struct fields become pub(crate) and fmc_full changes from DmaObject to KVec<u8> for CPU-side signature extraction.
--- drivers/gpu/nova-core/firmware/fsp.rs | 14 ++- drivers/gpu/nova-core/fsp.rs | 134 +++++++++++++++++++++++++- drivers/gpu/nova-core/gpu.rs | 1 - drivers/gpu/nova-core/mctp.rs | 2 - 4 files changed, 141 insertions(+), 10 deletions(-)
drivers/gpu/nova-core/firmware/fsp.rs +9 -5
@@ -13,16 +13,16 @@ gpu::Chipset, // }; -#[expect(unused)] +#[expect(dead_code)] pub (crate )struct FspFirmware {/// FMC firmware image data (only the "image" ELF section). - fmc_image:DmaObject , +pub (crate ) fmc_image:DmaObject ,/// Full FMC ELF data (for signature extraction). - fmc_full:DmaObject , +pub (crate ) fmc_full:KVec <u8 >, }impl FspFirmware { -#[expect(unused)] +#[expect(dead_code)] pub (crate )fn new ( dev: &device::Device <device::Bound >, chipset: Chipset,
@@ -36,9 +36,13 @@ pub(crate) fn new(EINVAL })?; +// Copy the full ELF into a kernel vector for CPU-side signature extraction +let mut fmc_full =KVec ::with_capacity (fw.data ().len (),GFP_KERNEL )?; + fmc_full.extend_from_slice (fw.data (),GFP_KERNEL )?; +Ok (Self { fmc_image:DmaObject ::from_data (dev, fmc_image_data)?, - fmc_full:DmaObject ::from_data (dev, fw.data ())?, + fmc_full, }) } }
drivers/gpu/nova-core/fsp.rs +132 -2
161 lines not on this page · raw message
drivers/gpu/nova-core/gpu.rs +0 -1
@@ -133,7 +133,6 @@ pub(crate) const fn arch(&self) -> Architecture {/// /// Hopper (GH100) uses version 1, Blackwell uses version 2. /// Returns `None` for architectures that do not use FSP. -#[expect(dead_code)] pub (crate )const fn fsp_cot_version (&self) ->Option <FspCotVersion > {match self.arch () {Architecture ::Hopper =>Some (FspCotVersion ::new (1 )),
drivers/gpu/nova-core/mctp.rs +0 -2
@@ -6,8 +6,6 @@//! Device Management) messages between the kernel driver and GPU firmware //! processors such as FSP and GSP. -#![expect(dead_code)] -/// NVDM message type identifiers carried over MCTP. #[derive( Debug , Clone , Copy , PartialEq , Eq )] #[repr( u32 )]
Signature · 1 line
2.53.0
PATCH v5 31/38 gpu: nova-core: Blackwell: use correct sysmem flush registers
In reply to John HubbardBlackwell GPUs moved the sysmem flush page registers away from the legacy NV_PFB_NISO_FLUSH_SYSMEM_ADDR used by Ampere/Ada.
GB10x uses HSHUB0 registers, with both a primary and EG (egress) pair that must be programmed to the same address. GB20x uses FBHUB0 registers.
Add separate GB100 and GB202 fb HALs, and split the Blackwell HAL dispatch so that each uses its respective registers.
--- drivers/gpu/nova-core/fb/hal.rs | 10 ++++- drivers/gpu/nova-core/fb/hal/gb100.rs | 47 +++++++++++++++++--- drivers/gpu/nova-core/fb/hal/gb202.rs | 62 +++++++++++++++++++++++++++ drivers/gpu/nova-core/regs.rs | 36 ++++++++++++++++ 4 files changed, 149 insertions(+), 6 deletions(-) create mode 100644 drivers/gpu/nova-core/fb/hal/gb202.rs
drivers/gpu/nova-core/fb/hal.rs +9 -1
@@ -13,9 +13,14 @@mod ga100;mod ga102;mod gb100; +mod gb202;mod gh100;mod tu102; +/// Non-WPR heap size for Blackwell (2 MiB + 128 KiB). +/// See Open RM: kgspCalculateFbLayout_GB100. +const BLACKWELL_NON_WPR_HEAP_SIZE :u32 =0x220000 ; +pub (crate )trait FbHal {/// Returns the address of the currently-registered sysmem flush page. fn read_sysmem_flush_page (&self, bar: &Bar0 ) ->u64 ;
@@ -46,6 +51,9 @@ pub(crate) fn fb_hal(chipset: Chipset) -> &'static dyn FbHal { Architecture::Ampere if chipset == Chipset::GA100 => ga100::GA100_HAL, Architecture::Ampere | Architecture::Ada => ga102::GA102_HAL, Architecture::Hopper => gh100::GH100_HAL, - Architecture::Blackwell => gb100::GB100_HAL, + Architecture::Blackwell => match chipset { + Chipset::GB100 | Chipset::GB102 => gb100::GB100_HAL, + _ => gb202::GB202_HAL, + }, } }
drivers/gpu/nova-core/fb/hal/gb100.rs +42 -5
71 lines not on this page · raw message
drivers/gpu/nova-core/fb/hal/gb202.rs new file +62 -0
62 lines not on this page · raw message
drivers/gpu/nova-core/regs.rs +36 -0
@@ -116,6 +116,42 @@ fn fmt(&self, f: &mut kernel::fmt::Formatter<'_>) -> kernel::fmt::Result { 23:0 adr_63_40 as u32; }); +// Blackwell GB10x sysmem flush registers (HSHUB0). +// +// GB10x GPUs use two pairs of HSHUB registers for sysmembar: a primary pair and an EG +// (egress) pair. Both must be programmed to the same address. Hardware ignores bits 7:0 +// of each LO register. HSHUB0 base is 0x00891000. + +register! (NV_PFB_HSHUB0_PCIE_FLUSH_SYSMEM_ADDR_LO @0x00891e50 { +31 :0 adras u32 ; +}); + +register! (NV_PFB_HSHUB0_PCIE_FLUSH_SYSMEM_ADDR_HI @0x00891e54 { +19 :0 adras u32 ; +}); + +register! (NV_PFB_HSHUB0_EG_PCIE_FLUSH_SYSMEM_ADDR_LO @0x008916c0 { +31 :0 adras u32 ; +}); + +register! (NV_PFB_HSHUB0_EG_PCIE_FLUSH_SYSMEM_ADDR_HI @0x008916c4 { +19 :0 adras u32 ; +}); + +// Blackwell GB20x sysmem flush registers (FBHUB0). +// +// Unlike the older NV_PFB_NISO_FLUSH_SYSMEM_ADDR registers which encode the address with an +// 8-bit right-shift, these registers take the raw address split into lower/upper 32-bit halves. +// The hardware ignores bits 7:0 of the LO register. + +register! (NV_PFB_FBHUB0_PCIE_FLUSH_SYSMEM_ADDR_LO @0x008a1d58 { +31 :0 adras u32 ; +}); + +register! (NV_PFB_FBHUB0_PCIE_FLUSH_SYSMEM_ADDR_HI @0x008a1d5c { +19 :0 adras u32 ; +}); +register! (NV_PFB_PRI_MMU_LOCAL_MEMORY_RANGE @0x00100ce0 {3 :0 lower_scaleas u8 ;9 :4 lower_magas u8 ;
Signature · 1 line
2.53.0
PATCH v5 32/38 gpu: nova-core: Hopper/Blackwell: larger WPR2 (GSP) heap
In reply to John HubbardHopper, Blackwell and later GPUs require a larger heap for WPR2.
--- drivers/gpu/nova-core/fb.rs | 2 +- drivers/gpu/nova-core/gsp/fw.rs | 74 ++++++++++++++++++++++++--------- 2 files changed, 55 insertions(+), 21 deletions(-)
drivers/gpu/nova-core/fb.rs +1 -1
@@ -247,7 +247,7 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result<let wpr2_heap = {const WPR2_HEAP_DOWN_ALIGN :Alignment =Alignment ::new ::<SZ_1M >();let wpr2_heap_size = - gsp::LibosParams ::from_chipset (chipset).wpr_heap_size (chipset, fb.end); + gsp::LibosParams ::from_chipset (chipset).wpr_heap_size (chipset, fb.end)?;let wpr2_heap_addr = (elf.start - wpr2_heap_size).align_down (WPR2_HEAP_DOWN_ALIGN );FbRange (wpr2_heap_addr..(elf.start).align_down (WPR2_HEAP_DOWN_ALIGN ))
drivers/gpu/nova-core/gsp/fw.rs +54 -20
115 lines not on this page · raw message
Signature · 1 line
2.53.0
PATCH v5 33/38 gpu: nova-core: refactor SEC2 booter loading into BooterFirmware::run()
In reply to John HubbardMove the SEC2 reset/load/boot sequence into a BooterFirmware::run() method, and call it from a thin run_booter() helper on Gsp. This is almost a pure refactoring with no behavior change, done in preparation for adding an alternative FSP boot path. The one slight difference is that an MBOX1 printing typo is fixed:
Previous output:
NovaCore 0000:e1:00.0: SEC2 MBOX0: 0x0, MBOX10x1
Fixed output:
NovaCore 0000:e1:00.0: SEC2 MBOX0: 0x0, MBOX1: 0x1
--- drivers/gpu/nova-core/firmware/booter.rs | 35 +++++++++++++++- drivers/gpu/nova-core/gsp/boot.rs | 52 +++++++++--------------- 2 files changed, 54 insertions(+), 33 deletions(-)
drivers/gpu/nova-core/firmware/booter.rs +34 -1
@@ -11,8 +11,12 @@use kernel::{ device, + dma::CoherentAllocation , prelude::*, - transmute::FromBytes ,// + transmute::{ +AsBytes , +FromBytes ,// + }, };use crate ::{
@@ -389,6 +393,35 @@ pub(crate) fn new( ucode: ucode_signed, }) } + +/// Load and run the booter firmware on SEC2. +/// +/// Resets SEC2, loads this firmware image, then boots with the WPR metadata +/// address passed via the SEC2 mailboxes. +pub (crate )fn run <T :AsBytes +FromBytes >( + &self, + dev: &device::Device <device::Bound >, + bar: &Bar0 , + sec2_falcon: &Falcon <Sec2 >, + wpr_meta: &CoherentAllocation <T >, + ) ->Result { + sec2_falcon.reset (bar)?; + sec2_falcon.load (bar, self)?; +let wpr_handle = wpr_meta.dma_handle (); +let (mbox0, mbox1) = sec2_falcon.boot ( + bar, +Some (wpr_handleas u32 ), +Some ((wpr_handle >>32 )as u32 ), + )?; +dev_dbg! (dev,"SEC2 MBOX0: {:#x}, MBOX1: {:#x}\n" , mbox0, mbox1); + +if mbox0 !=0 { +dev_err! (dev,"Booter-load failed with error {:#x}\n" , mbox0); +return Err (ENODEV ); + } + +Ok (()) + } }impl FalconLoadParams for BooterFirmware {
drivers/gpu/nova-core/gsp/boot.rs +20 -32
70 lines not on this page · raw message
Signature · 1 line
2.53.0
PATCH v5 34/38 gpu: nova-core: Hopper/Blackwell: add GSP lockdown release polling
In reply to John HubbardOn Hopper and Blackwell, FSP boots GSP with hardware lockdown enabled. After FSP Chain of Trust completes, the driver must poll for lockdown release before proceeding with GSP initialization. Add the register bit and helper functions needed for this polling.
--- drivers/gpu/nova-core/gsp/boot.rs | 80 ++++++++++++++++++++++++++++++- drivers/gpu/nova-core/regs.rs | 1 + 2 files changed, 80 insertions(+), 1 deletion(-)
drivers/gpu/nova-core/gsp/boot.rs +79 -1
@@ -15,7 +15,8 @@ falcon::{ gsp::Gsp, sec2::Sec2, - Falcon, // + Falcon, + FalconEngine, // }, fb::FbLayout, firmware::{
@@ -43,6 +44,54 @@ vbios::Vbios, }; +/// GSP lockdown pattern written by firmware to mbox0 while RISC-V branch privilege +/// lockdown is active. The low byte varies, the upper 24 bits are fixed. +const GSP_LOCKDOWN_PATTERN :u32 =0xbadf4100 ; +const GSP_LOCKDOWN_MASK :u32 =0xffffff00 ; + +/// GSP falcon mailbox state, used to track lockdown release status. +struct GspMbox { + mbox0:u32 , + mbox1:u32 , +} + +impl GspMbox { +/// Read both mailboxes from the GSP falcon. +fn read (gsp_falcon: &Falcon <Gsp >, bar: &Bar0 ) ->Self { +Self { + mbox0: gsp_falcon.read_mailbox0 (bar), + mbox1: gsp_falcon.read_mailbox1 (bar), + } + } + +/// Returns true if the lockdown pattern is present in mbox0. +fn is_locked_down (&self) ->bool { + self.mbox0 !=0 && (self.mbox0 &GSP_LOCKDOWN_MASK ) ==GSP_LOCKDOWN_PATTERN + } + +/// Combines mailbox0 and mailbox1 into a 64-bit address. +fn combined_addr (&self) ->u64 { + (u64::from (self.mbox1) <<32 ) | u64::from (self.mbox0) + } + +/// Returns true if GSP lockdown has been released. +/// +/// Checks the lockdown pattern, validates the boot params address, +/// and verifies the HWCFG2 lockdown bit is clear. +fn lockdown_released (&self, bar: &Bar0 , fmc_boot_params_addr:u64 ) ->bool { +if self.is_locked_down () { +return false ; + } + +if self.mbox0 !=0 && self.combined_addr () != fmc_boot_params_addr { +return true ; + } + +let hwcfg2 = regs::NV_PFALCON_FALCON_HWCFG2 ::read (bar, &crate ::falcon::gsp::Gsp ::ID ); + !hwcfg2.riscv_br_priv_lockdown () + } +} +impl super ::Gsp {/// Helper function to load and run the FWSEC-FRTS firmware and confirm that it has properly /// created the WPR2 region.
@@ -139,6 +188,35 @@ fn run_booter( booter.run (dev, bar, sec2_falcon, wpr_meta) } +/// Wait for GSP lockdown to be released after FSP Chain of Trust. +#[expect(dead_code)] +fn wait_for_gsp_lockdown_release ( + dev: &device::Device <device::Bound >, + bar: &Bar0 , + gsp_falcon: &Falcon <Gsp >, + fmc_boot_params_addr:u64 , + ) ->Result { +dev_dbg! (dev,"Waiting for GSP lockdown release\n" ); + +let mbox =read_poll_timeout ( + ||Ok (GspMbox ::read (gsp_falcon, bar)), + |mbox| mbox.lockdown_released (bar, fmc_boot_params_addr), +Delta ::from_millis (10 ), +Delta ::from_millis (4000 ), + ) + .inspect_err (|_| { +dev_err! (dev,"GSP lockdown release timeout\n" ); + })?; + +if mbox.mbox0 !=0 { +dev_err! (dev,"GSP-FMC boot failed (mbox: {:#x})\n" , mbox.mbox0); +return Err (EIO ); + } + +dev_dbg! (dev,"GSP lockdown released\n" ); +Ok (()) + } +/// Attempt to boot the GSP. /// /// This is a GPU-dependent and complex procedure that involves loading firmware files from
drivers/gpu/nova-core/regs.rs +1 -0
@@ -321,6 +321,7 @@ pub(crate) fn vga_workspace_addr(self) -> Option<u64> {register! (NV_PFALCON_FALCON_HWCFG2 @PFalconBase [0x000000f4 ] {10 :10 riscvas bool ;12 :12 mem_scrubbingas bool ,"Set to 0 after memory scrubbing is completed" ; +13 :13 riscv_br_priv_lockdownas bool ,"RISC-V branch privilege lockdown bit" ;31 :31 reset_readyas bool ,"Signal indicating that reset is completed (GA102+)" ; });
Signature · 1 line
2.53.0
PATCH v5 35/38 gpu: nova-core: Hopper/Blackwell: new location for PCI config mirror
In reply to John HubbardHopper and Blackwell GPUs use a different PCI config space mirror address (0x088000) compared to older architectures (0x088480). Update SetSystemInfo to accept a chipset parameter and select the correct address based on architecture.
--- drivers/gpu/nova-core/gsp/boot.rs | 2 +- drivers/gpu/nova-core/gsp/commands.rs | 8 +++++--- drivers/gpu/nova-core/gsp/fw/commands.rs | 18 +++++++++++++++--- 3 files changed, 21 insertions(+), 7 deletions(-)
drivers/gpu/nova-core/gsp/boot.rs +1 -1
@@ -248,7 +248,7 @@ pub(crate) fn boot(dma_write! (wpr_meta[0 ] =GspFwWprMeta ::new (&gsp_fw, &fb_layout))?; self.cmdq - .send_command (bar, commands::SetSystemInfo ::new (pdev))?; + .send_command (bar, commands::SetSystemInfo ::new (pdev, chipset))?; self.cmdq.send_command (bar, commands::SetRegistry ::new ())?; gsp_falcon.reset (bar)?;
drivers/gpu/nova-core/gsp/commands.rs +5 -3
@@ -20,6 +20,7 @@use crate ::{ driver::Bar0 , + gpu::Chipset , gsp::{ cmdq::{Cmdq ,
@@ -37,12 +38,13 @@/// The `GspSetSystemInfo` command. pub (crate )struct SetSystemInfo <'a> { pdev: &'a pci::Device <device::Bound >, + chipset:Chipset , }impl <'a>SetSystemInfo <'a> {/// Creates a new `GspSetSystemInfo` command using the parameters of `pdev`. -pub (crate )fn new (pdev: &'a pci::Device <device::Bound >) ->Self { -Self { pdev } +pub (crate )fn new (pdev: &'a pci::Device <device::Bound >, chipset:Chipset ) ->Self { +Self { pdev, chipset } } }
@@ -52,7 +54,7 @@ impl<'a> CommandToGsp for SetSystemInfo<'a> {type InitError =Error ;fn init (&self) ->impl Init <Self ::Command ,Self ::InitError > { -GspSetSystemInfo ::init (self.pdev) +GspSetSystemInfo ::init (self.pdev, self.chipset) } }
drivers/gpu/nova-core/gsp/fw/commands.rs +15 -3
@@ -10,7 +10,13 @@ }, // }; -use crate ::gsp::GSP_PAGE_SIZE ; +use crate ::{ + gpu::{ +Architecture , +Chipset ,// + }, + gsp::GSP_PAGE_SIZE ,// +};use super ::bindings;
@@ -24,7 +30,10 @@ pub(crate) struct GspSetSystemInfo { impl GspSetSystemInfo { /// Returns an in-place initializer for the `GspSetSystemInfo` command. #[allow(non_snake_case)] - pub(crate) fn init<'a>(dev: &'a pci::Device<device::Bound>) -> impl Init<Self, Error> + 'a { + pub(crate) fn init<'a>( + dev: &'a pci::Device<device::Bound>, + chipset: Chipset, + ) -> impl Init<Self, Error> + 'a { type InnerGspSystemInfo = bindings::GspSystemInfo; let init_inner = try_init!(InnerGspSystemInfo { gpuPhysAddr: dev.resource_start(0)?,
@@ -35,7 +44,10 @@ pub(crate) fn init<'a>(dev: &'a pci::Device<device::Bound>) -> impl Init<Self, E// Using TASK_SIZE in r535_gsp_rpc_set_system_info() seems wrong because // TASK_SIZE is per-task. That's probably a design issue in GSP-RM though. maxUserVa: (1 << 47) - 4096, - pciConfigMirrorBase: 0x088000, + pciConfigMirrorBase: match chipset.arch() { +Architecture ::Turing |Architecture ::Ampere |Architecture ::Ada =>0x088000 , +Architecture ::Hopper |Architecture ::Blackwell =>0x092000 , + }, pciConfigMirrorSize: 0x001000, PCIDeviceID: (u32::from(dev.device_id()) << 16) | u32::from(dev.vendor_id().as_raw()),
Signature · 1 line
2.53.0
PATCH v5 36/38 gpu: nova-core: Hopper/Blackwell: integrate FSP boot path into boot()
In reply to John HubbardAdd the FSP boot path for Hopper and Blackwell GPUs. These architectures use FSP with FMC firmware for Chain of Trust boot, rather than SEC2.
boot() now dispatches to boot_via_sec2() or boot_via_fsp() based on architecture. The SEC2 path keeps its original command ordering. The FSP path sends SetSystemInfo/SetRegistry after GSP becomes active. The GSP sequencer only runs for SEC2-based architectures.
--- drivers/gpu/nova-core/firmware/fsp.rs | 2 - drivers/gpu/nova-core/fsp.rs | 5 - drivers/gpu/nova-core/gsp/boot.rs | 190 +++++++++++++++++++------- 3 files changed, 144 insertions(+), 53 deletions(-)
drivers/gpu/nova-core/firmware/fsp.rs +0 -2
@@ -13,7 +13,6 @@ gpu::Chipset, // }; -#[expect(dead_code)] pub (crate )struct FspFirmware {/// FMC firmware image data (only the "image" ELF section). pub (crate ) fmc_image:DmaObject ,
@@ -22,7 +21,6 @@ pub(crate) struct FspFirmware { }impl FspFirmware { -#[expect(dead_code)] pub (crate )fn new ( dev: &device::Device <device::Bound >, chipset: Chipset,
drivers/gpu/nova-core/fsp.rs +0 -5
@@ -238,7 +238,6 @@ pub(crate) struct FmcBootArgs<'a> {impl <'a>FmcBootArgs <'a> {/// Build FMC boot arguments, allocating the DMA-coherent boot parameter /// structure that FSP will read. -#[expect(dead_code)] #[allow(clippy::too_many_arguments)] pub (crate )fn new ( dev: &device::Device<device::Bound>,
@@ -287,7 +286,6 @@ pub(crate) fn new(/// DMA address of the FMC boot parameters, needed after boot for lockdown /// release polling. -#[expect(dead_code)] pub (crate )fn boot_params_dma_handle (&self) ->u64 { self.fmc_boot_params.dma_handle () }
@@ -301,7 +299,6 @@ impl Fsp {/// /// Polls the thermal scratch register until FSP signals boot completion /// or timeout occurs. -#[expect(dead_code)] pub (crate )fn wait_secure_boot ( dev: &device::Device <device::Bound >, bar: &crate::driver::Bar0,
@@ -331,7 +328,6 @@ pub(crate) fn wait_secure_boot(/// /// Extracts real cryptographic signatures from FMC ELF32 firmware sections. /// Returns signatures in a heap-allocated structure to prevent stack overflow. -#[expect(dead_code)] pub (crate )fn extract_fmc_signatures ( dev: &device::Device <device::Bound >, fmc_fw_data: &[u8],
@@ -391,7 +387,6 @@ pub(crate) fn extract_fmc_signatures(/// /// Builds the COT message from the pre-configured [`FmcBootArgs`], sends it /// to FSP, and waits for the response. -#[expect(dead_code)] pub (crate )fn boot_fmc ( dev: &device::Device <device::Bound >, bar: &crate::driver::Bar0,
drivers/gpu/nova-core/gsp/boot.rs +144 -46
248 lines not on this page · raw message
Signature · 1 line
2.53.0
PATCH v5 37/38 rust: sizes: add u64 variants of SZ_* constants
In reply to John HubbardDrivers that operate on 64-bit address spaces (GPU framebuffer layouts, DMA regions, etc.) frequently need these size constants as a u64 type. Today this requires repeated usize-to-u64 conversion calls like usize_as_u64(SZ_1M) or u64::from_safe_cast(SZ_1M), which adds boilerplate without any safety benefit.
Add u64-typed constants (SZ_1K_U64 through SZ_2G_U64) alongside the existing usize constants. Every value fits in u64 (actually, within a u32 for that matter), so the as-cast is always lossless.
--- rust/kernel/sizes.rs | 51 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+)
rust/kernel/sizes.rs +51 -0
@@ -48,3 +48,54 @@pub const SZ_1G :usize = bindings::SZ_1G as usize ;/// 0x80000000 pub const SZ_2G :usize = bindings::SZ_2G as usize ; + +// `u64` variants of the size constants. These are the same values as the +// `usize` constants above, but typed as `u64` to avoid repeated conversion +// boilerplate in code that operates on 64-bit address spaces. +// +// CAST: every SZ_* value below fits in u64, so `as u64` is always lossless. + +/// [`SZ_1K`] as a [`u64`]. +pub const SZ_1K_U64 :u64 =SZ_1K as u64 ; +/// [`SZ_2K`] as a [`u64`]. +pub const SZ_2K_U64 :u64 =SZ_2K as u64 ; +/// [`SZ_4K`] as a [`u64`]. +pub const SZ_4K_U64 :u64 =SZ_4K as u64 ; +/// [`SZ_8K`] as a [`u64`]. +pub const SZ_8K_U64 :u64 =SZ_8K as u64 ; +/// [`SZ_16K`] as a [`u64`]. +pub const SZ_16K_U64 :u64 =SZ_16K as u64 ; +/// [`SZ_32K`] as a [`u64`]. +pub const SZ_32K_U64 :u64 =SZ_32K as u64 ; +/// [`SZ_64K`] as a [`u64`]. +pub const SZ_64K_U64 :u64 =SZ_64K as u64 ; +/// [`SZ_128K`] as a [`u64`]. +pub const SZ_128K_U64 :u64 =SZ_128K as u64 ; +/// [`SZ_256K`] as a [`u64`]. +pub const SZ_256K_U64 :u64 =SZ_256K as u64 ; +/// [`SZ_512K`] as a [`u64`]. +pub const SZ_512K_U64 :u64 =SZ_512K as u64 ; +/// [`SZ_1M`] as a [`u64`]. +pub const SZ_1M_U64 :u64 =SZ_1M as u64 ; +/// [`SZ_2M`] as a [`u64`]. +pub const SZ_2M_U64 :u64 =SZ_2M as u64 ; +/// [`SZ_4M`] as a [`u64`]. +pub const SZ_4M_U64 :u64 =SZ_4M as u64 ; +/// [`SZ_8M`] as a [`u64`]. +pub const SZ_8M_U64 :u64 =SZ_8M as u64 ; +/// [`SZ_16M`] as a [`u64`]. +pub const SZ_16M_U64 :u64 =SZ_16M as u64 ; +/// [`SZ_32M`] as a [`u64`]. +pub const SZ_32M_U64 :u64 =SZ_32M as u64 ; +/// [`SZ_64M`] as a [`u64`]. +pub const SZ_64M_U64 :u64 =SZ_64M as u64 ; +/// [`SZ_128M`] as a [`u64`]. +pub const SZ_128M_U64 :u64 =SZ_128M as u64 ; +/// [`SZ_256M`] as a [`u64`]. +pub const SZ_256M_U64 :u64 =SZ_256M as u64 ; +/// [`SZ_512M`] as a [`u64`]. +pub const SZ_512M_U64 :u64 =SZ_512M as u64 ; +/// [`SZ_1G`] as a [`u64`]. +pub const SZ_1G_U64 :u64 =SZ_1G as u64 ; +/// [`SZ_2G`] as a [`u64`]. +pub const SZ_2G_U64 :u64 =SZ_2G as u64 ;
Signature · 1 line
2.53.0
PATCH v5 38/38 gpu: nova-core: use SZ_*_U64 constants from kernel::sizes
In reply to John HubbardReplace manual usize_as_u64(SZ_*) and u64::from_safe_cast(SZ_*) conversions with the new SZ_*_U64 constants throughout fb.rs, gsp/fw.rs, and regs.rs. This removes the conversion boilerplate and the now-unused usize_as_u64 import in fb.rs.
--- drivers/gpu/nova-core/fb.rs | 19 ++++++++----------- drivers/gpu/nova-core/gsp/fw.rs | 23 ++++++++++------------- drivers/gpu/nova-core/regs.rs | 6 +++--- 3 files changed, 21 insertions(+), 27 deletions(-)
drivers/gpu/nova-core/fb.rs +8 -11
@@ -24,10 +24,7 @@ firmware::gsp::GspFirmware, gpu::Chipset, gsp, - num::{ - usize_as_u64, - FromSafeCast, // - }, + num::FromSafeCast, regs, };
@@ -105,7 +102,7 @@ pub(crate) fn calc_non_wpr_heap_size(chipset: Chipset) -> u64 { hal::fb_hal (chipset) .non_wpr_heap_size () .map (u64::from) - .unwrap_or (usize_as_u64 (SZ_1M )) + .unwrap_or (SZ_1M_U64 ) }pub (crate )struct FbRange (Range <u64 >);
@@ -136,8 +133,8 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if f.alternate() { let size = self.len(); - if size < usize_as_u64(SZ_1M) { - let size_kib = size / usize_as_u64(SZ_1K); + if size < SZ_1M_U64 { + let size_kib = size / SZ_1K_U64; f.write_fmt(fmt!( "{:#x}..{:#x} ({} KiB)", self.0.start,
@@ -145,7 +142,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { size_kib )) } else { - let size_mib = size / usize_as_u64(SZ_1M); + let size_mib = size / SZ_1M_U64; f.write_fmt(fmt!( "{:#x}..{:#x} ({} MiB)", self.0.start,
@@ -195,14 +192,14 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result<let vga_workspace = {let vga_base = { -const NV_PRAMIN_SIZE :u64 =usize_as_u64 (SZ_1M ); +const NV_PRAMIN_SIZE :u64 =SZ_1M_U64 ;let base = fb.end -NV_PRAMIN_SIZE ;if hal.supports_display (bar) {match regs::NV_PDISP_VGA_WORKSPACE_BASE ::read (bar).vga_workspace_addr () {Some (addr) => {if addr < base { -const VBIOS_WORKSPACE_SIZE :u64 =usize_as_u64 (SZ_128K ); +const VBIOS_WORKSPACE_SIZE :u64 =SZ_128K_U64 ;// Point workspace address to end of framebuffer. fb.end -VBIOS_WORKSPACE_SIZE
@@ -222,7 +219,7 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result<let frts = {const FRTS_DOWN_ALIGN :Alignment =Alignment ::new ::<SZ_128K >(); -const FRTS_SIZE :u64 =usize_as_u64 (SZ_1M ); +const FRTS_SIZE :u64 =SZ_1M_U64 ;let frts_base = vga_workspace.start.align_down (FRTS_DOWN_ALIGN ) -FRTS_SIZE ;FbRange (frts_base..frts_base +FRTS_SIZE )
drivers/gpu/nova-core/gsp/fw.rs +10 -13
@@ -16,10 +16,7 @@ Alignable, Alignment, // }, - sizes::{ - SZ_128K, - SZ_1M, // - }, + sizes::*, transmute::{AsBytes ,FromBytes ,//
@@ -53,9 +50,9 @@ enum GspFwHeapParams {}// See Open RM: kgspCalculateGspFwHeapSize and related functions. // // 14MB for Hopper/Blackwell+. -const GSP_FW_HEAP_PARAM_BASE_RM_SIZE_GH100 :u64 =14 * num::usize_as_u64 (SZ_1M ); +const GSP_FW_HEAP_PARAM_BASE_RM_SIZE_GH100 :u64 =14 *SZ_1M_U64 ;// 142MB client alloc for ~188MB total. -const GSP_FW_HEAP_PARAM_CLIENT_ALLOC_SIZE_GH100 :u64 =142 * num::usize_as_u64 (SZ_1M ); +const GSP_FW_HEAP_PARAM_CLIENT_ALLOC_SIZE_GH100 :u64 =142 *SZ_1M_U64 ;// Hopper/Blackwell+ minimum heap size: 170MB (88 + 12 + 70). // See Open RM: GSP_FW_HEAP_SIZE_OVERRIDE_LIBOS3_BAREMETAL_MIN_MB for the base 88MB, // plus Hopper+ additions in kgspCalculateGspFwHeapSize_GH100.
@@ -89,7 +86,7 @@ fn client_alloc_size(chipset: Chipset) -> Result<u64> {/// Returns the amount of memory to reserve for management purposes for a framebuffer of size /// `fb_size`. fn management_overhead (fb_size:u64 ) ->Result <u64 > { -let fb_size_gb = fb_size.div_ceil (u64::from_safe_cast (kernel::sizes::SZ_1G )); +let fb_size_gb = fb_size.div_ceil (SZ_1G_U64 ); u64::from (bindings::GSP_FW_HEAP_PARAM_SIZE_PER_GB_FB ) .saturating_mul (fb_size_gb)
@@ -111,9 +108,9 @@ impl LibosParams {const LIBOS2 :LibosParams =LibosParams { carveout_size: num::u32_as_u64 (bindings::GSP_FW_HEAP_PARAM_OS_SIZE_LIBOS2 ), allowed_heap_size: num::u32_as_u64 (bindings::GSP_FW_HEAP_SIZE_OVERRIDE_LIBOS2_MIN_MB ) - * num::usize_as_u64 (SZ_1M ) + *SZ_1M_U64 ..num::u32_as_u64 (bindings::GSP_FW_HEAP_SIZE_OVERRIDE_LIBOS2_MAX_MB ) - * num::usize_as_u64 (SZ_1M ), + *SZ_1M_U64 , };/// Version 3 of the GSP LIBOS (GA102+)
@@ -121,9 +118,9 @@ impl LibosParams { carveout_size: num::u32_as_u64(bindings::GSP_FW_HEAP_PARAM_OS_SIZE_LIBOS3_BAREMETAL), allowed_heap_size: num::u32_as_u64( bindings::GSP_FW_HEAP_SIZE_OVERRIDE_LIBOS3_BAREMETAL_MIN_MB , - ) * num::usize_as_u64 (SZ_1M ) + ) *SZ_1M_U64 ..num::u32_as_u64 (bindings::GSP_FW_HEAP_SIZE_OVERRIDE_LIBOS3_BAREMETAL_MAX_MB ) - * num::usize_as_u64(SZ_1M), + * SZ_1M_U64, };/// Hopper/Blackwell+ GPUs need a larger minimum heap size than the bindings specify.
@@ -132,9 +129,9 @@ impl LibosParams {const LIBOS_HOPPER :LibosParams =LibosParams { carveout_size: num::u32_as_u64 (bindings::GSP_FW_HEAP_PARAM_OS_SIZE_LIBOS3_BAREMETAL ), allowed_heap_size:GSP_FW_HEAP_SIZE_OVERRIDE_LIBOS3_BAREMETAL_MIN_MB_HOPPER - * num::usize_as_u64 (SZ_1M ) + *SZ_1M_U64 ..num::u32_as_u64 (bindings::GSP_FW_HEAP_SIZE_OVERRIDE_LIBOS3_BAREMETAL_MAX_MB ) - * num::usize_as_u64 (SZ_1M ), + *SZ_1M_U64 , };/// Returns the libos parameters corresponding to `chipset`.
drivers/gpu/nova-core/regs.rs +3 -3
@@ -10,6 +10,7 @@use kernel::{ io::Io , prelude::*, + sizes::*, time,// };
@@ -33,7 +34,6 @@ Architecture, Chipset, // }, - num::FromSafeCast, };// PMC
@@ -166,7 +166,7 @@ impl NV_PFB_PRI_MMU_LOCAL_MEMORY_RANGE {/// Returns the usable framebuffer size, in bytes. pub (crate )fn usable_fb_size (self) ->u64 {let size = (u64::from (self.lower_mag ()) << u64::from (self.lower_scale ())) - * u64::from_safe_cast (kernel::sizes::SZ_1M ); + *SZ_1M_U64 ;if self.ecc_mode_enabled () {// Remove the amount of memory reserved for ECC (one per 16 units).
@@ -255,7 +255,7 @@ pub(crate) fn completed(self) -> bool {impl NV_USABLE_FB_SIZE_IN_MB {/// Returns the usable framebuffer size, in bytes. pub (crate )fn usable_fb_size (self) ->u64 { - u64::from (self.value ()) * u64::from_safe_cast (kernel::sizes::SZ_1M ) + u64::from (self.value ()) *SZ_1M_U64 } }
Signature · 1 line
2.53.0