Commit 75f6b1de authored by Alistair Popple's avatar Alistair Popple Committed by Alexandre Courbot
Browse files

gpu: nova-core: gsp: Add GSP command queue bindings and handling 



This commit introduces core infrastructure for handling GSP command and
message queues in the nova-core driver. The command queue system enables
bidirectional communication between the host driver and GSP firmware
through a remote message passing interface.

The interface is based on passing serialised data structures over a ring
buffer with separate transmit and receive queues. Commands are sent by
writing to the CPU transmit queue and waiting for completion via the
receive queue.

To ensure safety mutable or immutable (depending on whether it is a send
or receive operation) references are taken on the command queue when
allocating the message to write/read to. This ensures message memory
remains valid and the command queue can't be mutated whilst an operation
is in progress.

Currently this is only used by the probe() routine and therefore can
only used by a single thread of execution. Locking to enable safe access
from multiple threads will be introduced in a future series when that
becomes necessary.

Signed-off-by: default avatarAlistair Popple <apopple@nvidia.com>
Co-developed-by: default avatarAlexandre Courbot <acourbot@nvidia.com>
Signed-off-by: default avatarAlexandre Courbot <acourbot@nvidia.com>
Message-ID: <20251110-gsp_boot-v9-9-8ae4058e3c0e@nvidia.com>
parent 88622323

drivers/gpu/nova-core/gsp.rs

+7 −0
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 
    transmute::AsBytes, //

};



pub(crate) mod cmdq;

mod fw;



pub(crate) use fw::{
@@ -22,6 +23,7 @@ 
};



use crate::{

    gsp::cmdq::Cmdq,

    gsp::fw::LibosMemoryRegionInitArgument,

    num, //

};
@@ -104,6 +106,8 @@ pub(crate) struct Gsp { 
    logintr: LogBuffer,

    /// RM log buffer.

    logrm: LogBuffer,

    /// Command queue.

    pub(crate) cmdq: Cmdq,

}



impl Gsp {
@@ -128,11 +132,14 @@ pub(crate) fn new(pdev: &pci::Device<device::Bound>) -> Result<impl PinInit<Self 
        let logrm = LogBuffer::new(dev)?;

        dma_write!(libos[2] = LibosMemoryRegionInitArgument::new("LOGRM", &logrm.0))?;



        let cmdq = Cmdq::new(dev)?;



        Ok(try_pin_init!(Self {

            libos,

            loginit,

            logintr,

            logrm,

            cmdq,

        }))

    }

}

drivers/gpu/nova-core/gsp/cmdq.rs

0 → 100644
+656 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/gpu/nova-core/gsp/fw.rs

+334 −1
Original line number Diff line number Diff line
@@ -5,10 +5,14 @@ 
// Alias to avoid repeating the version number with every use.

use r570_144 as bindings;



use core::ops::Range;

use core::{

    fmt,

    ops::Range, //

};



