From 1b4442fb65b04160e4b151ea8b526bdea3c677c3 Mon Sep 17 00:00:00 2001 From: Antonio SJ Musumeci Date: Tue, 26 Dec 2023 00:13:47 -0500 Subject: [PATCH] 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. --- Makefile.common | 3 + libopera/bool.h | 9 - libopera/endianness.h | 6 +- libopera/flags.h | 11 + libopera/opera_3do.c | 161 +++++----- libopera/opera_3do.h | 4 +- libopera/opera_arm.c | 386 +++++++----------------- libopera/opera_arm.h | 31 +- libopera/opera_arm_core.h | 7 - libopera/opera_bitop.c | 11 +- libopera/opera_clio.c | 38 +-- libopera/opera_clio.h | 4 +- libopera/opera_clock.c | 19 -- libopera/opera_clock.h | 4 - libopera/opera_core.h | 3 +- libopera/opera_dsp.c | 30 +- libopera/opera_dsp.h | 4 +- libopera/opera_log.c | 26 ++ libopera/opera_log.h | 19 ++ libopera/opera_madam.c | 140 +++------ libopera/opera_madam.h | 6 +- libopera/opera_mem.c | 201 +++++++++++++ libopera/opera_mem.h | 166 +++++++++++ libopera/opera_nvram.c | 42 +-- libopera/opera_nvram.h | 2 - libopera/opera_sport.c | 53 ++-- libopera/opera_sport.h | 6 +- libopera/opera_state.c | 85 ++++++ libopera/opera_state.h | 49 ++++ libopera/opera_vdlp.c | 453 ++++++++++++++++++----------- libopera/opera_vdlp.h | 10 +- libopera/opera_xbus.c | 72 ++--- libopera/opera_xbus.h | 4 +- libopera/opera_xbus_cdrom_plugin.c | 17 +- libretro.c | 90 +++--- lr_input.h | 2 + opera_lr_callbacks.h | 2 +- opera_lr_dsp_threaded.ic | 17 +- opera_lr_nvram.c | 27 +- opera_lr_nvram.h | 2 - opera_lr_opts.c | 15 +- retro_cdimage.c | 18 +- 42 files changed, 1326 insertions(+), 929 deletions(-) delete mode 100644 libopera/bool.h create mode 100644 libopera/flags.h create mode 100644 libopera/opera_log.c create mode 100644 libopera/opera_log.h create mode 100644 libopera/opera_mem.c create mode 100644 libopera/opera_mem.h create mode 100644 libopera/opera_state.c create mode 100644 libopera/opera_state.h diff --git a/Makefile.common b/Makefile.common index 19a0d3f..e0f986a 100644 --- a/Makefile.common +++ b/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 diff --git a/libopera/bool.h b/libopera/bool.h deleted file mode 100644 index 16243c8..0000000 --- a/libopera/bool.h +++ /dev/null @@ -1,9 +0,0 @@ -#ifndef LIBOPERA_BOOL_H_INCLUDED -#define LIBOPERA_BOOL_H_INCLUDED - -typedef int bool_t; - -#define TRUE 1 -#define FALSE 0 - -#endif diff --git a/libopera/endianness.h b/libopera/endianness.h index b5d80d0..1ea7a5e 100644 --- a/libopera/endianness.h +++ b/libopera/endianness.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 diff --git a/libopera/flags.h b/libopera/flags.h new file mode 100644 index 0000000..8d60466 --- /dev/null +++ b/libopera/flags.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 diff --git a/libopera/opera_3do.c b/libopera/opera_3do.c index 7e14a2e..0da6009 100644 --- a/libopera/opera_3do.c +++ b/libopera/opera_3do.c @@ -34,9 +34,12 @@ #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" @@ -44,21 +47,21 @@ #include #include +#include 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; + uint8_t *start = (uint8_t*)data_; + uint8_t *data = (uint8_t*)data_; + opera_state_hdr_t hdr = {0}; - data = buf_; - indexes = buf_; + hdr.version = 0x01; - 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(); + 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); - 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]]); + 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 1; + 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_); + + 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; + } } diff --git a/libopera/opera_3do.h b/libopera/opera_3do.h index aba66eb..0993e45 100644 --- a/libopera/opera_3do.h +++ b/libopera/opera_3do.h @@ -7,8 +7,8 @@ #include 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); diff --git a/libopera/opera_arm.c b/libopera/opera_arm.c index 43d0b45..ead81ce 100644 --- a/libopera/opera_arm.c +++ b/libopera/opera_arm.c @@ -28,10 +28,11 @@ * Felix Lazarev */ -#include "bool.h" +#include "boolean.h" #include "endianness.h" #include "hack_flags.h" #include "inline.h" + #include "opera_arm.h" #include "opera_arm_core.h" #include "opera_clio.h" @@ -39,7 +40,9 @@ #include "opera_diag_port.h" #include "opera_fixedpoint_math.h" #include "opera_madam.h" +#include "opera_mem.h" #include "opera_sport.h" +#include "opera_state.h" #include "opera_swi_hle_0x5XXXX.h" #include @@ -107,13 +110,6 @@ const static uint16_t cond_flags_cross[]= 0x0000 //never }; -#define DRAM_SIZE ( 2 * 1024 * 1024) -#define VRAM_SIZE ( 1 * 1024 * 1024) -#define RAM_SIZE ( 3 * 1024 * 1024) -#define ROM1_SIZE ( 1 * 1024 * 1024) -#define ROM2_SIZE ( 1 * 1024 * 1024) -#define NVRAM_SIZE (32 * 1024) - static int g_SWI_HLE; static arm_core_t CPU; static int CYCLES; //cycle counter @@ -125,128 +121,22 @@ static void mwriteb(uint32_t addr, uint8_t val); static uint32_t mreadw(uint32_t addr); static void mwritew(uint32_t addr,uint32_t val); -uint8_t* -opera_arm_nvram_get(void) -{ - return CPU.nvram; -} - -uint64_t -opera_arm_nvram_size(void) -{ - return NVRAM_SIZE; -} - -uint8_t* -opera_arm_rom1_get(void) -{ - return CPU.rom1; -} - -uint64_t -opera_arm_rom1_size(void) -{ - return ROM1_SIZE; -} - -void -opera_arm_rom1_byteswap_if_necessary(void) -{ - uint8_t *rom; - int64_t size; - - rom = opera_arm_rom1_get(); - size = opera_arm_rom1_size(); - - swap32_array_if_little_endian((uint32_t*)rom,(size / sizeof(uint32_t))); -} - -uint8_t* -opera_arm_rom2_get(void) -{ - return CPU.rom2; -} - -uint64_t -opera_arm_rom2_size(void) -{ - return ROM2_SIZE; -} - -void -opera_arm_rom2_byteswap_if_necessary(void) -{ - uint8_t *rom; - int64_t size; - - rom = opera_arm_rom2_get(); - size = opera_arm_rom2_size(); - - swap32_array_if_little_endian((uint32_t*)rom,(size / sizeof(uint32_t))); -} - -uint8_t* -opera_arm_ram_get(void) -{ - return CPU.ram; -} - -uint64_t -opera_arm_ram_size(void) -{ - return DRAM_SIZE; -} - -uint8_t* -opera_arm_vram_get(void) -{ - return (CPU.ram + DRAM_SIZE); -} - -uint64_t -opera_arm_vram_size(void) -{ - return VRAM_SIZE; -} - uint32_t opera_arm_state_size(void) { - return (sizeof(arm_core_t) + RAM_SIZE + ROM1_SIZE + NVRAM_SIZE); + return opera_state_save_size(sizeof(CPU)); } -void -opera_arm_state_save(void *buf_) +uint32_t +opera_arm_state_save(void *data_) { - memcpy(buf_,&CPU,sizeof(arm_core_t)); - memcpy(((uint8_t*)buf_)+sizeof(arm_core_t),CPU.ram,RAM_SIZE); - memcpy(((uint8_t*)buf_)+sizeof(arm_core_t)+RAM_SIZE,CPU.rom1,ROM1_SIZE); - memcpy(((uint8_t*)buf_)+sizeof(arm_core_t)+RAM_SIZE+ROM1_SIZE,CPU.nvram,NVRAM_SIZE); + return opera_state_save(data_,"ARM",&CPU,sizeof(CPU)); } -void -opera_arm_state_load(const void *buf_) +uint32_t +opera_arm_state_load(void const *data_) { - uint8_t i; - uint8_t *ram = CPU.ram; - uint8_t *rom1 = CPU.rom1; - uint8_t *rom2 = CPU.rom2; - uint8_t *nvram = CPU.nvram; - - memcpy(&CPU,buf_,sizeof(arm_core_t)); - memcpy(ram,((uint8_t*)buf_)+sizeof(arm_core_t),RAM_SIZE); - memcpy(rom1,((uint8_t*)buf_)+sizeof(arm_core_t)+RAM_SIZE,ROM1_SIZE); - memcpy(nvram,((uint8_t*)buf_)+sizeof(arm_core_t)+RAM_SIZE+ROM1_SIZE,NVRAM_SIZE); - - for(i = 3; i < 18; i++) - memcpy(ram + (i * 1024 * 1024), - ram + (2 * 1024 * 1024), - 1024 * 1024); - - CPU.ram = ram; - CPU.rom1 = rom1; - CPU.rom2 = rom2; - CPU.nvram = nvram; + return opera_state_load(&CPU,"ARM",data_,sizeof(CPU)); } static @@ -518,12 +408,6 @@ ARM_Change_ModeSafe(uint32_t mode_) } } -void -opera_arm_rom_select(int n_) -{ - CPU.rom = ((n_ == 0) ? CPU.rom1 : CPU.rom2); -} - static INLINE void @@ -634,14 +518,8 @@ opera_arm_init(void) for(i = 0;i < 7; i++) CPU.CASH[i] = CPU.FIQ[i] = 0; - CPU.ram = calloc(RAM_SIZE + 1024*1024*16,1); - CPU.rom1 = calloc(ROM1_SIZE,1); - CPU.rom2 = calloc(ROM2_SIZE,1); - CPU.rom = CPU.rom1; - CPU.nvram = calloc(NVRAM_SIZE,1); - - CPU.nFIQ = FALSE; - CPU.MAS_Access_Exept = FALSE; + CPU.nFIQ = false; + CPU.MAS_Access_Exept = false; CPU.USER[15] = ARM_INITIAL_PC; arm_cpsr_set(0x13); @@ -650,21 +528,7 @@ opera_arm_init(void) void opera_arm_destroy(void) { - if(CPU.nvram) - free(CPU.nvram); - CPU.nvram = NULL; - if(CPU.rom1) - free(CPU.rom1); - CPU.rom1 = NULL; - - if(CPU.rom2) - free(CPU.rom2); - CPU.rom2 = NULL; - - if(CPU.ram) - free(CPU.ram); - CPU.ram = NULL; } void @@ -673,7 +537,7 @@ opera_arm_reset(void) int i; CYCLES = 0; - CPU.rom = CPU.rom1; + opera_mem_rom_select(ROM1); for(i = 0; i < 16; i++) CPU.USER[i] = 0; @@ -689,9 +553,9 @@ opera_arm_reset(void) for(i = 0; i < 7; i++) CPU.CASH[i] = CPU.FIQ[i] = 0; - CPU.MAS_Access_Exept = FALSE; + CPU.MAS_Access_Exept = false; - CPU.nFIQ = FALSE; + CPU.nFIQ = false; CPU.USER[15] = ARM_INITIAL_PC; arm_cpsr_set(0x13); @@ -804,7 +668,7 @@ ldm_accur(uint32_t opc_, tmp+=0x1000; } - if((inuse == 1) && (base_comp & 0x1FFFFF)) + if((inuse == 1) && (base_comp)) { if(base_comp == addrr) inuse = 0; @@ -903,7 +767,7 @@ stm_accur(uint32_t opc_, if(list&1) { mwritew(base_comp,CPU.USER[i]); - if(base_comp & 0x1FFFFF) + if(base_comp) { addrr = base_comp; vall = CPU.USER[i]; @@ -975,54 +839,54 @@ static void decode_swi_hle(const uint32_t op_) switch(op_ & 0x000FFFFF) { case 0x50000: - opera_swi_hle_0x50000(CPU.ram,CPU.USER[0],CPU.USER[1],CPU.USER[2]); + opera_swi_hle_0x50000(DRAM,CPU.USER[0],CPU.USER[1],CPU.USER[2]); return; case 0x50001: - opera_swi_hle_0x50001(CPU.ram,CPU.USER[0],CPU.USER[1],CPU.USER[2]); + opera_swi_hle_0x50001(DRAM,CPU.USER[0],CPU.USER[1],CPU.USER[2]); return; case 0x50002: - opera_swi_hle_0x50002(CPU.ram,CPU.USER[0],CPU.USER[1],CPU.USER[2],CPU.USER[3]); + opera_swi_hle_0x50002(DRAM,CPU.USER[0],CPU.USER[1],CPU.USER[2],CPU.USER[3]); return; case 0x50003: break; case 0x50004: break; case 0x50005: - opera_swi_hle_0x50005(CPU.ram,CPU.USER[0],CPU.USER[1],CPU.USER[2],CPU.USER[3]); + opera_swi_hle_0x50005(DRAM,CPU.USER[0],CPU.USER[1],CPU.USER[2],CPU.USER[3]); return; case 0x50006: - opera_swi_hle_0x50006(CPU.ram,CPU.USER[0],CPU.USER[1],CPU.USER[2],CPU.USER[3]); + opera_swi_hle_0x50006(DRAM,CPU.USER[0],CPU.USER[1],CPU.USER[2],CPU.USER[3]); return; case 0x50007: - opera_swi_hle_0x50007(CPU.ram,CPU.USER[0],CPU.USER[1],CPU.USER[2]); + opera_swi_hle_0x50007(DRAM,CPU.USER[0],CPU.USER[1],CPU.USER[2]); return; case 0x50008: - opera_swi_hle_0x50008(CPU.ram,CPU.USER[0],CPU.USER[1],CPU.USER[2]); + opera_swi_hle_0x50008(DRAM,CPU.USER[0],CPU.USER[1],CPU.USER[2]); return; case 0x50009: - opera_swi_hle_0x50009(CPU.ram,CPU.USER[0],CPU.USER[1],CPU.USER[2],CPU.USER[3]); + opera_swi_hle_0x50009(DRAM,CPU.USER[0],CPU.USER[1],CPU.USER[2],CPU.USER[3]); return; case 0x5000A: break; case 0x5000B: break; case 0x5000C: - CPU.USER[0] = opera_swi_hle_0x5000C(CPU.ram,CPU.USER[0],CPU.USER[1]); + CPU.USER[0] = opera_swi_hle_0x5000C(DRAM,CPU.USER[0],CPU.USER[1]); return; case 0x5000E: - opera_swi_hle_0x5000E(CPU.ram,CPU.USER[0],CPU.USER[1],CPU.USER[2]); + opera_swi_hle_0x5000E(DRAM,CPU.USER[0],CPU.USER[1],CPU.USER[2]); return; case 0x5000F: - CPU.USER[0] = opera_swi_hle_0x5000F(CPU.ram,CPU.USER[0]); + CPU.USER[0] = opera_swi_hle_0x5000F(DRAM,CPU.USER[0]); return; case 0x50010: - CPU.USER[0] = opera_swi_hle_0x50010(CPU.ram,CPU.USER[0]); + CPU.USER[0] = opera_swi_hle_0x50010(DRAM,CPU.USER[0]); return; case 0x50011: - opera_swi_hle_0x50011(CPU.ram,CPU.USER[0],CPU.USER[1],CPU.USER[2],CPU.USER[3]); + opera_swi_hle_0x50011(DRAM,CPU.USER[0],CPU.USER[1],CPU.USER[2],CPU.USER[3]); return; case 0x50012: - opera_swi_hle_0x50012(CPU.ram,CPU.USER[0]); + opera_swi_hle_0x50012(DRAM,CPU.USER[0]); return; } @@ -1153,7 +1017,7 @@ ARM_ALU_Exec(uint32_t inst_, CPU.USER[(inst_ >> 12) & 0xF] = CPU.SPSR[arm_mode_table[CPU.CPSR & 0x1F]]; else CPU.USER[(inst_ >> 12) & 0xF] = CPU.CPSR; - return TRUE; + return true; case 18: case 22: if(!((inst_ >> 16) & 0x1) || !(arm_mode_table[MODE])) @@ -1170,7 +1034,7 @@ ARM_ALU_Exec(uint32_t inst_, else arm_cpsr_set(op2_); } - return TRUE; + return true; case 24: *rd_ = op1_ | op2_; break; @@ -1225,19 +1089,19 @@ ARM_ALU_Exec(uint32_t inst_, case 17: op1_ &= op2_; ARM_SET_ZN(op1_); - return TRUE; + return true; case 19: op1_ ^= op2_; ARM_SET_ZN(op1_); - return TRUE; + return true; case 21: ARM_SET_CV_sub(op1_ - op2_,op1_,op2_); ARM_SET_ZN(op1_ - op2_); - return TRUE; + return true; case 23: ARM_SET_CV(op1_ + op2_,op1_,op2_); ARM_SET_ZN(op1_ + op2_); - return TRUE; + return true; case 25: *rd_ = op1_ | op2_; ARM_SET_ZN(*rd_); @@ -1255,7 +1119,8 @@ ARM_ALU_Exec(uint32_t inst_, ARM_SET_ZN(*rd_); break; }; - return FALSE; + + return false; } static @@ -1441,19 +1306,19 @@ ARM_SWAP(uint32_t cmd_) if(cmd_ & (1 << 22)) { tmp = mreadb(addr); - // if(MAS_Access_Exept)return TRUE; + // if(MAS_Access_Exept)return true; mwriteb(addr,CPU.USER[cmd_ & 0xF]); CPU.USER[15] -= 8; - // if(MAS_Access_Exept)return TRUE; + // if(MAS_Access_Exept)return true; CPU.USER[(cmd_ >> 12) & 0xF] = tmp; } else { tmp = mreadw(addr); - //if(MAS_Access_Exept)return TRUE; + //if(MAS_Access_Exept)return true; mwritew(addr,CPU.USER[cmd_ & 0xF]); CPU.USER[15] -= 8; - //if(MAS_Access_Exept)return TRUE; + //if(MAS_Access_Exept)return true; if(addr & 3) tmp = ((tmp >> ((addr & 3) << 3)) | (tmp << (32 - ((addr & 3) << 3)))); CPU.USER[(cmd_ >> 12) & 0xF] = tmp; @@ -1513,10 +1378,10 @@ calcbits(uint32_t num_) static const int is_logic[] = { - TRUE,TRUE,FALSE,FALSE, - FALSE,FALSE,FALSE,FALSE, - TRUE,TRUE,FALSE,FALSE, - TRUE,TRUE,TRUE,TRUE + true,true,false,false, + false,false,false,false, + true,true,false,false, + true,true,true,true }; int32_t @@ -1530,7 +1395,7 @@ opera_arm_execute(void) uint32_t pc_tmp; int isexeption; - isexeption = FALSE; + isexeption = false; if((CPU.USER[15] == 0x94D60) && (CPU.USER[0] == 0x113000) && (CPU.USER[1] == 0x113000) && @@ -1546,10 +1411,10 @@ opera_arm_execute(void) CYCLES = -SCYCLE; if((cmd == 0xE5101810) && (CPU.CPSR == 0x80000093)) - isexeption = TRUE; + isexeption = true; if(((cond_flags_cross[cmd >> 28] >> (CPU.CPSR >> 28)) & 1) && - (isexeption == FALSE)) + (isexeption == false)) { switch((cmd >> 24) & 0xF) { @@ -1815,7 +1680,7 @@ opera_arm_execute(void) CPU.USER[14] = (CPU.USER[15] + 4); CPU.USER[15] = 0x00000010; CYCLES-=SCYCLE+NCYCLE; - MAS_Access_Exept=FALSE; + MAS_Access_Exept=false; break; } */ break; @@ -1847,7 +1712,7 @@ opera_arm_execute(void) if(!ISF && opera_clio_fiq_needed()/*CPU.nFIQ*/) { //Set_madam_FSM(FSM_SUSPENDED); - CPU.nFIQ = FALSE; + CPU.nFIQ = false; CPU.SPSR[arm_mode_table[0x11]] = CPU.CPSR; SETF(1); SETI(1); @@ -1859,80 +1724,28 @@ opera_arm_execute(void) return -CYCLES; } +static void -opera_mem_write8(uint32_t addr_, - uint8_t val_) -{ - CPU.ram[addr_] = val_; - if(!HIRESMODE || (addr_ < 0x200000)) - return; - CPU.ram[addr_ + 1*1024*1024] = val_; - CPU.ram[addr_ + 2*1024*1024] = val_; - CPU.ram[addr_ + 3*1024*1024] = val_; -} - -void -opera_mem_write16(uint32_t addr_, - uint16_t val_) -{ - *((uint16_t*)&CPU.ram[addr_]) = val_; - if(!HIRESMODE || (addr_ < 0x200000)) - return; - *((uint16_t*)&CPU.ram[addr_ + 1*1024*1024]) = val_; - *((uint16_t*)&CPU.ram[addr_ + 2*1024*1024]) = val_; - *((uint16_t*)&CPU.ram[addr_ + 3*1024*1024]) = val_; -} - -void -opera_mem_write32(uint32_t addr_, - uint32_t val_) -{ - *((uint32_t*)&CPU.ram[addr_]) = val_; - if(!HIRESMODE || (addr_ < 0x200000)) - return; - *((uint32_t*)&CPU.ram[addr_ + 1*1024*1024]) = val_; - *((uint32_t*)&CPU.ram[addr_ + 2*1024*1024]) = val_; - *((uint32_t*)&CPU.ram[addr_ + 3*1024*1024]) = val_; -} - -uint16_t -opera_mem_read16(uint32_t addr_) -{ - return *((uint16_t*)&CPU.ram[addr_]); -} - -uint32_t -opera_mem_read32(uint32_t addr_) -{ - return *((uint32_t*)&CPU.ram[addr_]); -} - -uint8_t -opera_mem_read8(uint32_t addr_) -{ - return CPU.ram[addr_]; -} - -static void mwritew(uint32_t addr_, uint32_t val_) +mwritew(uint32_t const addr_, + uint32_t const val_) { uint32_t index; + uint32_t const addr = (addr_ & ~3); - addr_ &= ~3; - - if(addr_ < 0x00300000) + if(addr < RAM_SIZE) { - opera_mem_write32(addr_,val_); + opera_mem_write32(addr,val_); return; } - index = (addr_ ^ 0x03300000); + index = (addr ^ 0x03300000); if(!(index & ~0x7FF)) { opera_madam_poke(index,val_); return; } - index = (addr_ ^ 0x03400000); + index = (addr ^ 0x03400000); if(!(index & ~0xFFFF)) { if(opera_clio_poke(index,val_)) @@ -1940,43 +1753,42 @@ static void mwritew(uint32_t addr_, uint32_t val_) return; } - index = (addr_ ^ 0x03200000); + index = (addr ^ 0x03200000); if(!(index & ~0xFFFFF)) { opera_sport_write_access(index,val_); return; } - index = (addr_ ^ 0x03100000); + index = (addr ^ 0x03100000); if(!(index & ~0xFFFFF)) { if(index & 0x80000) opera_diag_port_send(val_); else if(index & 0x40000) - CPU.nvram[(index >> 2) & 0x7FFF] = (uint8_t)val_; + NVRAM[(index >> 2) & NVRAM_SIZE_MASK] = (uint8_t)val_; } } static uint32_t -mreadw(uint32_t addr_) +mreadw(uint32_t const addr_) { int32_t index; + uint32_t const addr = (addr_ & ~3); - addr_ &= ~3; + if(addr < RAM_SIZE) + return opera_mem_read32(addr); - if(addr_ < 0x00300000) - return opera_mem_read32(addr_); - - index = (addr_ ^ 0x03300000); + index = (addr ^ 0x03300000); if(!(index & ~0xFFFFF)) return opera_madam_peek(index); - index = (addr_ ^ 0x03400000); + index = (addr ^ 0x03400000); if(!(index & ~0xFFFFF)) return opera_clio_peek(index); - index = (addr_ ^ 0x03200000); + index = (addr ^ 0x03200000); if(!(index & ~0xFFFFF)) { if(!(index & ~0x1FFF)) @@ -1985,36 +1797,39 @@ mreadw(uint32_t addr_) } /* Standard ROM */ - index = (addr_ ^ 0x03000000); - if(!(index & ~0xFFFFF)) - return *(uint32_t*)&CPU.rom[index]; + index = (addr ^ 0x03000000); + if(!(index & ~ROM1_SIZE_MASK)) + return *(uint32_t*)&ROM[index]; /* ANVIL ROM */ - index = (addr_ ^ 0x06000000); - if(!(index & ~0xFFFFF)) - return *(uint32_t*)&CPU.rom[index]; + index = (addr ^ 0x06000000); + if(!(index & ~ROM1_SIZE_MASK)) + return *(uint32_t*)&ROM[index]; - index = (addr_ ^ 0x03100000); + index = (addr ^ 0x03100000); if(!(index & ~0xFFFFF)) { if(index & 0x80000) return opera_diag_port_get(); else if(index & 0x40000) - return CPU.nvram[(index >> 2) & 0x7FFF]; + return NVRAM[(index >> 2) & NVRAM_SIZE_MASK]; } - /* MAS_Access_Exept = TRUE; */ + /* MAS_Access_Exept = true; */ return 0xBADACCE5; } -static void mwriteb(uint32_t addr_, uint8_t val_) +static +void +mwriteb(uint32_t const addr_, + uint8_t const val_) { int32_t index; - if(addr_ < 0x00300000) + if(addr_ < RAM_SIZE) { - opera_mem_write8(addr_ ^ 3,val_); + opera_mem_write8(addr_,val_); return; } @@ -2023,7 +1838,7 @@ static void mwriteb(uint32_t addr_, uint8_t val_) { if((index & 0x40000) == 0x40000) { - CPU.nvram[(index >> 2) & 0x7FFF] = val_; + NVRAM[(index >> 2) & NVRAM_SIZE_MASK] = val_; return; } } @@ -2031,31 +1846,31 @@ static void mwriteb(uint32_t addr_, uint8_t val_) static uint32_t -mreadb(uint32_t addr_) +mreadb(uint32_t const addr_) { int32_t index; - if(addr_ < 0x00300000) - return opera_mem_read8(addr_ ^ 3); + if(addr_ < RAM_SIZE) + return opera_mem_read8(addr_); /* Standard ROM */ index = (addr_ ^ 0x03000003); - if(!(index & ~0xFFFFF)) - return CPU.rom[index]; + if(!(index & ~ROM1_SIZE_MASK)) + return ROM[index]; /* ANVIL ROM */ index = (addr_ ^ 0x06000003); - if(!(index & ~0xFFFFF)) - return CPU.rom[index]; + if(!(index & ~ROM1_SIZE_MASK)) + return ROM[index]; index = (addr_ ^ 0x03100003); if(!(index & ~0xFFFFF)) { if((index & 0x40000) == 0x40000) - return CPU.nvram[(index >> 2) & 0x7FFF]; + return NVRAM[(index >> 2) & NVRAM_SIZE_MASK]; } - /* MAS_Access_Exept = TRUE; */ + /* MAS_Access_Exept = true; */ return 0xBADACCE5; } @@ -2121,12 +1936,9 @@ readusr(uint32_t n_) return 0; } -uint32_t opera_io_read(const uint32_t addr_) -{ - return mreadw(addr_); -} - -void opera_io_write(const uint32_t addr_, const uint32_t val_) +void +opera_io_write(uint32_t const addr_, + uint32_t const val_) { mwritew(addr_,val_); } diff --git a/libopera/opera_arm.h b/libopera/opera_arm.h index 9e260ae..97864f8 100644 --- a/libopera/opera_arm.h +++ b/libopera/opera_arm.h @@ -42,38 +42,11 @@ void opera_arm_init(void); void opera_arm_reset(void); void opera_arm_destroy(void); -void opera_mem_write8(uint32_t addr_, uint8_t val_); -void opera_mem_write16(uint32_t addr_, uint16_t val_); -void opera_mem_write32(uint32_t addr_, uint32_t val_); -uint8_t opera_mem_read8(uint32_t addr_); -uint16_t opera_mem_read16(uint32_t addr_); -uint32_t opera_mem_read32(uint32_t addr_); - void opera_io_write(const uint32_t addr_, const uint32_t val_); -uint32_t opera_io_read(const uint32_t addr_); uint32_t opera_arm_state_size(void); -void opera_arm_state_save(void *buf_); -void opera_arm_state_load(const void *buf_); - -uint8_t* opera_arm_nvram_get(void); -uint64_t opera_arm_nvram_size(void); - -void opera_arm_rom_select(int n_); - -uint8_t* opera_arm_rom1_get(void); -uint64_t opera_arm_rom1_size(void); -void opera_arm_rom1_byteswap_if_necessary(void); - -uint8_t* opera_arm_rom2_get(void); -uint64_t opera_arm_rom2_size(void); -void opera_arm_rom2_byteswap_if_necessary(void); - -uint8_t* opera_arm_ram_get(void); -uint64_t opera_arm_ram_size(void); - -uint8_t* opera_arm_vram_get(void); -uint64_t opera_arm_vram_size(void); +uint32_t opera_arm_state_save(void *buf_); +uint32_t opera_arm_state_load(const void *buf_); void opera_arm_swi_hle_set(const int hle); int opera_arm_swi_hle_get(void); diff --git a/libopera/opera_arm_core.h b/libopera/opera_arm_core.h index a54e1b4..70956c0 100644 --- a/libopera/opera_arm_core.h +++ b/libopera/opera_arm_core.h @@ -6,13 +6,6 @@ typedef struct arm_core_s arm_core_t; struct arm_core_s { - uint8_t *ram; - uint8_t *rom; /* points to current rom bank */ - uint8_t *rom1; - uint8_t *rom2; - uint8_t *nvram; - - //ARM60 registers uint32_t USER[16]; uint32_t CASH[7]; uint32_t SVC[2]; diff --git a/libopera/opera_bitop.c b/libopera/opera_bitop.c index bdd3c3a..14bcff6 100644 --- a/libopera/opera_bitop.c +++ b/libopera/opera_bitop.c @@ -24,6 +24,7 @@ #include #include "opera_arm.h" +#include "opera_mem.h" #include "opera_bitop.h" void BitReaderBig_AttachBuffer(struct BitReaderBig *bit, uint32_t buff) @@ -62,7 +63,7 @@ uint32_t BitReaderBig_Read(struct BitReaderBig *bit, uint8_t bits) if((8 - bit->bitpoint) > bit->bitset) { - retval = opera_mem_read8(bit->buf + (bit->point ^ 3)); + retval = opera_mem_read8(bit->buf + bit->point); retval >>= 8 - bit->bitpoint - bit->bitset; retval &= mas[bit->bitset]; bit->bitpoint += bit->bitset; @@ -71,7 +72,7 @@ uint32_t BitReaderBig_Read(struct BitReaderBig *bit, uint8_t bits) if (bit->bitpoint) { - retval = opera_mem_read8(bit->buf + (bit->point ^ 3)) & mas[8 - bit->bitpoint]; + retval = opera_mem_read8(bit->buf + bit->point) & mas[8 - bit->bitpoint]; bit->point++; bitcnt -= 8 - bit->bitpoint; } @@ -79,15 +80,15 @@ uint32_t BitReaderBig_Read(struct BitReaderBig *bit, uint8_t bits) while(bitcnt>=8) { retval <<= 8; - retval |= opera_mem_read8(bit->buf + (bit->point ^ 3)); + retval |= opera_mem_read8(bit->buf + bit->point); bit->point++; bitcnt-=8; } if(bitcnt) { - retval<<=bitcnt; - retval|=opera_mem_read8(bit->buf + (bit->point^3)) >> (8 - bitcnt); + retval <<= bitcnt; + retval |= opera_mem_read8(bit->buf + bit->point) >> (8 - bitcnt); } bit->bitpoint = bitcnt; diff --git a/libopera/opera_clio.c b/libopera/opera_clio.c index f5b86a5..331be50 100644 --- a/libopera/opera_clio.c +++ b/libopera/opera_clio.c @@ -33,6 +33,8 @@ #include "opera_clock.h" #include "opera_dsp.h" #include "opera_madam.h" +#include "opera_mem.h" +#include "opera_state.h" #include "opera_xbus.h" #include "boolean.h" @@ -79,26 +81,26 @@ int flagtime; int TIMER_VAL = 0; //0x415 static uint32_t *MADAM_REGS; -static clio_t CLIO; +static clio_t CLIO = {0}; uint32_t opera_clio_state_size(void) { - return sizeof(clio_t); + return opera_state_save_size(sizeof(clio_t)); } -void +uint32_t opera_clio_state_save(void *buf_) { - memcpy(buf_,&CLIO,sizeof(clio_t)); + return opera_state_save(buf_,"CLIO",&CLIO,sizeof(CLIO)); } -void +uint32_t opera_clio_state_load(const void *buf_) { TIMER_VAL = 0; - memcpy(&CLIO,buf_,sizeof(clio_t)); + return opera_state_load(&CLIO,"CLIO",buf_,sizeof(CLIO)); } #define CURADR MADAM_REGS[base+0x00] @@ -200,17 +202,10 @@ clio_handle_dma(uint32_t val_) b1 = opera_xbus_fifo_get_data(); b0 = opera_xbus_fifo_get_data(); -#ifdef MSB_FIRST opera_mem_write8(trg+0,b3); opera_mem_write8(trg+1,b2); opera_mem_write8(trg+2,b1); opera_mem_write8(trg+3,b0); -#else - opera_mem_write8(trg+0,b0); - opera_mem_write8(trg+1,b1); - opera_mem_write8(trg+2,b2); - opera_mem_write8(trg+3,b3); -#endif trg += 4; len -= 4; @@ -227,17 +222,10 @@ clio_handle_dma(uint32_t val_) b1 = opera_xbus_fifo_get_data(); b0 = opera_xbus_fifo_get_data(); -#ifdef MSB_FIRST opera_mem_write8(trg+0,b3); opera_mem_write8(trg+1,b2); opera_mem_write8(trg+2,b1); opera_mem_write8(trg+3,b0); -#else - opera_mem_write8(trg+0,b0); - opera_mem_write8(trg+1,b1); - opera_mem_write8(trg+2,b2); - opera_mem_write8(trg+3,b3); -#endif trg += 4; len -= 4; @@ -365,7 +353,7 @@ opera_clio_poke(uint32_t addr_, if_set_set_reset(&CLIO.regs[0x84],val_,0x40,0x04); if_set_set_reset(&CLIO.regs[0x84],val_,0x80,0x08); - opera_arm_rom_select(!!(val_ & 0x4)); + opera_mem_rom_select((val_ & 0x4) ? ROM2 : ROM1); return 0; } @@ -712,11 +700,7 @@ opera_clio_reset(void) uint16_t opera_clio_fifo_ei_read(uint16_t channel_) { -#ifdef MSB_FIRST return opera_mem_read16(((CLIO.fifo_i[channel_].start.addr + CLIO.fifo_i[channel_].idx))); -#else - return opera_mem_read16(((CLIO.fifo_i[channel_].start.addr + CLIO.fifo_i[channel_].idx)^2)); -#endif } static @@ -724,11 +708,7 @@ void opera_clio_fifo_eo_write(uint16_t channel_, uint16_t val_) { -#ifdef MSB_FIRST opera_mem_write16(((CLIO.fifo_o[channel_].start.addr + CLIO.fifo_o[channel_].idx)),val_); -#else - opera_mem_write16(((CLIO.fifo_o[channel_].start.addr + CLIO.fifo_o[channel_].idx)^2),val_); -#endif } static diff --git a/libopera/opera_clio.h b/libopera/opera_clio.h index 6371e3c..8d6d763 100644 --- a/libopera/opera_clio.h +++ b/libopera/opera_clio.h @@ -63,8 +63,8 @@ uint32_t opera_clio_timer_get_delay(void); void opera_clio_timer_execute(void); uint32_t opera_clio_state_size(void); -void opera_clio_state_save(void *buf_); -void opera_clio_state_load(const void *buf_); +uint32_t opera_clio_state_save(void *buf_); +uint32_t opera_clio_state_load(const void *buf_); EXTERN_C_END diff --git a/libopera/opera_clock.c b/libopera/opera_clock.c index ea1f7b8..a4ffc75 100644 --- a/libopera/opera_clock.c +++ b/libopera/opera_clock.c @@ -117,25 +117,6 @@ opera_clock_cpu_get_default_freq(void) return DEFAULT_CPU_FREQ; } -/* Unnecessary. For backwards compatibility. */ -uint32_t -opera_clock_state_size(void) -{ - return (sizeof(uint32_t) * 8); -} - -void -opera_clock_state_save(void *buf_) -{ - /* memcpy(buf_,&g_CLOCK,sizeof(opera_clock_t)); */ -} - -void -opera_clock_state_load(const void *buf_) -{ - /* memcpy(&g_CLOCK,buf_,sizeof(opera_clock_t)); */ -} - void opera_clock_init(void) { diff --git a/libopera/opera_clock.h b/libopera/opera_clock.h index 44c68e3..9c48bac 100644 --- a/libopera/opera_clock.h +++ b/libopera/opera_clock.h @@ -21,10 +21,6 @@ uint32_t opera_clock_cpu_get_freq(void); uint32_t opera_clock_cpu_get_default_freq(void); uint64_t opera_clock_cpu_cycles_per_field(void); -uint32_t opera_clock_state_size(void); -void opera_clock_state_save(void *buf); -void opera_clock_state_load(const void *buf); - void opera_clock_region_set_ntsc(void); void opera_clock_region_set_pal(void); diff --git a/libopera/opera_core.h b/libopera/opera_core.h index 6773b37..74b4296 100644 --- a/libopera/opera_core.h +++ b/libopera/opera_core.h @@ -34,9 +34,8 @@ typedef void* (*opera_ext_interface_t)(int, void*); EXTERN_C_BEGIN -extern int HIRESMODE; -extern int CNBFIX; extern uint32_t FIXMODE; +extern int CNBFIX; EXTERN_C_END diff --git a/libopera/opera_dsp.c b/libopera/opera_dsp.c index e5cf895..a2516e0 100644 --- a/libopera/opera_dsp.c +++ b/libopera/opera_dsp.c @@ -28,11 +28,13 @@ * Felix Lazarev */ -#include "bool.h" +#include "boolean.h" #include "inline.h" + #include "opera_clio.h" #include "opera_core.h" #include "opera_dsp.h" +#include "opera_state.h" #include "prng16.h" #include @@ -210,8 +212,8 @@ struct INTAG_s uint16_t nOP_MASK; uint16_t WRITEBACK; REQ_t req; - bool_t Running; - bool_t GenFIQ; + bool Running; + bool GenFIQ; }; typedef struct INTAG_s INTAG_t; @@ -433,7 +435,7 @@ dsp_write(uint32_t addr_, break; case 0x3EE: DSP.dregs.INT = val_; - DSP.flags.GenFIQ = TRUE; + DSP.flags.GenFIQ = true; break; case 0x3EF: DSP.dregs.DSPPRLD = val_; @@ -467,19 +469,19 @@ dsp_write(uint32_t addr_, uint32_t opera_dsp_state_size(void) { - return sizeof(dsp_t); + return opera_state_save_size(sizeof(DSP)); } -void +uint32_t opera_dsp_state_save(void *buf_) { - memcpy(buf_,&DSP,sizeof(dsp_t)); + return opera_state_save(buf_,"DSPP",&DSP,sizeof(DSP)); } -void +uint32_t opera_dsp_state_load(const void *buf_) { - memcpy(&DSP,buf_,sizeof(dsp_t)); + return opera_state_load(&DSP,"DSPP",buf_,sizeof(DSP)); } static @@ -802,8 +804,8 @@ opera_dsp_init(void) } } - DSP.flags.Running = FALSE; - DSP.flags.GenFIQ = FALSE; + DSP.flags.Running = false; + DSP.flags.GenFIQ = false; DSP.dregs.DSPPRLD = SYSTEM_TICKS; DSP.dregs.AUDCNT = SYSTEM_TICKS; @@ -841,7 +843,7 @@ opera_dsp_loop(void) uint32_t AOP = 0; /* 1st operand */ uint32_t RBSR = 0; /* return address */ int fExact = 0; - bool_t work = TRUE; + bool work = true; opera_dsp_reset(); @@ -878,7 +880,7 @@ opera_dsp_loop(void) case 6: /* -not used2- ins */ break; case 7: /* sleep */ - work = FALSE; + work = false; break; case 8: case 9: @@ -1221,7 +1223,7 @@ opera_dsp_loop(void) if(1 & DSP.flags.GenFIQ) { - DSP.flags.GenFIQ = FALSE; + DSP.flags.GenFIQ = false; opera_clio_fiq_generate(0x800,0); /* AudioFIQ */ } diff --git a/libopera/opera_dsp.h b/libopera/opera_dsp.h index 85795bc..8d20db3 100644 --- a/libopera/opera_dsp.h +++ b/libopera/opera_dsp.h @@ -53,8 +53,8 @@ void opera_dsp_init(void); void opera_dsp_reset(void); uint32_t opera_dsp_state_size(void); -void opera_dsp_state_save(void *buf_); -void opera_dsp_state_load(const void *buf_); +uint32_t opera_dsp_state_save(void *buf_); +uint32_t opera_dsp_state_load(void const *buf_); EXTERN_C_END diff --git a/libopera/opera_log.c b/libopera/opera_log.c new file mode 100644 index 0000000..662c8c5 --- /dev/null +++ b/libopera/opera_log.c @@ -0,0 +1,26 @@ +#include "opera_log.h" + +#include + +static void opera_log_printf_null(opera_log_level_t level, const char *fmt, ...); + +opera_log_printf_t opera_log_printf = opera_log_printf_null; + +static +void +opera_log_printf_null(opera_log_level_t level_, + const char* fmt_, + ...) +{ + (void)level_; + (void)fmt_; +} + +void +opera_log_set_func(void *func_) +{ + if(func_ == NULL) + func_ = opera_log_printf_null; + + opera_log_printf = func_; +} diff --git a/libopera/opera_log.h b/libopera/opera_log.h new file mode 100644 index 0000000..ba4d4ed --- /dev/null +++ b/libopera/opera_log.h @@ -0,0 +1,19 @@ +#ifndef LIBOPERA_LOG_H_INCLUDED +#define LIBOPERA_LOG_H_INCLUDED + +enum opera_log_level_t + { + OPERA_LOG_DEBUG = 0, + OPERA_LOG_INFO, + OPERA_LOG_WARN, + OPERA_LOG_ERROR + }; +typedef enum opera_log_level_t opera_log_level_t; + +typedef void (*opera_log_printf_t)(opera_log_level_t level, const char *fmt, ...); + +extern opera_log_printf_t opera_log_printf; + +void opera_log_set_func(void *func); + +#endif diff --git a/libopera/opera_madam.c b/libopera/opera_madam.c index 9569cc1..dda06d7 100644 --- a/libopera/opera_madam.c +++ b/libopera/opera_madam.c @@ -28,7 +28,7 @@ * Felix Lazarev */ -#include "bool.h" +#include "boolean.h" #include "endianness.h" #include "hack_flags.h" #include "inline.h" @@ -37,7 +37,9 @@ #include "opera_clio.h" #include "opera_core.h" #include "opera_madam.h" +#include "opera_mem.h" #include "opera_pbus.h" +#include "opera_state.h" #include "opera_vdlp.h" #include @@ -437,22 +439,21 @@ opera_madam_fsm_set(uint32_t val_) uint32_t opera_madam_state_size(void) { - return sizeof(madam_t); + return opera_state_save_size(sizeof(madam_t)); } -void +uint32_t opera_madam_state_save(void *buf_) { - memcpy(buf_,&MADAM,sizeof(madam_t)); + return opera_state_save(buf_,"MDAM",&MADAM,sizeof(MADAM)); } -void +uint32_t opera_madam_state_load(const void *buf_) { - memcpy(&MADAM,buf_,sizeof(madam_t)); + return opera_state_load(&MADAM,"MDAM",buf_,sizeof(MADAM)); } -static uint32_t mread32(uint32_t addr); static int32_t TestInitVisual(int32_t packed); static int32_t Init_Line_Map(void); static void Init_Scale_Map(void); @@ -486,7 +487,6 @@ static struct int Transparent; } pproj; -static uint8_t *DRAM; static uint32_t retuval; static uint32_t BITADDR; static uint32_t CCBFLAGS; @@ -855,11 +855,7 @@ LoadPLUT(uint32_t pnt_, for(i = 0; i < n_; i++) { -#ifdef MSB_FIRST MADAM.PLUT[i] = opera_mem_read16((((pnt_ >> 1) + i)) << 1); -#else - MADAM.PLUT[i] = opera_mem_read16((((pnt_ >> 1) + i)^1) << 1); -#endif } } @@ -886,7 +882,7 @@ opera_madam_cel_handle(void) return; } - CCBFLAGS = mread32(CURRENTCCB); + CCBFLAGS = opera_mem_read32(CURRENTCCB); CURRENTCCB += 4; if(CCBFLAGS & CCB_PXOR) @@ -905,7 +901,7 @@ opera_madam_cel_handle(void) PDATF = 0; NCCBF = 0; - NEXTCCB = mread32(CURRENTCCB) & 0xFFFFFFFC; + NEXTCCB = opera_mem_read32(CURRENTCCB) & 0xFFFFFFFC; if(!(CCBFLAGS & CCB_NPABS)) { @@ -920,7 +916,7 @@ opera_madam_cel_handle(void) CURRENTCCB += 4; - PDATA = mread32(CURRENTCCB) & 0xFFFFFFFC; + PDATA = opera_mem_read32(CURRENTCCB) & 0xFFFFFFFC; /* if((PDATA==0)) PDATF=1; @@ -937,7 +933,7 @@ opera_madam_cel_handle(void) if(CCBFLAGS & CCB_LDPLUT) { - PLUTDATA = mread32(CURRENTCCB) & 0xFFFFFFFC; + PLUTDATA = opera_mem_read32(CURRENTCCB) & 0xFFFFFFFC; /* if((PLUTDATA == 0)) PLUTF=1; @@ -962,8 +958,8 @@ opera_madam_cel_handle(void) if(CCBFLAGS & CCB_YOXY) { - XPOS1616 = mread32(CURRENTCCB); - YPOS1616 = mread32(CURRENTCCB + 4); + XPOS1616 = opera_mem_read32(CURRENTCCB); + YPOS1616 = opera_mem_read32(CURRENTCCB + 4); } CURRENTCCB += 8; @@ -985,47 +981,47 @@ opera_madam_cel_handle(void) if(CCBFLAGS & CCB_LDSIZE) { - HDX1616 = ((int32_t)mread32(CURRENTCCB)) >> 4; + HDX1616 = ((int32_t)opera_mem_read32(CURRENTCCB)) >> 4; CURRENTCCB += 4; - HDY1616 = ((int32_t)mread32(CURRENTCCB)) >> 4; + HDY1616 = ((int32_t)opera_mem_read32(CURRENTCCB)) >> 4; CURRENTCCB += 4; - VDX1616 = mread32(CURRENTCCB); + VDX1616 = opera_mem_read32(CURRENTCCB); CURRENTCCB += 4; - VDY1616 = mread32(CURRENTCCB); + VDY1616 = opera_mem_read32(CURRENTCCB); CURRENTCCB += 4; } if(CCBFLAGS & CCB_LDPRS) { - HDDX1616 = ((int32_t)mread32(CURRENTCCB)) >> 4; + HDDX1616 = ((int32_t)opera_mem_read32(CURRENTCCB)) >> 4; CURRENTCCB += 4; - HDDY1616 = ((int32_t)mread32(CURRENTCCB)) >> 4; + HDDY1616 = ((int32_t)opera_mem_read32(CURRENTCCB)) >> 4; CURRENTCCB += 4; } if(CCBFLAGS & CCB_LDPPMP) { - PIXC = mread32(CURRENTCCB); + PIXC = opera_mem_read32(CURRENTCCB); CURRENTCCB += 4; } if(CCBFLAGS & CCB_CCBPRE) { - PRE0 = mread32(CURRENTCCB); + PRE0 = opera_mem_read32(CURRENTCCB); CURRENTCCB += 4; if(!(CCBFLAGS & CCB_PACKED)) { - PRE1 = mread32(CURRENTCCB); + PRE1 = opera_mem_read32(CURRENTCCB); CURRENTCCB += 4; } } else if(!PDATF) { - PRE0 = mread32(PDATA); + PRE0 = opera_mem_read32(PDATA); PDATA += 4; if(!(CCBFLAGS & CCB_PACKED)) { - PRE1 = mread32(PDATA); + PRE1 = opera_mem_read32(PDATA); PDATA += 4; } } @@ -1139,7 +1135,7 @@ DMAPBus(void) while(((int32_t)MADAM.mregs[0x574] > 0) && (pbus_size > 0)) { opera_io_write(MADAM.mregs[0x570], - swap32_if_little_endian(*pbus_buf)); + swap32_if_little_endian(*pbus_buf)); pbus_buf++; pbus_size -= 4; MADAM.mregs[0x574] -= 4; @@ -1167,8 +1163,6 @@ opera_madam_init(uint8_t *mem_) opera_madam_reset(); - DRAM = mem_; - bitoper.bitset = 1; MADAM.FSM = FSM_IDLE; @@ -1215,46 +1209,6 @@ opera_madam_init(uint8_t *mem_) } } -static -INLINE -uint32_t -mread32(uint32_t addr_) -{ - return *((uint32_t*)&DRAM[addr_]); -} - -static -INLINE -void -mwrite16(const uint32_t addr_, - const uint16_t val_) -{ -#ifdef MSB_FIRST - const uint32_t addr = addr_; -#else - const uint32_t addr = addr_ ^ 2; -#endif - - *((uint16_t*)&DRAM[addr]) = val_; - if(!HIRESMODE || (addr < 0x200000)) - return; - *((uint16_t*)&DRAM[addr + 1*1024*1024]) = val_; - *((uint16_t*)&DRAM[addr + 2*1024*1024]) = val_; - *((uint16_t*)&DRAM[addr + 3*1024*1024]) = val_; -} - -static -INLINE -uint16_t -mread16(const uint32_t addr_) -{ -#ifdef MSB_FIRST - return *((uint16_t*)&DRAM[addr_]); -#else - return *((uint16_t*)&DRAM[addr_ ^ 2]); -#endif -} - static uint32_t PDEC(const uint32_t pixel_, @@ -1630,10 +1584,10 @@ process_pixel(int32_t x_, int32_t p; int32_t fp; - fp = mread16(REGCTL2 + XY2OFF(x_,y_,MADAM.rmod)); + fp = opera_mem_read16(REGCTL2 + XY2OFF(x_,y_,MADAM.rmod)); p = PPROC(curpix_,fp,lawv_); p = PPROJ_OUTPUT(curpix_,p,fp); - mwrite16(REGCTL3 + XY2OFF(x_,y_,MADAM.wmod),p); + opera_mem_write16(REGCTL3 + XY2OFF(x_,y_,MADAM.wmod),p); } uint32_t* @@ -2231,7 +2185,7 @@ DrawLRCel_New(void) for(j = TEXTURE_WI_START; j < SPRWI; j++) { - CURPIX = PDEC(mread16((PDATA + XY2OFF(j,i,offset << 2))),&LAMV); + CURPIX = PDEC(opera_mem_read16((PDATA + XY2OFF(j,i,offset << 2))),&LAMV); if(!pproj.Transparent) { @@ -2239,13 +2193,13 @@ DrawLRCel_New(void) uint32_t framePixel; if(FIXMODE & FIX_BIT_TIMING_6) - framePixel = mread16((REGCTL2+XY2OFF(xcur >> 16,(ycur>>16)<<1,MADAM.rmod))); + framePixel = opera_mem_read16((REGCTL2+XY2OFF(xcur >> 16,(ycur>>16)<<1,MADAM.rmod))); else - framePixel = mread16((REGCTL2+XY2OFF(xcur >> 16,ycur>>16,MADAM.rmod))); + framePixel = opera_mem_read16((REGCTL2+XY2OFF(xcur >> 16,ycur>>16,MADAM.rmod))); pixel = PPROC(CURPIX,framePixel,LAMV); pixel = PPROJ_OUTPUT(CURPIX,pixel,framePixel); - mwrite16((REGCTL3+XY2OFF(xcur >> 16,ycur >> 16,MADAM.wmod)),pixel); + opera_mem_write16((REGCTL3+XY2OFF(xcur >> 16,ycur >> 16,MADAM.wmod)),pixel); } xcur += HDX1616; @@ -2270,7 +2224,7 @@ DrawLRCel_New(void) for(j = 0; j < SPRWI; j++) { - CURPIX = PDEC(mread16((PDATA+XY2OFF(j,i,offset<<2))),&LAMV); + CURPIX = PDEC(opera_mem_read16((PDATA+XY2OFF(j,i,offset<<2))),&LAMV); if(!pproj.Transparent) { @@ -2305,7 +2259,7 @@ DrawLRCel_New(void) for(j = 0; j < SPRWI; j++) { - CURPIX = PDEC(mread16((PDATA+XY2OFF(j,i,offset<<2))),&LAMV); + CURPIX = PDEC(opera_mem_read16((PDATA+XY2OFF(j,i,offset<<2))),&LAMV); if(!pproj.Transparent) { @@ -2354,26 +2308,26 @@ static INLINE uint32_t TexelCCWTest(int64_t hdx, int64_t hdy, int64_t vdx, int64 } static -bool_t +bool QuadCCWTest(int32_t wdt_) { float wdt; uint32_t tmp; if((CCBFLAGS & CCB_ACCW) && (CCBFLAGS & CCB_ACW)) - return FALSE; + return false; wdt = (float)wdt_; tmp = TexelCCWTest(HDX1616, HDY1616, VDX1616, VDY1616); if (tmp != TexelCCWTest(HDX1616, HDY1616, VDX1616 + HDDX1616*wdt, VDY1616 + HDDY1616*wdt)) - return FALSE; + return false; if (tmp != TexelCCWTest(HDX1616 + HDDX1616*SPRHI, HDY1616 + HDDY1616*SPRHI, VDX1616, VDY1616)) - return FALSE; + return false; if (tmp != TexelCCWTest(HDX1616 + HDDX1616*SPRHI, HDY1616 + HDDY1616*SPRHI, VDX1616 + HDDX1616*SPRHI * wdt, VDY1616 + HDDY1616*SPRHI * wdt)) - return FALSE; + return false; if(tmp == (CCBFLAGS & (CCB_ACCW | CCB_ACW))) - return TRUE; - return FALSE; + return true; + return false; } static @@ -2719,7 +2673,7 @@ TexelDraw_Line(uint16_t CURPIX_, { uint32_t next; - next = mread16(REGCTL2 + XY2OFF(xcur_,ycur_,MADAM.rmod)); + next = opera_mem_read16(REGCTL2 + XY2OFF(xcur_,ycur_,MADAM.rmod)); if(next != curr) { curr = next; @@ -2727,7 +2681,7 @@ TexelDraw_Line(uint16_t CURPIX_, pixel = PPROJ_OUTPUT(CURPIX_,pixel,next); } - mwrite16(REGCTL3 + XY2OFF(xcur_,ycur_,MADAM.wmod),pixel); + opera_mem_write16(REGCTL3 + XY2OFF(xcur_,ycur_,MADAM.wmod),pixel); } } @@ -2742,14 +2696,14 @@ readPIX(int32_t x_, if(HIRESMODE) { src += XY2OFF(x_ >> 1,y_ >> 1,MADAM.rmod); - src += ((((y_ & 1) << 1) + (x_ & 1)) * 1024 * 1024); + src += ((((y_ & 1) << 1) + (x_ & 1)) * VRAM_SIZE); } else { src += XY2OFF(x_,y_,MADAM.rmod); } - return *((uint16_t*)&DRAM[src ^ 2]); + return opera_mem_read16(src); } static @@ -2764,14 +2718,14 @@ writePIX(int32_t x_, if(HIRESMODE) { src += XY2OFF(x_ >> 1,y_ >> 1,MADAM.wmod); - src += ((((y_ & 1) << 1) + (x_ & 1)) * 1024 * 1024); + src += ((((y_ & 1) << 1) + (x_ & 1)) * VRAM_SIZE); } else { src += XY2OFF(x_,y_,MADAM.wmod); } - *((uint16_t*)&DRAM[src ^ 2]) = p_; + opera_mem_write16(src,p_); } static diff --git a/libopera/opera_madam.h b/libopera/opera_madam.h index eac954e..6df4e9a 100644 --- a/libopera/opera_madam.h +++ b/libopera/opera_madam.h @@ -39,7 +39,7 @@ EXTERN_C_BEGIN -void opera_madam_init(uint8_t *mem_); +void opera_madam_init(); void opera_madam_reset(void); uint32_t opera_madam_fsm_get(void); @@ -58,8 +58,8 @@ void opera_madam_me_mode_software(void); void opera_madam_me_mode_hardware(void); uint32_t opera_madam_state_size(void); -void opera_madam_state_save(void *buf_); -void opera_madam_state_load(const void *buf_); +uint32_t opera_madam_state_save(void *buf_); +uint32_t opera_madam_state_load(void const *buf_); EXTERN_C_END diff --git a/libopera/opera_mem.c b/libopera/opera_mem.c new file mode 100644 index 0000000..ebe08f4 --- /dev/null +++ b/libopera/opera_mem.c @@ -0,0 +1,201 @@ +#include "opera_mem.h" +#include "endianness.h" +#include "opera_state.h" + +#include +#include +#include + +uint32_t RAM_SIZE = (DEFAULT_RAM_SIZE); +uint32_t HIRES_RAM_SIZE = (DEFAULT_HIRES_RAM_SIZE); +bool HIRESMODE = false; +uint8_t *DRAM = NULL; +uint32_t DRAM_SIZE = (DEFAULT_DRAM_SIZE); +uint8_t *VRAM = NULL; +uint32_t VRAM_SIZE = (DEFAULT_VRAM_SIZE); +uint32_t VRAM_SIZE_MASK = (DEFAULT_VRAM_SIZE - 1); +uint32_t HIRES_VRAM_SIZE = (DEFAULT_HIRES_VRAM_SIZE); +uint32_t HIRES_VRAM_SIZE_MASK = (DEFAULT_HIRES_VRAM_SIZE - 1); +uint8_t *NVRAM = NULL; +uint8_t *ROM = NULL; +uint8_t *ROM1 = NULL; +uint8_t *ROM2 = NULL; + +typedef struct opera_mem_state_t opera_mem_state_t; +struct opera_mem_state_t +{ + uint8_t mem_cfg; +}; + + +uint32_t +opera_mem_dram_size(opera_mem_cfg_t cfg_) +{ + return (((cfg_ & 0xF0) >> 4) * ONE_MB); +} + +uint32_t +opera_mem_vram_size(opera_mem_cfg_t cfg_) +{ + return (((cfg_ & 0x0F) >> 0) * ONE_MB); +} + +static +void +_setup_dram_vram(opera_mem_cfg_t const cfg_) +{ + DRAM_SIZE = opera_mem_dram_size(cfg_); + VRAM_SIZE = opera_mem_vram_size(cfg_); + VRAM_SIZE_MASK = (VRAM_SIZE - 1); + HIRES_VRAM_SIZE = (VRAM_SIZE * 4); + HIRES_VRAM_SIZE_MASK = (HIRES_RAM_SIZE - 1); + RAM_SIZE = (DRAM_SIZE + VRAM_SIZE); + HIRES_RAM_SIZE = (DRAM_SIZE + HIRES_VRAM_SIZE); + + /* VRAM is always at the top of DRAM */ + VRAM = &DRAM[DRAM_SIZE]; +} + +int +opera_mem_init() +{ + opera_mem_cfg_t cfg = DRAM_2MB_VRAM_1MB; + + /* + Allocate max possible RAM to make things easier + Since it is zeroed out it will compress well + */ + DRAM = calloc(MAX_HIRES_RAM_SIZE,1); + ROM1 = calloc(ROM1_SIZE,1); + ROM2 = calloc(ROM2_SIZE,1); + NVRAM = calloc(NVRAM_SIZE,1); + + _setup_dram_vram(cfg); + + opera_mem_rom_select(ROM1); + + return 0; +} + +int +opera_mem_cfg(opera_mem_cfg_t const cfg_) +{ + _setup_dram_vram(cfg_); + + return 0; +} + +void +opera_mem_destroy() +{ + if(DRAM) + free(DRAM); + DRAM = NULL; + VRAM = NULL; + + if(ROM1) + free(ROM1); + ROM1 = NULL; + + if(ROM2) + free(ROM2); + ROM2 = NULL; + + if(NVRAM) + free(NVRAM); + NVRAM = NULL; +} + +void +opera_mem_rom1_clear() +{ + memset(ROM1,0,ROM1_SIZE); +} + +void +opera_mem_rom1_byteswap32_if_le() +{ + uint32_t *mem; + uint64_t size; + + mem = (uint32_t*)ROM1; + size = (ROM1_SIZE / sizeof(uint32_t)); + + swap32_array_if_little_endian(mem,size); +} + +void +opera_mem_rom2_clear() +{ + memset(ROM2,0,ROM2_SIZE); +} + +void +opera_mem_rom2_byteswap32_if_le() +{ + uint32_t *mem; + uint64_t size; + + mem = (uint32_t*)ROM2; + size = (ROM2_SIZE / sizeof(uint32_t)); + + swap32_array_if_little_endian(mem,size); +} + +void +opera_mem_rom_select(void *rom_) +{ + if((rom_ != ROM1) || (rom_ != ROM2)) + rom_ = ROM1; + + ROM = rom_; +} + +uint32_t +opera_mem_state_size() +{ + uint32_t size; + + size = 0; + size += opera_state_save_size(sizeof(opera_mem_state_t)); + size += opera_state_save_size(MAX_HIRES_RAM_SIZE); + size += opera_state_save_size(ROM1_SIZE); + size += opera_state_save_size(ROM2_SIZE); + size += opera_state_save_size(NVRAM_SIZE); + + return size; +} + +uint32_t +opera_mem_state_save(void *data_) +{ + uint8_t *start = (uint8_t*)data_; + uint8_t *data = (uint8_t*)data_; + opera_mem_state_t memstate; + + memstate.mem_cfg = DRAM_2MB_VRAM_1MB; + + data += opera_state_save(data,"MCFG",&memstate,sizeof(memstate)); + data += opera_state_save(data,"RAM",DRAM,MAX_HIRES_RAM_SIZE); + data += opera_state_save(data,"ROM1",ROM1,ROM1_SIZE); + data += opera_state_save(data,"ROM2",ROM2,ROM2_SIZE); + data += opera_state_save(data,"NVRM",NVRAM,NVRAM_SIZE); + + return (data - start); +} + +uint32_t +opera_mem_state_load(void const *data_) +{ + uint8_t const *start = (uint8_t const*)data_; + uint8_t const *data = (uint8_t const*)data_; + opera_mem_state_t memstate; + + data += opera_state_load(&memstate,"MCFG",data,sizeof(memstate)); + data += opera_state_load(DRAM,"RAM",data,MAX_HIRES_RAM_SIZE); + data += opera_state_load(ROM1,"ROM1",data,ROM1_SIZE); + data += opera_state_load(ROM2,"ROM2",data,ROM2_SIZE); + data += opera_state_load(NVRAM,"NVRM",data,NVRAM_SIZE); + + return (data - start); +} diff --git a/libopera/opera_mem.h b/libopera/opera_mem.h new file mode 100644 index 0000000..8e591bd --- /dev/null +++ b/libopera/opera_mem.h @@ -0,0 +1,166 @@ +#ifndef LIBOPERA_MEM_H_INCLUDED +#define LIBOPERA_MEM_H_INCLUDED + +#include "boolean.h" +#include "inline.h" + +#include + +#define ONE_KB (1024) +#define ONE_MB (ONE_KB * 1024) + +#define DEFAULT_DRAM_SIZE (ONE_MB * 2) +#define DEFAULT_VRAM_SIZE (ONE_MB * 1) +#define DEFAULT_HIRES_VRAM_SIZE (DEFAULT_VRAM_SIZE * 4) +#define DEFAULT_RAM_SIZE (DEFAULT_DRAM_SIZE + DEFAULT_VRAM_SIZE) +#define DEFAULT_HIRES_RAM_SIZE (DEFAULT_DRAM_SIZE + DEFAULT_HIRES_VRAM_SIZE) +#define MAX_DRAM_SIZE (ONE_MB * 14) +#define MAX_VRAM_SIZE (ONE_MB * 2) +#define MAX_HIRES_VRAM_SIZE (MAX_VRAM_SIZE * 4) +#define MAX_HIRES_RAM_SIZE (MAX_DRAM_SIZE + MAX_HIRES_VRAM_SIZE) + +extern uint32_t RAM_SIZE; +extern uint32_t HIRES_RAM_SIZE; +extern bool HIRESMODE; + +extern uint8_t *DRAM; +extern uint32_t DRAM_SIZE; + +extern uint8_t *VRAM; +extern uint32_t VRAM_SIZE; +extern uint32_t VRAM_SIZE_MASK; +extern uint32_t HIRES_VRAM_SIZE; +extern uint32_t HIRES_VRAM_SIZE_MASK; + +extern uint8_t *NVRAM; +#define NVRAM_SIZE (ONE_KB * 32) +#define NVRAM_SIZE_MASK (NVRAM_SIZE - 1) + +extern uint8_t *ROM; + +extern uint8_t *ROM1; +#define ROM1_SIZE (ONE_MB * 1) +#define ROM1_SIZE_MASK (ROM1_SIZE - 1) + +extern uint8_t *ROM2; +#define ROM2_SIZE (ONE_MB * 1) +#define ROM2_SIZE_MASK (ROM2_SIZE - 1) + + +enum opera_mem_cfg_t + { + DRAM_VRAM_STOCK = 0x21, + DRAM_2MB_VRAM_1MB = 0x21, + DRAM_2MB_VRAM_2MB = 0x22, + DRAM_4MB_VRAM_1MB = 0x41, + DRAM_4MB_VRAM_2MB = 0x42, + DRAM_8MB_VRAM_1MB = 0x81, + DRAM_8MB_VRAM_2MB = 0x82, + DRAM_14MB_VRAM_2MB = 0xE2, + DRAM_15MB_VRAM_1MB = 0xF1 + }; +typedef enum opera_mem_cfg_t opera_mem_cfg_t; + +int opera_mem_init(); +void opera_mem_destroy(); + +void opera_mem_rom1_clear(); +void opera_mem_rom1_byteswap32_if_le(); +void opera_mem_rom2_clear(); +void opera_mem_rom2_byteswap32_if_le(); + +void opera_mem_rom_select(void *rom); + +uint32_t opera_mem_state_size(); +uint32_t opera_mem_state_save(void *data); +uint32_t opera_mem_state_load(void const *data); + +static +INLINE +uint8_t +opera_mem_read8(uint32_t const addr_) +{ +#if IS_BIG_ENDIAN + return DRAM[addr_]; +#else + return DRAM[addr_ ^ 3]; +#endif +} + +static +INLINE +uint16_t +opera_mem_read16(uint32_t const addr_) +{ +#if IS_BIG_ENDIAN + uint32_t const addr = addr_; +#else + uint32_t const addr = (addr_ ^ 2); +#endif + + return *((uint16_t const *)&DRAM[addr]); +} + +static +INLINE +uint32_t +opera_mem_read32(uint32_t const addr_) +{ + return *((uint32_t const *)&DRAM[addr_]); +} + +static +INLINE +void +opera_mem_write8(uint32_t const addr_, + uint8_t const val_) +{ +#if IS_BIG_ENDIAN + uint32_t const addr = addr_; +#else + uint32_t const addr = (addr_ ^ 3); +#endif + + DRAM[addr] = val_; + if(!HIRESMODE || (addr < DRAM_SIZE)) + return; + DRAM[addr + 1*VRAM_SIZE] = + DRAM[addr + 2*VRAM_SIZE] = + DRAM[addr + 3*VRAM_SIZE] = val_; +} + +static +INLINE +void +opera_mem_write16(uint32_t const addr_, + uint16_t const val_) +{ +#if IS_BIG_ENDIAN + uint32_t const addr = addr_; +#else + uint32_t const addr = (addr_ ^ 2); +#endif + + *((uint16_t*)&DRAM[addr]) = val_; + if(!HIRESMODE || (addr < DRAM_SIZE)) + return; + *((uint16_t*)&DRAM[addr + 1*VRAM_SIZE]) = + *((uint16_t*)&DRAM[addr + 2*VRAM_SIZE]) = + *((uint16_t*)&DRAM[addr + 3*VRAM_SIZE]) = val_; +} + +static +INLINE +void +opera_mem_write32(uint32_t const addr_, + uint32_t const val_) +{ + *((uint32_t*)&DRAM[addr_]) = val_; + if(!HIRESMODE || (addr_ < DRAM_SIZE)) + return; + *((uint32_t*)&DRAM[addr_ + 1*VRAM_SIZE]) = + *((uint32_t*)&DRAM[addr_ + 2*VRAM_SIZE]) = + *((uint32_t*)&DRAM[addr_ + 3*VRAM_SIZE]) = val_; +} + +#endif diff --git a/libopera/opera_nvram.c b/libopera/opera_nvram.c index 63dc653..6154781 100644 --- a/libopera/opera_nvram.c +++ b/libopera/opera_nvram.c @@ -1,6 +1,6 @@ -#include "opera_arm.h" +#include "opera_mem.h" -#include "retro_endianness.h" +#include "endianness.h" #include #include @@ -42,7 +42,7 @@ struct nvram_header_t void opera_nvram_init(void) { - nvram_header_t *nvram_hdr = (nvram_header_t*)opera_arm_nvram_get(); + nvram_header_t *nvram_hdr = (nvram_header_t*)NVRAM; memset(nvram_hdr,0,sizeof(nvram_header_t)); @@ -58,22 +58,22 @@ opera_nvram_init(void) nvram_hdr->label[2] = 'R'; nvram_hdr->label[3] = 'A'; nvram_hdr->label[4] = 'M'; - nvram_hdr->id = swap_if_little32(0xFFFFFFFF); - nvram_hdr->block_size = swap_if_little32(0x00000001); - nvram_hdr->block_count = swap_if_little32(0x00008000); - nvram_hdr->root_dir_id = swap_if_little32(0xFFFFFFFE); - nvram_hdr->root_dir_blocks = swap_if_little32(0x00000000); - nvram_hdr->root_dir_block_size = swap_if_little32(0x00000001); - nvram_hdr->last_root_dir_copy = swap_if_little32(0x00000000); - nvram_hdr->root_dir_copies[0] = swap_if_little32(0x00000084); - nvram_hdr->unknown_value0 = swap_if_little32(0x855A02B6); - nvram_hdr->unknown_value1 = swap_if_little32(0x00000098); - nvram_hdr->unknown_value2 = swap_if_little32(0x00000098); - nvram_hdr->unknown_value3 = swap_if_little32(0x00000014); - nvram_hdr->unknown_value4 = swap_if_little32(0x00000014); - nvram_hdr->unknown_value5 = swap_if_little32(0x7AA565BD); - nvram_hdr->unknown_value6 = swap_if_little32(0x00000084); - nvram_hdr->unknown_value7 = swap_if_little32(0x00000084); - nvram_hdr->blocks_remaining = swap_if_little32(0x00007F68); - nvram_hdr->unknown_value8 = swap_if_little32(0x00000014); + nvram_hdr->id = swap32_if_little_endian(0xFFFFFFFF); + nvram_hdr->block_size = swap32_if_little_endian(0x00000001); + nvram_hdr->block_count = swap32_if_little_endian(0x00008000); + nvram_hdr->root_dir_id = swap32_if_little_endian(0xFFFFFFFE); + nvram_hdr->root_dir_blocks = swap32_if_little_endian(0x00000000); + nvram_hdr->root_dir_block_size = swap32_if_little_endian(0x00000001); + nvram_hdr->last_root_dir_copy = swap32_if_little_endian(0x00000000); + nvram_hdr->root_dir_copies[0] = swap32_if_little_endian(0x00000084); + nvram_hdr->unknown_value0 = swap32_if_little_endian(0x855A02B6); + nvram_hdr->unknown_value1 = swap32_if_little_endian(0x00000098); + nvram_hdr->unknown_value2 = swap32_if_little_endian(0x00000098); + nvram_hdr->unknown_value3 = swap32_if_little_endian(0x00000014); + nvram_hdr->unknown_value4 = swap32_if_little_endian(0x00000014); + nvram_hdr->unknown_value5 = swap32_if_little_endian(0x7AA565BD); + nvram_hdr->unknown_value6 = swap32_if_little_endian(0x00000084); + nvram_hdr->unknown_value7 = swap32_if_little_endian(0x00000084); + nvram_hdr->blocks_remaining = swap32_if_little_endian(0x00007F68); + nvram_hdr->unknown_value8 = swap32_if_little_endian(0x00000014); } diff --git a/libopera/opera_nvram.h b/libopera/opera_nvram.h index 828ee20..463d119 100644 --- a/libopera/opera_nvram.h +++ b/libopera/opera_nvram.h @@ -1,8 +1,6 @@ #ifndef OPERA_NVRAM_H_INCLUDED #define OPERA_NVRAM_H_INCLUDED -#define NVRAM_SIZE (32 * 1024) - void opera_nvram_init(void); #endif diff --git a/libopera/opera_sport.c b/libopera/opera_sport.c index 2051705..07cab73 100644 --- a/libopera/opera_sport.c +++ b/libopera/opera_sport.c @@ -30,14 +30,17 @@ #include "inline.h" #include "opera_core.h" +#include "opera_mem.h" +#include "opera_state.h" #include #include #define SPORT_IDX_MASK 0x7FF -#define SPORT_IDX_SHIFT 7 +#define SPORT_IDX_SHIFT 9 #define SPORT_ELEM_COUNT 512 #define SPORT_BUFSIZE (SPORT_ELEM_COUNT * sizeof(uint32_t)) +#define SPORT_PAGE_TO_BYTE_OFFSET(IDX) (((IDX) & SPORT_IDX_MASK) << SPORT_IDX_SHIFT) struct sport_s { @@ -48,19 +51,18 @@ struct sport_s typedef struct sport_s sport_t; -static sport_t SPORT = {0}; -static void *VRAM; +static sport_t SPORT = {0}; void -opera_sport_init(uint8_t * const vram_) +opera_sport_init() { - VRAM = vram_; + } void opera_sport_set_source(const uint32_t rawidx_) { - SPORT.source = ((rawidx_ & SPORT_IDX_MASK) << SPORT_IDX_SHIFT); + SPORT.source = SPORT_PAGE_TO_BYTE_OFFSET(rawidx_); } static @@ -69,9 +71,8 @@ void sport_set_color(const uint32_t idx_) { int i; - uint32_t *vram = VRAM; + uint32_t * const vram = (uint32_t * const)&VRAM[idx_]; - vram = &vram[idx_]; for(i = 0; i < SPORT_ELEM_COUNT; i++) vram[i] = SPORT.color; } @@ -83,9 +84,8 @@ sport_set_color_with_mask(const uint32_t idx_, const uint32_t mask_) { int i; - uint32_t *vram = VRAM; + uint32_t * const vram = (uint32_t * const)&VRAM[idx_]; - vram = &vram[idx_]; for(i = 0; i < SPORT_ELEM_COUNT; i++) vram[i] = (((vram[i] ^ SPORT.color) & mask_) ^ SPORT.color); } @@ -96,9 +96,7 @@ void sport_memcpy(const uint32_t didx_, const uint32_t sidx_) { - uint32_t *vram = VRAM; - - memcpy(&vram[didx_],&vram[sidx_],SPORT_BUFSIZE); + memcpy(&VRAM[didx_],&VRAM[sidx_],SPORT_BUFSIZE); } static @@ -107,9 +105,9 @@ void sport_memcpy_highres(const uint32_t didx_, const uint32_t sidx_) { - sport_memcpy(didx_ + (1*1024*1024/sizeof(uint32_t)),sidx_); - sport_memcpy(didx_ + (2*1024*1024/sizeof(uint32_t)),sidx_); - sport_memcpy(didx_ + (3*1024*1024/sizeof(uint32_t)),sidx_); + sport_memcpy(didx_ + (1*VRAM_SIZE),sidx_); + sport_memcpy(didx_ + (2*VRAM_SIZE),sidx_); + sport_memcpy(didx_ + (3*VRAM_SIZE),sidx_); } static @@ -120,7 +118,7 @@ sport_flash_write(const uint32_t rawidx_, { uint32_t idx; - idx = ((rawidx_ & SPORT_IDX_MASK) << SPORT_IDX_SHIFT); + idx = SPORT_PAGE_TO_BYTE_OFFSET(rawidx_); if(mask_ == 0xFFFFFFFF) sport_set_color(idx); else @@ -151,13 +149,8 @@ void sport_copy_page_color_with_mask(const uint32_t mask_) { int i; - uint32_t *vram; - uint32_t *svram; - uint32_t *dvram; - - vram = VRAM; - svram = &vram[SPORT.source]; - dvram = &vram[SPORT.destination]; + uint32_t const * const svram = (uint32_t const * const)&VRAM[SPORT.source]; + uint32_t * const dvram = (uint32_t * const)&VRAM[SPORT.destination]; for(i = 0; i < SPORT_ELEM_COUNT; i++) dvram[i] = (((dvram[i] ^ svram[i]) & mask_) ^ svram[i]); @@ -174,7 +167,7 @@ void sport_copy_page(const uint32_t rawidx_, const uint32_t mask_) { - SPORT.destination = ((rawidx_ & SPORT_IDX_MASK) << SPORT_IDX_SHIFT); + SPORT.destination = SPORT_PAGE_TO_BYTE_OFFSET(rawidx_); if(mask_ == 0xFFFFFFFF) sport_copy_page_color(); else @@ -206,17 +199,17 @@ opera_sport_write_access(const uint32_t idx_, uint32_t opera_sport_state_size(void) { - return sizeof(sport_t); + return opera_state_save_size(sizeof(sport_t)); } -void +uint32_t opera_sport_state_save(void *buf_) { - memcpy(buf_,&SPORT,sizeof(sport_t)); + return opera_state_save(buf_,"SPRT",&SPORT,sizeof(sport_t)); } -void +uint32_t opera_sport_state_load(const void *buf_) { - memcpy(&SPORT,buf_,sizeof(sport_t)); + return opera_state_load(&SPORT,"SPRT",buf_,sizeof(sport_t)); } diff --git a/libopera/opera_sport.h b/libopera/opera_sport.h index af7b5ca..fccca69 100644 --- a/libopera/opera_sport.h +++ b/libopera/opera_sport.h @@ -37,14 +37,14 @@ EXTERN_C_BEGIN -void opera_sport_init(uint8_t * const vram_); +void opera_sport_init(); void opera_sport_set_source(const uint32_t idx_); void opera_sport_write_access(const uint32_t idx_, const uint32_t mask_); uint32_t opera_sport_state_size(void); -void opera_sport_state_save(void *buf_); -void opera_sport_state_load(const void *buf_); +uint32_t opera_sport_state_save(void *buf_); +uint32_t opera_sport_state_load(void const *buf_); EXTERN_C_END diff --git a/libopera/opera_state.c b/libopera/opera_state.c new file mode 100644 index 0000000..accc99e --- /dev/null +++ b/libopera/opera_state.c @@ -0,0 +1,85 @@ +#include "opera_state.h" + +#include "opera_log.h" + +#include +#include + +uint32_t +opera_state_get_version(void const *src_, + uint32_t const src_size_) +{ + uint8_t const *src; + opera_state_hdr_t hdr; + + src = (uint8_t const*)src_; + if(sizeof(hdr) > src_size_) + return 0; + + src += (sizeof(char[4]) + sizeof(uint32_t)); + memcpy(&hdr,src,sizeof(hdr)); + + return hdr.version; +} + +uint32_t +opera_state_save_size(uint32_t const src_size_) +{ + return (sizeof(char[4]) + sizeof(uint32_t) + src_size_); +} + +uint32_t +opera_state_save(void *dst_, + char const *name_, + void const *src_, + uint32_t const src_size_) +{ + char name[4] = {0}; + uint8_t *dst = dst_; + + opera_log_printf(OPERA_LOG_DEBUG, + "[Opera]: saving state %s of size %u\n", + name_, + src_size_); + + memcpy(name,name_,sizeof(name)); + memcpy(dst,name,sizeof(name)); + dst += sizeof(name); + + memcpy(dst,&src_size_,sizeof(src_size_)); + dst += sizeof(src_size_); + + memcpy(dst,src_,src_size_); + + return opera_state_save_size(src_size_); +} + +uint32_t +opera_state_load(void *dst_, + char const *name_, + void const *src_, + uint32_t const src_size_) +{ + char name[4] = {0}; + uint8_t const *src = src_; + uint32_t size = 0; + + opera_log_printf(OPERA_LOG_DEBUG, + "[Opera]: loading state %s of size %u\n", + name_, + src_size_); + + memcpy(name,src,sizeof(name)); + if(memcmp(name,name_,sizeof(name))) + return 0; + src += sizeof(name); + + memcpy(&size,src,sizeof(size)); + if(size != src_size_) + return 0; + src += sizeof(size); + + memcpy(dst_,src,src_size_); + + return opera_state_save_size(src_size_); +} diff --git a/libopera/opera_state.h b/libopera/opera_state.h new file mode 100644 index 0000000..83c5d53 --- /dev/null +++ b/libopera/opera_state.h @@ -0,0 +1,49 @@ +#ifndef LIBOPERA_STATE_H_INCLUDED +#define LIBOPERA_STATE_H_INCLUDED + +#include + +typedef struct opera_state_data_t opera_state_data_t; +struct opera_state_data_t +{ + uint8_t data[1024]; +}; + +typedef struct opera_state_hdr_v1_t opera_state_hdr_v1_t; +struct opera_state_hdr_v1_t +{ + uint8_t version; +}; + +typedef union opera_state_hdr_t opera_state_hdr_t; +union opera_state_hdr_t +{ + uint8_t version; + opera_state_data_t data; + opera_state_hdr_v1_t v1; +}; + +typedef struct opera_state_chunk_t opera_state_chunk_t; +struct opera_state_chunk_t +{ + char name[4]; + uint32_t size; + uint8_t data[1]; +}; + +uint32_t opera_state_get_version(void const *src, + uint32_t const src_size); + +uint32_t opera_state_save_size(uint32_t const src_size); + +uint32_t opera_state_load(void *dst, + char const *name, + void const *src, + uint32_t const src_size); +uint32_t opera_state_save(void *dst, + char const *name, + void const *src, + uint32_t const src_size); + + +#endif diff --git a/libopera/opera_vdlp.c b/libopera/opera_vdlp.c index 4c220d5..f5ab52b 100644 --- a/libopera/opera_vdlp.c +++ b/libopera/opera_vdlp.c @@ -1,13 +1,19 @@ +#include "flags.h" #include "hack_flags.h" #include "inline.h" +#include "boolean.h" + #include "opera_arm.h" #include "opera_core.h" +#include "opera_mem.h" #include "opera_region.h" +#include "opera_state.h" #include "opera_vdl.h" #include "opera_vdlp.h" #include "opera_vdlp_i.h" +#include #include #include #include @@ -18,21 +24,28 @@ - add pseudo random 3bit pattern for second clut bypass mode */ -static vdlp_t g_VDLP = {0}; -static uint8_t *g_VRAM = NULL; -static void *g_BUF = NULL; -static void *g_CURBUF = NULL; -static void (*g_RENDERER)(void) = NULL; +typedef void(*vdlp_renderer_t)(); + +static vdlp_t g_VDLP = {0}; +static void *g_BUF = NULL; +static void *g_CURBUF = NULL; +static vdlp_renderer_t g_RENDERER = NULL; +static uint32_t g_FLAGS = VDLP_FLAG_NONE; +static vdlp_pixel_format_e g_PIXEL_FORMAT = VDLP_PIXEL_FORMAT_0RGB1555; static const uint32_t PIXELS_PER_LINE_MODULO[8] = {320, 384, 512, 640, 1024, 320, 320, 320}; +/* + TODO: why the "& VRAM_SIZE_MASK"? + The addresses shouldn't be outside the RAM space but are at times. +*/ static INLINE uint32_t vram_read32(const uint32_t addr_) { - return *(uint32_t*)&g_VRAM[addr_ & 0x000FFFFF]; + return *(uint32_t const * const)&VRAM[addr_ & VRAM_SIZE_MASK]; } static @@ -41,7 +54,7 @@ void vram_write32(const uint32_t addr_, const uint32_t val_) { - *((uint32_t*)&g_VRAM[addr_]) = val_; + *((uint32_t * const)&VRAM[addr_ & VRAM_SIZE_MASK]) = val_; } static @@ -234,20 +247,25 @@ vdlp_render_pixel_0RGB1555_bypass_clut(const uint16_t p_) return user_clut_to_0RGB1555(p_); } -static void vdlp_render_line_0RGB1555(void) +static +void +vdlp_render_line_0RGB1555(void) { int x; - uint32_t *src; + int width; + uint32_t const *src; uint16_t *dst; - int width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + + width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + if(!g_VDLP.clut_ctrl.cdcw.enable_dma) - { - vdlp_render_line_black(width,sizeof(uint16_t)); - return; - } + { + vdlp_render_line_black(width,sizeof(uint16_t)); + return; + } dst = g_CURBUF; - src = (uint32_t*)(g_VRAM + ((g_VDLP.curr_bmp^2) & 0x0FFFFF)); + src = (uint32_t const *)&VRAM[(g_VDLP.curr_bmp ^ 2) & VRAM_SIZE_MASK]; if(!g_VDLP.disp_ctrl.dcw.clut_bypass) { for(x = 0; x < width; x++) @@ -259,51 +277,57 @@ static void vdlp_render_line_0RGB1555(void) dst[x] = vdlp_render_pixel_0RGB1555_bypass_clut(*(uint16_t*)&src[x]); } - g_CURBUF = (dst + width); + g_CURBUF = &dst[width]; } static void vdlp_render_line_0RGB1555_bypass_clut(void) { int x; + int width; uint32_t *src; uint16_t *dst; - int width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + + width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + if(!g_VDLP.clut_ctrl.cdcw.enable_dma) - { - vdlp_render_line_black(width,sizeof(uint16_t)); - return; - } + { + vdlp_render_line_black(width,sizeof(uint16_t)); + return; + } dst = g_CURBUF; - src = (uint32_t*)(g_VRAM + ((g_VDLP.curr_bmp^2) & 0x0FFFFF)); + src = (uint32_t*)&VRAM[(g_VDLP.curr_bmp ^ 2) & VRAM_SIZE_MASK]; for(x = 0; x < width; x++) dst[x] = fixed_clut_to_0RGB1555(*(uint16_t*)&src[x]); - g_CURBUF = (dst + width); + g_CURBUF = &dst[width]; } static void vdlp_render_line_0RGB1555_hires(void) { int x; + int width; uint16_t *dst0; uint16_t *dst1; uint32_t *src0; uint32_t *src1; uint32_t *src2; uint32_t *src3; - int width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + + width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + if(!g_VDLP.clut_ctrl.cdcw.enable_dma) - { - vdlp_render_line_black(width,sizeof(uint16_t)); - return; - } + { + vdlp_render_line_black(width,sizeof(uint16_t)); + return; + } dst0 = g_CURBUF; dst1 = (dst0 + (width << 1)); - src0 = (uint32_t*)(g_VRAM + ((g_VDLP.curr_bmp^2) & 0x0FFFFF)); - src1 = (src0 + ((1024 * 1024) / sizeof(uint32_t))); - src2 = (src1 + ((1024 * 1024) / sizeof(uint32_t))); - src3 = (src2 + ((1024 * 1024) / sizeof(uint32_t))); + src0 = (uint32_t*)&VRAM[(g_VDLP.curr_bmp ^ 2) & VRAM_SIZE_MASK]; + src1 = &src0[VRAM_SIZE / sizeof(uint32_t)]; + src2 = &src1[VRAM_SIZE / sizeof(uint32_t)]; + src3 = &src2[VRAM_SIZE / sizeof(uint32_t)]; if(!g_VDLP.disp_ctrl.dcw.clut_bypass) { for(x = 0; x < width; x++) @@ -328,28 +352,33 @@ static void vdlp_render_line_0RGB1555_hires(void) g_CURBUF = dst1; } -static void vdlp_render_line_0RGB1555_hires_bypass_clut(void) +static +void +vdlp_render_line_0RGB1555_hires_bypass_clut(void) { int x; + int width; uint16_t *dst0; uint16_t *dst1; uint32_t *src0; uint32_t *src1; uint32_t *src2; uint32_t *src3; - int width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + + width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + if(!g_VDLP.clut_ctrl.cdcw.enable_dma) - { - vdlp_render_line_black(width,sizeof(uint16_t)); - return; - } + { + vdlp_render_line_black(width,sizeof(uint16_t)); + return; + } dst0 = g_CURBUF; - dst1 = (dst0 + (width << 1)); - src0 = (uint32_t*)(g_VRAM + ((g_VDLP.curr_bmp^2) & 0x0FFFFF)); - src1 = (src0 + ((1024 * 1024) / sizeof(uint32_t))); - src2 = (src1 + ((1024 * 1024) / sizeof(uint32_t))); - src3 = (src2 + ((1024 * 1024) / sizeof(uint32_t))); + dst1 = &dst0[width << 1]; + src0 = (uint32_t*)&VRAM[(g_VDLP.curr_bmp ^ 2) & VRAM_SIZE_MASK]; + src1 = &src0[VRAM_SIZE / sizeof(uint32_t)]; + src2 = &src1[VRAM_SIZE / sizeof(uint32_t)]; + src3 = &src2[VRAM_SIZE / sizeof(uint32_t)]; for(x = 0; x < width; x++) { *dst0++ = fixed_clut_to_0RGB1555(*(uint16_t*)&src0[x]); @@ -362,6 +391,7 @@ static void vdlp_render_line_0RGB1555_hires_bypass_clut(void) } static +INLINE uint16_t fixed_clut_to_RGB565(const uint16_t p_) { @@ -369,6 +399,7 @@ fixed_clut_to_RGB565(const uint16_t p_) } static +INLINE uint16_t user_clut_to_RGB565(const uint16_t p_) { @@ -378,6 +409,7 @@ user_clut_to_RGB565(const uint16_t p_) } static +INLINE uint16_t background_to_RGB565(void) { @@ -387,6 +419,7 @@ background_to_RGB565(void) } static +INLINE uint16_t vdlp_render_pixel_RGB565(const uint16_t p_) { @@ -397,6 +430,7 @@ vdlp_render_pixel_RGB565(const uint16_t p_) } static +INLINE uint16_t vdlp_render_pixel_RGB565_bypass_clut(const uint16_t p_) { @@ -409,20 +443,25 @@ vdlp_render_pixel_RGB565_bypass_clut(const uint16_t p_) return user_clut_to_RGB565(p_); } -static void vdlp_render_line_RGB565(void) +static +void +vdlp_render_line_RGB565(void) { int x; + int width; uint32_t *src; uint16_t *dst; - int width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + + width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + if(!g_VDLP.clut_ctrl.cdcw.enable_dma) - { - vdlp_render_line_black(width,sizeof(uint16_t)); - return; - } + { + vdlp_render_line_black(width,sizeof(uint16_t)); + return; + } dst = g_CURBUF; - src = (uint32_t*)(g_VRAM + ((g_VDLP.curr_bmp^2) & 0x0FFFFF)); + src = (uint32_t*)&VRAM[(g_VDLP.curr_bmp ^ 2) & VRAM_SIZE_MASK]; if(!g_VDLP.disp_ctrl.dcw.clut_bypass) { for(x = 0; x < width; x++) @@ -434,51 +473,59 @@ static void vdlp_render_line_RGB565(void) dst[x] = vdlp_render_pixel_RGB565_bypass_clut(*(uint16_t*)&src[x]); } - g_CURBUF = (dst + width); + g_CURBUF = &dst[width]; } -static void vdlp_render_line_RGB565_bypass_clut(void) +static +void +vdlp_render_line_RGB565_bypass_clut(void) { int x; + int width; uint32_t *src; uint16_t *dst; - int width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + + width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + if(!g_VDLP.clut_ctrl.cdcw.enable_dma) - { - vdlp_render_line_black(width,sizeof(uint16_t)); - return; - } + { + vdlp_render_line_black(width,sizeof(uint16_t)); + return; + } dst = g_CURBUF; - src = (uint32_t*)(g_VRAM + ((g_VDLP.curr_bmp^2) & 0x0FFFFF)); + src = (uint32_t*)&VRAM[(g_VDLP.curr_bmp ^ 2) & VRAM_SIZE_MASK]; for(x = 0; x < width; x++) dst[x] = fixed_clut_to_RGB565(*(uint16_t*)&src[x]); - g_CURBUF = (dst + width); + g_CURBUF = &dst[width]; } static void vdlp_render_line_RGB565_hires(void) { int x; + int width; uint16_t *dst0; uint16_t *dst1; uint32_t *src0; uint32_t *src1; uint32_t *src2; uint32_t *src3; - int width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + + width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + if(!g_VDLP.clut_ctrl.cdcw.enable_dma) - { - vdlp_render_line_black_hires(width,sizeof(uint16_t)); - return; - } + { + vdlp_render_line_black_hires(width,sizeof(uint16_t)); + return; + } dst0 = g_CURBUF; - dst1 = (dst0 + (width << 1)); - src0 = (uint32_t*)(g_VRAM + ((g_VDLP.curr_bmp^2) & 0x0FFFFF)); - src1 = (src0 + ((1024 * 1024) / sizeof(uint32_t))); - src2 = (src1 + ((1024 * 1024) / sizeof(uint32_t))); - src3 = (src2 + ((1024 * 1024) / sizeof(uint32_t))); + dst1 = &dst0[width << 1]; + src0 = (uint32_t*)&VRAM[(g_VDLP.curr_bmp ^ 2) & VRAM_SIZE_MASK]; + src1 = &src0[VRAM_SIZE / sizeof(uint32_t)]; + src2 = &src1[VRAM_SIZE / sizeof(uint32_t)]; + src3 = &src2[VRAM_SIZE / sizeof(uint32_t)]; if(!g_VDLP.disp_ctrl.dcw.clut_bypass) { for(x = 0; x < width; x++) @@ -506,25 +553,28 @@ static void vdlp_render_line_RGB565_hires(void) static void vdlp_render_line_RGB565_hires_bypass_clut(void) { int x; + int width; uint16_t *dst0; uint16_t *dst1; uint32_t *src0; uint32_t *src1; uint32_t *src2; uint32_t *src3; - int width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + + width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + if(!g_VDLP.clut_ctrl.cdcw.enable_dma) - { - vdlp_render_line_black_hires(width,sizeof(uint16_t)); - return; - } + { + vdlp_render_line_black_hires(width,sizeof(uint16_t)); + return; + } dst0 = g_CURBUF; - dst1 = (dst0 + (width << 1)); - src0 = (uint32_t*)(g_VRAM + ((g_VDLP.curr_bmp^2) & 0x0FFFFF)); - src1 = (src0 + ((1024 * 1024) / sizeof(uint32_t))); - src2 = (src1 + ((1024 * 1024) / sizeof(uint32_t))); - src3 = (src2 + ((1024 * 1024) / sizeof(uint32_t))); + dst1 = &dst0[width << 1]; + src0 = (uint32_t*)&VRAM[(g_VDLP.curr_bmp ^ 2) & VRAM_SIZE_MASK]; + src1 = &src0[VRAM_SIZE / sizeof(uint32_t)]; + src2 = &src1[VRAM_SIZE / sizeof(uint32_t)]; + src3 = &src2[VRAM_SIZE / sizeof(uint32_t)]; for(x = 0; x < width; x++) { *dst0++ = fixed_clut_to_RGB565(*(uint16_t*)&src0[x]); @@ -537,6 +587,7 @@ static void vdlp_render_line_RGB565_hires_bypass_clut(void) } static +INLINE uint32_t fixed_clut_to_XRGB8888(const uint16_t p_) { @@ -546,6 +597,7 @@ fixed_clut_to_XRGB8888(const uint16_t p_) } static +INLINE uint32_t user_clut_to_XRGB8888(const uint16_t p_) { @@ -555,6 +607,7 @@ user_clut_to_XRGB8888(const uint16_t p_) } static +INLINE uint32_t vdlp_render_pixel_XRGB8888(const uint16_t p_) { @@ -565,6 +618,7 @@ vdlp_render_pixel_XRGB8888(const uint16_t p_) } static +INLINE uint32_t vdlp_render_pixel_XRGB8888_bypass_clut(const uint16_t p_) { @@ -577,20 +631,25 @@ vdlp_render_pixel_XRGB8888_bypass_clut(const uint16_t p_) return user_clut_to_XRGB8888(p_); } -static void vdlp_render_line_XRGB8888(void) +static +void +vdlp_render_line_XRGB8888(void) { int x; + int width; uint32_t *src; uint32_t *dst; - int width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + + width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + if(!g_VDLP.clut_ctrl.cdcw.enable_dma) - { - vdlp_render_line_black(width,sizeof(uint32_t)); - return; - } + { + vdlp_render_line_black(width,sizeof(uint32_t)); + return; + } dst = g_CURBUF; - src = (uint32_t*)(g_VRAM + ((g_VDLP.curr_bmp^2) & 0x0FFFFF)); + src = (uint32_t*)&VRAM[(g_VDLP.curr_bmp ^ 2) & VRAM_SIZE_MASK]; if(!g_VDLP.disp_ctrl.dcw.clut_bypass) { for(x = 0; x < width; x++) @@ -602,51 +661,61 @@ static void vdlp_render_line_XRGB8888(void) dst[x] = vdlp_render_pixel_XRGB8888_bypass_clut(*(uint16_t*)&src[x]); } - g_CURBUF = (dst + width); + g_CURBUF = &dst[width]; } -static void vdlp_render_line_XRGB8888_bypass_clut(void) +static +void +vdlp_render_line_XRGB8888_bypass_clut(void) { int x; + int width; uint32_t *src; uint32_t *dst; - int width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + + width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + if(!g_VDLP.clut_ctrl.cdcw.enable_dma) - { - vdlp_render_line_black(width,sizeof(uint32_t)); - return; - } + { + vdlp_render_line_black(width,sizeof(uint32_t)); + return; + } dst = g_CURBUF; - src = (uint32_t*)(g_VRAM + ((g_VDLP.curr_bmp^2) & 0x0FFFFF)); + src = (uint32_t*)&VRAM[(g_VDLP.curr_bmp ^ 2) & VRAM_SIZE_MASK]; for(x = 0; x < width; x++) dst[x] = fixed_clut_to_XRGB8888(*(uint16_t*)&src[x]); - g_CURBUF = (dst + width); + g_CURBUF = &dst[width]; } -static void vdlp_render_line_XRGB8888_hires(void) +static +void +vdlp_render_line_XRGB8888_hires(void) { int x; + int width; uint32_t *dst0; uint32_t *dst1; uint32_t *src0; uint32_t *src1; uint32_t *src2; uint32_t *src3; - int width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + + width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + if(!g_VDLP.clut_ctrl.cdcw.enable_dma) - { - vdlp_render_line_black_hires(width,sizeof(uint32_t)); - return; - } + { + vdlp_render_line_black_hires(width,sizeof(uint32_t)); + return; + } dst0 = g_CURBUF; - dst1 = (dst0 + (width << 1)); - src0 = (uint32_t*)(g_VRAM + ((g_VDLP.curr_bmp^2) & 0x0FFFFF)); - src1 = (src0 + ((1024 * 1024) / sizeof(uint32_t))); - src2 = (src1 + ((1024 * 1024) / sizeof(uint32_t))); - src3 = (src2 + ((1024 * 1024) / sizeof(uint32_t))); + dst1 = &dst0[width << 1]; + src0 = (uint32_t*)&VRAM[(g_VDLP.curr_bmp ^ 2) & VRAM_SIZE_MASK]; + src1 = &src0[VRAM_SIZE / sizeof(uint32_t)]; + src2 = &src1[VRAM_SIZE / sizeof(uint32_t)]; + src3 = &src2[VRAM_SIZE / sizeof(uint32_t)]; if(!g_VDLP.disp_ctrl.dcw.clut_bypass) { for(x = 0; x < width; x++) @@ -676,25 +745,28 @@ void vdlp_render_line_XRGB8888_hires_bypass_clut(void) { int x; + int width; uint32_t *dst0; uint32_t *dst1; uint32_t *src0; uint32_t *src1; uint32_t *src2; uint32_t *src3; - int width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + + width = PIXELS_PER_LINE_MODULO[g_VDLP.clut_ctrl.cdcw.fba_incr_modulo]; + if(!g_VDLP.clut_ctrl.cdcw.enable_dma) - { - vdlp_render_line_black_hires(width,sizeof(uint32_t)); - return; - } + { + vdlp_render_line_black_hires(width,sizeof(uint32_t)); + return; + } dst0 = g_CURBUF; - dst1 = (dst0 + (width << 1)); - src0 = (uint32_t*)(g_VRAM + ((g_VDLP.curr_bmp^2) & 0x0FFFFF)); - src1 = (src0 + ((1024 * 1024) / sizeof(uint32_t))); - src2 = (src1 + ((1024 * 1024) / sizeof(uint32_t))); - src3 = (src2 + ((1024 * 1024) / sizeof(uint32_t))); + dst1 = &dst0[width << 1]; + src0 = (uint32_t*)&VRAM[(g_VDLP.curr_bmp ^ 2) & VRAM_SIZE_MASK]; + src1 = &src0[VRAM_SIZE / sizeof(uint32_t)]; + src2 = &src1[VRAM_SIZE / sizeof(uint32_t)]; + src3 = &src2[VRAM_SIZE / sizeof(uint32_t)]; for(x = 0; x < width; x++) { *dst0++ = fixed_clut_to_XRGB8888(*(uint16_t*)&src0[x]); @@ -709,6 +781,7 @@ vdlp_render_line_XRGB8888_hires_bypass_clut(void) /* tick / increment frame buffer address */ static +INLINE uint32_t tick_fba(const uint32_t fba_) { @@ -767,7 +840,7 @@ opera_vdlp_process_line(int line_) void -opera_vdlp_init(uint8_t *vram_) +opera_vdlp_init() { uint32_t i; static const uint32_t StartupVDL[]= @@ -786,7 +859,6 @@ opera_vdlp_init(uint8_t *vram_) 0x002C0000, 0x002B0000 }; - g_VRAM = vram_; g_VDLP.head_vdl = 0xB0000; g_RENDERER = vdlp_render_line_XRGB8888; @@ -803,19 +875,19 @@ opera_vdlp_set_vdl_head(const uint32_t addr_) uint32_t opera_vdlp_state_size(void) { - return sizeof(vdlp_t); + return opera_state_save_size(sizeof(g_VDLP)); } -void +uint32_t opera_vdlp_state_save(void *buf_) { - //memcpy(buf_,&vdl,sizeof(vdlp_datum_t)); + return opera_state_save(buf_,"VDLP",&g_VDLP,sizeof(g_VDLP)); } -void +uint32_t opera_vdlp_state_load(const void *buf_) { - //memcpy(&vdl,buf_,sizeof(vdlp_datum_t)); + return opera_state_load(&g_VDLP,"VDLP",buf_,sizeof(g_VDLP)); } /* @@ -823,55 +895,110 @@ opera_vdlp_state_load(const void *buf_) sensitivy of this code and impact it can have on a lower end system such verbosity is necessary. */ + +#define _(X,Y) ((((uint64_t)VDLP_PIXEL_FORMAT_##X)<<32)|((Y)&VDLP_FLAGS)) void* get_renderer(vdlp_pixel_format_e pf_, uint32_t flags_) { - switch(pf_) + uint64_t x; + + x = ((((uint64_t)pf_) << 32) | flags_); + + switch(x) { - case VDLP_PIXEL_FORMAT_0RGB1555: - switch(flags_ & VDLP_FLAGS) - { - case VDLP_FLAG_NONE: - return vdlp_render_line_0RGB1555; - case VDLP_FLAG_CLUT_BYPASS: - return vdlp_render_line_0RGB1555_bypass_clut; - case VDLP_FLAG_HIRES_CEL: - return vdlp_render_line_0RGB1555_hires; - case VDLP_FLAG_CLUT_BYPASS|VDLP_FLAG_HIRES_CEL: - return vdlp_render_line_0RGB1555_hires_bypass_clut; - } - break; - case VDLP_PIXEL_FORMAT_RGB565: - switch(flags_ & VDLP_FLAGS) - { - case VDLP_FLAG_NONE: - return vdlp_render_line_RGB565; - case VDLP_FLAG_CLUT_BYPASS: - return vdlp_render_line_RGB565_bypass_clut; - case VDLP_FLAG_HIRES_CEL: - return vdlp_render_line_RGB565_hires; - case VDLP_FLAG_CLUT_BYPASS|VDLP_FLAG_HIRES_CEL: - return vdlp_render_line_RGB565_hires_bypass_clut; - } - break; - case VDLP_PIXEL_FORMAT_XRGB8888: - switch(flags_ & VDLP_FLAGS) - { - case VDLP_FLAG_NONE: - return vdlp_render_line_XRGB8888; - case VDLP_FLAG_CLUT_BYPASS: - return vdlp_render_line_XRGB8888_bypass_clut; - case VDLP_FLAG_HIRES_CEL: - return vdlp_render_line_XRGB8888_hires; - case VDLP_FLAG_CLUT_BYPASS|VDLP_FLAG_HIRES_CEL: - return vdlp_render_line_XRGB8888_hires_bypass_clut; - } - break; + case _(0RGB1555,VDLP_FLAG_NONE): + return vdlp_render_line_0RGB1555; + case _(0RGB1555,VDLP_FLAG_BYPASS_CLUT): + return vdlp_render_line_0RGB1555_bypass_clut; + case _(0RGB1555,VDLP_FLAG_HIRES_CEL): + return vdlp_render_line_0RGB1555_hires; + case _(0RGB1555,VDLP_FLAG_BYPASS_CLUT|VDLP_FLAG_HIRES_CEL): + return vdlp_render_line_0RGB1555_hires_bypass_clut; + + case _(RGB565,VDLP_FLAG_NONE): + return vdlp_render_line_RGB565; + case _(RGB565,VDLP_FLAG_BYPASS_CLUT): + return vdlp_render_line_RGB565_bypass_clut; + case _(RGB565,VDLP_FLAG_HIRES_CEL): + return vdlp_render_line_RGB565_hires; + case _(RGB565,VDLP_FLAG_BYPASS_CLUT|VDLP_FLAG_HIRES_CEL): + return vdlp_render_line_RGB565_hires_bypass_clut; + + case _(XRGB8888,VDLP_FLAG_NONE): + return vdlp_render_line_XRGB8888; + case _(XRGB8888,VDLP_FLAG_BYPASS_CLUT): + return vdlp_render_line_XRGB8888_bypass_clut; + case _(XRGB8888,VDLP_FLAG_HIRES_CEL): + return vdlp_render_line_XRGB8888_hires; + case _(XRGB8888,VDLP_FLAG_BYPASS_CLUT|VDLP_FLAG_HIRES_CEL): + return vdlp_render_line_XRGB8888_hires_bypass_clut; } return NULL; } +#undef _ + +int +opera_vdlp_set_video_buffer(void *buf_) +{ + g_BUF = buf_; + + return 0; +} + +int +opera_vdlp_set_hires(bool const v_) +{ + uint32_t flags; + vdlp_renderer_t new_renderer; + + flags = g_FLAGS; + set_or_clr_flag(flags,VDLP_FLAG_HIRES_CEL,v_); + + new_renderer = get_renderer(g_PIXEL_FORMAT,flags); + if(new_renderer == NULL) + return -1; + + g_RENDERER = new_renderer; + g_FLAGS = flags; + + return 0; +} + +int +opera_vdlp_set_bypass_clut(bool const v_) +{ + uint32_t flags; + vdlp_renderer_t new_renderer; + + flags = g_FLAGS; + set_or_clr_flag(flags,VDLP_FLAG_BYPASS_CLUT,v_); + + new_renderer = get_renderer(g_PIXEL_FORMAT,flags); + if(new_renderer == NULL) + return -1; + + g_RENDERER = new_renderer; + g_FLAGS = flags; + + return 0; +} + +int +opera_vdlp_set_pixel_format(vdlp_pixel_format_e v_) +{ + vdlp_renderer_t new_renderer; + + new_renderer = get_renderer(v_,g_FLAGS); + if(new_renderer == NULL) + return -1; + + g_RENDERER = new_renderer; + g_PIXEL_FORMAT = v_; + + return 0; +} int opera_vdlp_configure(void *buf_, diff --git a/libopera/opera_vdlp.h b/libopera/opera_vdlp.h index 139bb42..febb698 100644 --- a/libopera/opera_vdlp.h +++ b/libopera/opera_vdlp.h @@ -6,10 +6,10 @@ #include #define VDLP_FLAG_NONE 0 -#define VDLP_FLAG_CLUT_BYPASS (1<<0) +#define VDLP_FLAG_BYPASS_CLUT (1<<0) #define VDLP_FLAG_HIRES_CEL (1<<1) #define VDLP_FLAG_INTERPOLATION (1<<2) -#define VDLP_FLAGS (VDLP_FLAG_CLUT_BYPASS|VDLP_FLAG_HIRES_CEL|VDLP_FLAG_INTERPOLATION) +#define VDLP_FLAGS (VDLP_FLAG_BYPASS_CLUT|VDLP_FLAG_HIRES_CEL|VDLP_FLAG_INTERPOLATION) enum vdlp_pixel_format_e { @@ -22,14 +22,14 @@ typedef enum vdlp_pixel_format_e vdlp_pixel_format_e; EXTERN_C_BEGIN -void opera_vdlp_init(uint8_t *vram_); +void opera_vdlp_init(); void opera_vdlp_set_vdl_head(const uint32_t addr); void opera_vdlp_process_line(int line); uint32_t opera_vdlp_state_size(void); -void opera_vdlp_state_save(void *buf); -void opera_vdlp_state_load(const void *buf); +uint32_t opera_vdlp_state_save(void *buf); +uint32_t opera_vdlp_state_load(void const *buf); int opera_vdlp_configure(void *buf, vdlp_pixel_format_e pf, diff --git a/libopera/opera_xbus.c b/libopera/opera_xbus.c index 7c80947..46cc4f7 100644 --- a/libopera/opera_xbus.c +++ b/libopera/opera_xbus.c @@ -29,6 +29,7 @@ */ #include "opera_clio.h" +#include "opera_state.h" #include "opera_xbus.h" #include @@ -273,68 +274,71 @@ uint32_t opera_xbus_state_size(void) { int i; - uint32_t tmp = sizeof(xbus_datum_t); + uint32_t size = sizeof(xbus_datum_t); + + size = opera_state_save_size(sizeof(xbus_datum_t)); - tmp += (16 * 4); for(i = 0; i < 15; i++) { if(!xdev[i]) continue; - tmp += (uintptr_t)xdev[i](XBP_GET_SAVESIZE,NULL); + size += (uintptr_t)xdev[i](XBP_GET_SAVESIZE,NULL); } - return tmp; + return size; } -void opera_xbus_state_save(void *buf_) +uint32_t +opera_xbus_state_save(void *data_) { uint32_t i; - uint32_t j; - uint32_t off; - uint32_t tmp; + uint32_t rv; + uint32_t size; + uint8_t *data; - memcpy(buf_,&XBUS,sizeof(xbus_datum_t)); + data = data_; - j = off = sizeof(xbus_datum_t); - off += (16 * 4); + size = opera_state_save(data,"XBUS",&XBUS,sizeof(XBUS)); + if(size == 0) + return 0; for(i = 0; i < 15; i++) { if(!xdev[i]) - { - tmp = 0; - memcpy(&((uint8_t*)buf_)[j+i*4],&tmp,4); - } - else - { - xdev[i](XBP_GET_SAVEDATA,&((uint8_t*)buf_)[off]); - memcpy(&((uint8_t*)buf_)[j+i*4],&off,4); - off += (uintptr_t)xdev[i](XBP_GET_SAVESIZE,NULL); - } + break; + + rv = (uintptr_t)xdev[i](XBP_GET_SAVEDATA,&data[size]); + size += rv; } + + return size; } -void -opera_xbus_state_load(const void *buf_) +uint32_t +opera_xbus_state_load(void const *data_) { uint32_t i; - uint32_t j; - uint32_t offd; + uint32_t size; + uint32_t rv; + uint8_t *data; - j = sizeof(xbus_datum_t); + data = (uint8_t*)data_; - memcpy(&XBUS,buf_,j); + size = opera_state_load(&XBUS,"XBUS",data,sizeof(XBUS)); + if(size == 0) + return 0; for(i = 0; i < 15; i++) { - memcpy(&offd,&((uint8_t*)buf_)[j+i*4],4); - if(!xdev[i]) - continue; + break; - if(!offd) - xdev[i](XBP_RESET,NULL); - else - xdev[i](XBP_SET_SAVEDATA,&((uint8_t*)buf_)[offd]); + xdev[i](XBP_RESET,NULL); + rv = (uintptr_t)xdev[i](XBP_SET_SAVEDATA,&data[size]); + if(rv == 0) + return 0; + size += rv; } + + return size; } diff --git a/libopera/opera_xbus.h b/libopera/opera_xbus.h index dc24fe3..f773eb9 100644 --- a/libopera/opera_xbus.h +++ b/libopera/opera_xbus.h @@ -74,8 +74,8 @@ void opera_xbus_fifo_set_data(const uint32_t val_); uint32_t opera_xbus_fifo_get_data(void); uint32_t opera_xbus_state_size(void); -void opera_xbus_state_save(void *buf_); -void opera_xbus_state_load(const void *buf_); +uint32_t opera_xbus_state_save(void *data); +uint32_t opera_xbus_state_load(void const *data); EXTERN_C_END diff --git a/libopera/opera_xbus_cdrom_plugin.c b/libopera/opera_xbus_cdrom_plugin.c index 5a350cf..5bc2d88 100644 --- a/libopera/opera_xbus_cdrom_plugin.c +++ b/libopera/opera_xbus_cdrom_plugin.c @@ -1,6 +1,7 @@ -#include "bool.h" +#include "boolean.h" #include "opera_cdrom.h" +#include "opera_state.h" #include "opera_xbus.h" #include @@ -15,9 +16,9 @@ xbus_cdrom_plugin(int proc_, { case XBP_INIT: opera_cdrom_init(&g_CDROM_DEVICE); - return (void*)TRUE; + return (void*)true; case XBP_DESTROY: - return (void*)TRUE; + return (void*)true; case XBP_RESET: opera_cdrom_init(&g_CDROM_DEVICE); break; @@ -25,7 +26,7 @@ xbus_cdrom_plugin(int proc_, opera_cdrom_send_cmd(&g_CDROM_DEVICE,(uint8_t)(uintptr_t)data_); break; case XBP_FIQ: - return (void*)opera_cdrom_test_fiq(&g_CDROM_DEVICE); + return (void*)(uintptr_t)opera_cdrom_test_fiq(&g_CDROM_DEVICE); case XBP_GET_DATA: return (void*)(uintptr_t)opera_cdrom_fifo_get_data(&g_CDROM_DEVICE); case XBP_GET_STATUS: @@ -36,13 +37,11 @@ xbus_cdrom_plugin(int proc_, case XBP_GET_POLL: return (void*)(uintptr_t)g_CDROM_DEVICE.poll; case XBP_GET_SAVESIZE: - return (void*)(uintptr_t)sizeof(cdrom_device_t); + return (void*)(uintptr_t)opera_state_save_size(sizeof(cdrom_device_t)); case XBP_GET_SAVEDATA: - memcpy(data_,&g_CDROM_DEVICE,sizeof(cdrom_device_t)); - break; + return (void*)(uintptr_t)opera_state_save(data_,"CDRM",&g_CDROM_DEVICE,sizeof(g_CDROM_DEVICE)); case XBP_SET_SAVEDATA: - memcpy(&g_CDROM_DEVICE,data_,sizeof(cdrom_device_t)); - return (void*)TRUE; + return (void*)(uintptr_t)opera_state_load(&g_CDROM_DEVICE,"CDRM",data_,sizeof(g_CDROM_DEVICE)); }; return NULL; diff --git a/libretro.c b/libretro.c index 05921ce..3ddc89d 100644 --- a/libretro.c +++ b/libretro.c @@ -1,14 +1,11 @@ -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include +#include "lr_input.h" +#include "lr_input_crosshair.h" +#include "lr_input_descs.h" +#include "opera_lr_callbacks.h" +#include "opera_lr_dsp.h" +#include "opera_lr_nvram.h" +#include "opera_lr_opts.h" +#include "retro_cdimage.h" #include "libopera/hack_flags.h" #include "libopera/opera_3do.h" @@ -17,21 +14,26 @@ #include "libopera/opera_cdrom.h" #include "libopera/opera_clock.h" #include "libopera/opera_core.h" +#include "libopera/opera_log.h" #include "libopera/opera_madam.h" +#include "libopera/opera_mem.h" #include "libopera/opera_nvram.h" #include "libopera/opera_pbus.h" #include "libopera/opera_region.h" #include "libopera/opera_vdlp.h" #include "libopera/prng16.h" -#include "opera_lr_dsp.h" -#include "lr_input.h" -#include "lr_input_crosshair.h" -#include "lr_input_descs.h" -#include "opera_lr_nvram.h" -#include "opera_lr_callbacks.h" -#include "opera_lr_opts.h" -#include "retro_cdimage.h" +#include "file/file_path.h" +#include "libretro.h" +#include "libretro_core_options.h" +#include "retro_miscellaneous.h" +#include "streams/file_stream.h" + +#include +#include +#include +#include +#include #define CDIMAGE_SECTOR_SIZE 2048 @@ -215,24 +217,22 @@ bool retro_serialize(void *data_, size_t size_) { - if(size_ != opera_3do_state_size()) - return false; + uint32_t size; - opera_3do_state_save(data_); + size = opera_3do_state_save(data_,size_); - return true; + return (size == size_); } bool -retro_unserialize(const void *data_, +retro_unserialize(void const *data_, size_t size_) { - if(size_ != opera_3do_state_size()) - return false; + uint32_t size; - opera_3do_state_load(data_); + size = opera_3do_state_load(data_,size_); - return true; + return (size == size_); } void @@ -306,8 +306,8 @@ load_rom1(void) return -1; } - rom = opera_arm_rom1_get(); - size = opera_arm_rom1_size(); + rom = ROM1; + size = ROM1_SIZE; if((rv = read_file_from_system_directory(g_OPT_BIOS->filename,rom,size)) < 0) { retro_log_printf_cb(RETRO_LOG_ERROR, @@ -316,7 +316,7 @@ load_rom1(void) return -1; } - opera_arm_rom1_byteswap_if_necessary(); + opera_mem_rom1_byteswap32_if_le(); return 0; } @@ -329,8 +329,8 @@ load_rom2(void) uint8_t *rom; int64_t size; - rom = opera_arm_rom2_get(); - size = opera_arm_rom2_size(); + rom = ROM2; + size = ROM2_SIZE; if(g_OPT_FONT == NULL) { memset(rom,0,size); @@ -345,7 +345,7 @@ load_rom2(void) return -1; } - opera_arm_rom2_byteswap_if_necessary(); + opera_mem_rom2_byteswap32_if_le(); return 0; } @@ -539,9 +539,9 @@ retro_get_memory_data(unsigned id_) case RETRO_MEMORY_SAVE_RAM: return NULL; case RETRO_MEMORY_SYSTEM_RAM: - return opera_arm_ram_get(); + return DRAM; case RETRO_MEMORY_VIDEO_RAM: - return opera_arm_vram_get(); + return VRAM; } return NULL; @@ -555,9 +555,9 @@ retro_get_memory_size(unsigned id_) case RETRO_MEMORY_SAVE_RAM: return 0; case RETRO_MEMORY_SYSTEM_RAM: - return opera_arm_ram_size(); + return DRAM_SIZE; case RETRO_MEMORY_VIDEO_RAM: - return opera_arm_vram_size(); + return VRAM_SIZE; } return 0; @@ -567,11 +567,18 @@ void retro_init(void) { struct retro_log_callback log; - unsigned level = 5; - uint64_t serialization_quirks = RETRO_SERIALIZATION_QUIRK_SINGLE_SESSION; + unsigned level; + uint64_t serialization_quirks; + + level = 5; + serialization_quirks = (RETRO_SERIALIZATION_QUIRK_ENDIAN_DEPENDENT | + RETRO_SERIALIZATION_QUIRK_PLATFORM_DEPENDENT); if(retro_environment_cb(RETRO_ENVIRONMENT_GET_LOG_INTERFACE,&log)) - opera_lr_callbacks_set_log_printf(log.log); + { + opera_lr_callbacks_set_log_printf(log.log); + opera_log_set_func(log.log); + } retro_environment_cb(RETRO_ENVIRONMENT_SET_PERFORMANCE_LEVEL,&level); retro_environment_cb(RETRO_ENVIRONMENT_SET_SERIALIZATION_QUIRKS,&serialization_quirks); @@ -586,6 +593,7 @@ retro_init(void) void retro_deinit(void) { + } void diff --git a/lr_input.h b/lr_input.h index a221a32..80687d9 100644 --- a/lr_input.h +++ b/lr_input.h @@ -1,6 +1,8 @@ #ifndef LIBRETRO_LR_INPUT_H_INCLUDED #define LIBRETRO_LR_INPUT_H_INCLUDED +#include "libretro.h" + #include #define LR_INPUT_MAX_DEVICES 8 diff --git a/opera_lr_callbacks.h b/opera_lr_callbacks.h index 767a0af..27161d3 100644 --- a/opera_lr_callbacks.h +++ b/opera_lr_callbacks.h @@ -1,7 +1,7 @@ #ifndef OPERA_LR_CALLBACKS_H_INCLUDED #define OPERA_LR_CALLBACKS_H_INCLUDED -#include +#include "libretro.h" extern retro_audio_sample_t retro_audio_sample_cb; extern retro_audio_sample_batch_t retro_audio_sample_batch_cb; diff --git a/opera_lr_dsp_threaded.ic b/opera_lr_dsp_threaded.ic index ba51fc5..757156b 100644 --- a/opera_lr_dsp_threaded.ic +++ b/opera_lr_dsp_threaded.ic @@ -2,9 +2,10 @@ #include "opera_lr_callbacks.h" -#include "bool.h" +#include "boolean.h" #include + #include /* FORWARD DECLARATIONS */ @@ -16,7 +17,7 @@ static void dsp_upload_unlocked(void); #define DSP_BUF_SIZE_MASK (DSP_BUF_SIZE - 1) /* GLOBAL VARIABLES */ -static bool_t g_DSP_THREADED = FALSE; +static bool g_DSP_THREADED = false; static uint32_t g_DSP_BUF_IDX = 0; static uint32_t g_DSP_BUF_PENDING = 0; @@ -25,7 +26,7 @@ static int32_t g_DSP_BUF[DSP_BUF_SIZE]; static scond_t *g_DSP_COND = NULL; static slock_t *g_DSP_COND_MUTEX = NULL; static sthread_t *g_DSP_THREAD = NULL; -static bool g_DSP_THREAD_RUNNING = FALSE; +static bool g_DSP_THREAD_RUNNING = false; static slock_t *g_DSP_THREAD_MUTEX = NULL; static void (*g_DSP_UPLOAD)(void) = dsp_upload_unlocked; @@ -40,7 +41,7 @@ dsp_thread_loop(void *handle_) { int32_t sample; uint32_t pending; - bool running = TRUE; + bool running = true; while(running) { @@ -126,7 +127,7 @@ opera_lr_dsp_destroy(void) if(g_DSP_THREADED) { slock_lock(g_DSP_THREAD_MUTEX); - g_DSP_THREAD_RUNNING = FALSE; + g_DSP_THREAD_RUNNING = false; g_DSP_BUF_PENDING = 0; g_DSP_BUF_IDX = 0; slock_unlock(g_DSP_THREAD_MUTEX); @@ -142,12 +143,12 @@ opera_lr_dsp_destroy(void) g_DSP_COND = NULL; g_DSP_COND_MUTEX = NULL; g_DSP_THREAD_MUTEX = NULL; - g_DSP_THREADED = FALSE; + g_DSP_THREADED = false; } } void -opera_lr_dsp_init(const bool_t threaded_) +opera_lr_dsp_init(const bool threaded_) { if(g_DSP_THREADED == threaded_) return; @@ -162,7 +163,7 @@ opera_lr_dsp_init(const bool_t threaded_) g_DSP_COND = scond_new(); g_DSP_COND_MUTEX = slock_new(); g_DSP_THREAD_MUTEX = slock_new(); - g_DSP_THREAD_RUNNING = TRUE; + g_DSP_THREAD_RUNNING = true; g_DSP_THREAD = sthread_create(dsp_thread_loop, NULL); g_DSP_UPLOAD = dsp_upload_locked; diff --git a/opera_lr_nvram.c b/opera_lr_nvram.c index 63e00a2..7772ab8 100644 --- a/opera_lr_nvram.c +++ b/opera_lr_nvram.c @@ -1,18 +1,17 @@ -#include - -#include -#include -#include -#include -#include - -#include "libopera/opera_arm.h" -#include "libopera/opera_nvram.h" +#include "compat/strl.h" +#include "file/file_path.h" +#include "retro_miscellaneous.h" +#include "streams/file_stream.h" #include "opera_lr_callbacks.h" #include "opera_lr_nvram.h" #include "opera_lr_opts.h" +#include "libopera/opera_mem.h" +#include "libopera/opera_nvram.h" + +#include + static const char OLD_NVRAM_FILENAME[] = "3DO.nvram"; static @@ -358,8 +357,8 @@ opera_lr_nvram_save(const char *gamepath_) size_t nvram_size; const uint8_t *nvram_buf; - nvram_buf = opera_arm_nvram_get(); - nvram_size = opera_arm_nvram_size(); + nvram_buf = NVRAM; + nvram_size = NVRAM_SIZE; version = opera_lr_opts_nvram_version(); if(opera_lr_opts_is_nvram_shared() || (gamepath_ == NULL)) { @@ -386,8 +385,8 @@ opera_lr_nvram_load(const char *gamepath_) uint8_t *nvram_buf; uint32_t nvram_size; - nvram_buf = opera_arm_nvram_get(); - nvram_size = opera_arm_nvram_size(); + nvram_buf = NVRAM; + nvram_size = NVRAM_SIZE; version = opera_lr_opts_nvram_version(); if(opera_lr_opts_is_nvram_shared() || (gamepath_ == NULL)) { diff --git a/opera_lr_nvram.h b/opera_lr_nvram.h index 69fcf9e..559a1d1 100644 --- a/opera_lr_nvram.h +++ b/opera_lr_nvram.h @@ -1,8 +1,6 @@ #ifndef OPERA_LR_NVRAM_H_INCLUDED #define OPERA_LR_NVRAM_H_INCLUDED -#include - void opera_lr_nvram_load(const char *gamepath); void opera_lr_nvram_save(const char *gamepath); diff --git a/opera_lr_opts.c b/opera_lr_opts.c index 3451627..ac9129e 100644 --- a/opera_lr_opts.c +++ b/opera_lr_opts.c @@ -26,6 +26,7 @@ #include "libopera/opera_clock.h" #include "libopera/opera_core.h" #include "libopera/opera_madam.h" +#include "libopera/opera_mem.h" #include "libopera/opera_region.h" #include "libopera/opera_vdlp.h" @@ -59,14 +60,6 @@ getval(const char *key_) char key[64]; struct retro_variable var; - strncpy(key,"4do_",(sizeof(key)-1)); - strncat(key,key_,(sizeof(key)-1)); - var.key = key; - var.value = NULL; - rv = getvar(&var); - if(rv && (var.value != NULL)) - return var.value; - strncpy(key,"opera_",(sizeof(key)-1)); strncat(key,key_,(sizeof(key)-1)); var.key = key; @@ -229,7 +222,7 @@ opera_lr_opts_get_vdlp_flags(void) if(opera_lr_opts_is_enabled("high_resolution")) flags |= VDLP_FLAG_HIRES_CEL; if(opera_lr_opts_is_enabled("vdlp_bypass_clut")) - flags |= VDLP_FLAG_CLUT_BYPASS; + flags |= VDLP_FLAG_BYPASS_CLUT; return flags; } @@ -248,13 +241,13 @@ opera_lr_opts_process_high_resolution(void) rv = opera_lr_opts_is_enabled("high_resolution"); if(rv) { - HIRESMODE = 1; + HIRESMODE = true; g_OPT_VIDEO_WIDTH = (opera_region_width() << 1); g_OPT_VIDEO_HEIGHT = (opera_region_height() << 1); } else { - HIRESMODE = 0; + HIRESMODE = false; g_OPT_VIDEO_WIDTH = opera_region_width(); g_OPT_VIDEO_HEIGHT = opera_region_height(); } diff --git a/retro_cdimage.c b/retro_cdimage.c index d2403cd..ab64076 100644 --- a/retro_cdimage.c +++ b/retro_cdimage.c @@ -1,16 +1,16 @@ #include "retro_cdimage.h" +#include "retro_miscellaneous.h" + +#include "file/file_path.h" +#include "streams/chd_stream.h" +#include "streams/interface_stream.h" + +#include "endianness.h" + #include #include -#include -#include -#include -#include -#include - -#include - static void cdimage_set_size_and_offset(cdimage_t *cd_, @@ -202,5 +202,5 @@ retro_cdimage_get_number_of_logical_blocks(cdimage_t *cdimage_) if(rv == -1) return -1; - return swap_if_little32(blocks); + return swap32_if_little_endian(blocks); }