2022-04-23 10:59:50 +02:00
|
|
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2020-04-05 20:48:50 +02:00
|
|
|
|
|
|
|
#include <random>
|
|
|
|
|
2021-06-23 23:18:27 +02:00
|
|
|
#include "common/literals.h"
|
2022-02-21 21:37:59 +01:00
|
|
|
#include "common/settings.h"
|
2021-06-23 23:18:27 +02:00
|
|
|
|
2021-03-20 08:23:06 +01:00
|
|
|
#include "core/hle/kernel/board/nintendo/nx/k_system_control.h"
|
|
|
|
#include "core/hle/kernel/board/nintendo/nx/secure_monitor.h"
|
|
|
|
#include "core/hle/kernel/k_trace.h"
|
2021-02-12 03:55:22 +01:00
|
|
|
|
2021-02-19 03:38:23 +01:00
|
|
|
namespace Kernel::Board::Nintendo::Nx {
|
|
|
|
|
2021-03-20 08:23:06 +01:00
|
|
|
namespace impl {
|
|
|
|
|
2021-03-24 02:33:29 +01:00
|
|
|
constexpr const std::size_t RequiredNonSecureSystemMemorySizeVi = 0x2238 * 4 * 1024;
|
|
|
|
constexpr const std::size_t RequiredNonSecureSystemMemorySizeNvservices = 0x710 * 4 * 1024;
|
|
|
|
constexpr const std::size_t RequiredNonSecureSystemMemorySizeMisc = 0x80 * 4 * 1024;
|
2021-03-20 08:23:06 +01:00
|
|
|
|
|
|
|
} // namespace impl
|
|
|
|
|
2021-03-24 02:33:29 +01:00
|
|
|
constexpr const std::size_t RequiredNonSecureSystemMemorySize =
|
2021-03-20 08:23:06 +01:00
|
|
|
impl::RequiredNonSecureSystemMemorySizeVi + impl::RequiredNonSecureSystemMemorySizeNvservices +
|
|
|
|
impl::RequiredNonSecureSystemMemorySizeMisc;
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
2021-06-23 23:18:27 +02:00
|
|
|
using namespace Common::Literals;
|
|
|
|
|
2021-03-20 08:23:06 +01:00
|
|
|
u32 GetMemorySizeForInit() {
|
2022-02-21 21:37:59 +01:00
|
|
|
return Settings::values.use_extended_memory_layout ? Smc::MemorySize_6GB : Smc::MemorySize_4GB;
|
2021-03-20 08:23:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Smc::MemoryArrangement GetMemoryArrangeForInit() {
|
2022-02-21 21:37:59 +01:00
|
|
|
return Settings::values.use_extended_memory_layout ? Smc::MemoryArrangement_6GB
|
|
|
|
: Smc::MemoryArrangement_4GB;
|
2021-03-20 08:23:06 +01:00
|
|
|
}
|
|
|
|
} // namespace
|
|
|
|
|
2022-02-22 02:05:19 +01:00
|
|
|
size_t KSystemControl::Init::GetRealMemorySize() {
|
|
|
|
return GetIntendedMemorySize();
|
|
|
|
}
|
|
|
|
|
2021-03-20 08:23:06 +01:00
|
|
|
// Initialization.
|
|
|
|
size_t KSystemControl::Init::GetIntendedMemorySize() {
|
|
|
|
switch (GetMemorySizeForInit()) {
|
|
|
|
case Smc::MemorySize_4GB:
|
|
|
|
default: // All invalid modes should go to 4GB.
|
2021-06-23 23:18:27 +02:00
|
|
|
return 4_GiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
case Smc::MemorySize_6GB:
|
2021-06-23 23:18:27 +02:00
|
|
|
return 6_GiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
case Smc::MemorySize_8GB:
|
2021-06-23 23:18:27 +02:00
|
|
|
return 8_GiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PAddr KSystemControl::Init::GetKernelPhysicalBaseAddress(u64 base_address) {
|
2022-02-22 02:05:19 +01:00
|
|
|
const size_t real_dram_size = KSystemControl::Init::GetRealMemorySize();
|
|
|
|
const size_t intended_dram_size = KSystemControl::Init::GetIntendedMemorySize();
|
|
|
|
if (intended_dram_size * 2 < real_dram_size) {
|
|
|
|
return base_address;
|
|
|
|
} else {
|
|
|
|
return base_address + ((real_dram_size - intended_dram_size) / 2);
|
|
|
|
}
|
2021-03-20 08:23:06 +01:00
|
|
|
}
|
|
|
|
|
2021-02-19 03:38:23 +01:00
|
|
|
bool KSystemControl::Init::ShouldIncreaseThreadResourceLimit() {
|
|
|
|
return true;
|
|
|
|
}
|
2020-04-05 20:48:50 +02:00
|
|
|
|
2021-03-20 08:23:06 +01:00
|
|
|
std::size_t KSystemControl::Init::GetApplicationPoolSize() {
|
|
|
|
// Get the base pool size.
|
|
|
|
const size_t base_pool_size = []() -> size_t {
|
|
|
|
switch (GetMemoryArrangeForInit()) {
|
|
|
|
case Smc::MemoryArrangement_4GB:
|
|
|
|
default:
|
2021-06-23 23:18:27 +02:00
|
|
|
return 3285_MiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
case Smc::MemoryArrangement_4GBForAppletDev:
|
2021-06-23 23:18:27 +02:00
|
|
|
return 2048_MiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
case Smc::MemoryArrangement_4GBForSystemDev:
|
2021-06-23 23:18:27 +02:00
|
|
|
return 3285_MiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
case Smc::MemoryArrangement_6GB:
|
2021-06-23 23:18:27 +02:00
|
|
|
return 4916_MiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
case Smc::MemoryArrangement_6GBForAppletDev:
|
2021-06-23 23:18:27 +02:00
|
|
|
return 3285_MiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
case Smc::MemoryArrangement_8GB:
|
2021-06-23 23:18:27 +02:00
|
|
|
return 4916_MiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
}
|
|
|
|
}();
|
|
|
|
|
|
|
|
// Return (possibly) adjusted size.
|
|
|
|
return base_pool_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t KSystemControl::Init::GetAppletPoolSize() {
|
|
|
|
// Get the base pool size.
|
|
|
|
const size_t base_pool_size = []() -> size_t {
|
|
|
|
switch (GetMemoryArrangeForInit()) {
|
|
|
|
case Smc::MemoryArrangement_4GB:
|
|
|
|
default:
|
2021-06-23 23:18:27 +02:00
|
|
|
return 507_MiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
case Smc::MemoryArrangement_4GBForAppletDev:
|
2021-06-23 23:18:27 +02:00
|
|
|
return 1554_MiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
case Smc::MemoryArrangement_4GBForSystemDev:
|
2021-06-23 23:18:27 +02:00
|
|
|
return 448_MiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
case Smc::MemoryArrangement_6GB:
|
2021-06-23 23:18:27 +02:00
|
|
|
return 562_MiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
case Smc::MemoryArrangement_6GBForAppletDev:
|
2021-06-23 23:18:27 +02:00
|
|
|
return 2193_MiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
case Smc::MemoryArrangement_8GB:
|
2021-06-23 23:18:27 +02:00
|
|
|
return 2193_MiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
}
|
|
|
|
}();
|
|
|
|
|
|
|
|
// Return (possibly) adjusted size.
|
2021-06-23 23:18:27 +02:00
|
|
|
constexpr size_t ExtraSystemMemoryForAtmosphere = 33_MiB;
|
2021-03-20 08:23:06 +01:00
|
|
|
return base_pool_size - ExtraSystemMemoryForAtmosphere - KTraceBufferSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t KSystemControl::Init::GetMinimumNonSecureSystemPoolSize() {
|
|
|
|
// Verify that our minimum is at least as large as Nintendo's.
|
|
|
|
constexpr size_t MinimumSize = RequiredNonSecureSystemMemorySize;
|
|
|
|
static_assert(MinimumSize >= 0x29C8000);
|
|
|
|
|
|
|
|
return MinimumSize;
|
|
|
|
}
|
|
|
|
|
2020-08-05 21:33:09 +02:00
|
|
|
namespace {
|
2020-04-05 20:48:50 +02:00
|
|
|
template <typename F>
|
|
|
|
u64 GenerateUniformRange(u64 min, u64 max, F f) {
|
2020-08-05 21:33:09 +02:00
|
|
|
// Handle the case where the difference is too large to represent.
|
2020-04-05 20:48:50 +02:00
|
|
|
if (max == std::numeric_limits<u64>::max() && min == std::numeric_limits<u64>::min()) {
|
|
|
|
return f();
|
|
|
|
}
|
|
|
|
|
2020-08-05 21:33:09 +02:00
|
|
|
// Iterate until we get a value in range.
|
2020-04-05 20:48:50 +02:00
|
|
|
const u64 range_size = ((max + 1) - min);
|
|
|
|
const u64 effective_max = (std::numeric_limits<u64>::max() / range_size) * range_size;
|
|
|
|
while (true) {
|
|
|
|
if (const u64 rnd = f(); rnd < effective_max) {
|
|
|
|
return min + (rnd % range_size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-09 03:08:08 +01:00
|
|
|
} // Anonymous namespace
|
|
|
|
|
2021-02-12 03:55:22 +01:00
|
|
|
u64 KSystemControl::GenerateRandomU64() {
|
2022-04-05 06:37:46 +02:00
|
|
|
std::random_device device;
|
|
|
|
std::mt19937 gen(device());
|
|
|
|
std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
|
2020-08-05 21:33:09 +02:00
|
|
|
return distribution(gen);
|
|
|
|
}
|
|
|
|
|
2021-02-12 03:55:22 +01:00
|
|
|
u64 KSystemControl::GenerateRandomRange(u64 min, u64 max) {
|
2021-02-09 03:08:08 +01:00
|
|
|
return GenerateUniformRange(min, max, GenerateRandomU64);
|
2020-04-05 20:48:50 +02:00
|
|
|
}
|
|
|
|
|
2021-02-19 03:38:23 +01:00
|
|
|
} // namespace Kernel::Board::Nintendo::Nx
|