Fix save states and rework memory system

All the memory stuff is connected so when fixing the save states it
made sense to prepare for fixing up and enhancing the memory
code. Particularly for allowing for configurable amounts of memory for
homebrew.

Author: trapexit

Makefile.common

@@ -39,11 +39,14 @@ SOURCES_C += \
         $(OPERA_DIR)/opera_diag_port.c \
         $(OPERA_DIR)/opera_dsp.c \
         $(OPERA_DIR)/opera_fixedpoint_math.c \
+        $(OPERA_DIR)/opera_log.c \
         $(OPERA_DIR)/opera_madam.c \
+        $(OPERA_DIR)/opera_mem.c \
         $(OPERA_DIR)/opera_nvram.c \
         $(OPERA_DIR)/opera_pbus.c \
         $(OPERA_DIR)/opera_region.c \
         $(OPERA_DIR)/opera_sport.c \
+        $(OPERA_DIR)/opera_state.c \
         $(OPERA_DIR)/opera_vdlp.c \
         $(OPERA_DIR)/opera_xbus.c \
         $(OPERA_DIR)/opera_xbus_cdrom_plugin.c

libopera/bool.h

@@ -29,6 +29,7 @@
   defined(__i386) ||                            \
   defined(_M_IX86)
 #define IS_BIG_ENDIAN 0
+#define IS_LITTLE_ENDIAN 1
 #elif                                           \
   (defined(__BYTE_ORDER) &&                     \
    (__BYTE_ORDER == __BIG_ENDIAN)) ||           \
@@ -50,10 +51,13 @@
   defined(_XENON) ||                            \
   defined(__sparc__)
 #define IS_BIG_ENDIAN 1
+#define IS_LITTLE_ENDIAN 0
 #elif defined(MSB_FIRST)
 #define IS_BIG_ENDIAN 1
+#define IS_LITTLE_ENDIAN 0
 #else
 #define IS_BIG_ENDIAN 0
+#define IS_LITTLE_ENDIAN 1
 #endif
 
 #if defined(__GNUC__)
@@ -70,13 +74,11 @@
 
 #if IS_BIG_ENDIAN
 
-#define is_little_endian() (0)
 #define swap32_if_little_endian(X) (X)
 #define swap32_array_if_little_endian(X,Y)
 
 #else
 
-#define is_little_endian() (1)
 #define swap32_if_little_endian(X) (SWAP32(X))
 
 static

libopera/endianness.h

@@ -0,0 +1,11 @@
+#ifndef LIBOPERA_FLAGS_H_INCLUDED
+#define LIBOPERA_FLAGS_H_INCLUDED
+
+#define set_flag(V,F) ((V)|=(F))
+#define clr_flag(V,F) ((V)&=~(F))
+#define set_or_clr_flag(V,F,S) ((!!(S)) ? set_flag(V,F) : clr_flag(V,F))
+
+#define flag_is_set(V,F) (!!((V)&(F)))
+#define flag_is_clr(V,F) (!((V)&(F)))
+
+#endif

libopera/flags.h

@@ -34,31 +34,34 @@
 #include "opera_core.h"
 #include "opera_diag_port.h"
 #include "opera_dsp.h"
+#include "opera_log.h"
 #include "opera_madam.h"
+#include "opera_mem.h"
 #include "opera_region.h"
 #include "opera_sport.h"
+#include "opera_state.h"
 #include "opera_vdlp.h"
 #include "opera_xbus.h"
 #include "opera_xbus_cdrom_plugin.h"
 #include "inline.h"
 
 #include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
 
 static opera_ext_interface_t io_interface;
 
 extern int flagtime;
 
