Added My vision Core

ares/GNUmakefile

@@ -77,6 +77,10 @@ ifneq ($(filter $(cores),cv),)
   include $(ares.path)/cv/GNUmakefile
 endif
 
+ifneq ($(filter $(cores),myvision),)
+  include $(ares.path)/myvision/GNUmakefile
+endif
+
 ifneq ($(filter $(cores),gb),)
   include $(ares.path)/gb/GNUmakefile
 endif

ares/myvision/GNUmakefile

@@ -0,0 +1,15 @@
+ares.components += z80
+ares.components += tms9918
+ares.components += ay38910
+
+ares.objects += ares-myvision-cpu
+ares.objects += ares-myvision-vdp
+ares.objects += ares-myvision-psg
+ares.objects += ares-myvision-system
+ares.objects += ares-myvision-cartridge
+
+$(object.path)/ares-myvision-cpu.o:        $(ares.path)/myvision/cpu/cpu.cpp
+$(object.path)/ares-myvision-vdp.o:        $(ares.path)/myvision/vdp/vdp.cpp
+$(object.path)/ares-myvision-psg.o:        $(ares.path)/myvision/psg/psg.cpp
+$(object.path)/ares-myvision-system.o:     $(ares.path)/myvision/system/system.cpp
+$(object.path)/ares-myvision-cartridge.o:  $(ares.path)/myvision/cartridge/cartridge.cpp

ares/myvision/cartridge/cartridge.cpp

@@ -0,0 +1,45 @@
+#include <myvision/myvision.hpp>
+
+namespace ares::MyVision {
+
+Cartridge& cartridge = cartridgeSlot.cartridge;
+#include "slot.cpp"
+#include "serialization.cpp"
+
+auto Cartridge::allocate(Node::Port parent) -> Node::Peripheral {
+  return node = parent->append<Node::Peripheral>(string{system.name(), " Cartridge"});
+}
+
+auto Cartridge::connect() -> void {
+  if(!node->setPak(pak = platform->pak(node))) return;
+
+  information = {};
+  information.title  = pak->attribute("title");
+
+  if(auto fp = pak->read("program.rom")) {
+    rom.allocate(fp->size());
+    rom.load(fp);
+  }
+
+  power();
+}
+
+auto Cartridge::disconnect() -> void {
+  if(!node) return;
+  rom.reset();
+  pak.reset();
+  node.reset();
+}
+
+auto Cartridge::save() -> void {
+}
+
+auto Cartridge::power() -> void {
+}
+
+auto Cartridge::read(n16 address) -> n8 {
+  if(address >= rom.size()) return 0xff;
+  return rom.read(address);
+}
+
+}

ares/myvision/cartridge/cartridge.hpp

@@ -0,0 +1,29 @@
+struct Cartridge {
+  Node::Peripheral node;
+  VFS::Pak pak;
+
+  auto title() const -> string { return information.title; }
+
+  //cartridge.cpp
+  auto allocate(Node::Port) -> Node::Peripheral;
+  auto connect() -> void;
+  auto disconnect() -> void;
+
+  auto save() -> void;
+  auto power() -> void;
+
+  auto read(n16 address) -> n8;
+
+  //serialization.cpp
+  auto serialize(serializer&) -> void;
+
+private:
+  struct Information {
+    string title;
+  } information;
+
+  Memory::Readable<n8> rom;
+};
+
+#include "slot.hpp"
+extern Cartridge& cartridge;

ares/myvision/cartridge/serialization.cpp

@@ -0,0 +1,2 @@
+auto Cartridge::serialize(serializer& s) -> void {
+}

ares/myvision/cartridge/slot.cpp

@@ -0,0 +1,18 @@
+CartridgeSlot cartridgeSlot{"Cartridge Slot"};
+
+CartridgeSlot::CartridgeSlot(string name) : name(name) {
+}
+
+auto CartridgeSlot::load(Node::Object parent) -> void {
+  port = parent->append<Node::Port>(name);
+  port->setFamily(system.name());
+  port->setType("Cartridge");
+  port->setAllocate([&](auto name) { return cartridge.allocate(port); });
+  port->setConnect([&] { return cartridge.connect(); });
+  port->setDisconnect([&] { return cartridge.disconnect(); });
+}
+
+auto CartridgeSlot::unload() -> void {
+  cartridge.disconnect();
+  port = {};
+}

