Add external CD BIOS loading, fix boot vector setup

JoeMatt · claude · JoeMatt · commit 225973130a1b · 2026-04-16T01:36:57.000-04:00
The embedded CD BIOS data (jaguarCDBootROM) is scrambled and does not
contain valid 68K reset vectors, so CD games cannot boot with it.

Changes:
- Add load_external_cd_bios() to load a real BIOS dump from the
  system directory (looks for jaguarcd_bios.bin, jagcd_bios.bin, etc.)
- Validate the BIOS by checking that the initial PC points into the
  BIOS ROM range ($E00000-$E3FFFF)
- Move CD BIOS boot vector setup AFTER JaguarReset() since
  JaguarReset() overwrites RAM[0..7] when jaguarCartInserted is false
- Re-pulse the 68K reset after setting vectors so it picks them up
- Add test/test_cd_boot.c diagnostic harness for CD boot testing

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/libretro.c b/libretro.c
@@ -28,6 +28,7 @@ int64_t rfread(void* buffer, size_t elem_size, size_t elem_count, RFILE* stream)
 #include "settings.h"
 #include "tom.h"
 #include "state.h"
+#include "m68000/m68kinterface.h"
 
 #define SAMPLERATE 48000
 #define BUFPAL  1920
@@ -69,6 +70,8 @@ static bool libretro_supports_bitmasks = false;
 static bool save_data_needs_unpack = false;
 static bool jaguar_cd_mode = false;
 static char cd_image_path[4096] = {0};
+static bool cd_bios_loaded_externally = false;
+static uint8_t external_cd_bios[0x40000];  /* 256 KB */
 
 void retro_set_video_refresh(retro_video_refresh_t cb) { video_cb = cb; }
 void retro_set_audio_sample(retro_audio_sample_t cb) { (void)cb; }
@@ -944,6 +947,66 @@ void retro_cheat_set(unsigned index, bool enabled, const char *code)
    (void)code;
 }
 