-int      HIRESMODE = 0;
-uint32_t FIXMODE   = 0;
-int      CNBFIX    = 0;
+uint32_t FIXMODE = 0;
+int      CNBFIX  = 0;
 
 int
 opera_3do_init(opera_ext_interface_t callback_)
 {
   int i;
-  uint8_t *dram;
-  uint8_t *vram;
+
+  opera_mem_init();
 
   io_interface = callback_;
 
@@ -68,12 +71,9 @@ opera_3do_init(opera_ext_interface_t callback_)
 
   opera_arm_init();
 
-  dram = opera_arm_ram_get();
-  vram = opera_arm_vram_get();
-
-  opera_vdlp_init(vram);
-  opera_sport_init(vram);
-  opera_madam_init(dram);
+  opera_vdlp_init();
+  opera_sport_init();
+  opera_madam_init();
   opera_xbus_init(xbus_cdrom_plugin);
 
   /*
@@ -187,75 +187,106 @@ opera_3do_process_frame(void)
   field = !field;
 }
 
+static
+uint32_t
+opera_3do_state_size_v1(void)
+{
+  uint32_t size;
+
+  size  = 0;
+  size += opera_state_save_size(sizeof(opera_state_hdr_t));
+  size += opera_arm_state_size();
+  size += opera_clio_state_size();
+  size += opera_dsp_state_size();
+  size += opera_madam_state_size();
+  size += opera_mem_state_size();
+  size += opera_sport_state_size();
+  size += opera_vdlp_state_size();
+  size += opera_xbus_state_size();
+
+  return size;
+}
+
 uint32_t
 opera_3do_state_size(void)
 {
-  uint32_t tmp;
-
-  tmp  = 0;
-  tmp += 16 * 4;
-  tmp += opera_arm_state_size();
-  tmp += opera_vdlp_state_size();
-  tmp += opera_dsp_state_size();
-  tmp += opera_clio_state_size();
-  tmp += opera_clock_state_size();
-  tmp += opera_sport_state_size();
-  tmp += opera_madam_state_size();
-  tmp += opera_xbus_state_size();
-
-  return tmp;
+  return opera_3do_state_size_v1();
 }
 
-void
-opera_3do_state_save(void *buf_)
+static
+uint32_t
+opera_3do_state_save_v1(void         *data_,
+                        size_t const  size_)
 {
-  uint8_t *data;
-  uint32_t *indexes;
-
-  data    = buf_;
-  indexes = buf_;
-
-  indexes[0] = 0x97970101;
-  indexes[1] = 16 * 4;
-  indexes[2] = indexes[1] + opera_arm_state_size();
-  indexes[3] = indexes[2] + opera_vdlp_state_size();
-  indexes[4] = indexes[3] + opera_dsp_state_size();
-  indexes[5] = indexes[4] + opera_clio_state_size();
-  indexes[6] = indexes[5] + opera_clock_state_size();
-  indexes[7] = indexes[6] + opera_sport_state_size();
-  indexes[8] = indexes[7] + opera_madam_state_size();
-  indexes[9] = indexes[8] + opera_xbus_state_size();
-
-  opera_arm_state_save(&data[indexes[1]]);
-  opera_vdlp_state_save(&data[indexes[2]]);
-  opera_dsp_state_save(&data[indexes[3]]);
-  opera_clio_state_save(&data[indexes[4]]);
-  opera_clock_state_save(&data[indexes[5]]);
-  opera_sport_state_save(&data[indexes[6]]);
-  opera_madam_state_save(&data[indexes[7]]);
-  opera_xbus_state_save(&data[indexes[8]]);
+  uint8_t *start = (uint8_t*)data_;
+  uint8_t *data  = (uint8_t*)data_;
+  opera_state_hdr_t hdr = {0};
+
+  hdr.version = 0x01;
+
+  data += opera_state_save(data,"3DO",&hdr,sizeof(hdr));
+  data += opera_arm_state_save(data);
+  data += opera_clio_state_save(data);
+  data += opera_dsp_state_save(data);
+  data += opera_madam_state_save(data);
+  data += opera_mem_state_save(data);
+  data += opera_sport_state_save(data);
+  data += opera_vdlp_state_save(data);
+  data += opera_xbus_state_save(data);
+
+  return (data - start);
 }
 
-int
-opera_3do_state_load(const void *buf_)
+uint32_t
+opera_3do_state_save(void         *data_,
+                     size_t const  size_)
 {
-  const uint8_t *data;
-  const uint32_t *indexes;
+  return opera_3do_state_save_v1(data_,size_);
+}
 
-  data    = buf_;
-  indexes = buf_;
+static
+uint32_t
+opera_3do_state_load_v1(const void   *data_,
+                        size_t const  size_)
+{
+  uint8_t const *start = (uint8_t const*)data_;
+  uint8_t const *data  = (uint8_t const*)data_;
+  opera_state_hdr_t hdr = {0};
 
-  if(indexes[0] != 0x97970101)
+  if(size_ != opera_3do_state_size_v1())
     return 0;
 
-  opera_arm_state_load(&data[indexes[1]]);
-  opera_vdlp_state_load(&data[indexes[2]]);
-  opera_dsp_state_load(&data[indexes[3]]);
-  opera_clio_state_load(&data[indexes[4]]);
-  opera_clock_state_load(&data[indexes[5]]);
-  opera_sport_state_load(&data[indexes[6]]);
-  opera_madam_state_load(&data[indexes[7]]);
-  opera_xbus_state_load(&data[indexes[8]]);
+  data += opera_state_load(&hdr,"3DO",data,sizeof(hdr));
+  data += opera_arm_state_load(data);
+  data += opera_clio_state_load(data);
+  data += opera_dsp_state_load(data);
+  data += opera_madam_state_load(data);
+  data += opera_mem_state_load(data);
+  data += opera_sport_state_load(data);
+  data += opera_vdlp_state_load(data);
+  data += opera_xbus_state_load(data);
+
+  return (data - start);
+}
+
+uint32_t
+opera_3do_state_load(void const *data_,
+                     size_t      size_)
+{
+  uint32_t version;
+
+  version = opera_state_get_version(data_,size_);
 
-  return 1;
+  opera_log_printf(OPERA_LOG_DEBUG,"[Opera]: loading state... version %x\n",version);
+
+  switch(version)
+    {
+    case 0x01:
+      return opera_3do_state_load_v1(data_,size_);
+    default:
+      opera_log_printf(OPERA_LOG_ERROR,
+                       "[Opera]: unable to load state - unknown state version %x\n",
+                       version);
+      return 0;
+    }
 }

libopera/opera_3do.c

@@ -7,8 +7,8 @@
 #include <stdint.h>
 
 uint32_t opera_3do_state_size(void);
-void     opera_3do_state_save(void *buf);
-int      opera_3do_state_load(const void *buf);
+uint32_t opera_3do_state_save(void *buf, size_t size);
+uint32_t opera_3do_state_load(void const *buf, size_t size);
 
 int      opera_3do_init(opera_ext_interface_t callback);
 void     opera_3do_destroy(void);