ares/myvision/cartridge/slot.hpp

@@ -0,0 +1,13 @@
+struct CartridgeSlot {
+  Node::Port port;
+  Cartridge cartridge;
+
+  //slot.cpp
+  CartridgeSlot(string name);
+  auto load(Node::Object) -> void;
+  auto unload() -> void;
+
+  const string name;
+};
+
+extern CartridgeSlot cartridgeSlot;

ares/myvision/cpu/cpu.cpp

@@ -0,0 +1,65 @@
+#include <myvision/myvision.hpp>
+
+namespace ares::MyVision {
+
+CPU cpu;
+#include "memory.cpp"
+#include "debugger.cpp"
+#include "serialization.cpp"
+
+auto CPU::load(Node::Object parent) -> void {
+  ram.allocate(0x10000);
+
+  node = parent->append<Node::Object>("CPU");
+
+  debugger.load(node);
+}
+
+auto CPU::unload() -> void {
+  ram.reset();
+  node = {};
+  debugger = {};
+}
+
+auto CPU::main() -> void {
+  if(state.nmiPending) {
+    state.nmiPending = 0;  //edge-sensitive
+    debugger.interrupt("NMI");
+    nmi();
+  }
+
+  if(state.irqLine) {
+    //level-sensitive
+    debugger.interrupt("IRQ");
+    irq();
+  }
+
+  debugger.instruction();
+  instruction();
+}
+
+auto CPU::step(uint clocks) -> void {
+  Thread::step(clocks);
+  Thread::synchronize();
+}
+
+auto CPU::setNMI(bool value) -> void {
+  if(!state.nmiLine && value) state.nmiPending = 1;
+  state.nmiLine = value;
+}
+
+auto CPU::setIRQ(bool value) -> void {
+  state.irqLine = value;
+}
+
+auto CPU::power() -> void {
+  Z80::bus = this;
+  Z80::power();
+  Thread::create(Constants::Colorburst::NTSC, {&CPU::main, this});
+
+  PC = 0x0000;  //reset vector address
+  state = {};
+  ram.fill(0);
+}
+
+}

ares/myvision/cpu/cpu.hpp

@@ -0,0 +1,53 @@
+struct CPU : Z80, Z80::Bus, Thread {
+  Node::Object node;
+  Memory::Writable<n8> ram;
+
+  struct Debugger {
+    //debugger.cpp
+    auto load(Node::Object) -> void;
+    auto instruction() -> void;
+    auto interrupt(string_view) -> void;
+
+    struct Memory {
+      Node::Debugger::Memory ram;
+    } memory;
+
+    struct Tracer {
+      Node::Debugger::Tracer::Instruction instruction;
+      Node::Debugger::Tracer::Notification interrupt;
+    } tracer;
+  } debugger;
+
+  auto synchronizing() const -> bool override { return scheduler.synchronizing(); }
+
+  //cpu.cpp
+  auto load(Node::Object) -> void;
+  auto unload() -> void;
+
+  auto main() -> void;
+  auto step(u32 clocks) -> void override;
+
+  auto setNMI(bool value) -> void;
+  auto setIRQ(bool value) -> void;
+
+  auto power() -> void;
+
+  //memory.cpp
+  auto read(n16 address) -> n8 override;
+  auto write(n16 address, n8 data) -> void override;
+
+  auto in(n16 address) -> n8 override;
+  auto out(n16 address, n8 data) -> void override;
+
+  //serialization.cpp
+  auto serialize(serializer&) -> void;
+
+private:
+  struct State {
+    bool nmiPending = 0;
+    bool nmiLine = 0;
+    bool irqLine = 0;
+  } state;
+};
+
+extern CPU cpu;

ares/myvision/cpu/debugger.cpp