use kernel::{

    dma::CoherentAllocation,

    prelude::*,

    ptr::{

        Alignable,

        Alignment, //
@@ -27,6 +31,7 @@ 
    fb::FbLayout,

    firmware::gsp::GspFirmware,

    gpu::Chipset,

    gsp::GSP_PAGE_SIZE,

    num::{

        self,

        FromSafeCast, //
@@ -181,6 +186,128 @@ pub(crate) fn new(gsp_firmware: &GspFirmware, fb_layout: &FbLayout) -> Self { 
    }

}



#[derive(Copy, Clone, Debug, PartialEq)]

#[repr(u32)]

pub(crate) enum MsgFunction {

    // Common function codes

    Nop = bindings::NV_VGPU_MSG_FUNCTION_NOP,

    SetGuestSystemInfo = bindings::NV_VGPU_MSG_FUNCTION_SET_GUEST_SYSTEM_INFO,

    AllocRoot = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_ROOT,

    AllocDevice = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_DEVICE,

    AllocMemory = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_MEMORY,

    AllocCtxDma = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CTX_DMA,

    AllocChannelDma = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CHANNEL_DMA,

    MapMemory = bindings::NV_VGPU_MSG_FUNCTION_MAP_MEMORY,

    BindCtxDma = bindings::NV_VGPU_MSG_FUNCTION_BIND_CTX_DMA,

    AllocObject = bindings::NV_VGPU_MSG_FUNCTION_ALLOC_OBJECT,

    Free = bindings::NV_VGPU_MSG_FUNCTION_FREE,

    Log = bindings::NV_VGPU_MSG_FUNCTION_LOG,

    GetGspStaticInfo = bindings::NV_VGPU_MSG_FUNCTION_GET_GSP_STATIC_INFO,

    SetRegistry = bindings::NV_VGPU_MSG_FUNCTION_SET_REGISTRY,

    GspSetSystemInfo = bindings::NV_VGPU_MSG_FUNCTION_GSP_SET_SYSTEM_INFO,

    GspInitPostObjGpu = bindings::NV_VGPU_MSG_FUNCTION_GSP_INIT_POST_OBJGPU,

    GspRmControl = bindings::NV_VGPU_MSG_FUNCTION_GSP_RM_CONTROL,

    GetStaticInfo = bindings::NV_VGPU_MSG_FUNCTION_GET_STATIC_INFO,



    // Event codes

    GspInitDone = bindings::NV_VGPU_MSG_EVENT_GSP_INIT_DONE,

    GspRunCpuSequencer = bindings::NV_VGPU_MSG_EVENT_GSP_RUN_CPU_SEQUENCER,

    PostEvent = bindings::NV_VGPU_MSG_EVENT_POST_EVENT,

    RcTriggered = bindings::NV_VGPU_MSG_EVENT_RC_TRIGGERED,

    MmuFaultQueued = bindings::NV_VGPU_MSG_EVENT_MMU_FAULT_QUEUED,

    OsErrorLog = bindings::NV_VGPU_MSG_EVENT_OS_ERROR_LOG,

    GspPostNoCat = bindings::NV_VGPU_MSG_EVENT_GSP_POST_NOCAT_RECORD,

    GspLockdownNotice = bindings::NV_VGPU_MSG_EVENT_GSP_LOCKDOWN_NOTICE,

    UcodeLibOsPrint = bindings::NV_VGPU_MSG_EVENT_UCODE_LIBOS_PRINT,

}



impl fmt::Display for MsgFunction {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        match self {

            // Common function codes

            MsgFunction::Nop => write!(f, "NOP"),

            MsgFunction::SetGuestSystemInfo => write!(f, "SET_GUEST_SYSTEM_INFO"),

            MsgFunction::AllocRoot => write!(f, "ALLOC_ROOT"),

            MsgFunction::AllocDevice => write!(f, "ALLOC_DEVICE"),

            MsgFunction::AllocMemory => write!(f, "ALLOC_MEMORY"),

            MsgFunction::AllocCtxDma => write!(f, "ALLOC_CTX_DMA"),

            MsgFunction::AllocChannelDma => write!(f, "ALLOC_CHANNEL_DMA"),

            MsgFunction::MapMemory => write!(f, "MAP_MEMORY"),

            MsgFunction::BindCtxDma => write!(f, "BIND_CTX_DMA"),

            MsgFunction::AllocObject => write!(f, "ALLOC_OBJECT"),

            MsgFunction::Free => write!(f, "FREE"),

            MsgFunction::Log => write!(f, "LOG"),

            MsgFunction::GetGspStaticInfo => write!(f, "GET_GSP_STATIC_INFO"),

            MsgFunction::SetRegistry => write!(f, "SET_REGISTRY"),

            MsgFunction::GspSetSystemInfo => write!(f, "GSP_SET_SYSTEM_INFO"),

            MsgFunction::GspInitPostObjGpu => write!(f, "GSP_INIT_POST_OBJGPU"),

            MsgFunction::GspRmControl => write!(f, "GSP_RM_CONTROL"),

            MsgFunction::GetStaticInfo => write!(f, "GET_STATIC_INFO"),



            // Event codes

            MsgFunction::GspInitDone => write!(f, "INIT_DONE"),

            MsgFunction::GspRunCpuSequencer => write!(f, "RUN_CPU_SEQUENCER"),

            MsgFunction::PostEvent => write!(f, "POST_EVENT"),

            MsgFunction::RcTriggered => write!(f, "RC_TRIGGERED"),

            MsgFunction::MmuFaultQueued => write!(f, "MMU_FAULT_QUEUED"),

            MsgFunction::OsErrorLog => write!(f, "OS_ERROR_LOG"),

            MsgFunction::GspPostNoCat => write!(f, "NOCAT"),

            MsgFunction::GspLockdownNotice => write!(f, "LOCKDOWN_NOTICE"),

            MsgFunction::UcodeLibOsPrint => write!(f, "LIBOS_PRINT"),

        }

    }

}



impl TryFrom<u32> for MsgFunction {

    type Error = kernel::error::Error;



    fn try_from(value: u32) -> Result<MsgFunction> {

        match value {

            bindings::NV_VGPU_MSG_FUNCTION_NOP => Ok(MsgFunction::Nop),

            bindings::NV_VGPU_MSG_FUNCTION_SET_GUEST_SYSTEM_INFO => {

                Ok(MsgFunction::SetGuestSystemInfo)

            }

            bindings::NV_VGPU_MSG_FUNCTION_ALLOC_ROOT => Ok(MsgFunction::AllocRoot),

            bindings::NV_VGPU_MSG_FUNCTION_ALLOC_DEVICE => Ok(MsgFunction::AllocDevice),

            bindings::NV_VGPU_MSG_FUNCTION_ALLOC_MEMORY => Ok(MsgFunction::AllocMemory),

            bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CTX_DMA => Ok(MsgFunction::AllocCtxDma),

            bindings::NV_VGPU_MSG_FUNCTION_ALLOC_CHANNEL_DMA => Ok(MsgFunction::AllocChannelDma),

            bindings::NV_VGPU_MSG_FUNCTION_MAP_MEMORY => Ok(MsgFunction::MapMemory),

            bindings::NV_VGPU_MSG_FUNCTION_BIND_CTX_DMA => Ok(MsgFunction::BindCtxDma),

            bindings::NV_VGPU_MSG_FUNCTION_ALLOC_OBJECT => Ok(MsgFunction::AllocObject),

            bindings::NV_VGPU_MSG_FUNCTION_FREE => Ok(MsgFunction::Free),

            bindings::NV_VGPU_MSG_FUNCTION_LOG => Ok(MsgFunction::Log),

            bindings::NV_VGPU_MSG_FUNCTION_GET_GSP_STATIC_INFO => Ok(MsgFunction::GetGspStaticInfo),

            bindings::NV_VGPU_MSG_FUNCTION_SET_REGISTRY => Ok(MsgFunction::SetRegistry),

            bindings::NV_VGPU_MSG_FUNCTION_GSP_SET_SYSTEM_INFO => Ok(MsgFunction::GspSetSystemInfo),

            bindings::NV_VGPU_MSG_FUNCTION_GSP_INIT_POST_OBJGPU => {

                Ok(MsgFunction::GspInitPostObjGpu)

            }

            bindings::NV_VGPU_MSG_FUNCTION_GSP_RM_CONTROL => Ok(MsgFunction::GspRmControl),

            bindings::NV_VGPU_MSG_FUNCTION_GET_STATIC_INFO => Ok(MsgFunction::GetStaticInfo),

            bindings::NV_VGPU_MSG_EVENT_GSP_INIT_DONE => Ok(MsgFunction::GspInitDone),

            bindings::NV_VGPU_MSG_EVENT_GSP_RUN_CPU_SEQUENCER => {

                Ok(MsgFunction::GspRunCpuSequencer)

            }

            bindings::NV_VGPU_MSG_EVENT_POST_EVENT => Ok(MsgFunction::PostEvent),

            bindings::NV_VGPU_MSG_EVENT_RC_TRIGGERED => Ok(MsgFunction::RcTriggered),

            bindings::NV_VGPU_MSG_EVENT_MMU_FAULT_QUEUED => Ok(MsgFunction::MmuFaultQueued),

            bindings::NV_VGPU_MSG_EVENT_OS_ERROR_LOG => Ok(MsgFunction::OsErrorLog),

            bindings::NV_VGPU_MSG_EVENT_GSP_POST_NOCAT_RECORD => Ok(MsgFunction::GspPostNoCat),

            bindings::NV_VGPU_MSG_EVENT_GSP_LOCKDOWN_NOTICE => Ok(MsgFunction::GspLockdownNotice),

            bindings::NV_VGPU_MSG_EVENT_UCODE_LIBOS_PRINT => Ok(MsgFunction::UcodeLibOsPrint),

            _ => Err(EINVAL),

        }

    }

}



impl From<MsgFunction> for u32 {

    fn from(value: MsgFunction) -> Self {

        // CAST: `MsgFunction` is `repr(u32)` and can thus be cast losslessly.

        value as u32

    }

}



/// Struct containing the arguments required to pass a memory buffer to the GSP

/// for use during initialisation.

///
@@ -235,3 +362,209 @@ fn id8(name: &str) -> u64 { 
        })

    }

}



