Diamond75/Panda3DS
1
0
Fork 0
mirror of https://github.com/wheremyfoodat/Panda3DS.git synced 2025-04-09 23:55:40 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #72 from wheremyfoodat/cxi

Browse source 
Add CXI ROM support
This commit is contained in:
wheremyfoodat 2023-07-06 16:45:28 +03:00 • committed by GitHub
commit cb64b721e8
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 166 additions and 101 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 "memory.hpp"
#include "gl_state.hpp" #include "gl_state.hpp"
enum class ROMType { None, ELF, NCSD }; enum class ROMType { None, ELF, NCSD, CXI };
class Emulator { class Emulator {
CPU cpu; CPU cpu;
@ -54,7 +54,7 @@ class Emulator {
void runFrame(); void runFrame();
bool loadROM(const std::filesystem::path& path); 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(const std::filesystem::path& path);
bool loadELF(std::ifstream& file); bool loadELF(std::ifstream& file);
void initGraphicsContext(); void initGraphicsContext();

5
include/memory.hpp
View file

@ -150,7 +150,10 @@ public:
void* getReadPointer(u32 address); void* getReadPointer(u32 address);
void* getWritePointer(u32 address); void* getWritePointer(u32 address);
std::optional<u32> loadELF(std::ifstream& file); 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); u8 read8(u32 vaddr);
u16 read16(u32 vaddr); u16 read16(u32 vaddr);

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

@ -1,121 +1,179 @@
#include "loader/ncsd.hpp"
#include <cstring> #include <cstring>
#include <optional> #include <optional>
#include "loader/ncsd.hpp"
#include "memory.hpp" #include "memory.hpp"
std::optional<NCSD> Memory::loadNCSD(Crypto::AESEngine &aesEngine, const std::filesystem::path& path) { bool Memory::mapCXI(NCSD& ncsd, NCCH& cxi) {
NCSD ncsd; printf("Text address = %08X, size = %08X\n", cxi.text.address, cxi.text.size);
if (!ncsd.file.open(path, "rb")) printf("Rodata address = %08X, size = %08X\n", cxi.rodata.address, cxi.rodata.size);
return std::nullopt; printf("Data address = %08X, size = %08X\n", cxi.data.address, cxi.data.size);
u8 magic[4]; // Must be "NCSD" // Map code file to memory
ncsd.file.seek(0x100); auto& code = cxi.codeFile;
auto [success, bytes] = ncsd.file.readBytes(magic, 4); 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 (!success || bytes != 4) { if (code.size() < totalSize) {
printf("Failed to read NCSD magic\n"); Helpers::panic("Total code size as reported by the exheader is larger than the .code file");
return std::nullopt; return false;
} }
if (magic[0] != 'N' || magic[1] != 'C' || magic[2] != 'S' || magic[3] != 'D') { const auto opt = findPaddr(totalSize);
printf("NCSD with wrong magic value\n"); if (!opt.has_value()) {
return std::nullopt; Helpers::panic("Failed to find paddr to map CXI file's code to");
} return false;
}
std::tie(success, bytes) = ncsd.file.readBytes(&ncsd.size, 4); const auto paddr = opt.value();
if (!success || bytes != 4) { std::memcpy(&fcram[paddr], &code[0], totalSize); // Copy the 3 segments + BSS to FCRAM
printf("Failed to read NCSD size\n");
return std::nullopt;
}
ncsd.size *= NCSD::mediaUnit; // Convert size to bytes // Map the ROM on the kernel side
u32 textOffset = 0;
u32 textAddr = cxi.text.address;
u32 textSize = cxi.text.pageCount * pageSize;
// Read partition data u32 rodataOffset = textOffset + textSize;
ncsd.file.seek(0x120); u32 rodataAddr = cxi.rodata.address;
// 2 u32s per partition (offset and length), 8 partitions total u32 rodataSize = cxi.rodata.pageCount * pageSize;
constexpr size_t partitionDataSize = 8 * 2; // Size of partition in u32s
u32 partitionData[8 * 2];
std::tie(success, bytes) = ncsd.file.read(partitionData, partitionDataSize, sizeof(u32));
if (!success || bytes != partitionDataSize) {
printf("Failed to read NCSD partition data\n");
return std::nullopt;
}
for (int i = 0; i < 8; i++) { u32 dataOffset = rodataOffset + rodataSize;
auto& partition = ncsd.partitions[i]; u32 dataAddr = cxi.data.address;
NCCH& ncch = partition.ncch; u32 dataSize = cxi.data.pageCount * pageSize + bssSize; // We're merging the data and BSS segments, as BSS is just pre-initted .data
partition.offset = u64(partitionData[i * 2]) * NCSD::mediaUnit;
partition.length = u64(partitionData[i * 2 + 1]) * NCSD::mediaUnit;
ncch.partitionIndex = i; allocateMemory(textAddr, paddr + textOffset, textSize, true, true, false, true); // Text is R-X
ncch.fileOffset = partition.offset; 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-
if (partition.length != 0) { // Initialize the NCCH of each partition ncsd.entrypoint = textAddr;
NCCH::FSInfo ncchFsInfo;
ncchFsInfo.offset = partition.offset; // Back the IOFile for accessing the ROM, as well as the ROM's CXI partition, in the memory class.
ncchFsInfo.size = partition.length; CXIFile = ncsd.file;
loadedCXI = cxi;
}
if (!ncch.loadFromHeader(aesEngine, ncsd.file, ncchFsInfo)) { std::optional<NCSD> Memory::loadNCSD(Crypto::AESEngine& aesEngine, const std::filesystem::path& path) {
printf("Invalid NCCH partition\n"); NCSD ncsd;
return std::nullopt; if (!ncsd.file.open(path, "rb")) return std::nullopt;
}
}
}
auto& cxi = ncsd.partitions[0].ncch;
if (!cxi.hasExtendedHeader() || !cxi.hasCode()) {
printf("NCSD with an invalid CXI in partition 0?\n");
return std::nullopt;
}
printf("Text address = %08X, size = %08X\n", cxi.text.address, cxi.text.size); u8 magic[4]; // Must be "NCSD"
printf("Rodata address = %08X, size = %08X\n", cxi.rodata.address, cxi.rodata.size); ncsd.file.seek(0x100);
printf("Data address = %08X, size = %08X\n", cxi.data.address, cxi.data.size); auto [success, bytes] = ncsd.file.readBytes(magic, 4);
// 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) { if (!success || bytes != 4) {
Helpers::panic("Total code size as reported by the exheader is larger than the .code file"); printf("Failed to read NCSD magic\n");
return std::nullopt; return std::nullopt;
} }
const auto opt = findPaddr(totalSize); if (magic[0] != 'N' || magic[1] != 'C' || magic[2] != 'S' || magic[3] != 'D') {
if (!opt.has_value()) { printf("NCSD with wrong magic value\n");
Helpers::panic("Failed to find paddr to map CXI file's code to"); return std::nullopt;
return std::nullopt; }
}
const auto paddr = opt.value(); std::tie(success, bytes) = ncsd.file.readBytes(&ncsd.size, 4);
std::memcpy(&fcram[paddr], &code[0], totalSize); // Copy the 3 segments + BSS to FCRAM if (!success || bytes != 4) {
printf("Failed to read NCSD size\n");
return std::nullopt;
}
// Map the ROM on the kernel side ncsd.size *= NCSD::mediaUnit; // Convert size to bytes
u32 textOffset = 0;
u32 textAddr = cxi.text.address;
u32 textSize = cxi.text.pageCount * pageSize;
u32 rodataOffset = textOffset + textSize; // Read partition data
u32 rodataAddr = cxi.rodata.address; ncsd.file.seek(0x120);
u32 rodataSize = cxi.rodata.pageCount * pageSize; // 2 u32s per partition (offset and length), 8 partitions total
constexpr size_t partitionDataSize = 8 * 2; // Size of partition in u32s
u32 partitionData[8 * 2];
std::tie(success, bytes) = ncsd.file.read(partitionData, partitionDataSize, sizeof(u32));
if (!success || bytes != partitionDataSize) {
printf("Failed to read NCSD partition data\n");
return std::nullopt;
}
u32 dataOffset = rodataOffset + rodataSize; for (int i = 0; i < 8; i++) {
u32 dataAddr = cxi.data.address; auto& partition = ncsd.partitions[i];
u32 dataSize = cxi.data.pageCount * pageSize + bssSize; // We're merging the data and BSS segments, as BSS is just pre-initted .data NCCH& ncch = partition.ncch;
partition.offset = u64(partitionData[i * 2]) * NCSD::mediaUnit;
partition.length = u64(partitionData[i * 2 + 1]) * NCSD::mediaUnit;
allocateMemory(textAddr, paddr + textOffset, textSize, true, true, false, true); // Text is R-X ncch.partitionIndex = i;
allocateMemory(rodataAddr, paddr + rodataOffset, rodataSize, true, true, false, false); // Rodata is R-- ncch.fileOffset = partition.offset;
allocateMemory(dataAddr, paddr + dataOffset, dataSize, true, true, true, false); // Data+BSS is RW-
ncsd.entrypoint = textAddr; if (partition.length != 0) { // Initialize the NCCH of each partition
NCCH::FSInfo ncchFsInfo;
// Back the IOFile for accessing the ROM, as well as the ROM's CXI partition, in the memory class. ncchFsInfo.offset = partition.offset;
CXIFile = ncsd.file; ncchFsInfo.size = partition.length;
loadedCXI = cxi;
return ncsd; if (!ncch.loadFromHeader(aesEngine, ncsd.file, ncchFsInfo)) {
printf("Invalid NCCH partition\n");
return std::nullopt;
}
}
}
auto& cxi = ncsd.partitions[0].ncch;
if (!cxi.hasExtendedHeader() || !cxi.hasCode()) {
printf("NCSD with an invalid CXI in partition 0?\n");
return std::nullopt;
}
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") if (extension == ".elf" || extension == ".axf")
return loadELF(path); return loadELF(path);
else if (extension == ".3ds") else if (extension == ".3ds")
return loadNCSD(path); return loadNCSD(path, ROMType::NCSD);
else if (extension == ".cxi")
return loadNCSD(path, ROMType::CXI);
else { else {
printf("Unknown file type\n"); printf("Unknown file type\n");
return false; return false;
} }
} }
bool Emulator::loadNCSD(const std::filesystem::path& path) { // Used for loading both CXI and NCSD files since they are both so similar and use the same interface
romType = ROMType::NCSD; // (We promote CXI files to NCSD internally for ease)
std::optional<NCSD> opt = memory.loadNCSD(aesEngine, path); 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()) { if (!opt.has_value()) {
return false; return false;