Address review: preserve saves across soft reset, sync on write

- EepromReset/MTReset: preserve save data across soft resets,
  only reset the state machine (fixes data loss on retro_reset)
- EEPROMSave: sync save buffer on every EEPROM write via
  eeprom_dirty_cb so frontends that cache the pointer see fresh data
- Remove cdromEEPROM from save buffer (not wired to any emulation
  code, was always 0xFF) — save size is now 128 bytes
- EepromInit/MTInit: only blank memory on first power-on, not
  on subsequent calls

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: JoeMatt

libretro.c

@@ -31,20 +31,21 @@ int game_width               = 0;
 int game_height              = 0;
 
 extern uint16_t eeprom_ram[64];
-extern uint16_t cdromEEPROM[64];
 extern uint8_t mtMem[0x20000];
 extern uint32_t jaguarMainROMCRC32;
+extern void (*eeprom_dirty_cb)(void);
 
-/* Combined save buffer for RETRO_MEMORY_SAVE_RAM.
- * Layout: [cart EEPROM 128 bytes][CDROM EEPROM 128 bytes]
- * For Memory Track cart (CRC 0xFDF37F47): mtMem is used directly (128K).
+/* Save buffer for RETRO_MEMORY_SAVE_RAM.
+ * Regular carts: 128 bytes (64 x 16-bit EEPROM words, big-endian packed).
+ * Memory Track cart (CRC 0xFDF37F47): mtMem is used directly (128K).
  *
- * EEPROM data is stored big-endian on disk (high byte first per 16-bit word)
- * to match the Jaguar's native byte order. This is handled by pack/unpack
- * functions so the in-memory uint16_t arrays work on any host. */
-#define EEPROM_SAVE_SIZE 256  /* 128 bytes cart + 128 bytes CDROM */
+ * The save buffer is kept in sync on every EEPROM write via eeprom_dirty_cb,
+ * so frontends that cache the pointer always see current data. */
+#define EEPROM_SAVE_SIZE 128  /* 64 x 16-bit words, big-endian */
 #define MT_SAVE_SIZE     0x20000  /* 128K Memory Track */
 static uint8_t eeprom_save_buf[EEPROM_SAVE_SIZE];
+static void eeprom_pack_save_buf(void);
+static void eeprom_unpack_save_buf(void);
 
 static retro_video_refresh_t video_cb;
 static retro_input_poll_t input_poll_cb;
@@ -976,6 +977,9 @@ bool retro_load_game(const struct retro_game_info *info)
 
    check_variables();
 
+   /* Register EEPROM dirty callback so the save buffer stays in sync */
+   eeprom_dirty_cb = eeprom_pack_save_buf;
+
    JaguarInit();                                             // set up hardware
    memcpy(jagMemSpace + 0xE00000,
          ((vjs.biosType == BT_K_SERIES) ? jaguarBootROM : jaguarBootROM2),
@@ -1031,6 +1035,9 @@ unsigned retro_api_version(void)
 
 /* Pack EEPROM uint16_t arrays into the save buffer (big-endian).
  * Called before the frontend reads save data. */
+/* Pack eeprom_ram[] into the save buffer (big-endian byte order).
+ * Called on every EEPROM write via eeprom_dirty_cb so the buffer
+ * is always up-to-date for frontends that cache the pointer. */
 static void eeprom_pack_save_buf(void)
 {
    unsigned i;
@@ -1039,24 +1046,16 @@ static void eeprom_pack_save_buf(void)
       eeprom_save_buf[(i * 2) + 0] = eeprom_ram[i] >> 8;
       eeprom_save_buf[(i * 2) + 1] = eeprom_ram[i] & 0xFF;
    }
-   for (i = 0; i < 64; i++)
-   {
-      eeprom_save_buf[128 + (i * 2) + 0] = cdromEEPROM[i] >> 8;
-      eeprom_save_buf[128 + (i * 2) + 1] = cdromEEPROM[i] & 0xFF;
-   }
 }
 
-/* Unpack the save buffer back into EEPROM uint16_t arrays.
- * Called after the frontend loads save data. */
+/* Unpack the save buffer back into eeprom_ram[].
+ * Called once after the frontend loads .srm data. */
 static void eeprom_unpack_save_buf(void)
 {
    unsigned i;
    for (i = 0; i < 64; i++)
       eeprom_ram[i] = ((uint16_t)eeprom_save_buf[(i * 2) + 0] << 8)
                     | eeprom_save_buf[(i * 2) + 1];
-   for (i = 0; i < 64; i++)
-      cdromEEPROM[i] = ((uint16_t)eeprom_save_buf[128 + (i * 2) + 0] << 8)
-                      | eeprom_save_buf[128 + (i * 2) + 1];
 }
 
 void *retro_get_memory_data(unsigned type)
