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

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 "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);

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

@ -1,121 +1,179 @@
#include "loader/ncsd.hpp"
#include <cstring>
#include <optional>
#include "loader/ncsd.hpp"
#include "memory.hpp"
std::optional<NCSD> Memory::loadNCSD(Crypto::AESEngine &aesEngine, const std::filesystem::path& path) {
NCSD ncsd;
if (!ncsd.file.open(path, "rb"))
return std::nullopt;
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);
u8 magic[4]; // Must be "NCSD"
ncsd.file.seek(0x100);
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 (!success || bytes != 4) {
printf("Failed to read NCSD magic\n");
return std::nullopt;
}
if (code.size() < totalSize) {
Helpers::panic("Total code size as reported by the exheader is larger than the .code file");
return false;
}
if (magic[0] != 'N' || magic[1] != 'C' || magic[2] != 'S' || magic[3] != 'D') {
printf("NCSD with wrong magic value\n");
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 false;
}
std::tie(success, bytes) = ncsd.file.readBytes(&ncsd.size, 4);
if (!success || bytes != 4) {
printf("Failed to read NCSD size\n");
return std::nullopt;
}
const auto paddr = opt.value();
std::memcpy(&fcram[paddr], &code[0], totalSize); // Copy the 3 segments + BSS to FCRAM
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
ncsd.file.seek(0x120);
// 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 rodataOffset = textOffset + textSize;
u32 rodataAddr = cxi.rodata.address;
u32 rodataSize = cxi.rodata.pageCount * pageSize;
for (int i = 0; i < 8; i++) {
auto& partition = ncsd.partitions[i];
NCCH& ncch = partition.ncch;
partition.offset = u64(partitionData[i * 2]) * NCSD::mediaUnit;
partition.length = u64(partitionData[i * 2 + 1]) * NCSD::mediaUnit;
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
ncch.partitionIndex = i;
ncch.fileOffset = partition.offset;
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-
if (partition.length != 0) { // Initialize the NCCH of each partition
NCCH::FSInfo ncchFsInfo;
ncsd.entrypoint = textAddr;
ncchFsInfo.offset = partition.offset;
ncchFsInfo.size = partition.length;
// 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 (!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;
}
std::optional<NCSD> Memory::loadNCSD(Crypto::AESEngine& aesEngine, const std::filesystem::path& path) {
NCSD ncsd;
if (!ncsd.file.open(path, "rb")) 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
u8 magic[4]; // Must be "NCSD"
ncsd.file.seek(0x100);
auto [success, bytes] = ncsd.file.readBytes(magic, 4);
if (code.size() < totalSize) {
Helpers::panic("Total code size as reported by the exheader is larger than the .code file");
return std::nullopt;
}
if (!success || bytes != 4) {
printf("Failed to read NCSD magic\n");
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;
}
if (magic[0] != 'N' || magic[1] != 'C' || magic[2] != 'S' || magic[3] != 'D') {
printf("NCSD with wrong magic value\n");
return std::nullopt;
}
const auto paddr = opt.value();
std::memcpy(&fcram[paddr], &code[0], totalSize); // Copy the 3 segments + BSS to FCRAM
std::tie(success, bytes) = ncsd.file.readBytes(&ncsd.size, 4);
if (!success || bytes != 4) {
printf("Failed to read NCSD size\n");
return std::nullopt;
}
// Map the ROM on the kernel side
u32 textOffset = 0;
u32 textAddr = cxi.text.address;
u32 textSize = cxi.text.pageCount * pageSize;
ncsd.size *= NCSD::mediaUnit; // Convert size to bytes
u32 rodataOffset = textOffset + textSize;
u32 rodataAddr = cxi.rodata.address;
u32 rodataSize = cxi.rodata.pageCount * pageSize;
// Read partition data
ncsd.file.seek(0x120);
// 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;
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
for (int i = 0; i < 8; i++) {
auto& partition = ncsd.partitions[i];
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
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-
ncch.partitionIndex = i;
ncch.fileOffset = partition.offset;
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.
CXIFile = ncsd.file;
loadedCXI = cxi;
ncchFsInfo.offset = partition.offset;
ncchFsInfo.size = partition.length;
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")
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;