/// TX header for setting up a message queue with the GSP.

#[repr(transparent)]

pub(crate) struct MsgqTxHeader(bindings::msgqTxHeader);



impl MsgqTxHeader {

    /// Create a new TX queue header.

    ///

    /// # Arguments

    ///

    /// * `msgq_size` - Total size of the message queue structure, in bytes.

    /// * `rx_hdr_offset` - Offset, in bytes, of the start of the RX header in the message queue

    ///   structure.

    /// * `msg_count` - Number of messages that can be sent, i.e. the number of memory pages

    ///   allocated for the message queue in the message queue structure.

    pub(crate) fn new(msgq_size: u32, rx_hdr_offset: u32, msg_count: u32) -> Self {

        Self(bindings::msgqTxHeader {

            version: 0,

            size: msgq_size,

            msgSize: num::usize_into_u32::<GSP_PAGE_SIZE>(),

            msgCount: msg_count,

            writePtr: 0,

            flags: 1,

            rxHdrOff: rx_hdr_offset,

            entryOff: num::usize_into_u32::<GSP_PAGE_SIZE>(),

        })

    }



    /// Returns the value of the write pointer for this queue.

    pub(crate) fn write_ptr(&self) -> u32 {

        let ptr = core::ptr::from_ref(&self.0.writePtr);



        // SAFETY: `ptr` is a valid pointer to a `u32`.

        unsafe { ptr.read_volatile() }

    }



