WIP initial state

memory/bus.cpp

@@ -0,0 +1,51 @@
+#include "bus.h"
+
+Bus::Bus() : map() {}
+
+std::optional<Bus::MapEntry> Bus::find_entry(u16 addr)
+{
+  for(auto it = map.begin(); it != map.end(); ++it)
+    {
+      if (addr >= it->start && addr <= it->end)
+        return std::make_optional(*it);
+    }
+
+  return {};
+}
+
+void Bus::map_device(u16 start, u16 end, Mem_device* dev)
+{
+  map.push_back(Bus::MapEntry{ start, end, dev });
+}
+
+void Bus::write8(u16 addr, u8 data)
+{
+  auto mapentry = find_entry(addr);
+
+  if(!mapentry) return;
+
+  mapentry->dev->write8(addr - mapentry->start, data);
+}
+
+u8 Bus::read8(u16 addr)
+{
+  auto mapentry = find_entry(addr);
+
+  if(!mapentry) return 0xFFu;
+
+  return mapentry->dev->read8(addr - mapentry->start);
+}
+
+void Bus::write16(u16 addr, u16 data)
+{
+  auto mapentry = find_entry(addr);
+  if(!mapentry) return;
+  mapentry->dev->write16(addr - mapentry->start, data);
+}
+
+u16 Bus::read16(u16 addr)
+{
+  auto mapentry = find_entry(addr);
+  if(!mapentry) return 0xFFFFu;
+  return mapentry->dev->read16(addr - mapentry->start);
+}

memory/bus.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <vector>
+#include <optional>
+
+#include "mem_device.h"
+
+class Bus : public Mem_device {
+private:
+  struct MapEntry {
+    u16 start;
+    u16 end;
+    Mem_device *dev;
+  };
+
+  std::optional<MapEntry> find_entry(u16 addr);
+
+public:
+  Bus();
+
+  void map_device(u16 start, u16 end, Mem_device* dev);
+
+  virtual void write8(u16 addr, u8 data);
+  virtual u8 read8(u16 addr);
+
+  virtual void write16(u16 addr, u16 data);
+  virtual u16 read16(u16 addr);
+
+private:
+  std::vector<MapEntry> map;
+};

memory/mem_device.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "types.h"
+
+class Mem_device {
+public:
+  virtual void write8(u16 addr, u8 data) = 0;
+  virtual u8 read8(u16 addr) = 0;
+
+  virtual void write16(u16 addr, u16 data) = 0;
+  virtual u16 read16(u16 addr) = 0;
+};

memory/ram.cpp

@@ -0,0 +1,31 @@
+#include "ram.h"
+
+RAM::RAM(u16 size) : size(size), readonly(false) {
+  memory = new u8[size];
+}
+
+RAM::RAM(u8* memory, u16 size, bool readonly = false)
+  : memory(memory), size(size), readonly(readonly)
+{}
+
+void RAM::write8(u16 addr, u8 data) {
+  if(addr >= size || readonly) return;
+  memory[addr] = data;
+}
+
+u8 RAM::read8(u16 addr) {
+  if (addr >= size) return 0xFFu;
+  return memory[addr];
+}
+
+void RAM::write16(u16 addr, u16 data) {
+  if(addr >= size - 1 || readonly) return;
+  u16 *ptr = (u16*)&memory[addr];
+  *ptr = data;
+}
+
+u16 RAM::read16(u16 addr) {
+  if(addr >= size - 1) return;
+  u16 *ptr = (u16*)&memory[addr];
+  return *ptr;
+}

memory/ram.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "mem_device.h"
+
+class RAM : public Mem_device {
+private:
+  u8* memory;
+  u16 size;
+  bool readonly;
+
+public:
+  RAM(u16 size);
+  RAM(u8* memory, u16 size, bool readonly = false);
+
+  virtual void write8(u16 addr, u8 data);
+  virtual u8 read8(u16 addr);
+
+  virtual void write16(u16 addr, u16 data);
+  virtual u16 read16(u16 addr);
+};