gsp.rs

  1// SPDX-License-Identifier: GPL-2.0
  2
  3mod boot;
  4
  5use kernel::{
  6    device,
  7    dma::{
  8        CoherentAllocation,
  9        DmaAddress, //
 10    },
 11    dma_write,
 12    pci,
 13    prelude::*,
 14    transmute::AsBytes, //
 15};
 16
 17pub(crate) mod cmdq;
 18pub(crate) mod commands;
 19mod fw;
 20mod sequencer;
 21
 22pub(crate) use fw::{
 23    GspFwWprMeta,
 24    LibosParams, //
 25};
 26
 27use crate::{
 28    gsp::cmdq::Cmdq,
 29    gsp::fw::{
 30        GspArgumentsCached,
 31        LibosMemoryRegionInitArgument, //
 32    },
 33    num,
 34};
 35
 36pub(crate) const GSP_PAGE_SHIFT: usize = 12;
 37pub(crate) const GSP_PAGE_SIZE: usize = 1 << GSP_PAGE_SHIFT;
 38
 39/// Number of GSP pages to use in a RM log buffer.
 40const RM_LOG_BUFFER_NUM_PAGES: usize = 0x10;
 41
 42/// Array of page table entries, as understood by the GSP bootloader.
 43#[repr(C)]
 44struct PteArray<const NUM_ENTRIES: usize>([u64; NUM_ENTRIES]);
 45
 46/// SAFETY: arrays of `u64` implement `AsBytes` and we are but a wrapper around one.
 47unsafe impl<const NUM_ENTRIES: usize> AsBytes for PteArray<NUM_ENTRIES> {}
 48
 49impl<const NUM_PAGES: usize> PteArray<NUM_PAGES> {
 50    /// Creates a new page table array mapping `NUM_PAGES` GSP pages starting at address `start`.
 51    fn new(start: DmaAddress) -> Result<Self> {
 52        let mut ptes = [0u64; NUM_PAGES];
 53        for (i, pte) in ptes.iter_mut().enumerate() {
 54            *pte = start
 55                .checked_add(num::usize_as_u64(i) << GSP_PAGE_SHIFT)
 56                .ok_or(EOVERFLOW)?;
 57        }
 58
 59        Ok(Self(ptes))
 60    }
 61}
 62
 63/// The logging buffers are byte queues that contain encoded printf-like
 64/// messages from GSP-RM.  They need to be decoded by a special application
 65/// that can parse the buffers.
 66///
 67/// The 'loginit' buffer contains logs from early GSP-RM init and
 68/// exception dumps.  The 'logrm' buffer contains the subsequent logs. Both are
 69/// written to directly by GSP-RM and can be any multiple of GSP_PAGE_SIZE.
 70///
 71/// The physical address map for the log buffer is stored in the buffer
 72/// itself, starting with offset 1. Offset 0 contains the "put" pointer (pp).
 73/// Initially, pp is equal to 0. If the buffer has valid logging data in it,
 74/// then pp points to index into the buffer where the next logging entry will
 75/// be written. Therefore, the logging data is valid if:
 76///   1 <= pp < sizeof(buffer)/sizeof(u64)
 77struct LogBuffer(CoherentAllocation<u8>);
 78
 79impl LogBuffer {
 80    /// Creates a new `LogBuffer` mapped on `dev`.
 81    fn new(dev: &device::Device<device::Bound>) -> Result<Self> {
 82        const NUM_PAGES: usize = RM_LOG_BUFFER_NUM_PAGES;
 83
 84        let mut obj = Self(CoherentAllocation::<u8>::alloc_coherent(
 85            dev,
 86            NUM_PAGES * GSP_PAGE_SIZE,
 87            GFP_KERNEL | __GFP_ZERO,
 88        )?);
 89        let ptes = PteArray::<NUM_PAGES>::new(obj.0.dma_handle())?;
 90
 91        // SAFETY: `obj` has just been created and we are its sole user.
 92        unsafe {
 93            // Copy the self-mapping PTE at the expected location.
 94            obj.0
 95                .as_slice_mut(size_of::<u64>(), size_of_val(&ptes))?
 96                .copy_from_slice(ptes.as_bytes())
 97        };
 98
 99        Ok(obj)
100    }
101}
102
103/// GSP runtime data.
104#[pin_data]
105pub(crate) struct Gsp {
106    /// Libos arguments.
107    pub(crate) libos: CoherentAllocation<LibosMemoryRegionInitArgument>,
108    /// Init log buffer.
109    loginit: LogBuffer,
110    /// Interrupts log buffer.
111    logintr: LogBuffer,
112    /// RM log buffer.
113    logrm: LogBuffer,
114    /// Command queue.
115    pub(crate) cmdq: Cmdq,
116    /// RM arguments.
117    rmargs: CoherentAllocation<GspArgumentsCached>,
118}
119
120impl Gsp {
121    // Creates an in-place initializer for a `Gsp` manager for `pdev`.
122    pub(crate) fn new(pdev: &pci::Device<device::Bound>) -> Result<impl PinInit<Self, Error>> {
123        let dev = pdev.as_ref();
124        let libos = CoherentAllocation::<LibosMemoryRegionInitArgument>::alloc_coherent(
125            dev,
126            GSP_PAGE_SIZE / size_of::<LibosMemoryRegionInitArgument>(),
127            GFP_KERNEL | __GFP_ZERO,
128        )?;
129
130        // Initialise the logging structures. The OpenRM equivalents are in:
131        // _kgspInitLibosLoggingStructures (allocates memory for buffers)
132        // kgspSetupLibosInitArgs_IMPL (creates pLibosInitArgs[] array)
133        let loginit = LogBuffer::new(dev)?;
134        dma_write!(libos[0] = LibosMemoryRegionInitArgument::new("LOGINIT", &loginit.0))?;
135
136        let logintr = LogBuffer::new(dev)?;
137        dma_write!(libos[1] = LibosMemoryRegionInitArgument::new("LOGINTR", &logintr.0))?;
138
139        let logrm = LogBuffer::new(dev)?;
140        dma_write!(libos[2] = LibosMemoryRegionInitArgument::new("LOGRM", &logrm.0))?;
141
142        let cmdq = Cmdq::new(dev)?;
143
144        let rmargs = CoherentAllocation::<GspArgumentsCached>::alloc_coherent(
145            dev,
146            1,
147            GFP_KERNEL | __GFP_ZERO,
148        )?;
149        dma_write!(rmargs[0] = fw::GspArgumentsCached::new(&cmdq))?;
150        dma_write!(libos[3] = LibosMemoryRegionInitArgument::new("RMARGS", &rmargs))?;
151
152        Ok(try_pin_init!(Self {
153            libos,
154            loginit,
155            logintr,
156            logrm,
157            rmargs,
158            cmdq,
159        }))
160    }
161}