138 lines
4.1 KiB
Rust
138 lines
4.1 KiB
Rust
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
use kernel::device;
|
|
use kernel::pci;
|
|
use kernel::prelude::*;
|
|
|
|
use crate::driver::Bar0;
|
|
use crate::falcon::{gsp::Gsp, sec2::Sec2, Falcon};
|
|
use crate::fb::FbLayout;
|
|
use crate::firmware::{
|
|
booter::{BooterFirmware, BooterKind},
|
|
fwsec::{FwsecCommand, FwsecFirmware},
|
|
gsp::GspFirmware,
|
|
FIRMWARE_VERSION,
|
|
};
|
|
use crate::gpu::Chipset;
|
|
use crate::regs;
|
|
use crate::vbios::Vbios;
|
|
|
|
impl super::Gsp {
|
|
/// Helper function to load and run the FWSEC-FRTS firmware and confirm that it has properly
|
|
/// created the WPR2 region.
|
|
fn run_fwsec_frts(
|
|
dev: &device::Device<device::Bound>,
|
|
falcon: &Falcon<Gsp>,
|
|
bar: &Bar0,
|
|
bios: &Vbios,
|
|
fb_layout: &FbLayout,
|
|
) -> Result<()> {
|
|
// Check that the WPR2 region does not already exists - if it does, we cannot run
|
|
// FWSEC-FRTS until the GPU is reset.
|
|
if regs::NV_PFB_PRI_MMU_WPR2_ADDR_HI::read(bar).higher_bound() != 0 {
|
|
dev_err!(
|
|
dev,
|
|
"WPR2 region already exists - GPU needs to be reset to proceed\n"
|
|
);
|
|
return Err(EBUSY);
|
|
}
|
|
|
|
let fwsec_frts = FwsecFirmware::new(
|
|
dev,
|
|
falcon,
|
|
bar,
|
|
bios,
|
|
FwsecCommand::Frts {
|
|
frts_addr: fb_layout.frts.start,
|
|
frts_size: fb_layout.frts.end - fb_layout.frts.start,
|
|
},
|
|
)?;
|
|
|
|
// Run FWSEC-FRTS to create the WPR2 region.
|
|
fwsec_frts.run(dev, falcon, bar)?;
|
|
|
|
// SCRATCH_E contains the error code for FWSEC-FRTS.
|
|
let frts_status = regs::NV_PBUS_SW_SCRATCH_0E_FRTS_ERR::read(bar).frts_err_code();
|
|
if frts_status != 0 {
|
|
dev_err!(
|
|
dev,
|
|
"FWSEC-FRTS returned with error code {:#x}",
|
|
frts_status
|
|
);
|
|
|
|
return Err(EIO);
|
|
}
|
|
|
|
// Check that the WPR2 region has been created as we requested.
|
|
let (wpr2_lo, wpr2_hi) = (
|
|
regs::NV_PFB_PRI_MMU_WPR2_ADDR_LO::read(bar).lower_bound(),
|
|
regs::NV_PFB_PRI_MMU_WPR2_ADDR_HI::read(bar).higher_bound(),
|
|
);
|
|
|
|
match (wpr2_lo, wpr2_hi) {
|
|
(_, 0) => {
|
|
dev_err!(dev, "WPR2 region not created after running FWSEC-FRTS\n");
|
|
|
|
Err(EIO)
|
|
}
|
|
(wpr2_lo, _) if wpr2_lo != fb_layout.frts.start => {
|
|
dev_err!(
|
|
dev,
|
|
"WPR2 region created at unexpected address {:#x}; expected {:#x}\n",
|
|
wpr2_lo,
|
|
fb_layout.frts.start,
|
|
);
|
|
|
|
Err(EIO)
|
|
}
|
|
(wpr2_lo, wpr2_hi) => {
|
|
dev_dbg!(dev, "WPR2: {:#x}-{:#x}\n", wpr2_lo, wpr2_hi);
|
|
dev_dbg!(dev, "GPU instance built\n");
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Attempt to boot the GSP.
|
|
///
|
|
/// This is a GPU-dependent and complex procedure that involves loading firmware files from
|
|
/// user-space, patching them with signatures, and building firmware-specific intricate data
|
|
/// structures that the GSP will use at runtime.
|
|
///
|
|
/// Upon return, the GSP is up and running, and its runtime object given as return value.
|
|
pub(crate) fn boot(
|
|
self: Pin<&mut Self>,
|
|
pdev: &pci::Device<device::Bound>,
|
|
bar: &Bar0,
|
|
chipset: Chipset,
|
|
gsp_falcon: &Falcon<Gsp>,
|
|
sec2_falcon: &Falcon<Sec2>,
|
|
) -> Result {
|
|
let dev = pdev.as_ref();
|
|
|
|
let bios = Vbios::new(dev, bar)?;
|
|
|
|
let _gsp_fw = KBox::pin_init(
|
|
GspFirmware::new(dev, chipset, FIRMWARE_VERSION)?,
|
|
GFP_KERNEL,
|
|
)?;
|
|
|
|
let fb_layout = FbLayout::new(chipset, bar)?;
|
|
dev_dbg!(dev, "{:#x?}\n", fb_layout);
|
|
|
|
Self::run_fwsec_frts(dev, gsp_falcon, bar, &bios, &fb_layout)?;
|
|
|
|
let _booter_loader = BooterFirmware::new(
|
|
dev,
|
|
BooterKind::Loader,
|
|
chipset,
|
|
FIRMWARE_VERSION,
|
|
sec2_falcon,
|
|
bar,
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|