    /// Sets the value of the write pointer for this queue.

    pub(crate) fn set_write_ptr(&mut self, val: u32) {

        let ptr = core::ptr::from_mut(&mut self.0.writePtr);



        // SAFETY: `ptr` is a valid pointer to a `u32`.

        unsafe { ptr.write_volatile(val) }

    }

}



// SAFETY: Padding is explicit and does not contain uninitialized data.

unsafe impl AsBytes for MsgqTxHeader {}



/// RX header for setting up a message queue with the GSP.

#[repr(transparent)]

pub(crate) struct MsgqRxHeader(bindings::msgqRxHeader);



/// Header for the message RX queue.

impl MsgqRxHeader {

    /// Creates a new RX queue header.

    pub(crate) fn new() -> Self {

        Self(Default::default())

    }



    /// Returns the value of the read pointer for this queue.

    pub(crate) fn read_ptr(&self) -> u32 {

        let ptr = core::ptr::from_ref(&self.0.readPtr);



        // SAFETY: `ptr` is a valid pointer to a `u32`.

        unsafe { ptr.read_volatile() }

    }



    /// Sets the value of the read pointer for this queue.

    pub(crate) fn set_read_ptr(&mut self, val: u32) {

        let ptr = core::ptr::from_mut(&mut self.0.readPtr);



        // SAFETY: `ptr` is a valid pointer to a `u32`.

        unsafe { ptr.write_volatile(val) }

    }

}



// SAFETY: Padding is explicit and does not contain uninitialized data.

unsafe impl AsBytes for MsgqRxHeader {}



bitfield! {

    struct MsgHeaderVersion(u32) {

        31:24 major as u8;

        23:16 minor as u8;

    }

}



impl MsgHeaderVersion {

    const MAJOR_TOT: u8 = 3;

    const MINOR_TOT: u8 = 0;



    fn new() -> Self {

        Self::default()

            .set_major(Self::MAJOR_TOT)

            .set_minor(Self::MINOR_TOT)

    }

}



impl bindings::rpc_message_header_v {

