hocclk: add bpmpfw loading

Source/hoc-clk/sysmodule/Makefile

@@ -22,7 +22,7 @@ CONFIG_DIR	:=	horizon-oc
 BUILD		:=	build
 OUTDIR		:=	out
 RESOURCES	:=	res
-SOURCES		:=	src src/hos src/i2c src/ipc src/board src/display src/tsensor src/mgr src/file src/soc src/mapping src/pwr src/util
+SOURCES		:=	src src/hos src/i2c src/ipc src/board src/bpmp src/display src/tsensor src/mgr src/file src/soc src/mapping src/pwr src/util
 DATA		:=	data
 INCLUDES	:=	../common/include src/hos src/soc src/i2c src/util src/pwr src/ipc
 EXEFS_SRC	:=	exefs_src

Source/hoc-clk/sysmodule/src/board/board.cpp

@@ -35,6 +35,7 @@
 #include <t210.h>
 #include <tmp451.h>
 
+#include "../bpmp/bpmp.hpp"
 #include "../display/display_refresh_rate.hpp"
 #include "../file/file_utils.hpp"
 #include "../hos/apm_ext.h"
@@ -52,7 +53,7 @@
 
 namespace board {
 
-    u64 clkVirtAddr, dsiVirtAddr, apbVirtAddr, fuseVirtAddr;
+    u64 clkVirtAddr, dsiVirtAddr, apbVirtAddr, fuseVirtAddr, sysVirtAddr, actmonVirtAddr;
 
     HocClkSocType gSocType;
     u8 gDramID;
@@ -153,6 +154,10 @@ namespace board {
         rc = QueryMemoryMapping(&fuseVirtAddr, 0x7000F000, 0x1000);
         ASSERT_RESULT_OK(rc, "QueryMemoryMapping (fuse)");
 
+        rc = QueryMemoryMapping(&sysVirtAddr, 0x6000C000, 0x1000);
+        ASSERT_RESULT_OK(rc, "QueryMemoryMapping (sys)");
+        actmonVirtAddr = sysVirtAddr + 0x800;
+
         FetchHardwareInfos();
 
         Result nvCheck = 1;
@@ -173,6 +178,11 @@ namespace board {
 
         tsensor::InitializeSoctherm();  // SOCTHERM must be init before AOTAG
 
+        Result bpmpfwRc = bpmp::StartBpmfwExecution();
+        if (R_FAILED(bpmpfwRc)) {
+            fileUtils::LogLine("[bpmp] StartBpmfwExecution failed: 0x%x", bpmpfwRc);
+        }
+
         // PMC exosphere check
         SecmonArgs args = {};
         args.X[0] = 0xF0000002;

Source/hoc-clk/sysmodule/src/board/board.hpp

@@ -42,7 +42,7 @@
 #define HOSSVC_HAS_TC (hosversionAtLeast(5, 0, 0))
 
 namespace board {
-    extern u64 clkVirtAddr, dsiVirtAddr, apbVirtAddr, fuseVirtAddr;
+    extern u64 clkVirtAddr, dsiVirtAddr, apbVirtAddr, fuseVirtAddr, sysVirtAddr, actmonVirtAddr;
     extern HocClkSocType gSocType;
     extern u8 gDramID;
     extern HocClkConsoleType gConsoleType;

Source/hoc-clk/sysmodule/src/bpmp/bpmp.cpp

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) Souldbminer, Lightos and Horizon OC Contributors
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <cstdio>
+#include <cstring>
+#include <switch.h>
+
+#include "../board/board.hpp"
+#include "../file/file_utils.hpp"
+#include "../mapping/mem_map.hpp"
+#include "bpmp.hpp"
+
+namespace bpmp {
+
+    namespace {
+
+        constexpr u64 FlowCtlrPhysBase = 0x60007000;
+        constexpr u64 EvpPhysBase = 0x6000F000;
+
+        constexpr u32 ClkRstRstDevLSet = 0x300;
+        constexpr u32 ClkRstRstDevLClr = 0x304;
+        constexpr u32 RstDevLCopRstBit = (1u << 1); /* SWR_COP_RST */
+
+        constexpr u32 ApbMiscSlaveSecurityReg0 = 0xC00;
+        constexpr u32 ApbMiscSlaveSecurityReg1 = 0xC04;
+        constexpr u32 ApbMiscSlaveSecurityReg2 = 0xC08;
+
+        /* Relative to actmonVirtAddr */
+        constexpr u32 ActmonCopCtrl       = 0xC0;
+        constexpr u32 ActmonCopIntrStatus = 0xE4;
+
+        constexpr u32 EvpCopResetVector         = 0x200;
+        constexpr u32 EvpCopUndefVector         = 0x204;
+        constexpr u32 EvpCopSwiVector           = 0x208;
+        constexpr u32 EvpCopPrefetchAbortVector = 0x20C;
+        constexpr u32 EvpCopDataAbortVector     = 0x210;
+        constexpr u32 EvpCopRsvdVector          = 0x214;
+        constexpr u32 EvpCopIrqVector           = 0x218;
+        constexpr u32 EvpCopFiqVector           = 0x21C;
+
+        constexpr u32 FlowCtlrHaltCopEvents = 0x004;
+        constexpr u32 FlowModeNone          = 0x00000000;
+
+        constexpr u64 FwIramPhysBase = 0x40004000;
+        constexpr u32 FwStagingSize  = 0x8000;
+
+        alignas(4096) u8 s_fwStageBuf[FwStagingSize];
+
+        inline volatile u32 &Mmio(u64 base_va, u32 offset) {
+            return *reinterpret_cast<volatile u32 *>(base_va + offset);
+        }
+
+    } // namespace
+
+    Result StartBpmfwExecution() {
+        if (!IsPatchedExosphere()) {
+            fileUtils::LogLine("[bpmp] Cannot start without patched exosphere");
+            return (Result)1;
+        }
+
+        std::memset(s_fwStageBuf, 0, sizeof(s_fwStageBuf));
+
+        FILE *f = fopen("sdmc:/config/horizon-oc/bpmpfw.bin", "rb");
+        if (!f) {
+            fileUtils::LogLine("[bpmp] StartBpmfwExecution: bpmpfw.bin not found");
+            return (Result)1;
+        }
+
+        const size_t fw_size = fread(s_fwStageBuf, 1, sizeof(s_fwStageBuf), f);
+        fclose(f);
+
+        if (fw_size == 0) {
+            fileUtils::LogLine("[bpmp] StartBpmfwExecution: bpmpfw.bin is empty");
+            return (Result)1;
+        }
+
+        fileUtils::LogLine("[bpmp] StartBpmfwExecution: loaded %zu bytes, loading at 0x%llx",
+                            fw_size, static_cast<unsigned long long>(FwIramPhysBase));
+
+        /* Set BPMP reset */
+        Mmio(board::clkVirtAddr, ClkRstRstDevLSet) = RstDevLCopRstBit;
+
+        /* Grant BPMP access to all a bunch of registers that are useful */
+        Mmio(board::apbVirtAddr, ApbMiscSlaveSecurityReg0) = 0;
+        Mmio(board::apbVirtAddr, ApbMiscSlaveSecurityReg1) = 0;
+        Mmio(board::apbVirtAddr, ApbMiscSlaveSecurityReg2) = 0;
+
+        /* Set up exeption vectors for bpmp */
+        const u32 fw_reset_vector = static_cast<u32>(FwIramPhysBase + 0x0);
+        const u32 fw_panic_vector = static_cast<u32>(FwIramPhysBase + 0x4);
+
+        SmcReadWriteRegister(EvpPhysBase + EvpCopResetVector,         0xFFFFFFFF, fw_reset_vector);
+        SmcReadWriteRegister(EvpPhysBase + EvpCopUndefVector,         0xFFFFFFFF, fw_panic_vector);
+        SmcReadWriteRegister(EvpPhysBase + EvpCopSwiVector,           0xFFFFFFFF, fw_panic_vector);
+        SmcReadWriteRegister(EvpPhysBase + EvpCopPrefetchAbortVector, 0xFFFFFFFF, fw_panic_vector);
+        SmcReadWriteRegister(EvpPhysBase + EvpCopDataAbortVector,     0xFFFFFFFF, fw_panic_vector);
+        SmcReadWriteRegister(EvpPhysBase + EvpCopRsvdVector,          0xFFFFFFFF, fw_panic_vector);
+        SmcReadWriteRegister(EvpPhysBase + EvpCopIrqVector,           0xFFFFFFFF, fw_panic_vector);
+        SmcReadWriteRegister(EvpPhysBase + EvpCopFiqVector,           0xFFFFFFFF, fw_panic_vector);
+
+        /* Disable actmon monitoring to avoid hang on FW >4.0.0 */
+        Mmio(board::actmonVirtAddr, ActmonCopCtrl) = 0;
+        Mmio(board::actmonVirtAddr, ActmonCopIntrStatus) = Mmio(board::actmonVirtAddr, ActmonCopIntrStatus);
+
+        /* Load the BPMPFW into iram per page. TODO: determine if this is nessesary */
+        constexpr size_t PageSize = 4096;
+        for (size_t ofs = 0; ofs < fw_size; ofs += PageSize) {
+            const size_t chunk = (fw_size - ofs) < PageSize ? (fw_size - ofs) : PageSize;
+
+            Result copy_rc = SmcCopyToIram(FwIramPhysBase + ofs, s_fwStageBuf + ofs, static_cast<u32>(chunk));
+            if (R_FAILED(copy_rc)) {
+                fileUtils::LogLine("[bpmp] SmcCopyToIram failed at +0x%zx: 0x%x", ofs, copy_rc);
+                return copy_rc;
+            }
+        }
+
+        /* Clear BPMP reset. */
+        Mmio(board::clkVirtAddr, ClkRstRstDevLClr) = RstDevLCopRstBit;
+
+        /* Clear the halt written by bootloader. */
+        SmcReadWriteRegister(FlowCtlrPhysBase + FlowCtlrHaltCopEvents, 0xFFFFFFFF, FlowModeNone);
+
+        return 0;
+    }
+
+} // namespace bpmp

Source/hoc-clk/sysmodule/src/bpmp/bpmp.hpp

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Souldbminer, Lightos and Horizon OC Contributors
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#pragma once
+#include <switch.h>
+
+namespace bpmp {
+    Result StartBpmfwExecution();
+}

Source/hoc-clk/sysmodule/src/mapping/mem_map.cpp

@@ -65,4 +65,28 @@ Result SmcCopyToIram(uintptr_t dest, const void *src, u32 size) {
         rc = (26u | ((u32)args.X[0] << 9u));
     }
     return rc;
+}
+
+bool IsPatchedExosphere() {
+    constexpr u64 EvpPhysBase          = 0x6000F000;
+    constexpr u64 EvpCopResetVector    = 0x200;
+
+    SecmonArgs args = {};
+    args.X[0] = 0xF0000002;
+    args.X[1] = EvpPhysBase + EvpCopResetVector;
+    args.X[2] = 0;
+    args.X[3] = 0;
+    svcCallSecureMonitor(&args);
+
+    return args.X[0] == 0;
+}
+
+u32 SmcReadWriteRegister(u64 phys_addr, u32 mask, u32 value) {
+    SecmonArgs args = {};
+    args.X[0] = 0xF0000002;
+    args.X[1] = phys_addr;
+    args.X[2] = mask;
+    args.X[3] = value;
+    svcCallSecureMonitor(&args);
+    return (u32)args.X[1];
 }

Source/hoc-clk/sysmodule/src/mapping/mem_map.hpp

@@ -22,3 +22,5 @@ Result QueryMemoryMapping(u64 *virtaddr, u64 physaddr, u64 size);
 Result MapAddress(u64 &va, const u64 &physAddr, const char *name);
 Result SmcCopyFromIram(void *dest, uintptr_t src, u32 size);
 Result SmcCopyToIram(uintptr_t dest, const void *src, u32 size);
+bool IsPatchedExosphere();
+u32 SmcReadWriteRegister(u64 phys_addr, u32 mask, u32 value);