@@ -1068,8 +1067,7 @@ void *retro_get_memory_data(unsigned type)
       /* Memory Track cart uses 128K NVRAM directly */
       if (jaguarMainROMCRC32 == 0xFDF37F47)
          return mtMem;
-      /* Regular carts: pack EEPROM into endian-safe buffer */
-      eeprom_pack_save_buf();
+      /* Regular carts: return the pre-packed save buffer */
       return eeprom_save_buf;
    }
    return NULL;

src/eeprom.c

@@ -16,10 +16,14 @@
 #include "eeprom.h"
 
 #include <stdlib.h>
+#include <stdbool.h>
 #include <string.h>								// For memset
 
 uint16_t eeprom_ram[64];
-uint16_t cdromEEPROM[64];
+
+/* Callback to sync the save buffer when EEPROM is modified.
+ * Set by libretro.c to keep RETRO_MEMORY_SAVE_RAM up to date. */
+void (*eeprom_dirty_cb)(void) = NULL;
 
 // Private function prototypes
 static void EEPROMSave(void);
@@ -45,31 +49,49 @@ static uint16_t jerry_writes_enabled = 0;
 static uint16_t jerry_ee_direct_jump = 0;
 
 
+static bool eeprom_initialized = false;
+
 void EepromInit(void)
 {
-   /* EEPROM data is now loaded/saved by the frontend via
-    * retro_get_memory_data(RETRO_MEMORY_SAVE_RAM). No file I/O here. */
+   /* On first init (power-on), fill EEPROM with 0xFF (blank state).
+    * The frontend will overwrite this via RETRO_MEMORY_SAVE_RAM
+    * before the first retro_run() if a save file exists. */
+   if (!eeprom_initialized)
+   {
+      memset(eeprom_ram, 0xFF, 64 * sizeof(uint16_t));
+      eeprom_initialized = true;
+   }
 }
 
 
 void EepromReset(void)
 {
-   /* Fill with 0xFF (blank EEPROM state). If the frontend has
-    * previously saved data, it will overwrite this via the
-    * RETRO_MEMORY_SAVE_RAM interface before the first frame. */
-   memset(eeprom_ram, 0xFF, 64 * sizeof(uint16_t));
-   memset(cdromEEPROM, 0xFF, 64 * sizeof(uint16_t));
+   /* Preserve EEPROM contents across soft resets — save data must
+    * survive retro_reset(). Only the state machine is reset. */
+   jerry_ee_state = EE_STATE_START;
+   jerry_ee_op = 0;
+   jerry_ee_rstate = 0;
+   jerry_ee_address_data = 0;
+   jerry_ee_address_cnt = 6;
+   jerry_ee_data = 0;
+   jerry_ee_data_cnt = 16;
+   jerry_writes_enabled = 0;
+   jerry_ee_direct_jump = 0;
 }
 
 
 void EepromDone(void)
 {
+   eeprom_initialized = false;
 }
 
 
 static void EEPROMSave(void)
 {
-   /* No-op: the frontend persists SRAM via retro_get_memory_data. */
+   /* Notify libretro.c to sync the save buffer so frontends that
+    * cache the RETRO_MEMORY_SAVE_RAM pointer see fresh data. */
+   if (eeprom_dirty_cb)
+      eeprom_dirty_cb();
 }
 
 

src/memtrack.c

@@ -32,29 +32,37 @@ enum { MT_IDLE, MT_PHASE1, MT_PHASE2 };
 uint8_t mtMem[0x20000];
 uint8_t mtCommand = MT_NONE;
 uint8_t mtState = MT_IDLE;
+static int mt_initialized = 0;
 
 // Private function prototypes
 void MTStateMachine(uint8_t reg, uint16_t data);
 
 
 void MTInit(void)
 {
-	/* Memory Track data is now loaded/saved by the frontend via
-	 * retro_get_memory_data(RETRO_MEMORY_SAVE_RAM). No file I/O here. */
+	/* On first init (power-on), fill with 0xFF (blank NVRAM state).
+	 * The frontend will overwrite this via RETRO_MEMORY_SAVE_RAM
+	 * before the first retro_run() if a save file exists. */
+	if (!mt_initialized)
+	{
+		memset(mtMem, 0xFF, 0x20000);
+		mt_initialized = 1;
+	}
 }
 
 
 void MTReset(void)
 {
-	/* Fill with 0xFF (blank EEPROM state). If the frontend has
-	 * previously saved data, it will overwrite this via the
-	 * RETRO_MEMORY_SAVE_RAM interface before the first frame. */
-	memset(mtMem, 0xFF, 0x20000);
+	/* Preserve Memory Track contents across soft resets.
+	 * Only reset the command state machine. */
+	mtCommand = MT_NONE;
+	mtState = MT_IDLE;
 }
 
 
 void MTDone(void)
 {
+	mt_initialized = 0;
 }