    fn init(cmd_size: usize, function: MsgFunction) -> impl Init<Self, Error> {

        type RpcMessageHeader = bindings::rpc_message_header_v;



        try_init!(RpcMessageHeader {

            header_version: MsgHeaderVersion::new().into(),

            signature: bindings::NV_VGPU_MSG_SIGNATURE_VALID,

            function: function.into(),

            length: size_of::<Self>()

                .checked_add(cmd_size)

                .ok_or(EOVERFLOW)

                .and_then(|v| v.try_into().map_err(|_| EINVAL))?,

            rpc_result: 0xffffffff,

            rpc_result_private: 0xffffffff,

            ..Zeroable::init_zeroed()

        })

    }

}



// SAFETY: We can't derive the Zeroable trait for this binding because the

// procedural macro doesn't support the syntax used by bindgen to create the

// __IncompleteArrayField types. So instead we implement it here, which is safe

// because these are explicitly padded structures only containing types for

// which any bit pattern, including all zeros, is valid.

unsafe impl Zeroable for bindings::rpc_message_header_v {}



/// GSP Message Element.

///

/// This is essentially a message header expected to be followed by the message data.

#[repr(transparent)]

pub(crate) struct GspMsgElement {

    inner: bindings::GSP_MSG_QUEUE_ELEMENT,

}



impl GspMsgElement {

    /// Creates a new message element.

    ///

    /// # Arguments

    ///

    /// * `sequence` - Sequence number of the message.

    /// * `cmd_size` - Size of the command (not including the message element), in bytes.

    /// * `function` - Function of the message.

    #[allow(non_snake_case)]

    pub(crate) fn init(

        sequence: u32,

        cmd_size: usize,

        function: MsgFunction,

    ) -> impl Init<Self, Error> {

        type RpcMessageHeader = bindings::rpc_message_header_v;

        type InnerGspMsgElement = bindings::GSP_MSG_QUEUE_ELEMENT;

        let init_inner = try_init!(InnerGspMsgElement {

            seqNum: sequence,

            elemCount: size_of::<Self>()

                .checked_add(cmd_size)

                .ok_or(EOVERFLOW)?

                .div_ceil(GSP_PAGE_SIZE)

                .try_into()

                .map_err(|_| EOVERFLOW)?,

            rpc <- RpcMessageHeader::init(cmd_size, function),

            ..Zeroable::init_zeroed()

        });



        try_init!(GspMsgElement {

            inner <- init_inner,

        })

    }



    /// Sets the checksum of this message.

    ///

    /// Since the header is also part of the checksum, this is usually called after the whole

    /// message has been written to the shared memory area.

    pub(crate) fn set_checksum(&mut self, checksum: u32) {

        self.inner.checkSum = checksum;

    }



    /// Returns the total length of the message.

    pub(crate) fn length(&self) -> usize {

        // `rpc.length` includes the length of the GspRpcHeader but not the message header.

        size_of::<Self>() - size_of::<bindings::rpc_message_header_v>()

            + num::u32_as_usize(self.inner.rpc.length)

    }



    // Returns the sequence number of the message.

    pub(crate) fn sequence(&self) -> u32 {

        self.inner.rpc.sequence

    }



    // Returns the function of the message, if it is valid, or the invalid function number as an

    // error.

    pub(crate) fn function(&self) -> Result<MsgFunction, u32> {

        self.inner

            .rpc

            .function

            .try_into()

            .map_err(|_| self.inner.rpc.function)

    }



    // Returns the number of elements (i.e. memory pages) used by this message.

    pub(crate) fn element_count(&self) -> u32 {

        self.inner.elemCount

    }

}



// SAFETY: Padding is explicit and does not contain uninitialized data.

unsafe impl AsBytes for GspMsgElement {}



// SAFETY: This struct only contains integer types for which all bit patterns

// are valid.

unsafe impl FromBytes for GspMsgElement {}

drivers/gpu/nova-core/gsp/fw/r570_144/bindings.rs

+409 −0

File changed.

Preview size limit exceeded, changes collapsed.

drivers/gpu/nova-core/regs.rs

+4 −0
Original line number Diff line number Diff line
@@ -86,6 +86,10 @@ pub(crate) fn chipset(self) -> Result<Chipset> { 
    30:30   ecc_mode_enabled as bool;

});



register!(NV_PGSP_QUEUE_HEAD @ 0x00110c00 {

    31:0    address as u32;

});



impl NV_PFB_PRI_MMU_LOCAL_MEMORY_RANGE {

    /// Returns the usable framebuffer size, in bytes.

    pub(crate) fn usable_fb_size(self) -> u64 {