web-a2e 1.0.0

package/src/core/mmu/mmu.hpp

@@ -0,0 +1,236 @@
+/*
+ * mmu.hpp - Memory management unit with soft switches
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+#pragma once
+
+#include "../types.hpp"
+#include <array>
+#include <cstdint>
+#include <functional>
+#include <memory>
+
+namespace a2e {
+
+// Forward declaration
+class ExpansionCard;
+
+class MMU {
+public:
+  using KeyboardCallback = std::function<uint8_t()>;
+  using KeyStrobeCallback = std::function<void()>;
+  using AnyKeyDownCallback = std::function<bool()>;   // Returns true if any key is currently held
+  using SpeakerCallback = std::function<void()>;
+  using ButtonCallback = std::function<uint8_t(int)>; // Returns button state for button 0-2
+  using CycleCallback = std::function<uint64_t()>;    // Returns current CPU cycle count
+  using VideoSwitchCallback = std::function<void()>;  // Called when video-relevant switches change
+  using WatchpointReadCallback = std::function<void(uint16_t, uint8_t)>;
+  using WatchpointWriteCallback = std::function<void(uint16_t, uint8_t)>;
+
+  MMU();
+  ~MMU();  // Defined in mmu.cpp (needed for unique_ptr<ExpansionCard>)
+
+  // Memory access
+  uint8_t read(uint16_t address);
+  void write(uint16_t address, uint8_t value);
+
+  // Non-side-effecting read for debugger/memory viewer
+  uint8_t peek(uint16_t address) const;
+
+  // Non-side-effecting read of auxiliary memory (for text selection in 80-col mode)
+  uint8_t peekAux(uint16_t address) const;
+
+  // Direct memory access (bypasses soft switches)
+  uint8_t readRAM(uint16_t address, bool aux = false) const;
+  void writeRAM(uint16_t address, uint8_t value, bool aux = false);
+
+  // Language card RAM access (for state serialization)
+  const uint8_t *getLCBank1(bool aux = false) const {
+    return aux ? auxLcBank1_.data() : lcBank1_.data();
+  }
+  const uint8_t *getLCBank2(bool aux = false) const {
+    return aux ? auxLcBank2_.data() : lcBank2_.data();
+  }
+  const uint8_t *getLCHighRAM(bool aux = false) const {
+    return aux ? auxLcHighRAM_.data() : lcHighRAM_.data();
+  }
+  void setLCBank1(const uint8_t *data, bool aux = false) {
+    auto &bank = aux ? auxLcBank1_ : lcBank1_;
+    std::copy(data, data + bank.size(), bank.begin());
+  }
+  void setLCBank2(const uint8_t *data, bool aux = false) {
+    auto &bank = aux ? auxLcBank2_ : lcBank2_;
+    std::copy(data, data + bank.size(), bank.begin());
+  }
+  void setLCHighRAM(const uint8_t *data, bool aux = false) {
+    auto &bank = aux ? auxLcHighRAM_ : lcHighRAM_;
+    std::copy(data, data + bank.size(), bank.begin());
+  }
+
+  // ROM loading - combined 16KB system ROM ($C000-$FFFF)
+  void loadROM(const uint8_t *systemRom, size_t systemSize,
+               const uint8_t *charRom, size_t charSize);
+
+  // Character ROM access (for video)
+  uint8_t readCharROM(uint16_t address) const;
+
+  // Soft switch state
+  const SoftSwitches &getSoftSwitches() const { return switches_; }
+
+  // Callbacks
+  void setKeyboardCallback(KeyboardCallback cb) {
+    keyboardCallback_ = std::move(cb);
+  }
+  void setKeyStrobeCallback(KeyStrobeCallback cb) {
+    keyStrobeCallback_ = std::move(cb);
+  }
+  void setAnyKeyDownCallback(AnyKeyDownCallback cb) {
+    anyKeyDownCallback_ = std::move(cb);
+  }
+  void setSpeakerCallback(SpeakerCallback cb) {
+    speakerCallback_ = std::move(cb);
+  }
+  void setButtonCallback(ButtonCallback cb) { buttonCallback_ = std::move(cb); }
+  void setCycleCallback(CycleCallback cb) { cycleCallback_ = std::move(cb); }
+  void setVideoSwitchCallback(VideoSwitchCallback cb) { videoSwitchCallback_ = std::move(cb); }
+  void setWatchpointCallbacks(WatchpointReadCallback readCb, WatchpointWriteCallback writeCb) {
+    watchpointReadCallback_ = std::move(readCb);
+    watchpointWriteCallback_ = std::move(writeCb);
+  }
+  void setWatchpointsActive(bool active) { watchpointsActive_ = active; }
+
+  // Paddle/joystick input
+  void setPaddleValue(int paddle, uint8_t value) {
+    if (paddle >= 0 && paddle < 4) {
+      paddleValues_[paddle] = value;
+    }
+  }
+  uint8_t getPaddleValue(int paddle) const {
+    return (paddle >= 0 && paddle < 4) ? paddleValues_[paddle] : 128;
+  }
+
+
+  // ===== Expansion Slot Management =====
+
+  /**
+   * Insert a card into an expansion slot
+   * @param slot Slot number (1-7)
+   * @param card Card to insert (ownership transferred)
+   * @return Previously installed card, or nullptr if slot was empty
+   */
+  std::unique_ptr<ExpansionCard> insertCard(uint8_t slot, std::unique_ptr<ExpansionCard> card);
+
+  /**
+   * Remove a card from an expansion slot
+   * @param slot Slot number (1-7)
+   * @return The removed card, or nullptr if slot was empty
+   */
+  std::unique_ptr<ExpansionCard> removeCard(uint8_t slot);
+
+  /**
+   * Get a card from a slot (non-owning)
+   * @param slot Slot number (1-7)
+   * @return Pointer to card, or nullptr if slot is empty
+   */
+  ExpansionCard* getCard(uint8_t slot) const;
+
+  /**
+   * Check if a slot is empty
+   * @param slot Slot number (1-7)
+   * @return true if no card is installed
+   */
+  bool isSlotEmpty(uint8_t slot) const;
+
+  /**
+   * Get which slot's expansion ROM is active
+   * @return Active slot (1-7), or 0 if none
+   */
+  uint8_t getActiveExpansionSlot() const { return activeExpansionSlot_; }
+
+  // Reset
+  void reset();
+  void warmReset();  // Reset soft switches and cards, preserve RAM
+
+  // Memory access tracking for debugger heat map
+  void enableTracking(bool enable) { trackingEnabled_ = enable; }
+  bool isTrackingEnabled() const { return trackingEnabled_; }
+  void clearTracking();
+  void decayTracking(uint8_t amount = 1); // Reduce all counts for real-time visualization
+  const uint8_t* getReadCounts() const { return readCounts_.data(); }
+  const uint8_t* getWriteCounts() const { return writeCounts_.data(); }
+
+  // Direct memory array access for heat map visualization
+  const uint8_t* getMainRAM() const { return mainRAM_.data(); }
+  const uint8_t* getAuxRAM() const { return auxRAM_.data(); }
+  const uint8_t* getSystemROM() const { return systemROM_.data(); }
+
+private:
+  // Soft switch handling
+  uint8_t readSoftSwitch(uint16_t address);
+  uint8_t peekSoftSwitch(uint16_t address) const;
+  void writeSoftSwitch(uint16_t address, uint8_t value);
+
+  // Floating bus - returns value video hardware is currently reading
+  uint8_t getFloatingBusValue();
+
+  // Language card logic
+  uint8_t readLanguageCard(uint16_t address);
+  void writeLanguageCard(uint16_t address, uint8_t value);
+  uint8_t handleLanguageCardSwitch(uint8_t reg);
+  void handleLanguageCardSwitchWrite(uint8_t reg);
+
+  // Memory banks
+  std::array<uint8_t, MAIN_RAM_SIZE> mainRAM_{};
+  std::array<uint8_t, AUX_RAM_SIZE> auxRAM_{};
+
+  // Language card RAM banks
+  std::array<uint8_t, 0x1000> lcBank1_{};   // $D000-$DFFF bank 1
+  std::array<uint8_t, 0x1000> lcBank2_{};   // $D000-$DFFF bank 2
+  std::array<uint8_t, 0x2000> lcHighRAM_{}; // $E000-$FFFF
+
+  // Auxiliary language card banks
+  std::array<uint8_t, 0x1000> auxLcBank1_{};
+  std::array<uint8_t, 0x1000> auxLcBank2_{};
+  std::array<uint8_t, 0x2000> auxLcHighRAM_{};
+
+  // ROM - combined 16KB system ROM ($C000-$FFFF)
+  std::array<uint8_t, 0x4000> systemROM_{}; // $C000-$FFFF (16KB)
+  std::array<uint8_t, CHAR_ROM_SIZE> charROM_{};
+
+  // Soft switches
+  SoftSwitches switches_;
+
+  // Keyboard state
+  uint8_t keyboardLatch_ = 0;
+
+  // Paddle/joystick state
+  std::array<uint8_t, 4> paddleValues_ = {128, 128, 128, 128}; // Centered by default
+  uint64_t paddleTriggerCycle_ = 0;
+  static constexpr int PADDLE_CYCLES_PER_UNIT = 11; // ~11 cycles per paddle unit
+
+  // Callbacks
+  KeyboardCallback keyboardCallback_;
+  KeyStrobeCallback keyStrobeCallback_;
+  AnyKeyDownCallback anyKeyDownCallback_;
+  SpeakerCallback speakerCallback_;
+  ButtonCallback buttonCallback_;
+  CycleCallback cycleCallback_;
+  VideoSwitchCallback videoSwitchCallback_;
+  WatchpointReadCallback watchpointReadCallback_;
+  WatchpointWriteCallback watchpointWriteCallback_;
+  bool watchpointsActive_ = false;
+
+  // Expansion slots (1-7, index 0-6)
+  std::array<std::unique_ptr<ExpansionCard>, 7> slots_;
+  uint8_t activeExpansionSlot_ = 0;  // Which card owns $C800-$CFFF (0 = none)
+
+  // Memory access tracking for debugger heat map
+  bool trackingEnabled_ = false;
+  std::array<uint8_t, 65536> readCounts_{};
+  std::array<uint8_t, 65536> writeCounts_{};
+};
+
+} // namespace a2e

