void Cartridge::parse_markup_sdd1(Markup::Node root) {
if(root.exists() == false) return;
has_sdd1 = true;
parse_markup_memory(sdd1.rom, root["rom"], ID::SDD1ROM, false);
parse_markup_memory(sdd1.ram, root["ram"], ID::SDD1RAM, true);
for(auto& node : root) {
if(node.name != "map") continue;
if(node["id"].data == "io") {
Mapping m({&SDD1::read, &sdd1}, {&SDD1::write, &sdd1});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].data == "rom") {
Mapping m({&SDD1::mcurom_read, &sdd1}, {&SDD1::mcurom_write, &sdd1});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].data == "ram") {
Mapping m({&SDD1::mcuram_read, &sdd1}, {&SDD1::mcuram_write, &sdd1});
parse_markup_map(m, node);
mapping.append(m);
}
}
}
void Cartridge::parse_markup_superfx(Markup::Node root) {
if(!root) return;
has_superfx = true;
auto rom = root.find("rom");
auto ram = root.find("ram");
parse_markup_memory(superfx.rom, rom(0), ID::SuperFXROM, false);
parse_markup_memory(superfx.ram, ram(0), ID::SuperFXRAM, true);
for(auto node : root.find("map")) {
if(node["id"].text() == "io") {
Mapping m({&SuperFX::mmio_read, &superfx}, {&SuperFX::mmio_write, &superfx});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].text() == "rom") {
Mapping m(superfx.cpurom);
parse_markup_map(m, node);
if(m.size == 0) m.size = superfx.rom.size();
mapping.append(m);
}
if(node["id"].text() == "ram") {
Mapping m(superfx.cpuram);
parse_markup_map(m, node);
if(m.size == 0) m.size = superfx.ram.size();
mapping.append(m);
}
}
}
void Cartridge::parse_markup_bsx(Markup::Node root) {
if(root.exists() == false) return;
has_bs_cart = true;
has_bs_slot = true;
interface->loadRequest(ID::Satellaview, "BS-X Satellaview", "bs");
parse_markup_memory(bsxcartridge.rom, root["rom"], ID::BsxROM, false);
parse_markup_memory(bsxcartridge.ram, root["ram"], ID::BsxRAM, true);
parse_markup_memory(bsxcartridge.psram, root["psram"], ID::BsxPSRAM, true);
for(auto& node : root) {
if(node.name != "map") continue;
if(node["id"].data == "rom"
|| node["id"].data == "ram") {
Mapping m({&BSXCartridge::mcu_read, &bsxcartridge}, {&BSXCartridge::mcu_write, &bsxcartridge});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].data == "io") {
Mapping m({&BSXCartridge::mmio_read, &bsxcartridge}, {&BSXCartridge::mmio_write, &bsxcartridge});
parse_markup_map(m, node);
mapping.append(m);
}
}
}
void Cartridge::parse_markup_sdd1(Markup::Node root) {
if(!root) return;
has_sdd1 = true;
auto rom = root.find("rom");
auto ram = root.find("ram");
parse_markup_memory(sdd1.rom, rom(0), ID::SDD1ROM, false);
parse_markup_memory(sdd1.ram, ram(0), ID::SDD1RAM, true);
for(auto node : root.find("map")) {
if(node["id"].text() == "io") {
Mapping m({&SDD1::read, &sdd1}, {&SDD1::write, &sdd1});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].text() == "rom") {
Mapping m({&SDD1::mcurom_read, &sdd1}, {&SDD1::mcurom_write, &sdd1});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].text() == "ram") {
Mapping m({&SDD1::mcuram_read, &sdd1}, {&SDD1::mcuram_write, &sdd1});
parse_markup_map(m, node);
mapping.append(m);
}
}
}
void Cartridge::parse_markup_sufamiturbo(Markup::Node root, bool slot) {
if(root.exists() == false) return;
has_st_slots = true;
if(slot == 0) {
//load required slot A (will request slot B if slot A cartridge is linkable)
interface->loadRequest(ID::SufamiTurboSlotA, "Sufami Turbo - Slot A", "st");
}
for(auto& node : root.find("map")) {
SufamiTurboCartridge &cart = (slot == 0 ? sufamiturboA : sufamiturboB);
if(node["id"].data == "rom") {
if(cart.rom.size() == 0) continue;
Mapping m(cart.rom);
parse_markup_map(m, node);
if(m.size == 0) m.size = cart.rom.size();
if(m.size) mapping.append(m);
}
if(node["id"].data == "ram") {
if(cart.ram.size() == 0) continue;
Mapping m(cart.ram);
parse_markup_map(m, node);
if(m.size == 0) m.size = cart.ram.size();
if(m.size) mapping.append(m);
}
}
}
void Cartridge::parse_markup_spc7110(Markup::Node root) {
if(!root) return;
has_spc7110 = true;
auto rom = root.find("rom");
auto ram = root.find("ram");
parse_markup_memory(spc7110.prom, rom(0), ID::SPC7110PROM, false);
parse_markup_memory(spc7110.drom, rom(1), ID::SPC7110DROM, false);
parse_markup_memory(spc7110.ram, ram(0), ID::SPC7110RAM, true);
for(auto node : root.find("map")) {
if(node["id"].text() == "io") {
Mapping m({&SPC7110::read, &spc7110}, {&SPC7110::write, &spc7110});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].text() == "rom") {
Mapping m({&SPC7110::mcurom_read, &spc7110}, {&SPC7110::mcurom_write, &spc7110});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].text() == "ram") {
Mapping m({&SPC7110::mcuram_read, &spc7110}, {&SPC7110::mcuram_write, &spc7110});
parse_markup_map(m, node);
mapping.append(m);
}
}
}
void Cartridge::parse_markup_spc7110(Markup::Node root) {
if(root.exists() == false) return;
has_spc7110 = true;
parse_markup_memory(spc7110.prom, root["rom[0]"], ID::SPC7110PROM, false);
parse_markup_memory(spc7110.drom, root["rom[1]"], ID::SPC7110DROM, false);
parse_markup_memory(spc7110.ram, root["ram"], ID::SPC7110RAM, true);
for(auto& node : root) {
if(node.name != "map") continue;
if(node["id"].data == "io") {
Mapping m({&SPC7110::read, &spc7110}, {&SPC7110::write, &spc7110});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].data == "rom") {
Mapping m({&SPC7110::mcurom_read, &spc7110}, {&SPC7110::mcurom_write, &spc7110});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].data == "ram") {
Mapping m({&SPC7110::mcuram_read, &spc7110}, {&SPC7110::mcuram_write, &spc7110});
parse_markup_map(m, node);
mapping.append(m);
}
}
}
void Cartridge::parse_markup_bsx(XML::Node &root) {
if(root.exists() == false) return;
if(mode.value != Mode::BsxSlotted && mode.value != Mode::Bsx) return;
has_bsx_slot = true;
for(auto &node : root["slot"]) {
if(node.name != "map") continue;
Mapping m(bsxflash.memory);
parse_markup_map(m, node);
mapping.append(m);
}
for(auto &node : root["mmio"]) {
if(node.name != "map") continue;
Mapping m({ &BSXCartridge::mmio_read, &bsxcartridge }, { &BSXCartridge::mmio_write, &bsxcartridge });
parse_markup_map(m, node);
mapping.append(m);
}
for(auto &node : root["mcu"]) {
if(node.name != "map") continue;
Mapping m({ &BSXCartridge::mcu_read, &bsxcartridge }, { &BSXCartridge::mcu_write, &bsxcartridge });
parse_markup_map(m, node);
mapping.append(m);
}
}
void Cartridge::parse_markup_cartridge(Markup::Node root) {
if(root.exists() == false) return;
parse_markup_memory(rom, root["rom"], ID::ROM, false);
parse_markup_memory(ram, root["ram"], ID::RAM, true);
for(auto& node : root) {
if(node.name != "map") continue;
if(node["id"].data == "rom") {
Mapping m(rom);
parse_markup_map(m, node);
if(m.size == 0) m.size = rom.size();
m.fastmode = Mapping::fastmode_readonly;
m.fastptr = rom.data();
mapping.append(m);
}
if(node["id"].data == "ram") {
Mapping m(ram);
parse_markup_map(m, node);
if(m.size == 0) m.size = ram.size();
m.fastmode = Mapping::fastmode_readwrite;
m.fastptr = ram.data();
mapping.append(m);
}
}
}
void Cartridge::parse_markup_sufamiturbo(XML::Node &root) {
if(root.exists() == false) return;
if(mode.value != Mode::SufamiTurbo) return;
for(auto &slot : root) {
if(slot.name != "slot") continue;
bool slotid = slot["id"].data == "A" ? 0 : slot["id"].data == "B" ? 1 : 0;
for(auto &node : slot) {
if(node.name == "rom") {
for(auto &leaf : node) {
if(leaf.name != "map") continue;
Memory &memory = slotid == 0 ? sufamiturbo.slotA.rom : sufamiturbo.slotB.rom;
Mapping m(memory);
parse_markup_map(m, leaf);
if(m.size == 0) m.size = memory.size();
if(m.size) mapping.append(m);
}
}
if(node.name == "ram") {
unsigned ram_size = numeral(node["size"].data);
for(auto &leaf : node) {
if(leaf.name != "map") continue;
Memory &memory = slotid == 0 ? sufamiturbo.slotA.ram : sufamiturbo.slotB.ram;
Mapping m(memory);
parse_markup_map(m, leaf);
if(m.size == 0) m.size = ram_size;
if(m.size) mapping.append(m);
}
}
}
}
}
void Cartridge::parse_markup_superfx(Markup::Node root) {
if(root.exists() == false) return;
has_superfx = true;
parse_markup_memory(superfx.rom, root["rom"], ID::SuperFXROM, false);
parse_markup_memory(superfx.ram, root["ram"], ID::SuperFXRAM, true);
for(auto& node : root) {
if(node.name != "map") continue;
if(node["id"].data == "io") {
Mapping m({&SuperFX::mmio_read, &superfx}, {&SuperFX::mmio_write, &superfx});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].data == "rom") {
Mapping m(superfx.cpurom);
parse_markup_map(m, node);
if(m.size == 0) m.size = superfx.rom.size();
mapping.append(m);
}
if(node["id"].data == "ram") {
Mapping m(superfx.cpuram);
parse_markup_map(m, node);
if(m.size == 0) m.size = superfx.ram.size();
mapping.append(m);
}
}
}
void Cartridge::parse_markup_necdsp(Markup::Node root) {
if(root.exists() == false) return;
if(interface->bind->altImplementation(Alt::ForDSP)==Alt::DSP::HLE)
{
parse_markup_necdsp_hle(root);
return;
}
has_necdsp = true;
for(auto& word : necdsp.programROM) word = 0x000000;
for(auto& word : necdsp.dataROM) word = 0x0000;
for(auto& word : necdsp.dataRAM) word = 0x0000;
necdsp.frequency = numeral(root["frequency"].data);
if(necdsp.frequency == 0) necdsp.frequency = 8000000;
necdsp.revision
= root["model"].data == "uPD7725" ? NECDSP::Revision::uPD7725
: root["model"].data == "uPD96050" ? NECDSP::Revision::uPD96050
: NECDSP::Revision::uPD7725;
string programROMName = root["rom[0]/name"].data;
string dataROMName = root["rom[1]/name"].data;
string dataRAMName = root["ram/name"].data;
if(necdsp.revision == NECDSP::Revision::uPD7725) {
interface->loadRequest(ID::Nec7725DSPPROM, programROMName);
interface->loadRequest(ID::Nec7725DSPDROM, dataROMName);
if(dataRAMName.empty() == false) {
interface->loadRequest(ID::Nec7725DSPRAM, dataRAMName);
memory.append({ID::Nec7725DSPRAM, dataRAMName});
}
}
if(necdsp.revision == NECDSP::Revision::uPD96050) {
interface->loadRequest(ID::Nec96050DSPPROM, programROMName);
interface->loadRequest(ID::Nec96050DSPDROM, dataROMName);
if(dataRAMName.empty() == false) {
interface->loadRequest(ID::Nec96050DSPRAM, dataRAMName);
memory.append({ID::Nec96050DSPRAM, dataRAMName});
}
}
for(auto& node : root) {
if(node.name != "map") continue;
if(node["id"].data == "io") {
Mapping m({&NECDSP::read, &necdsp}, {&NECDSP::write, &necdsp});
parse_markup_map(m, node);
mapping.append(m);
necdsp.Select = numeral(node["select"].data);
}
if(node["id"].data == "ram") {
Mapping m({&NECDSP::ram_read, &necdsp}, {&NECDSP::ram_write, &necdsp});
parse_markup_map(m, node);
mapping.append(m);
}
}
}
void Cartridge::parse_markup_necdsp(Markup::Node root) {
if(!root) return;
has_necdsp = true;
for(auto& word : necdsp.programROM) word = 0x000000;
for(auto& word : necdsp.dataROM) word = 0x0000;
for(auto& word : necdsp.dataRAM) word = 0x0000;
necdsp.frequency = root["frequency"].decimal();
if(necdsp.frequency == 0) necdsp.frequency = 8000000;
necdsp.revision
= root["model"].text() == "uPD7725" ? NECDSP::Revision::uPD7725
: root["model"].text() == "uPD96050" ? NECDSP::Revision::uPD96050
: NECDSP::Revision::uPD7725;
auto rom = root.find("rom");
auto ram = root.find("ram");
string programROMName = rom(0)["name"].text();
string dataROMName = rom(1)["name"].text();
string dataRAMName = ram(0)["name"].text();
if(necdsp.revision == NECDSP::Revision::uPD7725) {
interface->loadRequest(ID::Nec7725DSPPROM, programROMName);
interface->loadRequest(ID::Nec7725DSPDROM, dataROMName);
if(dataRAMName.empty() == false) {
interface->loadRequest(ID::Nec7725DSPRAM, dataRAMName);
memory.append({ID::Nec7725DSPRAM, dataRAMName});
}
}
if(necdsp.revision == NECDSP::Revision::uPD96050) {
interface->loadRequest(ID::Nec96050DSPPROM, programROMName);
interface->loadRequest(ID::Nec96050DSPDROM, dataROMName);
if(dataRAMName.empty() == false) {
interface->loadRequest(ID::Nec96050DSPRAM, dataRAMName);
memory.append({ID::Nec96050DSPRAM, dataRAMName});
}
}
for(auto node : root.find("map")) {
if(node["id"].text() == "io") {
Mapping m({&NECDSP::read, &necdsp}, {&NECDSP::write, &necdsp});
parse_markup_map(m, node);
mapping.append(m);
necdsp.Select = node["select"].decimal();
}
if(node["id"].text() == "ram") {
Mapping m({&NECDSP::ram_read, &necdsp}, {&NECDSP::ram_write, &necdsp});
parse_markup_map(m, node);
mapping.append(m);
}
}
}
void Cartridge::parse_markup_hitachidsp(XML::Node &root) {
if(root.exists() == false) return;
has_hitachidsp = true;
for(unsigned n = 0; n < 1024; n++) hitachidsp.dataROM[n] = 0x000000;
hitachidsp.frequency = numeral(root["frequency"].data);
if(hitachidsp.frequency == 0) hitachidsp.frequency = 20000000;
string firmware = root["firmware"].data;
string sha256 = root["sha256"].data;
string path = interface()->path(Slot::Base, firmware);
file fp;
if(fp.open(path, file::mode::read) == false) {
interface()->message({ "Warning: Hitachi DSP firmware ", firmware, " is missing." });
} else if(fp.size() != 1024 * 3) {
interface()->message({ "Warning: Hitachi DSP firmware ", firmware, " is of the wrong file size." });
fp.close();
} else {
for(unsigned n = 0; n < 1024; n++) hitachidsp.dataROM[n] = fp.readl(3);
if(!sha256.empty()) {
//XML file specified SHA256 sum for program. Verify file matches the hash.
fp.seek(0);
uint8 data[3072];
fp.read(data, 3072);
if(sha256 != nall::sha256(data, 3072)) {
interface()->message({ "Warning: Hitachi DSP firmware ", firmware, " SHA256 sum is incorrect." });
}
}
fp.close();
}
for(auto &node : root) {
if(node.name == "rom") {
for(auto &leaf : node) {
if(leaf.name != "map") continue;
Mapping m({ &HitachiDSP::rom_read, &hitachidsp }, { &HitachiDSP::rom_write, &hitachidsp });
parse_markup_map(m, leaf);
mapping.append(m);
}
}
if(node.name == "mmio") {
for(auto &leaf : node) {
Mapping m({ &HitachiDSP::dsp_read, &hitachidsp }, { &HitachiDSP::dsp_write, &hitachidsp });
parse_markup_map(m, leaf);
mapping.append(m);
}
}
}
}
void Cartridge::parse_markup_hitachidsp(Markup::Node root, unsigned roms) {
if(root.exists() == false) return;
if(interface->bind->altImplementation(Alt::ForDSP) == Alt::DSP::HLE)
{
//this is after checking existence because we don't want to ask which DSP to use and then use none of them
parse_markup_hitachidsp_hle(root);
return;
}
has_hitachidsp = true;
parse_markup_memory(hitachidsp.rom, root["rom[0]"], ID::HitachiDSPROM, false);
parse_markup_memory(hitachidsp.ram, root["ram[0]"], ID::HitachiDSPRAM, true);
for(auto& word : hitachidsp.dataROM) word = 0x000000;
for(auto& word : hitachidsp.dataRAM) word = 0x00;
hitachidsp.Frequency = numeral(root["frequency"].data);
if(hitachidsp.Frequency == 0) hitachidsp.frequency = 20000000;
hitachidsp.Roms = roms;
string dataROMName = root["rom[1]/name"].data;
string dataRAMName = root["ram[1]/name"].data;
interface->loadRequest(ID::HitachiDSPDROM, dataROMName);
if(dataRAMName.empty() == false) {
interface->loadRequest(ID::HitachiDSPDRAM, dataRAMName);
}
for(auto& node : root) {
if(node.name != "map") continue;
if(node["id"].data == "io") {
Mapping m({&HitachiDSP::dsp_read, &hitachidsp}, {&HitachiDSP::dsp_write, &hitachidsp});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].data == "rom") {
Mapping m({&HitachiDSP::rom_read, &hitachidsp}, {&HitachiDSP::rom_write, &hitachidsp});
parse_markup_map(m, node);
if(m.size == 0) m.size = hitachidsp.rom.size();
mapping.append(m);
}
if(node["id"].data == "ram") {
Mapping m({&HitachiDSP::ram_read, &hitachidsp}, {&HitachiDSP::ram_write, &hitachidsp});
parse_markup_map(m, node);
if(m.size == 0) m.size = hitachidsp.ram.size();
mapping.append(m);
}
}
}
void Cartridge::parse_markup_spc7110(XML::Node &root) {
if(root.exists() == false) return;
has_spc7110 = true;
has_spc7110rtc = root["rtc"].exists();
auto &ram = root["ram"];
auto &mmio = root["mmio"];
auto &mcu = root["mcu"];
auto &dcu = root["dcu"];
auto &rtc = root["rtc"];
ram_size = numeral(ram["size"].data);
for(auto &node : ram) {
if(node.name != "map") continue;
Mapping m({ &SPC7110::ram_read, &spc7110 }, { &SPC7110::ram_write, &spc7110 });
parse_markup_map(m, node);
mapping.append(m);
}
for(auto &node : mmio) {
if(node.name != "map") continue;
Mapping m({ &SPC7110::mmio_read, &spc7110 }, { &SPC7110::mmio_write, &spc7110 });
parse_markup_map(m, node);
mapping.append(m);
}
spc7110.data_rom_offset = numeral(mcu["offset"].data);
if(spc7110.data_rom_offset == 0) spc7110.data_rom_offset = 0x100000;
for(auto &node : mcu) {
if(node.name != "map") continue;
Mapping m({ &SPC7110::mcu_read, &spc7110 }, { &SPC7110::mcu_write, &spc7110 });
parse_markup_map(m, node);
mapping.append(m);
}
for(auto &node : dcu) {
if(node.name != "map") continue;
Mapping m({ &SPC7110::dcu_read, &spc7110 }, { &SPC7110::dcu_write, &spc7110 });
parse_markup_map(m, node);
mapping.append(m);
}
for(auto &node : rtc) {
if(node.name != "map") continue;
Mapping m({ &SPC7110::mmio_read, &spc7110 }, { &SPC7110::mmio_write, &spc7110 });
parse_markup_map(m, node);
mapping.append(m);
}
}
void Cartridge::parse_markup_event(Markup::Node root) {
if(root.exists() == false) return;
has_event = true;
for(auto& node : root) {
if(node.name != "rom") continue;
unsigned id = numeral(node["id"].data);
if(id > 3) continue;
parse_markup_memory(event.rom[id], node, ID::EventROM0 + id, false);
}
parse_markup_memory(event.ram, root["ram"], ID::EventRAM, true);
event.board = Event::Board::CampusChallenge92;
if(root["name"].data == "Campus Challenge '92") event.board = Event::Board::CampusChallenge92;
if(root["name"].data == "Powerfest '94") event.board = Event::Board::Powerfest94;
event.revision = root["revision"].data == "B" ? 2 : 1;
lstring part = root["timer"].data.split<1>(":");
if(part.size() == 1) event.timer = decimal(part(0));
if(part.size() == 2) event.timer = decimal(part(0)) * 60 + decimal(part(1));
for(auto& node : root) {
if(node.name != "map") continue;
if(node["id"].data == "rom") {
Mapping m({&Event::rom_read, &event}, [](unsigned, uint8) {});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].data == "ram") {
Mapping m({&Event::ram_read, &event}, {&Event::ram_write, &event});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].data == "dr") {
Mapping m([](unsigned) -> uint8 { return cpu.regs.mdr; }, {&Event::dr, &event});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].data == "sr") {
Mapping m({&Event::sr, &event}, [](unsigned, uint8) {});
parse_markup_map(m, node);
mapping.append(m);
}
}
}
void Cartridge::parse_markup_sa1(XML::Node &root) {
if(root.exists() == false) return;
has_sa1 = true;
auto &mcurom = root["mcu"]["rom"];
auto &mcuram = root["mcu"]["ram"];
auto &iram = root["iram"];
auto &bwram = root["bwram"];
auto &mmio = root["mmio"];
for(auto &node : mcurom) {
if(node.name != "map") continue;
Mapping m({ &SA1::mmc_read, &sa1 }, { &SA1::mmc_write, &sa1 });
parse_markup_map(m, node);
mapping.append(m);
}
for(auto &node : mcuram) {
if(node.name != "map") continue;
Mapping m({ &SA1::mmc_cpu_read, &sa1 }, { &SA1::mmc_cpu_write, &sa1 });
parse_markup_map(m, node);
mapping.append(m);
}
for(auto &node : iram) {
if(node.name != "map") continue;
Mapping m(sa1.cpuiram);
parse_markup_map(m, node);
if(m.size == 0) m.size = 2048;
mapping.append(m);
}
ram_size = numeral(bwram["size"].data);
for(auto &node : bwram) {
if(node.name != "map") continue;
Mapping m(sa1.cpubwram);
parse_markup_map(m, node);
if(m.size == 0) m.size = ram_size;
mapping.append(m);
}
for(auto &node : mmio) {
if(node.name != "map") continue;
Mapping m({ &SA1::mmio_read, &sa1 }, { &SA1::mmio_write, &sa1 });
parse_markup_map(m, node);
mapping.append(m);
}
}
void Cartridge::parse_markup_necdsp_hle(Markup::Node root) {
if (root["model"].data == "uPD7725") {
Mapping m;
unsigned int select=0;
unsigned int * selectaddr=NULL;
for(auto& node : root) {
if (node.name == "rom" && node["id"].data == "program") {
if (node["name"].data == "dsp1.program.rom" || node["name"].data == "dsp1b.program.rom") {
has_dsp1 = true;
m.reader = {&DSP1::read, &dsp1};
m.writer = {&DSP1::write, &dsp1};
selectaddr = &dsp1.Select;
}
if (node["name"].data == "dsp2.program.rom") {
has_dsp2 = true;
m.reader = {&DSP2::read, &dsp2};
m.writer = {&DSP2::write, &dsp2};
selectaddr = &dsp2.Select;
}
if (node["name"].data == "dsp3.program.rom") {
has_dsp3 = true;
m.reader = {&DSP3::read, &dsp3};
m.writer = {&DSP3::write, &dsp3};
//some of the chips hardcode the Select value
}
if (node["name"].data == "dsp4.program.rom") {
has_dsp4 = true;
m.reader = {&DSP4::read, &dsp4};
m.writer = {&DSP4::write, &dsp4};
}
}
if (node.name == "map" && node["id"].data == "io") {
parse_markup_map(m, node);
select = numeral(node["select"].data);
}
}
if (selectaddr) *selectaddr=select;
mapping.append(m);
} else {
Mapping m({&ST0010::read, &st0010}, {&ST0010::write, &st0010});
for(auto& node : root) {
if(node.name != "map") continue;
parse_markup_map(m, node);
mapping.append(m);
}
}
}
void Cartridge::parse_markup_armdsp(XML::Node &root) {
if(root.exists() == false) return;
has_armdsp = true;
string firmware = root["firmware"].data;
string sha256 = root["sha256"].data;
string path = interface()->path(Slot::Base, firmware);
file fp;
if(fp.open(path, file::mode::read) == false) {
interface()->message({ "Warning: ARM DSP firmware ", firmware, " is missing." });
} else if(fp.size() != 160 * 1024) {
interface()->message({ "Warning: ARM DSP firmware ", firmware, " is of the wrong file size." });
fp.close();
} else {
fp.read(armdsp.firmware, fp.size());
if(!sha256.empty()) {
if(sha256 != nall::sha256(armdsp.firmware, fp.size())) {
interface()->message({ "Warning: ARM DSP firmware ", firmware, " SHA256 sum is incorrect." });
}
}
fp.close();
}
for(auto &node : root) {
if(node.name != "map") continue;
Mapping m({ &ArmDSP::mmio_read, &armdsp }, { &ArmDSP::mmio_write, &armdsp });
parse_markup_map(m, node);
mapping.append(m);
}
}
void Cartridge::parse_markup_icd2(Markup::Node root) {
if(root.exists() == false) return;
if(interface->bind->altImplementation(Alt::ForSuperGameBoy)==Alt::SuperGameBoy::External)
{
if (parse_markup_icd2_external(root)) return;
}
has_gb_slot = true;
icd2.revision = max(1, numeral(root["revision"].data));
GameBoy::cartridge.load_empty(GameBoy::System::Revision::SuperGameBoy);
interface->loadRequest(ID::SuperGameBoy, "Game Boy", "gb");
string bootROMName = root["rom"]["name"].data;
interface->loadRequest(ID::SuperGameBoyBootROM, bootROMName);
for(auto& node : root) {
if(node.name != "map") continue;
if(node["id"].data == "io") {
Mapping m({&ICD2::read, &icd2}, {&ICD2::write, &icd2});
parse_markup_map(m, node);
mapping.append(m);
}
}
}
bool Cartridge::parse_markup_icd2_external(Markup::Node root) {
//root.exists() is known true here
if (!sgbExternal.load_library("/home/alcaro/Desktop/minir/cores/bsnes_v073/supergameboy/libsupergameboy.so"))
{
interface->bind->notify("Couldn't load external GB emulator, falling back to internal");
return false;
}
has_sgbexternal = true;
sgbExternal.revision = max(1, numeral(root["revision"].data));
GameBoy::cartridge.load_empty(GameBoy::System::Revision::SuperGameBoy);
interface->loadRequest(ID::SuperGameBoy, "Game Boy", "gb");
for(auto& node : root) {
if(node.name != "map") continue;
if(node["id"].data == "io") {
Mapping m({&SGBExternal::read, &sgbExternal}, {&SGBExternal::write, &sgbExternal});
parse_markup_map(m, node);
mapping.append(m);
}
}
return true;
}
void Cartridge::parse_markup_armdsp(Markup::Node root) {
if(!root) return;
has_armdsp = true;
auto rom = root.find("rom");
auto ram = root.find("ram");
string programROMName = rom(0)["name"].text();
string dataROMName = rom(1)["name"].text();
string dataRAMName = ram(0)["name"].text();
interface->loadRequest(ID::ArmDSPPROM, programROMName);
interface->loadRequest(ID::ArmDSPDROM, dataROMName);
if(dataRAMName.empty() == false) {
interface->loadRequest(ID::ArmDSPRAM, dataRAMName);
memory.append({ID::ArmDSPRAM, dataRAMName});
}
for(auto node : root.find("map")) {
if(node["id"].text() == "io") {
Mapping m({&ArmDSP::mmio_read, &armdsp}, {&ArmDSP::mmio_write, &armdsp});
parse_markup_map(m, node);
mapping.append(m);
}
}
}
void Cartridge::parse_markup_armdsp(Markup::Node root) {
if(root.exists() == false) return;
has_armdsp = true;
string programROMName = root["rom[0]/name"].data;
string dataROMName = root["rom[1]/name"].data;
string dataRAMName = root["ram/name"].data;
interface->loadRequest(ID::ArmDSPPROM, programROMName);
interface->loadRequest(ID::ArmDSPDROM, dataROMName);
if(dataRAMName.empty() == false) {
interface->loadRequest(ID::ArmDSPRAM, dataRAMName);
memory.append({ID::ArmDSPRAM, dataRAMName});
}
for(auto& node : root) {
if(node.name != "map") continue;
if(node["id"].data == "io") {
Mapping m({&ArmDSP::mmio_read, &armdsp}, {&ArmDSP::mmio_write, &armdsp});
parse_markup_map(m, node);
mapping.append(m);
}
}
}
void Cartridge::parse_markup_hitachidsp(Markup::Node root, unsigned roms) {
if(!root) return;
has_hitachidsp = true;
auto rom = root.find("rom");
auto ram = root.find("ram");
parse_markup_memory(hitachidsp.rom, rom(0), ID::HitachiDSPROM, false);
parse_markup_memory(hitachidsp.ram, ram(0), ID::HitachiDSPRAM, true);
for(auto& word : hitachidsp.dataROM) word = 0x000000;
for(auto& word : hitachidsp.dataRAM) word = 0x00;
hitachidsp.Frequency = root["frequency"].decimal();
if(hitachidsp.Frequency == 0) hitachidsp.frequency = 20000000;
hitachidsp.Roms = roms;
string dataROMName = rom(1)["name"].text();
string dataRAMName = ram(1)["name"].text();
interface->loadRequest(ID::HitachiDSPDROM, dataROMName);
if(dataRAMName.empty() == false) {
interface->loadRequest(ID::HitachiDSPDRAM, dataRAMName);
}
for(auto node : root.find("map")) {
if(node["id"].text() == "io") {
Mapping m({&HitachiDSP::dsp_read, &hitachidsp}, {&HitachiDSP::dsp_write, &hitachidsp});
parse_markup_map(m, node);
mapping.append(m);
}
if(node["id"].text() == "rom") {
Mapping m({&HitachiDSP::rom_read, &hitachidsp}, {&HitachiDSP::rom_write, &hitachidsp});
parse_markup_map(m, node);
if(m.size == 0) m.size = hitachidsp.rom.size();
mapping.append(m);
}
if(node["id"].text() == "ram") {
Mapping m({&HitachiDSP::ram_read, &hitachidsp}, {&HitachiDSP::ram_write, &hitachidsp});
parse_markup_map(m, node);
if(m.size == 0) m.size = hitachidsp.ram.size();
mapping.append(m);
}
}
}
void Cartridge::parse_markup_sdd1(XML::Node &root) {
if(root.exists() == false) return;
has_sdd1 = true;
for(auto &node : root["mmio"]) {
if(node.name != "map") continue;
Mapping m({ &SDD1::mmio_read, &sdd1 }, { &SDD1::mmio_write, &sdd1 });
parse_markup_map(m, node);
mapping.append(m);
}
for(auto &node : root["mcu"]) {
if(node.name != "map") continue;
Mapping m({ &SDD1::mcu_read, &sdd1 }, { &SDD1::mcu_write, &sdd1 });
parse_markup_map(m, node);
mapping.append(m);
}
}
void Cartridge::parse_markup_ram(XML::Node &root) {
if(root.exists() == false) return;
ram_size = numeral(root["size"].data);
for(auto &node : root) {
Mapping m(ram);
parse_markup_map(m, node);
if(m.size == 0) m.size = ram_size;
mapping.append(m);
}
}
void Cartridge::parse_markup_rom(XML::Node &root) {
if(root.exists() == false) return;
for(auto &node : root) {
if(node.name != "map") continue;
Mapping m(rom);
parse_markup_map(m, node);
if(m.size == 0) m.size = rom.size();
mapping.append(m);
}
}
void Cartridge::parse_markup_obc1(XML::Node &root) {
if(root.exists() == false) return;
has_obc1 = true;
for(auto &node : root) {
if(node.name != "map") continue;
Mapping m({ &OBC1::read, &obc1 }, { &OBC1::write, &obc1 });
parse_markup_map(m, node);
mapping.append(m);
}
}
void Cartridge::parse_markup_hitachidsp_hle(Markup::Node root) {
//root.exists() is known true in the HLE chip handlers
parse_markup_cartridge(root);
has_cx4 = true;
for(auto& node : root) {
if(node.name != "map" || node["id"].data != "io") continue;
Mapping m({&Cx4::read, &cx4}, {&Cx4::write, &cx4});
parse_markup_map(m, node);
mapping.append(m);
}
}
