Diamond75/Panda3DS
1
0
Fork 0
mirror of https://github.com/wheremyfoodat/Panda3DS.git synced 2025-04-06 22:25:41 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add CXI ROM support

Browse source 
Co-Authored-By: Kelpsy <138107494+Kelpsyberry@users.noreply.github.com>
This commit is contained in:
wheremyfoodat 2023-07-06 16:21:26 +03:00
parent 4e5eb884ed
commit 187feb5772
4 changed files with 118 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
include/emulator.hpp
View file

@ -13,7 +13,7 @@
#include "memory.hpp"
#include "gl_state.hpp"
enum class ROMType { None, ELF, NCSD };
enum class ROMType { None, ELF, NCSD, CXI };
class Emulator {
CPU cpu;
@ -54,7 +54,7 @@ class Emulator {
void runFrame();
bool loadROM(const std::filesystem::path& path);
bool loadNCSD(const std::filesystem::path& path);
bool loadNCSD(const std::filesystem::path& path, ROMType type);
bool loadELF(const std::filesystem::path& path);
bool loadELF(std::ifstream& file);
void initGraphicsContext();

5
include/memory.hpp
View file

@ -150,7 +150,10 @@ public:
void* getReadPointer(u32 address);
void* getWritePointer(u32 address);
std::optional<u32> loadELF(std::ifstream& file);
std::optional<NCSD> loadNCSD(Crypto::AESEngine &aesEngine, const std::filesystem::path& path);
std::optional<NCSD> loadNCSD(Crypto::AESEngine& aesEngine, const std::filesystem::path& path);
std::optional<NCSD> loadCXI(Crypto::AESEngine& aesEngine, const std::filesystem::path& path);
bool mapCXI(NCSD& ncsd, NCCH& cxi);
u8 read8(u32 vaddr);
u16 read16(u32 vaddr);

151
src/core/loader/ncsd.cpp
View file

@ -3,6 +3,56 @@
#include "loader/ncsd.hpp"
#include "memory.hpp"
bool Memory::mapCXI(NCSD& ncsd, NCCH& cxi) {
printf("Text address = %08X, size = %08X\n", cxi.text.address, cxi.text.size);
printf("Rodata address = %08X, size = %08X\n", cxi.rodata.address, cxi.rodata.size);
printf("Data address = %08X, size = %08X\n", cxi.data.address, cxi.data.size);
// Map code file to memory
auto& code = cxi.codeFile;
u32 bssSize = (cxi.bssSize + 0xfff) & ~0xfff; // Round BSS size up to a page boundary
// Total memory to allocate for loading
u32 totalSize = (cxi.text.pageCount + cxi.rodata.pageCount + cxi.data.pageCount) * pageSize + bssSize;
code.resize(code.size() + bssSize, 0); // Pad the .code file with zeroes for the BSS segment
if (code.size() < totalSize) {
Helpers::panic("Total code size as reported by the exheader is larger than the .code file");
return false;
}
const auto opt = findPaddr(totalSize);
if (!opt.has_value()) {
Helpers::panic("Failed to find paddr to map CXI file's code to");
return false;
}
const auto paddr = opt.value();
std::memcpy(&fcram[paddr], &code[0], totalSize); // Copy the 3 segments + BSS to FCRAM
// Map the ROM on the kernel side
u32 textOffset = 0;
u32 textAddr = cxi.text.address;
u32 textSize = cxi.text.pageCount * pageSize;
u32 rodataOffset = textOffset + textSize;
u32 rodataAddr = cxi.rodata.address;
u32 rodataSize = cxi.rodata.pageCount * pageSize;
u32 dataOffset = rodataOffset + rodataSize;
u32 dataAddr = cxi.data.address;
u32 dataSize = cxi.data.pageCount * pageSize + bssSize; // We're merging the data and BSS segments, as BSS is just pre-initted .data
allocateMemory(textAddr, paddr + textOffset, textSize, true, true, false, true); // Text is R-X
allocateMemory(rodataAddr, paddr + rodataOffset, rodataSize, true, true, false, false); // Rodata is R--
allocateMemory(dataAddr, paddr + dataOffset, dataSize, true, true, true, false); // Data+BSS is RW-
ncsd.entrypoint = textAddr;
// Back the IOFile for accessing the ROM, as well as the ROM's CXI partition, in the memory class.
CXIFile = ncsd.file;
loadedCXI = cxi;
}
std::optional<NCSD> Memory::loadNCSD(Crypto::AESEngine &aesEngine, const std::filesystem::path& path) {
NCSD ncsd;
if (!ncsd.file.open(path, "rb"))
@ -69,53 +119,60 @@ std::optional<NCSD> Memory::loadNCSD(Crypto::AESEngine &aesEngine, const std::fi
return std::nullopt;
}
printf("Text address = %08X, size = %08X\n", cxi.text.address, cxi.text.size);
printf("Rodata address = %08X, size = %08X\n", cxi.rodata.address, cxi.rodata.size);
printf("Data address = %08X, size = %08X\n", cxi.data.address, cxi.data.size);
// Map code file to memory
auto& code = cxi.codeFile;
u32 bssSize = (cxi.bssSize + 0xfff) & ~0xfff; // Round BSS size up to a page boundary
// Total memory to allocate for loading
u32 totalSize = (cxi.text.pageCount + cxi.rodata.pageCount + cxi.data.pageCount) * pageSize + bssSize;
code.resize(code.size() + bssSize, 0); // Pad the .code file with zeroes for the BSS segment
if (code.size() < totalSize) {
Helpers::panic("Total code size as reported by the exheader is larger than the .code file");
return std::nullopt;
}
const auto opt = findPaddr(totalSize);
if (!opt.has_value()) {
Helpers::panic("Failed to find paddr to map CXI file's code to");
return std::nullopt;
}
const auto paddr = opt.value();
std::memcpy(&fcram[paddr], &code[0], totalSize); // Copy the 3 segments + BSS to FCRAM
// Map the ROM on the kernel side
u32 textOffset = 0;
u32 textAddr = cxi.text.address;
u32 textSize = cxi.text.pageCount * pageSize;
u32 rodataOffset = textOffset + textSize;
u32 rodataAddr = cxi.rodata.address;
u32 rodataSize = cxi.rodata.pageCount * pageSize;
u32 dataOffset = rodataOffset + rodataSize;
u32 dataAddr = cxi.data.address;
u32 dataSize = cxi.data.pageCount * pageSize + bssSize; // We're merging the data and BSS segments, as BSS is just pre-initted .data
allocateMemory(textAddr, paddr + textOffset, textSize, true, true, false, true); // Text is R-X
allocateMemory(rodataAddr, paddr + rodataOffset, rodataSize, true, true, false, false); // Rodata is R--
allocateMemory(dataAddr, paddr + dataOffset, dataSize, true, true, true, false); // Data+BSS is RW-
ncsd.entrypoint = textAddr;
// Back the IOFile for accessing the ROM, as well as the ROM's CXI partition, in the memory class.
CXIFile = ncsd.file;
loadedCXI = cxi;
if (!mapCXI(ncsd, cxi)) {
printf("Failed to map CXI\n");
return std::nullopt;
}
return ncsd;
}
// We are lazy so we take CXI files, easily "convert" them to NCSD internally, then use our existing NCSD infrastructure
// This is easy because NCSD is just CXI + some more NCCH partitions, which we can make empty when converting to NCSD
std::optional<NCSD> Memory::loadCXI(Crypto::AESEngine& aesEngine, const std::filesystem::path& path) {
NCSD ncsd;
if (!ncsd.file.open(path, "rb")) {
return std::nullopt;
}
// Make partitions 1 through 8 of the converted NCSD empty
// Partition 0 (CXI partition of an NCSD) is the only one we care about
for (int i = 1; i < 8; i++) {
auto& partition = ncsd.partitions[i];
NCCH& ncch = partition.ncch;
partition.offset = 0ull;
partition.length = 0ull;
ncch.partitionIndex = i;
ncch.fileOffset = partition.offset;
}
auto& cxiPartition = ncsd.partitions[0];
auto& cxi = cxiPartition.ncch;
std::optional<u64> size = ncsd.file.size();
if (!size.has_value()) {
return std::nullopt;
}
cxiPartition.offset = 0ull;
cxiPartition.length = size.value();
NCCH::FSInfo cxiInfo{.offset = cxiPartition.offset, .size = cxiPartition.length, .hashRegionSize = 0, .encryptionInfo = std::nullopt};
if (!cxi.loadFromHeader(aesEngine, ncsd.file, cxiInfo)) {
printf("Invalid CXI partition\n");
return std::nullopt;
}
if (!cxi.hasExtendedHeader() || !cxi.hasCode()) {
printf("CXI does not have exheader or code file?\n");
return std::nullopt;
}
if (!mapCXI(ncsd, cxi)) {
printf("Failed to map CXI\n");
return std::nullopt;
}
return ncsd;
}

12
src/emulator.cpp
View file

@ -288,16 +288,20 @@ bool Emulator::loadROM(const std::filesystem::path& path) {
if (extension == ".elf" || extension == ".axf")
return loadELF(path);
else if (extension == ".3ds")
return loadNCSD(path);
return loadNCSD(path, ROMType::NCSD);
else if (extension == ".cxi")
return loadNCSD(path, ROMType::CXI);
else {
printf("Unknown file type\n");
return false;
}
}
bool Emulator::loadNCSD(const std::filesystem::path& path) {
romType = ROMType::NCSD;
std::optional<NCSD> opt = memory.loadNCSD(aesEngine, path);
// Used for loading both CXI and NCSD files since they are both so similar and use the same interface
// (We promote CXI files to NCSD internally for ease)
bool Emulator::loadNCSD(const std::filesystem::path& path, ROMType type) {
romType = type;
std::optional<NCSD> opt = (type == ROMType::NCSD) ? memory.loadNCSD(aesEngine, path) : memory.loadCXI(aesEngine, path);
if (!opt.has_value()) {
return false;