package/src/core/types.hpp

@@ -0,0 +1,196 @@
+/*
+ * types.hpp - Shared constants, types, and color palettes for the Apple IIe emulator
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+
+namespace a2e {
+
+// Memory size constants
+constexpr size_t MAIN_RAM_SIZE = 64 * 1024; // 64KB main RAM
+constexpr size_t AUX_RAM_SIZE = 64 * 1024;  // 64KB auxiliary RAM
+constexpr size_t ROM_SIZE = 16 * 1024;      // 16KB ROM ($C000-$FFFF)
+constexpr size_t CHAR_ROM_SIZE = 8 * 1024;  // 8KB character ROM (US + UK sets)
+constexpr size_t DISK_ROM_SIZE = 256;       // 256 bytes Disk II ROM
+
+// Display constants
+constexpr int SCREEN_WIDTH = 560;  // 280 * 2 for double-width pixels
+constexpr int SCREEN_HEIGHT = 384; // 192 * 2 for double-height pixels
+constexpr int FRAMEBUFFER_SIZE = SCREEN_WIDTH * SCREEN_HEIGHT * 4; // RGBA
+
+// Timing constants
+constexpr double CPU_CLOCK_HZ = 1023000.0; // 1.023 MHz
+constexpr int AUDIO_SAMPLE_RATE = 48000;
+constexpr double CYCLES_PER_SAMPLE =
+    CPU_CLOCK_HZ / AUDIO_SAMPLE_RATE; // ~21.3125
+
+constexpr int CYCLES_PER_SCANLINE = 65;
+constexpr int SCANLINES_PER_FRAME = 262;
+constexpr int CYCLES_PER_FRAME =
+    CYCLES_PER_SCANLINE * SCANLINES_PER_FRAME; // 17030
+
+// Video mode flags
+enum class VideoMode : uint8_t {
+  TEXT_40 = 0,
+  TEXT_80,
+  LORES,
+  HIRES,
+  DOUBLE_LORES,
+  DOUBLE_HIRES
+};
+
+// Soft switch state - comprehensive Apple IIe soft switches
+struct SoftSwitches {
+  // Display switches ($C050-$C057)
+  bool text = true;   // $C050/$C051: TEXT/GRAPHICS mode
+  bool mixed = false; // $C052/$C053: Mixed mode (4 lines text at bottom)
+  bool page2 = false; // $C054/$C055: PAGE1/PAGE2
+  bool hires = false; // $C056/$C057: LORES/HIRES
+
+  // 80-column switches ($C00C-$C00F)
+  bool col80 = false;      // $C00C/$C00D: 40/80 column mode
+  bool altCharSet = false; // $C00E/$C00F: Primary/alternate character set
+
+  // Memory switches ($C000-$C00B)
+  bool store80 = false;   // $C000/$C001: 80STORE
+  bool ramrd = false;     // $C002/$C003: RAMRD - aux RAM read
+  bool ramwrt = false;    // $C004/$C005: RAMWRT - aux RAM write
+  bool intcxrom = false;  // $C006/$C007: INTCXROM - internal slot ROM
+  bool altzp = false;     // $C008/$C009: ALTZP - aux zero page/stack
+  bool slotc3rom = false; // $C00A/$C00B: SLOTC3ROM - slot 3 ROM
+  bool intc8rom = false;  // Internal $C800-$CFFF ROM active
+
+  // Language card ($C080-$C08F)
+  bool lcram = false;      // LC RAM enabled for read
+  bool lcram2 = false;     // LC RAM bank 2
+  bool lcwrite = false;    // LC RAM write-enabled
+  bool lcprewrite = false; // LC pre-write state
+
+  // Annunciators ($C058-$C05F)
+  bool an0 = false; // $C058/$C059: Annunciator 0
+  bool an1 = false; // $C05A/$C05B: Annunciator 1
+  bool an2 = false; // $C05C/$C05D: Annunciator 2
+  bool an3 = false; // $C05E/$C05F: Annunciator 3 (DHIRES control)
+
+  // I/O state (read-only status)
+  bool vblBar = false; // $C019: Vertical blank (true = in VBL)
+
+  // Button states ($C061-$C063)
+  bool button0 = false; // $C061: Open Apple / Button 0
+  bool button1 = false; // $C062: Closed Apple / Button 1
+  bool button2 = false; // $C063: Button 2 / Shift key state
+
+  // Keyboard
+  uint8_t keyLatch = 0;   // $C000: Keyboard latch (bit 7 = key available)
+  bool keyStrobe = false; // $C010: Keyboard strobe (key available)
+
+  // Paddle/Joystick
+  uint8_t paddle0 = 128; // $C064: PDL0 value (0-255, 128 = center)
+  uint8_t paddle1 = 128; // $C065: PDL1 value
+  uint8_t paddle2 = 128; // $C066: PDL2 value
+  uint8_t paddle3 = 128; // $C067: PDL3 value
+
+  // Cassette (stub)
+  bool cassetteOut = false; // $C020: Cassette output
+  bool cassetteIn = false;  // $C060: Cassette input
+
+  // IOU / DHIRES
+  bool ioudis = false; // $C07E/$C07F: IOU disable (IIc specific)
+  bool dhires = false; // Double hi-res mode (AN3 off + 80COL + HIRES)
+};
+
+// Disk drive state
+struct DriveState {
+  bool motorOn = false;
+  bool writeMode = false;
+  int currentTrack = 0; // 0-34
+  int currentPhase = 0; // Stepper motor phase
+  int headPosition = 0; // Bit position on track
+  uint8_t dataLatch = 0;
+  bool diskInserted = false;
+};
+
+// CPU status flags are defined in cpu/cpu6502.hpp
+
+// Color palette for Apple II
+constexpr std::array<uint32_t, 16> LORES_COLORS = {{
+    0xFF000000, // 0: Black
+    0xFFE31E60, // 1: Magenta
+    0xFF604EBD, // 2: Dark Blue
+    0xFFFF44FD, // 3: Purple
+    0xFF00A360, // 4: Dark Green
+    0xFF9C9C9C, // 5: Grey 1
+    0xFF14CFFD, // 6: Medium Blue
+    0xFFD0C3FF, // 7: Light Blue
+    0xFF607203, // 8: Brown
+    0xFFFF6A3C, // 9: Orange
+    0xFF9C9C9C, // 10: Grey 2
+    0xFFFFA0D0, // 11: Pink
+    0xFF14F53C, // 12: Light Green
+    0xFFD0DD8D, // 13: Yellow
+    0xFF72FFD0, // 14: Aqua
+    0xFFFFFFFF  // 15: White
+}};
+
+// HiRes artifact colors (NTSC-accurate values)
+// Group 1 (high bit = 0): Black, Green, Violet, White
+// Group 2 (high bit = 1): Black, Orange, Blue, White
+constexpr std::array<uint32_t, 6> HIRES_COLORS = {{
+    0xFF000000, // 0: Black
+    0xFF14F53C, // 1: Green (odd pixels, high bit = 0)
+    0xFFFF44FD, // 2: Violet (even pixels, high bit = 0)
+    0xFFFFFFFF, // 3: White
+    0xFF14CFFD, // 4: Blue (even pixels, high bit = 1)
+    0xFFFF6A3C  // 5: Orange (odd pixels, high bit = 1)
+}};
+
+// Double Lo-Res / Double Hi-Res color palette
+// Different from Lo-Res due to 14MHz dot rate vs 7MHz (changes NTSC phase
+// relationship) Based on AppleWin's DoubleHiresPalIndex mapping See:
+// https://github.com/AppleWin/AppleWin/blob/master/source/RGBMonitor.cpp
+constexpr std::array<uint32_t, 16> DLGR_COLORS = {{
+    0xFF000000, // 0: Black        (LORES[0])
+    0xFF604EBD, // 1: Dark Blue    (LORES[2])
+    0xFF00A360, // 2: Dark Green   (LORES[4])
+    0xFF14CFFD, // 3: Medium Blue  (LORES[6])
+    0xFF607203, // 4: Brown        (LORES[8])
+    0xFF9C9C9C, // 5: Grey         (LORES[10])
+    0xFF14F53C, // 6: Light Green  (LORES[12])
+    0xFF72FFD0, // 7: Aqua         (LORES[14])
+    0xFFE31E60, // 8: Magenta      (LORES[1])
+    0xFFFF44FD, // 9: Purple       (LORES[3])
+    0xFF9C9C9C, // 10: Grey        (LORES[5])
+    0xFFD0C3FF, // 11: Light Blue  (LORES[7])
+    0xFFFF6A3C, // 12: Orange      (LORES[9])
+    0xFFFFA0D0, // 13: Pink        (LORES[11])
+    0xFFD0DD8D, // 14: Yellow      (LORES[13])
+    0xFFFFFFFF  // 15: White       (LORES[15])
+}};
+
+// Snapshot of video-relevant soft switch state for per-scanline rendering
+struct VideoSwitchState {
+  bool text;
+  bool mixed;
+  bool page2;
+  bool hires;
+  bool col80;
+  bool altCharSet;
+  bool store80;
+  bool an3;
+};
+
+// Records a video switch change at a specific cycle within a frame
+struct VideoSwitchChange {
+  uint32_t cycleOffset;       // Cycle offset from frame start
+  VideoSwitchState state;     // Full snapshot after the change
+};
+
+} // namespace a2e