artemist/yuzu
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

common: common_sizes: Move sizes to the Common namespace.

Browse source
This commit is contained in:
bunnei 2021-03-23 18:31:46 -07:00
parent 1d78190843
commit ab5995c7ae
5 changed files with 50 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/common/common_sizes.h
View file

@ -8,6 +8,8 @@
#include "common/common_types.h" #include "common/common_types.h"
namespace Common {
enum : u64 { enum : u64 {
Size_1_KB = 0x400ULL, Size_1_KB = 0x400ULL,
Size_64_KB = 64ULL * Size_1_KB, Size_64_KB = 64ULL * Size_1_KB,
@ -37,3 +39,5 @@ enum : u64 {
Size_512_GB = 512ULL * Size_1_GB, Size_512_GB = 512ULL * Size_1_GB,
Size_Invalid = std::numeric_limits<u64>::max(), Size_Invalid = std::numeric_limits<u64>::max(),
}; };
} // namespace Common

32
src/core/hle/kernel/board/nintendo/nx/k_system_control.cpp
View file

@ -57,11 +57,11 @@ size_t KSystemControl::Init::GetIntendedMemorySize() {
switch (GetMemorySizeForInit()) { switch (GetMemorySizeForInit()) {
case Smc::MemorySize_4GB: case Smc::MemorySize_4GB:
default: // All invalid modes should go to 4GB. default: // All invalid modes should go to 4GB.
return Size_4_GB; return Common::Size_4_GB;
case Smc::MemorySize_6GB: case Smc::MemorySize_6GB:
return Size_6_GB; return Common::Size_6_GB;
case Smc::MemorySize_8GB: case Smc::MemorySize_8GB:
return Size_8_GB; return Common::Size_8_GB;
} }
} }
@ -79,17 +79,17 @@ std::size_t KSystemControl::Init::GetApplicationPoolSize() {
switch (GetMemoryArrangeForInit()) { switch (GetMemoryArrangeForInit()) {
case Smc::MemoryArrangement_4GB: case Smc::MemoryArrangement_4GB:
default: default:
return Size_3285_MB; return Common::Size_3285_MB;
case Smc::MemoryArrangement_4GBForAppletDev: case Smc::MemoryArrangement_4GBForAppletDev:
return Size_2048_MB; return Common::Size_2048_MB;
case Smc::MemoryArrangement_4GBForSystemDev: case Smc::MemoryArrangement_4GBForSystemDev:
return Size_3285_MB; return Common::Size_3285_MB;
case Smc::MemoryArrangement_6GB: case Smc::MemoryArrangement_6GB:
return Size_4916_MB; return Common::Size_4916_MB;
case Smc::MemoryArrangement_6GBForAppletDev: case Smc::MemoryArrangement_6GBForAppletDev:
return Size_3285_MB; return Common::Size_3285_MB;
case Smc::MemoryArrangement_8GB: case Smc::MemoryArrangement_8GB:
return Size_4916_MB; return Common::Size_4916_MB;
} }
}(); }();
@ -103,22 +103,22 @@ size_t KSystemControl::Init::GetAppletPoolSize() {
switch (GetMemoryArrangeForInit()) { switch (GetMemoryArrangeForInit()) {
case Smc::MemoryArrangement_4GB: case Smc::MemoryArrangement_4GB:
default: default:
return Size_507_MB; return Common::Size_507_MB;
case Smc::MemoryArrangement_4GBForAppletDev: case Smc::MemoryArrangement_4GBForAppletDev:
return Size_1554_MB; return Common::Size_1554_MB;
case Smc::MemoryArrangement_4GBForSystemDev: case Smc::MemoryArrangement_4GBForSystemDev:
return Size_448_MB; return Common::Size_448_MB;
case Smc::MemoryArrangement_6GB: case Smc::MemoryArrangement_6GB:
return Size_562_MB; return Common::Size_562_MB;
case Smc::MemoryArrangement_6GBForAppletDev: case Smc::MemoryArrangement_6GBForAppletDev:
return Size_2193_MB; return Common::Size_2193_MB;
case Smc::MemoryArrangement_8GB: case Smc::MemoryArrangement_8GB:
return Size_2193_MB; return Common::Size_2193_MB;
} }
}(); }();
// Return (possibly) adjusted size. // Return (possibly) adjusted size.
constexpr size_t ExtraSystemMemoryForAtmosphere = Size_33_MB; constexpr size_t ExtraSystemMemoryForAtmosphere = Common::Size_33_MB;
return base_pool_size - ExtraSystemMemoryForAtmosphere - KTraceBufferSize; return base_pool_size - ExtraSystemMemoryForAtmosphere - KTraceBufferSize;
} }