+/* Try to load a CD BIOS from the system directory.
+ * Looks for several common filenames. Returns true if loaded. */
+static bool load_external_cd_bios(void)
+{
+   const char *system_dir = NULL;
+   /* Common filenames for the Jaguar CD BIOS (256 KB) */
+   static const char *bios_names[] = {
+      "jaguarcd_bios.bin",
+      "jagcd_bios.bin",
+      "jaguarcd.bin",
+      "jagcd.bin",
+      NULL
+   };
+
+   if (!environ_cb(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &system_dir) || !system_dir)
+      return false;
+
+   for (int i = 0; bios_names[i]; i++)
+   {
+      char path[4096];
+      RFILE *f;
+
+      snprintf(path, sizeof(path), "%s/%s", system_dir, bios_names[i]);
+      f = rfopen(path, "rb");
+      if (!f)
+         continue;
+
+      rfseek(f, 0, SEEK_END);
+      int64_t size = rftell(f);
+      rfseek(f, 0, SEEK_SET);
+
+      if (size != 0x40000)  /* Must be exactly 256 KB */
+      {
+         rfclose(f);
+         continue;
+      }
+
+      if (rfread(external_cd_bios, 1, 0x40000, f) != 0x40000)
+      {
+         rfclose(f);
+         continue;
+      }
+      rfclose(f);
+
+      /* Validate: first 8 bytes should be valid 68K vectors.
+       * Initial PC should be in the BIOS ROM range $E00000-$E3FFFF. */
+      {
+         uint32_t pc = (external_cd_bios[4] << 24) | (external_cd_bios[5] << 16)
+                     | (external_cd_bios[6] << 8)  | external_cd_bios[7];
+         if (pc >= 0xE00000 && pc <= 0xE3FFFF)
+         {
+            cd_bios_loaded_externally = true;
+            return true;
+         }
+      }
+   }
+
+   return false;
+}
+
 bool retro_load_game(const struct retro_game_info *info)
 {
    unsigned i;
@@ -1043,6 +1106,16 @@ bool retro_load_game(const struct retro_game_info *info)
       /* For CD mode, force BIOS on -- CD games require the BIOS */
       vjs.useJaguarBIOS = true;
       vjs.useCDBIOS     = true;
+
+      /* Try to load an external CD BIOS from the system directory.
+       * The embedded CD BIOS data is scrambled and non-functional;
+       * a real BIOS dump is required for CD games to boot. */
+      cd_bios_loaded_externally = false;
+      if (!load_external_cd_bios())
+      {
+         /* No external BIOS found -- CD games won't boot.
+          * We still allow loading so users see a diagnostic screen. */
+      }
    }
 
    /* For CD mode, open the disc image BEFORE JaguarInit() so that
@@ -1070,10 +1143,17 @@ bool retro_load_game(const struct retro_game_info *info)
 
    if (jaguar_cd_mode)
    {
-      /* Load CD BIOS at $E00000 (256 KB = 0x40000 bytes) */
-      uint8_t *cdBios = (vjs.cdBiosType == CDBIOS_DEV)
-         ? jaguarDevCDBootROM : jaguarCDBootROM;
-      memcpy(jagMemSpace + 0xE00000, cdBios, 0x40000);
+      /* Load CD BIOS at $E00000 (256 KB = 0x40000 bytes).
+       * Prefer the external BIOS file (real dump); fall back to
+       * embedded data (which is scrambled and won't boot). */
+      if (cd_bios_loaded_externally)
+         memcpy(jagMemSpace + 0xE00000, external_cd_bios, 0x40000);
+      else
+      {
+         uint8_t *cdBios = (vjs.cdBiosType == CDBIOS_DEV)
+            ? jaguarDevCDBootROM : jaguarCDBootROM;
+         memcpy(jagMemSpace + 0xE00000, cdBios, 0x40000);
+      }
    }
    else
    {
@@ -1092,21 +1172,6 @@ bool retro_load_game(const struct retro_game_info *info)
 
    if (jaguar_cd_mode)
    {
-      // For CD mode, the BIOS handles boot
-      // Set the stack pointer and boot from BIOS
-      SET32(jaguarMainRAM, 0, 0x00200000);
-
-      // The BIOS entry vectors are in the CD BIOS ROM itself
-      // Read the reset vector from the BIOS: first long = initial SP, second long = initial PC
-      {
-         uint8_t *biosBase = jagMemSpace + 0xE00000;
-         uint32_t initialSP = GET32(biosBase, 0);
-         uint32_t initialPC = GET32(biosBase, 4);
-
-         SET32(jaguarMainRAM, 0, initialSP);
-         SET32(jaguarMainRAM, 4, initialPC);
-      }
-
       jaguarCartInserted = false;
    }
    else
@@ -1147,6 +1212,17 @@ bool retro_load_game(const struct retro_game_info *info)
 
    JaguarReset();
 
+   if (jaguar_cd_mode)
+   {
+      /* Set up CD BIOS boot vectors AFTER JaguarReset(), because
+       * JaguarReset() overwrites RAM[0..7] with jaguarRunAddress
+       * when jaguarCartInserted is false. */
+      uint8_t *biosBase = jagMemSpace + 0xE00000;
+      SET32(jaguarMainRAM, 0, GET32(biosBase, 0));  /* Initial SP */
+      SET32(jaguarMainRAM, 4, GET32(biosBase, 4));  /* Initial PC */
+      m68k_pulse_reset();  /* Re-reset 68K to pick up new vectors */
+   }
+
    /* The frontend will load .srm data into our save buffer (returned by
     * retro_get_memory_data) after this function returns but before the
     * first retro_run(). We unpack it on the first frame. */
diff --git a/test/test_cd_boot.c b/test/test_cd_boot.c
@@ -0,0 +1,221 @@
+/* test_cd_boot.c -- Minimal test harness for CD boot diagnostics.
+ * Build: make -j4 && cc -o test/test_cd_boot test/test_cd_boot.c -L. -lvirtualjaguar_libretro -Wl,-rpath,.
+ * Actually, just link against the dylib directly:
+ *   cc -o test/test_cd_boot test/test_cd_boot.c -ldl
+ * Or use the simpler approach: include retro API and call it. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dlfcn.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include "../libretro-common/include/libretro.h"
+
+/* Function pointers for the libretro API */
+static void (*p_retro_init)(void);
+static void (*p_retro_deinit)(void);
+static void (*p_retro_set_environment)(retro_environment_t);
+static void (*p_retro_set_video_refresh)(retro_video_refresh_t);
+static void (*p_retro_set_audio_sample)(retro_audio_sample_t);
+static void (*p_retro_set_audio_sample_batch)(retro_audio_sample_batch_t);
+static void (*p_retro_set_input_poll)(retro_input_poll_t);
+static void (*p_retro_set_input_state)(retro_input_state_t);
+static bool (*p_retro_load_game)(const struct retro_game_info *);
+static void (*p_retro_unload_game)(void);
+static void (*p_retro_run)(void);
+static void (*p_retro_get_system_info)(struct retro_system_info *);
+static void (*p_retro_get_system_av_info)(struct retro_system_av_info *);
+
+static unsigned frame_count = 0;
+static uint32_t last_frame_hash = 0;
+static unsigned width_seen = 0, height_seen = 0;
+static bool got_video = false;
+
+static void video_refresh(const void *data, unsigned width, unsigned height, size_t pitch)
+{
+   if (!data) return;
+   got_video = true;
+   width_seen = width;
+   height_seen = height;
+
+   /* Simple hash of video buffer to detect changes */
+   const uint32_t *pixels = (const uint32_t *)data;
+   uint32_t hash = 0;
+   unsigned total = width * height;
+   for (unsigned i = 0; i < total; i += 97)  /* sample every 97th pixel */
+      hash = hash * 31 + pixels[i];
+
+   if (hash != last_frame_hash)
+   {
+      /* Check if frame is all black (or near-black) */
+      unsigned nonblack = 0;
+      for (unsigned i = 0; i < total; i += 37)
+      {
+         uint32_t p = pixels[i] & 0x00FFFFFF;
+         if (p > 0x010101)
+            nonblack++;
+      }
+      printf("  Frame %u: %ux%u, hash=0x%08X, nonblack_samples=%u/%u\n",
+             frame_count, width, height, hash, nonblack, total / 37);
+      last_frame_hash = hash;
+   }
+}
+
+static void audio_sample(int16_t left, int16_t right) { (void)left; (void)right; }
+static size_t audio_sample_batch(const int16_t *data, size_t frames) { (void)data; return frames; }
+static void input_poll(void) {}
+static int16_t input_state(unsigned port, unsigned device, unsigned index, unsigned id)
+{
+   (void)port; (void)device; (void)index; (void)id;
+   return 0;
+}
+
+static void log_printf(enum retro_log_level level, const char *fmt, ...)
+{
+   va_list ap;
+   const char *lvl_str[] = {"DEBUG", "INFO", "WARN", "ERROR"};
+   printf("[%s] ", lvl_str[level < 4 ? level : 3]);
+   va_start(ap, fmt);
+   vprintf(fmt, ap);
+   va_end(ap);
+}
+
+static struct retro_log_callback log_cb = { log_printf };
+
+static bool environment(unsigned cmd, void *data)
+{
+   switch (cmd)
+   {
+   case RETRO_ENVIRONMENT_GET_LOG_INTERFACE:
+      *(struct retro_log_callback *)data = log_cb;
+      return true;
+   case RETRO_ENVIRONMENT_SET_PIXEL_FORMAT:
+      return true;
+   case RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY:
+      /* Look for BIOS files in test/roms/private or current dir */
+      *(const char **)data = "test/roms/private";
+      return true;
+   case RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY:
+      *(const char **)data = ".";
+      return true;
+   case RETRO_ENVIRONMENT_SET_VARIABLES:
+   case RETRO_ENVIRONMENT_SET_CORE_OPTIONS_V2:
+      return true;
+   case RETRO_ENVIRONMENT_GET_VARIABLE:
+   {
+      struct retro_variable *var = (struct retro_variable *)data;
+      /* Force CD BIOS on */
+      if (var->key && strcmp(var->key, "virtualjaguar_bios") == 0)
+      {
+         var->value = "enabled";
+         return true;
+      }
+      if (var->key && strcmp(var->key, "virtualjaguar_usefastblitter") == 0)
+      {
+         var->value = "enabled";
+         return true;
+      }
+      var->value = NULL;
+      return false;
+   }
+   case RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE:
+      *(bool *)data = false;
+      return true;
+   default:
+      return false;
+   }
+}
+
+int main(int argc, char *argv[])
+{
+   if (argc < 2)
+   {
+      fprintf(stderr, "Usage: %s <path-to-cue-or-chd> [num_frames]\n", argv[0]);
+      return 1;
+   }
+
+   const char *image_path = argv[1];
+   unsigned num_frames = argc > 2 ? atoi(argv[2]) : 300;
+
+   /* Load the core */
+   void *handle = dlopen("./virtualjaguar_libretro.dylib", RTLD_NOW);
+   if (!handle)
+   {
+      fprintf(stderr, "Failed to load core: %s\n", dlerror());
+      return 1;
+   }
+
+#define LOAD_SYM(sym) do { \
+   p_##sym = dlsym(handle, #sym); \
+   if (!p_##sym) { fprintf(stderr, "Missing symbol: %s\n", #sym); return 1; } \
+} while(0)
+
+   LOAD_SYM(retro_init);
+   LOAD_SYM(retro_deinit);
+   LOAD_SYM(retro_set_environment);
+   LOAD_SYM(retro_set_video_refresh);
+   LOAD_SYM(retro_set_audio_sample);
+   LOAD_SYM(retro_set_audio_sample_batch);
+   LOAD_SYM(retro_set_input_poll);
+   LOAD_SYM(retro_set_input_state);
+   LOAD_SYM(retro_load_game);
+   LOAD_SYM(retro_unload_game);
+   LOAD_SYM(retro_run);
+   LOAD_SYM(retro_get_system_info);
+   LOAD_SYM(retro_get_system_av_info);
+
+   p_retro_set_environment(environment);
+   p_retro_set_video_refresh(video_refresh);
+   p_retro_set_audio_sample(audio_sample);
+   p_retro_set_audio_sample_batch(audio_sample_batch);
+   p_retro_set_input_poll(input_poll);
+   p_retro_set_input_state(input_state);
+
+   p_retro_init();
+
+   struct retro_game_info game = {0};
+   game.path = image_path;
+
+   printf("Loading CD image: %s\n", image_path);
+   if (!p_retro_load_game(&game))
+   {
+      fprintf(stderr, "retro_load_game failed!\n");
+      p_retro_deinit();
+      dlclose(handle);
+      return 1;
+   }
+
+   printf("Game loaded successfully. Running %u frames...\n", num_frames);
+
+   /* Check initial RAM state */
+   /* Access jaguarMainRAM to read vectors */
+   uint8_t *(*get_ram)(void) = dlsym(handle, "GetRamPtr");
+   if (get_ram)
+   {
+      uint8_t *ram = get_ram();
+      uint32_t sp = (ram[0]<<24) | (ram[1]<<16) | (ram[2]<<8) | ram[3];
+      uint32_t pc = (ram[4]<<24) | (ram[5]<<16) | (ram[6]<<8) | ram[7];
+      printf("Initial vectors: SP=0x%08X, PC=0x%08X\n", sp, pc);
+   }
+
+   for (frame_count = 0; frame_count < num_frames; frame_count++)
+   {
+      p_retro_run();
+
+      /* Print status at key frames */
+      if (frame_count == 0 || frame_count == 10 || frame_count == 30 ||
+          frame_count == 60 || frame_count == 120 || frame_count == 299)
+      {
+         if (!got_video)
+            printf("  Frame %u: no video output\n", frame_count);
+      }
+   }
+
+   printf("\nDone. Total frames: %u\n", num_frames);
+
+   p_retro_unload_game();
+   p_retro_deinit();
+   dlclose(handle);
+   return 0;
+}
