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); }