@@ -0,0 +1,36 @@
+auto CPU::Debugger::load(Node::Object parent) -> void {
+  memory.ram = parent->append<Node::Debugger::Memory>("CPU RAM");
+  memory.ram->setSize(cpu.ram.size());
+  memory.ram->setRead([&](u32 address) -> u8 {
+    return cpu.ram[address];
+  });
+  memory.ram->setWrite([&](u32 address, u8 data) -> void {
+    cpu.ram[address] = data;
+  });
+
+  //memory.expansion = parent->append<Node::Debugger::Memory>("CPU EXPRAM");
+  //memory.expansion->setSize(cpu.expansion.size());
+  //memory.expansion->setRead([&](u32 address) -> u8 {
+  //  return cpu.expansion[address];
+  //});
+  //memory.expansion->setWrite([&](u32 address, u8 data) -> void {
+  //  cpu.expansion[address] = data;
+  //});
+
+  tracer.instruction = parent->append<Node::Debugger::Tracer::Instruction>("Instruction", "CPU");
+  tracer.instruction->setAddressBits(16);
+
+  tracer.interrupt = parent->append<Node::Debugger::Tracer::Notification>("Interrupt", "CPU");
+}
+
+auto CPU::Debugger::instruction() -> void {
+  if(tracer.instruction->enabled() && tracer.instruction->address(cpu.PC)) {
+    tracer.instruction->notify(cpu.disassembleInstruction(), cpu.disassembleContext());
+  }
+}
+
+auto CPU::Debugger::interrupt(string_view type) -> void {
+  if(tracer.interrupt->enabled()) {
+    tracer.interrupt->notify(type);
+  }
+}

ares/myvision/cpu/memory.cpp

@@ -0,0 +1,44 @@
+auto CPU::read(n16 address) -> n8 {
+
+  // VIDEO
+  if (address == 0xe000) return vdp.data();
+  if (address == 0xe002) return vdp.status();
+
+  // MAIN
+  if (address < 0x6000) return cartridge.read(address);
+  if (address >= 0xa000 && address <= 0xa800) return ram.read(address - 0xa000);
+
+  return 0;
+}
+
+auto CPU::write(n16 address, n8 data) -> void {
+
+  // VIDEO
+  if (address == 0xe000) return vdp.data(data);
+  if (address == 0xe002) return vdp.control(data);
+
+  // MAIN
+  if (address < 0x6000) return; // ALL RETAIL GAMES ARE WRITE ONLY
+  if (address >= 0xa000 && address <= 0xffff) return ram.write(address - 0xa000, data);
+
+  return;
+}
+
+auto CPU::out(n16 address, n8 data) -> void {
+  address &= 0xff;
+  if (address == 0x00) {
+    return psg.select(data);
+  }
+  if (address == 0x01) {
+    return psg.write(data);
+  }
+}
+
+auto CPU::in(n16 address) -> n8 {
+  address &= 0xff;
+  if (address == 0x02) {
+	  return psg.read();
+  }
+
+  return 0xff;
+}

ares/myvision/cpu/serialization.cpp

@@ -0,0 +1,8 @@
+auto CPU::serialize(serializer& s) -> void {
+  Z80::serialize(s);
+  Thread::serialize(s);
+  s(ram);
+  s(state.nmiPending);
+  s(state.nmiLine);
+  s(state.irqLine);
+}

ares/myvision/myvision.hpp

@@ -0,0 +1,21 @@
+#pragma once
+//started: 2023-07-19
+
+#include <ares/ares.hpp>
+
+#include <component/processor/z80/z80.hpp>
+#include <component/video/tms9918/tms9918.hpp>
+#include <component/audio/ay38910/ay38910.hpp>
+
+namespace ares::MyVision {
+  #include <ares/inline.hpp>
+  auto enumerate() -> vector<string>;
+  auto load(Node::System& node, string name) -> bool;
+
+  #include <myvision/cpu/cpu.hpp>
+  #include <myvision/vdp/vdp.hpp>
+  #include <myvision/psg/psg.hpp>
+
+  #include <myvision/system/system.hpp>
+  #include <myvision/cartridge/cartridge.hpp>
+}