libretro/opera-libretro
1
0 Fork 0
mirror of https://github.com/libretro/opera-libretro.git synced 2026-11-07 04:25:58 -10:00
Code Issues Packages Projects Releases Wiki Activity

Fix save states and rework memory system

Browse Source 
All the memory stuff is connected so when fixing the save states it
made sense to prepare for fixing up and enhancing the memory
code. Particularly for allowing for configurable amounts of memory for
homebrew.
This commit is contained in:
Antonio SJ Musumeci committed 2023-12-26 18:10:15 -05:00
1 parent a7bbf963da
commit 1b4442fb65
42 files changed
+1326 -929
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Makefile.common
+3
View File
@@ -39,11 +39,14 @@ SOURCES_C += \
$(OPERA_DIR)/opera_diag_port.c \
$(OPERA_DIR)/opera_dsp.c \
$(OPERA_DIR)/opera_fixedpoint_math.c \
$(OPERA_DIR)/opera_log.c \
$(OPERA_DIR)/opera_madam.c \
$(OPERA_DIR)/opera_mem.c \
$(OPERA_DIR)/opera_nvram.c \
$(OPERA_DIR)/opera_pbus.c \
$(OPERA_DIR)/opera_region.c \
$(OPERA_DIR)/opera_sport.c \
$(OPERA_DIR)/opera_state.c \
$(OPERA_DIR)/opera_vdlp.c \
$(OPERA_DIR)/opera_xbus.c \
$(OPERA_DIR)/opera_xbus_cdrom_plugin.c
libopera/bool.h
-9
View File
@@ -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
libopera/endianness.h
+4 -2
View File
@@ -29,6 +29,7 @@
defined(__i386) || \
defined(_M_IX86)
#define IS_BIG_ENDIAN 0
#define IS_LITTLE_ENDIAN 1
#elif \
(defined(__BYTE_ORDER) && \
(__BYTE_ORDER == __BIG_ENDIAN)) || \
@@ -50,10 +51,13 @@
defined(_XENON) || \
defined(__sparc__)
#define IS_BIG_ENDIAN 1
#define IS_LITTLE_ENDIAN 0
#elif defined(MSB_FIRST)
#define IS_BIG_ENDIAN 1
#define IS_LITTLE_ENDIAN 0
#else
#define IS_BIG_ENDIAN 0
#define IS_LITTLE_ENDIAN 1
#endif
#if defined(__GNUC__)
@@ -70,13 +74,11 @@
#if IS_BIG_ENDIAN
#define is_little_endian() (0)
#define swap32_if_little_endian(X) (X)
#define swap32_array_if_little_endian(X,Y)
#else
#define is_little_endian() (1)
#define swap32_if_little_endian(X) (SWAP32(X))
static
libopera/flags.h
+11
View File
@@ -0,0 +1,11 @@
#ifndef LIBOPERA_FLAGS_H_INCLUDED
#define LIBOPERA_FLAGS_H_INCLUDED
#define set_flag(V,F) ((V)|=(F))
#define clr_flag(V,F) ((V)&=~(F))
#define set_or_clr_flag(V,F,S) ((!!(S)) ? set_flag(V,F) : clr_flag(V,F))
#define flag_is_set(V,F) (!!((V)&(F)))
#define flag_is_clr(V,F) (!((V)&(F)))
#endif
libopera/opera_3do.c
+96 -65
View File
@@ -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 <stdint.h>
#include <stdlib.h>
#include <string.h>
static opera_ext_interface_t io_interface;
extern int flagtime;
int HIRESMODE = 0;
uint32_t FIXMODE = 0;
int CNBFIX = 0;
uint32_t FIXMODE = 0;
int CNBFIX = 0;
int
opera_3do_init(opera_ext_interface_t callback_)
{
int i;
uint8_t *dram;
uint8_t *vram;
opera_mem_init();
io_interface = callback_;
@@ -68,12 +71,9 @@ opera_3do_init(opera_ext_interface_t callback_)
opera_arm_init();
dram = opera_arm_ram_get();
vram = opera_arm_vram_get();
opera_vdlp_init(vram);
opera_sport_init(vram);
opera_madam_init(dram);
opera_vdlp_init();
opera_sport_init();
opera_madam_init();
opera_xbus_init(xbus_cdrom_plugin);
/*
@@ -187,75 +187,106 @@ opera_3do_process_frame(void)
field = !field;
}
static
uint32_t
opera_3do_state_size_v1(void)
{
uint32_t size;
size = 0;
size += opera_state_save_size(sizeof(opera_state_hdr_t));
size += opera_arm_state_size();
size += opera_clio_state_size();
size += opera_dsp_state_size();
size += opera_madam_state_size();
size += opera_mem_state_size();
size += opera_sport_state_size();
size += opera_vdlp_state_size();
size += opera_xbus_state_size();
return size;
}
uint32_t
opera_3do_state_size(void)
{
uint32_t tmp;
tmp = 0;
tmp += 16 * 4;
tmp += opera_arm_state_size();
tmp += opera_vdlp_state_size();
tmp += opera_dsp_state_size();
tmp += opera_clio_state_size();
tmp += opera_clock_state_size();
tmp += opera_sport_state_size();
tmp += opera_madam_state_size();
tmp += opera_xbus_state_size();
return tmp;
return opera_3do_state_size_v1();
}
void
opera_3do_state_save(void *buf_)
static
uint32_t
opera_3do_state_save_v1(void *data_,
size_t const size_)
{
uint8_t *data;
uint32_t *indexes;
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;
}
}
libopera/opera_3do.h
+2 -2
View File
@@ -7,8 +7,8 @@
#include <stdint.h>
uint32_t opera_3do_state_size(void);
void opera_3do_state_save(void *buf);
int opera_3do_state_load(const void *buf);
uint32_t opera_3do_state_save(void *buf, size_t size);
uint32_t opera_3do_state_load(void const *buf, size_t size);
int opera_3do_init(opera_ext_interface_t callback);
void opera_3do_destroy(void);
libopera/opera_arm.c
+99 -287
View File
@@ -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 <stdint.h>
@@ -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_);
}
libopera/opera_arm.h
+2 -29
View File
@@ -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);
libopera/opera_arm_core.h
-7
View File
@@ -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];
libopera/opera_bitop.c
+6 -5
View File
@@ -24,6 +24,7 @@
#include <stdint.h>
#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;
libopera/opera_clio.c
+9 -29
View File
@@ -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
libopera/opera_clio.h
+2 -2
View File
@@ -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
libopera/opera_clock.c
-19
View File
@@ -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)
{
libopera/opera_clock.h
-4
View File
@@ -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);
libopera/opera_core.h
+1 -2
View File
@@ -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
libopera/opera_dsp.c
+16 -14
View File
@@ -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 <string.h>
@@ -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 */
}
libopera/opera_dsp.h
+2 -2
View File
@@ -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
libopera/opera_log.c
+26
View File
@@ -0,0 +1,26 @@
#include "opera_log.h"
#include <stddef.h>
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_;
}
libopera/opera_log.h
+19
View File
@@ -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
libopera/opera_madam.c
+47 -93
View File
@@ -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 <math.h>
@@ -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
libopera/opera_madam.h
+3 -3
View File
@@ -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
libopera/opera_mem.c
+201
View File
@@ -0,0 +1,201 @@
#include "opera_mem.h"
#include "endianness.h"
#include "opera_state.h"
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
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);
}
libopera/opera_mem.h
+166
View File
@@ -0,0 +1,166 @@
#ifndef LIBOPERA_MEM_H_INCLUDED
#define LIBOPERA_MEM_H_INCLUDED
#include "boolean.h"
#include "inline.h"
#include <stdint.h>
#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
libopera/opera_nvram.c
+21 -21
View File
@@ -1,6 +1,6 @@
#include "opera_arm.h"
#include "opera_mem.h"
#include "retro_endianness.h"
#include "endianness.h"
#include <stdint.h>
#include <string.h>
@@ -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);
}
libopera/opera_nvram.h
-2
View File
@@ -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
libopera/opera_sport.c
+23 -30
View File
@@ -30,14 +30,17 @@
#include "inline.h"
#include "opera_core.h"
#include "opera_mem.h"
#include "opera_state.h"
#include <stdint.h>
#include <string.h>
#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));
}
libopera/opera_sport.h
+3 -3
View File
@@ -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
libopera/opera_state.c
+85
View File
@@ -0,0 +1,85 @@
#include "opera_state.h"
#include "opera_log.h"
#include <stdint.h>
#include <string.h>
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_);
}
libopera/opera_state.h
+49
View File
@@ -0,0 +1,49 @@
#ifndef LIBOPERA_STATE_H_INCLUDED
#define LIBOPERA_STATE_H_INCLUDED
#include <stdint.h>
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
libopera/opera_vdlp.c
+290 -163
View File
@@ -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 <assert.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
@@ -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_,
libopera/opera_vdlp.h
+5 -5
View File
@@ -6,10 +6,10 @@
#include <stdint.h>
#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,
libopera/opera_xbus.c
+38 -34
View File
@@ -29,6 +29,7 @@
*/
#include "opera_clio.h"
#include "opera_state.h"
#include "opera_xbus.h"
#include <stdint.h>
@@ -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;
}
libopera/opera_xbus.h
+2 -2
View File
@@ -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
libopera/opera_xbus_cdrom_plugin.c
+8 -9
View File
@@ -1,6 +1,7 @@
#include "bool.h"
#include "boolean.h"
#include "opera_cdrom.h"
#include "opera_state.h"
#include "opera_xbus.h"
#include <string.h>
@@ -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;
libretro.c
+49 -41
View File
@@ -1,14 +1,11 @@
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <file/file_path.h>
#include <libretro.h>
#include <libretro_core_options.h>
#include <retro_miscellaneous.h>
#include <streams/file_stream.h>
#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 <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#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
lr_input.h
+2
View File
@@ -1,6 +1,8 @@
#ifndef LIBRETRO_LR_INPUT_H_INCLUDED
#define LIBRETRO_LR_INPUT_H_INCLUDED
#include "libretro.h"
#include <stdint.h>
#define LR_INPUT_MAX_DEVICES 8
opera_lr_callbacks.h
+1 -1
View File
@@ -1,7 +1,7 @@
#ifndef OPERA_LR_CALLBACKS_H_INCLUDED
#define OPERA_LR_CALLBACKS_H_INCLUDED
#include <libretro.h>
#include "libretro.h"
extern retro_audio_sample_t retro_audio_sample_cb;
extern retro_audio_sample_batch_t retro_audio_sample_batch_cb;
opera_lr_dsp_threaded.ic
+9 -8
View File
@@ -2,9 +2,10 @@
#include "opera_lr_callbacks.h"
#include "bool.h"
#include "boolean.h"
#include <rthreads/rthreads.h>
#include <stdint.h>
/* 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;
opera_lr_nvram.c
+13 -14
View File
@@ -1,18 +1,17 @@
#include <string.h>
#include <compat/strl.h>
#include <file/file_path.h>
#include <retro_endianness.h>
#include <retro_miscellaneous.h>
#include <streams/file_stream.h>
#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 <string.h>
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))
{
opera_lr_nvram.h
-2
View File
@@ -1,8 +1,6 @@
#ifndef OPERA_LR_NVRAM_H_INCLUDED
#define OPERA_LR_NVRAM_H_INCLUDED
#include <stdint.h>
void opera_lr_nvram_load(const char *gamepath);
void opera_lr_nvram_save(const char *gamepath);
opera_lr_opts.c
+4 -11
View File
@@ -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();
}
retro_cdimage.c
+9 -9
View File
@@ -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 <stdlib.h>
#include <string.h>
#include <file/file_path.h>
#include <retro_endianness.h>
#include <streams/chd_stream.h>
#include <streams/interface_stream.h>
#include <retro_miscellaneous.h>
#include <libretro.h>
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);
}