gpu: nova-core: Create initial Gsp (f38b4f10) · Commits · git / linux-net

drivers/gpu/nova-core/gpu.rs

+1 −1

Original line number	Diff line number	Diff line
		@@ -231,7 +231,7 @@ pub(crate) fn new<'a>(

		sec2_falcon: Falcon::new(pdev.as_ref(), spec.chipset)?,

		gsp <- Gsp::new(),
		gsp <- Gsp::new(pdev)?,

		_: { gsp.boot(pdev, bar, spec.chipset, gsp_falcon, sec2_falcon)? },

drivers/gpu/nova-core/gsp.rs

+117 −6

Original line number	Diff line number	Diff line
		@@ -2,7 +2,17 @@

		mod boot;

		use kernel::prelude::*;
		use kernel::{
		device,
		dma::{
		CoherentAllocation,
		DmaAddress, //
		},
		dma_write,
		pci,
		prelude::*,
		transmute::AsBytes, //
		};

		mod fw;

		@@ -11,17 +21,118 @@
		LibosParams, //
		};

		use crate::{
		gsp::fw::LibosMemoryRegionInitArgument,
		num, //
		};

		pub(crate) const GSP_PAGE_SHIFT: usize = 12;
		pub(crate) const GSP_PAGE_SIZE: usize = 1 << GSP_PAGE_SHIFT;

		/// GSP runtime data.
		/// Number of GSP pages to use in a RM log buffer.
		const RM_LOG_BUFFER_NUM_PAGES: usize = 0x10;

		/// Array of page table entries, as understood by the GSP bootloader.
		#[repr(C)]
		struct PteArray<const NUM_ENTRIES: usize>([u64; NUM_ENTRIES]);

		/// SAFETY: arrays of `u64` implement `AsBytes` and we are but a wrapper around one.
		unsafe impl<const NUM_ENTRIES: usize> AsBytes for PteArray<NUM_ENTRIES> {}

		impl<const NUM_PAGES: usize> PteArray<NUM_PAGES> {
		/// Creates a new page table array mapping `NUM_PAGES` GSP pages starting at address `start`.
		fn new(start: DmaAddress) -> Result<Self> {
		let mut ptes = [0u64; NUM_PAGES];
		for (i, pte) in ptes.iter_mut().enumerate() {
		*pte = start
		.checked_add(num::usize_as_u64(i) << GSP_PAGE_SHIFT)
		.ok_or(EOVERFLOW)?;
		}

		Ok(Self(ptes))
		}
		}

		/// The logging buffers are byte queues that contain encoded printf-like
		/// messages from GSP-RM. They need to be decoded by a special application
		/// that can parse the buffers.
		///
		/// The 'loginit' buffer contains logs from early GSP-RM init and
		/// exception dumps. The 'logrm' buffer contains the subsequent logs. Both are
		/// written to directly by GSP-RM and can be any multiple of GSP_PAGE_SIZE.
		///
		/// This is an empty pinned placeholder for now.
		/// The physical address map for the log buffer is stored in the buffer
		/// itself, starting with offset 1. Offset 0 contains the "put" pointer (pp).
		/// Initially, pp is equal to 0. If the buffer has valid logging data in it,
		/// then pp points to index into the buffer where the next logging entry will
		/// be written. Therefore, the logging data is valid if:
		/// 1 <= pp < sizeof(buffer)/sizeof(u64)
		struct LogBuffer(CoherentAllocation<u8>);

		impl LogBuffer {
		/// Creates a new `LogBuffer` mapped on `dev`.
		fn new(dev: &device::Device<device::Bound>) -> Result<Self> {
		const NUM_PAGES: usize = RM_LOG_BUFFER_NUM_PAGES;

		let mut obj = Self(CoherentAllocation::<u8>::alloc_coherent(
		dev,
		NUM_PAGES * GSP_PAGE_SIZE,
		GFP_KERNEL \| __GFP_ZERO,
		)?);
		let ptes = PteArray::<NUM_PAGES>::new(obj.0.dma_handle())?;

		// SAFETY: `obj` has just been created and we are its sole user.
		unsafe {
		// Copy the self-mapping PTE at the expected location.
		obj.0
		.as_slice_mut(size_of::<u64>(), size_of_val(&ptes))?
		.copy_from_slice(ptes.as_bytes())
		};

		Ok(obj)
		}
		}

		/// GSP runtime data.
		#[pin_data]
		pub(crate) struct Gsp {}
		pub(crate) struct Gsp {
		/// Libos arguments.
		pub(crate) libos: CoherentAllocation<LibosMemoryRegionInitArgument>,
		/// Init log buffer.
		loginit: LogBuffer,
		/// Interrupts log buffer.
		logintr: LogBuffer,
		/// RM log buffer.
		logrm: LogBuffer,
		}

		impl Gsp {
		pub(crate) fn new() -> impl PinInit<Self> {
		pin_init!(Self {})
		// Creates an in-place initializer for a `Gsp` manager for `pdev`.
		pub(crate) fn new(pdev: &pci::Device<device::Bound>) -> Result<impl PinInit<Self, Error>> {
		let dev = pdev.as_ref();
		let libos = CoherentAllocation::<LibosMemoryRegionInitArgument>::alloc_coherent(
		dev,
		GSP_PAGE_SIZE / size_of::<LibosMemoryRegionInitArgument>(),
		GFP_KERNEL \| __GFP_ZERO,
		)?;

		// Initialise the logging structures. The OpenRM equivalents are in:
		// _kgspInitLibosLoggingStructures (allocates memory for buffers)
		// kgspSetupLibosInitArgs_IMPL (creates pLibosInitArgs[] array)
		let loginit = LogBuffer::new(dev)?;
		dma_write!(libos[0] = LibosMemoryRegionInitArgument::new("LOGINIT", &loginit.0))?;

		let logintr = LogBuffer::new(dev)?;
		dma_write!(libos[1] = LibosMemoryRegionInitArgument::new("LOGINTR", &logintr.0))?;

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

		Ok(try_pin_init!(Self {
		libos,
		loginit,
		logintr,
		logrm,
		}))
		}
		}

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

+60 −0

Original line number	Diff line number	Diff line
		@@ -8,11 +8,16 @@
		use core::ops::Range;

		use kernel::{
		dma::CoherentAllocation,
		ptr::{
		Alignable,
		Alignment, //
		},
		sizes::SZ_1M,
		transmute::{
		AsBytes,
		FromBytes, //
		},
		};

		use crate::{
		@@ -116,3 +121,58 @@ pub(crate) fn wpr_heap_size(&self, chipset: Chipset, fb_size: u64) -> u64 {
		/// addresses of the GSP bootloader and firmware.
		#[repr(transparent)]
		pub(crate) struct GspFwWprMeta(bindings::GspFwWprMeta);

		/// Struct containing the arguments required to pass a memory buffer to the GSP
		/// for use during initialisation.
		///
		/// The GSP only understands 4K pages (GSP_PAGE_SIZE), so even if the kernel is
		/// configured for a larger page size (e.g. 64K pages), we need to give
		/// the GSP an array of 4K pages. Since we only create physically contiguous
		/// buffers the math to calculate the addresses is simple.
		///
		/// The buffers must be a multiple of GSP_PAGE_SIZE. GSP-RM also currently
		/// ignores the @kind field for LOGINIT, LOGINTR, and LOGRM, but expects the
		/// buffers to be physically contiguous anyway.
		///
		/// The memory allocated for the arguments must remain until the GSP sends the
		/// init_done RPC.
		#[repr(transparent)]
		pub(crate) struct LibosMemoryRegionInitArgument(bindings::LibosMemoryRegionInitArgument);

		// SAFETY: Padding is explicit and does not contain uninitialized data.
		unsafe impl AsBytes for LibosMemoryRegionInitArgument {}

		// SAFETY: This struct only contains integer types for which all bit patterns
		// are valid.
		unsafe impl FromBytes for LibosMemoryRegionInitArgument {}

		impl LibosMemoryRegionInitArgument {
		pub(crate) fn new<A: AsBytes + FromBytes>(
		name: &'static str,
		obj: &CoherentAllocation<A>,
		) -> Self {
		/// Generates the `ID8` identifier required for some GSP objects.
		fn id8(name: &str) -> u64 {
		let mut bytes = [0u8; core::mem::size_of::<u64>()];

		for (c, b) in name.bytes().rev().zip(&mut bytes) {
		*b = c;
		}

		u64::from_ne_bytes(bytes)
		}

		Self(bindings::LibosMemoryRegionInitArgument {
		id8: id8(name),
		pa: obj.dma_handle(),
		size: num::usize_as_u64(obj.size()),
		kind: num::u32_into_u8::<
		{ bindings::LibosMemoryRegionKind_LIBOS_MEMORY_REGION_CONTIGUOUS },
		>(),
		loc: num::u32_into_u8::<
		{ bindings::LibosMemoryRegionLoc_LIBOS_MEMORY_REGION_LOC_SYSMEM },
		>(),
		..Default::default()
		})
		}
		}

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

+19 −0

Original line number	Diff line number	Diff line
		@@ -124,3 +124,22 @@ fn default() -> Self {
		}
		}
		}
		pub type LibosAddress = u64_;
		pub const LibosMemoryRegionKind_LIBOS_MEMORY_REGION_NONE: LibosMemoryRegionKind = 0;
		pub const LibosMemoryRegionKind_LIBOS_MEMORY_REGION_CONTIGUOUS: LibosMemoryRegionKind = 1;
		pub const LibosMemoryRegionKind_LIBOS_MEMORY_REGION_RADIX3: LibosMemoryRegionKind = 2;
		pub type LibosMemoryRegionKind = ffi::c_uint;
		pub const LibosMemoryRegionLoc_LIBOS_MEMORY_REGION_LOC_NONE: LibosMemoryRegionLoc = 0;
		pub const LibosMemoryRegionLoc_LIBOS_MEMORY_REGION_LOC_SYSMEM: LibosMemoryRegionLoc = 1;
		pub const LibosMemoryRegionLoc_LIBOS_MEMORY_REGION_LOC_FB: LibosMemoryRegionLoc = 2;
		pub type LibosMemoryRegionLoc = ffi::c_uint;
		#[repr(C)]
		#[derive(Debug, Default, Copy, Clone)]
		pub struct LibosMemoryRegionInitArgument {
		pub id8: LibosAddress,
		pub pa: LibosAddress,
		pub size: LibosAddress,
		pub kind: u8_,
		pub loc: u8_,
		pub __bindgen_padding_0: [u8; 6usize],
		}