29
src/core/hle/kernel/k_address_space_info.cpp
View file

@ -14,24 +14,25 @@ namespace {
// clang-format off // clang-format off
constexpr std::array<KAddressSpaceInfo, 13> AddressSpaceInfos{{ constexpr std::array<KAddressSpaceInfo, 13> AddressSpaceInfos{{
{ .bit_width = 32, .address = Size_2_MB , .size = Size_1_GB - Size_2_MB , .type = KAddressSpaceInfo::Type::MapSmall, }, { .bit_width = 32, .address = Common::Size_2_MB , .size = Common::Size_1_GB - Common::Size_2_MB , .type = KAddressSpaceInfo::Type::MapSmall, },
{ .bit_width = 32, .address = Size_1_GB , .size = Size_4_GB - Size_1_GB , .type = KAddressSpaceInfo::Type::MapLarge, }, { .bit_width = 32, .address = Common::Size_1_GB , .size = Common::Size_4_GB - Common::Size_1_GB , .type = KAddressSpaceInfo::Type::MapLarge, },
{ .bit_width = 32, .address = Size_Invalid, .size = Size_1_GB , .type = KAddressSpaceInfo::Type::Heap, }, { .bit_width = 32, .address = Common::Size_Invalid, .size = Common::Size_1_GB , .type = KAddressSpaceInfo::Type::Alias, },
{ .bit_width = 32, .address = Size_Invalid, .size = Size_1_GB , .type = KAddressSpaceInfo::Type::Alias, }, { .bit_width = 32, .address = Common::Size_Invalid, .size = Common::Size_1_GB , .type = KAddressSpaceInfo::Type::Heap, },
{ .bit_width = 36, .address = Size_128_MB , .size = Size_2_GB - Size_128_MB, .type = KAddressSpaceInfo::Type::MapSmall, }, { .bit_width = 36, .address = Common::Size_128_MB , .size = Common::Size_2_GB - Common::Size_128_MB, .type = KAddressSpaceInfo::Type::MapSmall, },
{ .bit_width = 36, .address = Size_2_GB , .size = Size_64_GB - Size_2_GB , .type = KAddressSpaceInfo::Type::MapLarge, }, { .bit_width = 36, .address = Common::Size_2_GB , .size = Common::Size_64_GB - Common::Size_2_GB , .type = KAddressSpaceInfo::Type::MapLarge, },
{ .bit_width = 36, .address = Size_Invalid, .size = Size_6_GB , .type = KAddressSpaceInfo::Type::Heap, }, { .bit_width = 36, .address = Common::Size_Invalid, .size = Common::Size_6_GB , .type = KAddressSpaceInfo::Type::Heap, },
{ .bit_width = 36, .address = Size_Invalid, .size = Size_6_GB , .type = KAddressSpaceInfo::Type::Alias, }, { .bit_width = 36, .address = Common::Size_Invalid, .size = Common::Size_6_GB , .type = KAddressSpaceInfo::Type::Alias, },
{ .bit_width = 39, .address = Size_128_MB , .size = Size_512_GB - Size_128_MB, .type = KAddressSpaceInfo::Type::Map39Bit, }, { .bit_width = 39, .address = Common::Size_128_MB , .size = Common::Size_512_GB - Common::Size_128_MB, .type = KAddressSpaceInfo::Type::Map39Bit, },
{ .bit_width = 39, .address = Size_Invalid, .size = Size_64_GB , .type = KAddressSpaceInfo::Type::MapSmall }, { .bit_width = 39, .address = Common::Size_Invalid, .size = Common::Size_64_GB , .type = KAddressSpaceInfo::Type::MapSmall },
{ .bit_width = 39, .address = Size_Invalid, .size = Size_6_GB , .type = KAddressSpaceInfo::Type::Heap, }, { .bit_width = 39, .address = Common::Size_Invalid, .size = Common::Size_6_GB , .type = KAddressSpaceInfo::Type::Heap, },
{ .bit_width = 39, .address = Size_Invalid, .size = Size_64_GB , .type = KAddressSpaceInfo::Type::Alias, }, { .bit_width = 39, .address = Common::Size_Invalid, .size = Common::Size_64_GB , .type = KAddressSpaceInfo::Type::Alias, },
{ .bit_width = 39, .address = Size_Invalid, .size = Size_2_GB , .type = KAddressSpaceInfo::Type::Stack, }, { .bit_width = 39, .address = Common::Size_Invalid, .size = Common::Size_2_GB , .type = KAddressSpaceInfo::Type::Stack, },
}}; }};
// clang-format on // clang-format on
constexpr bool IsAllowedIndexForAddress(std::size_t index) { constexpr bool IsAllowedIndexForAddress(std::size_t index) {
return index < AddressSpaceInfos.size() && AddressSpaceInfos[index].address != Size_Invalid; return index < AddressSpaceInfos.size() &&
AddressSpaceInfos[index].address != Common::Size_Invalid;
} }
using IndexArray = using IndexArray =

16
src/core/hle/kernel/k_memory_layout.h
View file

@ -14,20 +14,20 @@
namespace Kernel { namespace Kernel {
constexpr std::size_t L1BlockSize = Size_1_GB; constexpr std::size_t L1BlockSize = Common::Size_1_GB;
constexpr std::size_t L2BlockSize = Size_2_MB; constexpr std::size_t L2BlockSize = Common::Size_2_MB;
constexpr std::size_t GetMaximumOverheadSize(std::size_t size) { constexpr std::size_t GetMaximumOverheadSize(std::size_t size) {
return (Common::DivideUp(size, L1BlockSize) + Common::DivideUp(size, L2BlockSize)) * PageSize; return (Common::DivideUp(size, L1BlockSize) + Common::DivideUp(size, L2BlockSize)) * PageSize;
} }
constexpr std::size_t MainMemorySize = Size_4_GB; constexpr std::size_t MainMemorySize = Common::Size_4_GB;
constexpr std::size_t MainMemorySizeMax = Size_8_GB; constexpr std::size_t MainMemorySizeMax = Common::Size_8_GB;
constexpr std::size_t ReservedEarlyDramSize = 0x60000; constexpr std::size_t ReservedEarlyDramSize = 0x60000;
constexpr std::size_t DramPhysicalAddress = 0x80000000; constexpr std::size_t DramPhysicalAddress = 0x80000000;
constexpr std::size_t KernelAslrAlignment = Size_2_MB; constexpr std::size_t KernelAslrAlignment = Common::Size_2_MB;
constexpr std::size_t KernelVirtualAddressSpaceWidth = 1ULL << 39; constexpr std::size_t KernelVirtualAddressSpaceWidth = 1ULL << 39;
constexpr std::size_t KernelPhysicalAddressSpaceWidth = 1ULL << 48; constexpr std::size_t KernelPhysicalAddressSpaceWidth = 1ULL << 48;
@ -51,10 +51,10 @@ constexpr std::size_t KernelPhysicalAddressSpaceSize =
constexpr std::size_t KernelPhysicalAddressCodeBase = DramPhysicalAddress + ReservedEarlyDramSize; constexpr std::size_t KernelPhysicalAddressCodeBase = DramPhysicalAddress + ReservedEarlyDramSize;
constexpr std::size_t KernelPageTableHeapSize = GetMaximumOverheadSize(MainMemorySizeMax); constexpr std::size_t KernelPageTableHeapSize = GetMaximumOverheadSize(MainMemorySizeMax);
constexpr std::size_t KernelInitialPageHeapSize = Size_128_KB; constexpr std::size_t KernelInitialPageHeapSize = Common::Size_128_KB;
constexpr std::size_t KernelSlabHeapDataSize = Size_5_MB; constexpr std::size_t KernelSlabHeapDataSize = Common::Size_5_MB;
constexpr std::size_t KernelSlabHeapGapsSize = Size_2_MB - Size_64_KB; constexpr std::size_t KernelSlabHeapGapsSize = Common::Size_2_MB - Common::Size_64_KB;
constexpr std::size_t KernelSlabHeapSize = KernelSlabHeapDataSize + KernelSlabHeapGapsSize; constexpr std::size_t KernelSlabHeapSize = KernelSlabHeapDataSize + KernelSlabHeapGapsSize;
// NOTE: This is calculated from KThread slab counts, assuming KThread size <= 0x860. // NOTE: This is calculated from KThread slab counts, assuming KThread size <= 0x860.

14
src/core/hle/kernel/kernel.cpp
View file

@ -289,8 +289,8 @@ struct KernelCore::Impl {
const VAddr code_end_virt_addr = KernelVirtualAddressCodeEnd; const VAddr code_end_virt_addr = KernelVirtualAddressCodeEnd;
// Setup the containing kernel region. // Setup the containing kernel region.
constexpr size_t KernelRegionSize = Size_1_GB; constexpr size_t KernelRegionSize = Common::Size_1_GB;
constexpr size_t KernelRegionAlign = Size_1_GB; constexpr size_t KernelRegionAlign = Common::Size_1_GB;
constexpr VAddr kernel_region_start = constexpr VAddr kernel_region_start =
Common::AlignDown(code_start_virt_addr, KernelRegionAlign); Common::AlignDown(code_start_virt_addr, KernelRegionAlign);
size_t kernel_region_size = KernelRegionSize; size_t kernel_region_size = KernelRegionSize;
@ -337,7 +337,7 @@ struct KernelCore::Impl {
// Decide on the actual size for the misc region. // Decide on the actual size for the misc region.
constexpr size_t MiscRegionAlign = KernelAslrAlignment; constexpr size_t MiscRegionAlign = KernelAslrAlignment;
constexpr size_t MiscRegionMinimumSize = Size_32_MB; constexpr size_t MiscRegionMinimumSize = Common::Size_32_MB;
const size_t misc_region_size = Common::AlignUp( const size_t misc_region_size = Common::AlignUp(
std::max(misc_region_needed_size, MiscRegionMinimumSize), MiscRegionAlign); std::max(misc_region_needed_size, MiscRegionMinimumSize), MiscRegionAlign);
ASSERT(misc_region_size > 0); ASSERT(misc_region_size > 0);
@ -350,7 +350,7 @@ struct KernelCore::Impl {
misc_region_start, misc_region_size, KMemoryRegionType_KernelMisc)); misc_region_start, misc_region_size, KMemoryRegionType_KernelMisc));
// Setup the stack region. // Setup the stack region.
constexpr size_t StackRegionSize = Size_14_MB; constexpr size_t StackRegionSize = Common::Size_14_MB;
constexpr size_t StackRegionAlign = KernelAslrAlignment; constexpr size_t StackRegionAlign = KernelAslrAlignment;
const VAddr stack_region_start = const VAddr stack_region_start =
memory_layout.GetVirtualMemoryRegionTree().GetRandomAlignedRegion( memory_layout.GetVirtualMemoryRegionTree().GetRandomAlignedRegion(
@ -382,7 +382,7 @@ struct KernelCore::Impl {
slab_region_start, slab_region_size, KMemoryRegionType_KernelSlab)); slab_region_start, slab_region_size, KMemoryRegionType_KernelSlab));
// Setup the temp region. // Setup the temp region.
constexpr size_t TempRegionSize = Size_128_MB; constexpr size_t TempRegionSize = Common::Size_128_MB;
constexpr size_t TempRegionAlign = KernelAslrAlignment; constexpr size_t TempRegionAlign = KernelAslrAlignment;
const VAddr temp_region_start = const VAddr temp_region_start =
memory_layout.GetVirtualMemoryRegionTree().GetRandomAlignedRegion( memory_layout.GetVirtualMemoryRegionTree().GetRandomAlignedRegion(
@ -438,7 +438,7 @@ struct KernelCore::Impl {
// Determine size available for kernel page table heaps, requiring > 8 MB. // Determine size available for kernel page table heaps, requiring > 8 MB.
const PAddr resource_end_phys_addr = slab_start_phys_addr + resource_region_size; const PAddr resource_end_phys_addr = slab_start_phys_addr + resource_region_size;
const size_t page_table_heap_size = resource_end_phys_addr - slab_end_phys_addr; const size_t page_table_heap_size = resource_end_phys_addr - slab_end_phys_addr;
ASSERT(page_table_heap_size / Size_4_MB > 2); ASSERT(page_table_heap_size / Common::Size_4_MB > 2);
// Insert a physical region for the kernel page table heap region // Insert a physical region for the kernel page table heap region
ASSERT(memory_layout.GetPhysicalMemoryRegionTree().Insert( ASSERT(memory_layout.GetPhysicalMemoryRegionTree().Insert(
@ -463,7 +463,7 @@ struct KernelCore::Impl {
ASSERT(linear_extents.GetEndAddress() != 0); ASSERT(linear_extents.GetEndAddress() != 0);
// Setup the linear mapping region. // Setup the linear mapping region.
constexpr size_t LinearRegionAlign = Size_1_GB; constexpr size_t LinearRegionAlign = Common::Size_1_GB;
const PAddr aligned_linear_phys_start = const PAddr aligned_linear_phys_start =
Common::AlignDown(linear_extents.GetAddress(), LinearRegionAlign); Common::AlignDown(linear_extents.GetAddress(), LinearRegionAlign);
const size_t linear_region_size = const size_t linear_region_size =