starred/Mu
1
0
Fork 0
mirror of https://github.com/libretro/Mu.git synced 2026-07-08 17:57:01 +00:00
Code Issues 18 Packages Projects Releases 2 Wiki Activity

Clean up emulator*State* functions

Browse Source
This commit is contained in:
meepingsnesroms
2019-05-01 11:06:39 -07:00
parent cb9093c5f4
commit 4d803c6fc0
16 changed files with 404 additions and 289 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
bugs/shadowTheifBug/Screenshot_20190426-220702.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 123 KiB

4
bugs/shadowTheifBug/text.txt Normal file
View File

@@ -0,0 +1,4 @@
Whenever I register ShadowThief, this happens:
It happens on any version of Mu
PHEM/ST is fine

6
qtBuildSystem/Mu/Mu.pro
View File

@@ -204,6 +204,7 @@ CONFIG += c++11
INCLUDEPATH += $$PWD/qt-common/include
SOURCES += \
../../src/dbvz.c \
debugviewer.cpp \
emuwrapper.cpp \
main.cpp \
@@ -227,10 +228,10 @@ SOURCES += \
../../src/m68k/m68kopnz.c \
../../src/m68k/m68kops.c \
../../src/expansionHardware.c \
../../src/m515Bus.c \
../../src/dbvzRegisters.c
../../src/m515Bus.c
HEADERS += \
../../src/dbvz.h \
debugviewer.h \
emuwrapper.h \
mainwindow.h \
@@ -266,7 +267,6 @@ HEADERS += \
../../src/m515Bus.h \
../../src/dbvzRegisterAccessors.c.h \
../../src/dbvzTiming.c.h \
../../src/dbvzRegisters.h \
FORMS += \
mainwindow.ui \

2
src/ads7846.c
View File

@@ -3,7 +3,7 @@
#include "emulator.h"
#include "portability.h"
#include "dbvzRegisters.h"
#include "dbvz.h"
bool ads7846PenIrqEnabled;

268
src/dbvzRegisters.c → src/dbvz.c
View File

@@ -4,7 +4,7 @@
#include "emulator.h"
#include "specs/dragonballVzRegisterSpec.h"
#include "dbvzRegisters.h"
#include "dbvz.h"
#include "m515Bus.h"
#include "portability.h"
#include "flx68000.h"
@@ -13,7 +13,7 @@
#include "audio/blip_buf.h"
#include "debug/sandbox.h"
uint8_t dbvzReg[DBVZ_REG_SIZE];
dbvz_chip_t dbvzChipSelects[DBVZ_CHIP_END];
double dbvzSysclksPerClk32;//how many SYSCLK cycles before toggling the 32.768 kHz crystal
uint32_t dbvzFrameClk32s;//how many CLK32s have happened in the current frame
@@ -1007,11 +1007,11 @@ void dbvzSetRegister32(uint32_t address, uint32_t value){
}
}
void dbvzResetRegisters(void){
void dbvzReset(void){
uint32_t oldRtc = registerArrayRead32(RTCTIME);//preserve RTCTIME
uint16_t oldDayr = registerArrayRead16(DAYR);//preserve DAYR
memset(palmReg, 0x00, DBVZ_REG_SIZE - DBVZ_BOOTLOADER_SIZE);
memset(dbvzReg, 0x00, DBVZ_REG_SIZE - DBVZ_BOOTLOADER_SIZE);
dbvzSysclksPerClk32 = 0.0;
clk32Counter = 0;
pctlrCpuClockDivider = 1.0;
@@ -1157,9 +1157,269 @@ void dbvzResetRegisters(void){
updateBacklightAmplifierStatus();
dbvzSysclksPerClk32 = sysclksPerClk32();
dbvzResetAddressSpace();
flx68000Reset();
}
uint32_t dbvzStateSize(void){
uint32_t size = 0;
size += flx68000StateSize();
size += DBVZ_REG_SIZE;//hardware registers
size += DBVZ_TOTAL_MEMORY_BANKS;
size += sizeof(uint32_t) * 4 * DBVZ_CHIP_END;//chip select states
size += sizeof(uint8_t) * 5 * DBVZ_CHIP_END;//chip select states
size += sizeof(uint64_t) * 5;//32.32 fixed point double, timerXCycleCounter and CPU cycle timers
size += sizeof(int8_t);//pllSleepWait
size += sizeof(int8_t);//pllWakeWait
size += sizeof(uint32_t);//clk32Counter
size += sizeof(uint64_t);//pctlrCpuClockDivider
size += sizeof(uint16_t) * 2;//timerStatusReadAcknowledge
size += sizeof(uint8_t);//portDInterruptLastValue
size += sizeof(uint16_t) * 9;//RX 8 * 16 SPI1 FIFO, 1 index is for FIFO full
size += sizeof(uint16_t) * 9;//TX 8 * 16 SPI1 FIFO, 1 index is for FIFO full
size += sizeof(uint8_t) * 5;//spi1(R/T)x(Read/Write)Position / spi1RxOverflowed
size += sizeof(int32_t);//pwm1ClocksToNextSample
size += sizeof(uint8_t) * 6;//pwm1Fifo[6]
size += sizeof(uint8_t) * 2;//pwm1(Read/Write)
//debugLog("size is:%d\n", size);
return size;
}
void dbvzSaveState(uint8_t* data){
uint32_t offset = 0;
uint8_t index;
//CPU core
flx68000SaveState(data + offset);
offset += flx68000StateSize();
//memory
memcpy(data + offset, dbvzReg, DBVZ_REG_SIZE);
swap16BufferIfLittle(data + offset, DBVZ_REG_SIZE / sizeof(uint16_t));
offset += DBVZ_REG_SIZE;
memcpy(data + offset, dbvzBankType, DBVZ_TOTAL_MEMORY_BANKS);
offset += DBVZ_TOTAL_MEMORY_BANKS;
for(index = DBVZ_CHIP_BEGIN; index < DBVZ_CHIP_END; index++){
writeStateValue8(data + offset, dbvzChipSelects[index].enable);
offset += sizeof(uint8_t);
writeStateValue32(data + offset, dbvzChipSelects[index].start);
offset += sizeof(uint32_t);
writeStateValue32(data + offset, dbvzChipSelects[index].lineSize);
offset += sizeof(uint32_t);
writeStateValue32(data + offset, dbvzChipSelects[index].mask);
offset += sizeof(uint32_t);
writeStateValue8(data + offset, dbvzChipSelects[index].inBootMode);
offset += sizeof(uint8_t);
writeStateValue8(data + offset, dbvzChipSelects[index].readOnly);
offset += sizeof(uint8_t);
writeStateValue8(data + offset, dbvzChipSelects[index].readOnlyForProtectedMemory);
offset += sizeof(uint8_t);
writeStateValue8(data + offset, dbvzChipSelects[index].supervisorOnlyProtectedMemory);
offset += sizeof(uint8_t);
writeStateValue32(data + offset, dbvzChipSelects[index].unprotectedSize);
offset += sizeof(uint32_t);
}
//timing
writeStateValueDouble(data + offset, dbvzSysclksPerClk32);
offset += sizeof(uint64_t);
writeStateValueDouble(data + offset, palmCycleCounter);
offset += sizeof(uint64_t);
writeStateValueDouble(data + offset, palmClockMultiplier);
offset += sizeof(uint64_t);
writeStateValue8(data + offset, pllSleepWait);
offset += sizeof(int8_t);
writeStateValue8(data + offset, pllWakeWait);
offset += sizeof(int8_t);
writeStateValue32(data + offset, clk32Counter);
offset += sizeof(uint32_t);
writeStateValueDouble(data + offset, pctlrCpuClockDivider);
offset += sizeof(uint64_t);
writeStateValueDouble(data + offset, timerCycleCounter[0]);
offset += sizeof(uint64_t);
writeStateValueDouble(data + offset, timerCycleCounter[1]);
offset += sizeof(uint64_t);
writeStateValue16(data + offset, timerStatusReadAcknowledge[0]);
offset += sizeof(uint16_t);
writeStateValue16(data + offset, timerStatusReadAcknowledge[1]);
offset += sizeof(uint16_t);
writeStateValue8(data + offset, portDInterruptLastValue);
offset += sizeof(uint8_t);
//SPI1
for(index = 0; index < 9; index++){
writeStateValue16(data + offset, spi1RxFifo[index]);
offset += sizeof(uint16_t);
}
for(index = 0; index < 9; index++){
writeStateValue16(data + offset, spi1TxFifo[index]);
offset += sizeof(uint16_t);
}
writeStateValue8(data + offset, spi1RxReadPosition);
offset += sizeof(uint8_t);
writeStateValue8(data + offset, spi1RxWritePosition);
offset += sizeof(uint8_t);
writeStateValue8(data + offset, spi1RxOverflowed);
offset += sizeof(uint8_t);
writeStateValue8(data + offset, spi1TxReadPosition);
offset += sizeof(uint8_t);
writeStateValue8(data + offset, spi1TxWritePosition);
offset += sizeof(uint8_t);
//PWM1, audio
writeStateValue32(data + offset, pwm1ClocksToNextSample);
offset += sizeof(int32_t);
for(index = 0; index < 6; index++){
writeStateValue8(data + offset, pwm1Fifo[index]);
offset += sizeof(uint8_t);
}
writeStateValue8(data + offset, pwm1ReadPosition);
offset += sizeof(uint8_t);
writeStateValue8(data + offset, pwm1WritePosition);
offset += sizeof(uint8_t);
//debugLog("save offset is:%d\n", offset);
}
void dbvzLoadState(uint8_t* data){
uint32_t offset = 0;
uint8_t index;
//CPU core
flx68000LoadState(data + offset);
offset += flx68000StateSize();
//memory
memcpy(dbvzReg, data + offset, DBVZ_REG_SIZE);
swap16BufferIfLittle(dbvzReg, DBVZ_REG_SIZE / sizeof(uint16_t));
offset += DBVZ_REG_SIZE;
memcpy(dbvzBankType, data + offset, DBVZ_TOTAL_MEMORY_BANKS);
offset += DBVZ_TOTAL_MEMORY_BANKS;
for(index = DBVZ_CHIP_BEGIN; index < DBVZ_CHIP_END; index++){
dbvzChipSelects[index].enable = readStateValue8(data + offset);
offset += sizeof(uint8_t);
dbvzChipSelects[index].start = readStateValue32(data + offset);
offset += sizeof(uint32_t);
dbvzChipSelects[index].lineSize = readStateValue32(data + offset);
offset += sizeof(uint32_t);
dbvzChipSelects[index].mask = readStateValue32(data + offset);
offset += sizeof(uint32_t);
dbvzChipSelects[index].inBootMode = readStateValue8(data + offset);
offset += sizeof(uint8_t);
dbvzChipSelects[index].readOnly = readStateValue8(data + offset);
offset += sizeof(uint8_t);
dbvzChipSelects[index].readOnlyForProtectedMemory = readStateValue8(data + offset);
offset += sizeof(uint8_t);
dbvzChipSelects[index].supervisorOnlyProtectedMemory = readStateValue8(data + offset);
offset += sizeof(uint8_t);
dbvzChipSelects[index].unprotectedSize = readStateValue32(data + offset);
offset += sizeof(uint32_t);
}
//timing
dbvzSysclksPerClk32 = readStateValueDouble(data + offset);
offset += sizeof(uint64_t);
palmCycleCounter = readStateValueDouble(data + offset);
offset += sizeof(uint64_t);
palmClockMultiplier = readStateValueDouble(data + offset);
offset += sizeof(uint64_t);
pllSleepWait = readStateValue8(data + offset);
offset += sizeof(int8_t);
pllWakeWait = readStateValue8(data + offset);
offset += sizeof(int8_t);
clk32Counter = readStateValue32(data + offset);
offset += sizeof(uint32_t);
pctlrCpuClockDivider = readStateValueDouble(data + offset);
offset += sizeof(uint64_t);
timerCycleCounter[0] = readStateValueDouble(data + offset);
offset += sizeof(uint64_t);
timerCycleCounter[1] = readStateValueDouble(data + offset);
offset += sizeof(uint64_t);
timerStatusReadAcknowledge[0] = readStateValue16(data + offset);
offset += sizeof(uint16_t);
timerStatusReadAcknowledge[1] = readStateValue16(data + offset);
offset += sizeof(uint16_t);
portDInterruptLastValue = readStateValue8(data + offset);
offset += sizeof(uint8_t);
//SPI1
for(index = 0; index < 9; index++){
spi1RxFifo[index] = readStateValue16(data + offset);
offset += sizeof(uint16_t);
}
for(index = 0; index < 9; index++){
spi1TxFifo[index] = readStateValue16(data + offset);
offset += sizeof(uint16_t);
}
spi1RxReadPosition = readStateValue8(data + offset);
offset += sizeof(uint8_t);
spi1RxWritePosition = readStateValue8(data + offset);
offset += sizeof(uint8_t);
spi1RxOverflowed = readStateValue8(data + offset);
offset += sizeof(uint8_t);
spi1TxReadPosition = readStateValue8(data + offset);
offset += sizeof(uint8_t);
spi1TxWritePosition = readStateValue8(data + offset);
offset += sizeof(uint8_t);
//PWM1, audio
pwm1ClocksToNextSample = readStateValue32(data + offset);
offset += sizeof(int32_t);
for(index = 0; index < 6; index++){
pwm1Fifo[index] = readStateValue8(data + offset);
offset += sizeof(uint8_t);
}
pwm1ReadPosition = readStateValue8(data + offset);
offset += sizeof(uint8_t);
pwm1WritePosition = readStateValue8(data + offset);
offset += sizeof(uint8_t);
//debugLog("load offset is:%d\n", offset);
}
void dbvzLoadStateFinished(void){
flx68000LoadStateFinished();
}
void dbvzLoadBootloader(uint8_t* data, uint32_t size){
uint16_t index;
if(!data)
size = 0;
size = u32Min(size, DBVZ_BOOTLOADER_SIZE);
for(index = 0; index < size; index++)
registerArrayWrite8(DBVZ_REG_SIZE - DBVZ_BOOTLOADER_SIZE + index, data[index]);
for(index = size; index < DBVZ_BOOTLOADER_SIZE; index++)
registerArrayWrite8(DBVZ_REG_SIZE - DBVZ_BOOTLOADER_SIZE + index, 0x00);
}
void dbvzSetRtc(uint16_t days, uint8_t hours, uint8_t minutes, uint8_t seconds){
registerArrayWrite32(RTCTIME, hours << 24 & 0x1F000000 | minutes << 16 & 0x003F0000 | seconds & 0x0000003F);
registerArrayWrite16(DAYR, days & 0x01FF);
}
void dbvzExecute(void){
uint32_t samples;
//I/O
m515RefreshInputState();
//CPU
dbvzFrameClk32s = 0;
for(; palmCycleCounter < (double)M515_CRYSTAL_FREQUENCY / EMU_FPS; palmCycleCounter += 1.0){
flx68000Execute();
dbvzFrameClk32s++;
}
palmCycleCounter -= (double)M515_CRYSTAL_FREQUENCY / EMU_FPS;
//audio
blip_end_frame(palmAudioResampler, blip_clocks_needed(palmAudioResampler, AUDIO_SAMPLES_PER_FRAME));
blip_read_samples(palmAudioResampler, palmAudio, AUDIO_SAMPLES_PER_FRAME, true);
MULTITHREAD_LOOP(samples) for(samples = 0; samples < AUDIO_SAMPLES_PER_FRAME * 2; samples += 2)
palmAudio[samples + 1] = palmAudio[samples];
}

15
src/dbvzRegisters.h → src/dbvz.h
View File

@@ -1,5 +1,5 @@
#ifndef DBVZ_REGISTERS_H
#define DBVZ_REGISTERS_H
#ifndef DBVZ_H
#define DBVZ_H
#include <stdint.h>
#include <stdbool.h>
@@ -64,6 +64,7 @@ typedef struct{
}dbvz_chip_t;
//variables
extern uint8_t dbvzReg[];
extern dbvz_chip_t dbvzChipSelects[];
extern double dbvzSysclksPerClk32;
extern uint32_t dbvzFrameClk32s;
@@ -116,7 +117,15 @@ void dbvzSetRegister16(uint32_t address, uint16_t value);
void dbvzSetRegister32(uint32_t address, uint32_t value);
//config
void dbvzResetRegisters(void);
void dbvzReset(void);
uint32_t dbvzStateSize(void);
void dbvzSaveState(uint8_t* data);
void dbvzLoadState(uint8_t* data);
void dbvzLoadStateFinished(void);
void dbvzLoadBootloader(uint8_t* data, uint32_t size);
void dbvzSetRtc(uint16_t days, uint8_t hours, uint8_t minutes, uint8_t seconds);
void dbvzExecute(void);
#endif

12
src/dbvzRegisterAccessors.c.h
View File

@@ -11,12 +11,12 @@ static uint8_t getPortKValue(void);
static uint8_t getPortMValue(void);
//basic accessors
static uint8_t registerArrayRead8(uint32_t address){return M68K_BUFFER_READ_8(palmReg, address, 0xFFF);}
static uint16_t registerArrayRead16(uint32_t address){return M68K_BUFFER_READ_16(palmReg, address, 0xFFF);}
static uint32_t registerArrayRead32(uint32_t address){return M68K_BUFFER_READ_32(palmReg, address, 0xFFF);}
static void registerArrayWrite8(uint32_t address, uint8_t value){M68K_BUFFER_WRITE_8(palmReg, address, 0xFFF, value);}
static void registerArrayWrite16(uint32_t address, uint16_t value){M68K_BUFFER_WRITE_16(palmReg, address, 0xFFF, value);}
static void registerArrayWrite32(uint32_t address, uint32_t value){M68K_BUFFER_WRITE_32(palmReg, address, 0xFFF, value);}
static uint8_t registerArrayRead8(uint32_t address){return M68K_BUFFER_READ_8(dbvzReg, address, 0xFFF);}
static uint16_t registerArrayRead16(uint32_t address){return M68K_BUFFER_READ_16(dbvzReg, address, 0xFFF);}
static uint32_t registerArrayRead32(uint32_t address){return M68K_BUFFER_READ_32(dbvzReg, address, 0xFFF);}
static void registerArrayWrite8(uint32_t address, uint8_t value){M68K_BUFFER_WRITE_8(dbvzReg, address, 0xFFF, value);}
static void registerArrayWrite16(uint32_t address, uint16_t value){M68K_BUFFER_WRITE_16(dbvzReg, address, 0xFFF, value);}
static void registerArrayWrite32(uint32_t address, uint32_t value){M68K_BUFFER_WRITE_32(dbvzReg, address, 0xFFF, value);}
//interrupt setters, used for setting an interrupt with masking by IMR and logging in IPR
static void setIprIsrBit(uint32_t interruptBit){

2
src/debug/sandbox.c
View File

@@ -14,7 +14,7 @@
#include "../m68k/m68kcpu.h"
#include "../emulator.h"
#include "../ads7846.h"
#include "../dbvzRegisters.h"
#include "../dbvz.h"
#include "../portability.h"
#include "../specs/emuFeatureRegisterSpec.h"
#include "sandbox.h"

360
src/emulator.c
View File

@@ -4,9 +4,8 @@
#include <string.h>
#include "audio/blip_buf.h"
#include "flx68000.h"
#include "emulator.h"
#include "dbvzRegisters.h"
#include "dbvz.h"
#include "expansionHardware.h"
#include "m515Bus.h"
#include "sed1376.h"
@@ -50,7 +49,6 @@ bool palmEmulatingTungstenC;
#endif
uint8_t* palmRam;
uint8_t* palmRom;
uint8_t* palmReg;
input_t palmInput;
sd_card_t palmSdCard;
misc_hw_t palmMisc;
@@ -66,31 +64,16 @@ double palmClockMultiplier;//used by the emulator to overclock the emulated P
#if defined(EMU_SUPPORT_PALM_OS5)
static void emulatorTungstenCFrame(void){
//CPU
pxa255Execute();
}
#endif
static void emulatorM515Frame(void){
uint32_t samples;
//I/O
m515RefreshInputState();
//CPU
dbvzFrameClk32s = 0;
for(; palmCycleCounter < (double)M515_CRYSTAL_FREQUENCY / EMU_FPS; palmCycleCounter += 1.0){
flx68000Execute();
dbvzFrameClk32s++;
}
palmCycleCounter -= (double)M515_CRYSTAL_FREQUENCY / EMU_FPS;
dbvzExecute();
//audio
blip_end_frame(palmAudioResampler, blip_clocks_needed(palmAudioResampler, AUDIO_SAMPLES_PER_FRAME));
blip_read_samples(palmAudioResampler, palmAudio, AUDIO_SAMPLES_PER_FRAME, true);
MULTITHREAD_LOOP(samples) for(samples = 0; samples < AUDIO_SAMPLES_PER_FRAME * 2; samples += 2)
palmAudio[samples + 1] = palmAudio[samples];
//video
//LCD controller
sed1376Render();
}
@@ -159,14 +142,12 @@ uint32_t emulatorInit(buffer_t palmRomDump, buffer_t palmBootDump, uint32_t enab
//allocate buffers, add 4 to memory regions to prevent SIGSEGV from accessing off the end
palmRom = malloc(M515_ROM_SIZE + 4);
palmRam = malloc(M515_RAM_SIZE + 4);
palmReg = malloc(DBVZ_REG_SIZE + 4);
palmFramebuffer = malloc(160 * 220 * sizeof(uint16_t));
palmAudio = malloc(AUDIO_SAMPLES_PER_FRAME * 2 * sizeof(int16_t));
palmAudioResampler = blip_new(AUDIO_SAMPLE_RATE);//have 1 second of samples
if(!palmRom || !palmRam || !palmReg || !palmFramebuffer || !palmAudio || !palmAudioResampler){
if(!palmRom || !palmRam || !palmFramebuffer || !palmAudio || !palmAudioResampler){
free(palmRom);
free(palmRam);
free(palmReg);
free(palmFramebuffer);
free(palmAudio);
blip_delete(palmAudioResampler);
@@ -179,15 +160,7 @@ uint32_t emulatorInit(buffer_t palmRomDump, buffer_t palmBootDump, uint32_t enab
memset(palmRom + palmRomDump.size, 0x00, M515_ROM_SIZE - palmRomDump.size);
swap16BufferIfLittle(palmRom, M515_ROM_SIZE / sizeof(uint16_t));
memset(palmRam, 0x00, M515_RAM_SIZE);
if(palmBootDump.data){
memcpy(palmReg + DBVZ_REG_SIZE - 1 - DBVZ_BOOTLOADER_SIZE, palmBootDump.data, u32Min(palmBootDump.size, DBVZ_BOOTLOADER_SIZE));
if(palmBootDump.size < DBVZ_BOOTLOADER_SIZE)
memset(palmReg + DBVZ_REG_SIZE - 1 - DBVZ_BOOTLOADER_SIZE + palmBootDump.size, 0x00, DBVZ_BOOTLOADER_SIZE - palmBootDump.size);
swap16BufferIfLittle(palmReg + DBVZ_REG_SIZE - 1 - DBVZ_BOOTLOADER_SIZE, DBVZ_BOOTLOADER_SIZE / sizeof(uint16_t));
}
else{
memset(palmReg + DBVZ_REG_SIZE - 1 - DBVZ_BOOTLOADER_SIZE, 0x00, DBVZ_BOOTLOADER_SIZE);
}
dbvzLoadBootloader(palmBootDump.data, palmBootDump.size);
memcpy(palmFramebuffer + 160 * 160, silkscreen160x60, 160 * 60 * sizeof(uint16_t));
memset(palmAudio, 0x00, AUDIO_SAMPLES_PER_FRAME * 2/*channels*/ * sizeof(int16_t));
memset(&palmInput, 0x00, sizeof(palmInput));
@@ -203,7 +176,6 @@ uint32_t emulatorInit(buffer_t palmRomDump, buffer_t palmBootDump, uint32_t enab
//initialize components
blip_set_rates(palmAudioResampler, AUDIO_CLOCK_RATE, AUDIO_SAMPLE_RATE);
flx68000Init();
sandboxInit();
//reset everything
@@ -225,7 +197,6 @@ void emulatorExit(void){
#endif
free(palmRom);
free(palmRam);
free(palmReg);
#if defined(EMU_SUPPORT_PALM_OS5)
}
#endif
@@ -278,7 +249,7 @@ void emulatorSoftReset(void){
ads7846Reset();
pdiUsbD12Reset();
expansionHardwareReset();
flx68000Reset();
dbvzReset();
sandboxReset();
//sdCardReset() should not be called here, the SD card does not have a reset line and should only be reset by a power cycle
#if defined(EMU_SUPPORT_PALM_OS5)
@@ -302,30 +273,24 @@ uint32_t emulatorGetStateSize(void){
size += sizeof(uint32_t);//palmEmuFeatures.info
size += sizeof(uint64_t);//palmSdCard.flashChip.size, needs to be done first to verify the malloc worked
size += sizeof(uint16_t) * 2;//palmFramebuffer(Width/Height)
size += flx68000StateSize();
size += sed1376StateSize();
size += ads7846StateSize();
size += pdiUsbD12StateSize();
size += expansionHardwareStateSize();
#if defined(EMU_SUPPORT_PALM_OS5)
if(palmEmulatingTungstenC){
size += pxa255StateSize();
size += expansionHardwareStateSize();
size += TUNGSTEN_C_RAM_SIZE;//system RAM buffer
}
else{
#endif
size += dbvzStateSize();
size += sed1376StateSize();
size += ads7846StateSize();
size += pdiUsbD12StateSize();
size += expansionHardwareStateSize();
size += M515_RAM_SIZE;//system RAM buffer
#if defined(EMU_SUPPORT_PALM_OS5)
}
#endif
size += sandboxStateSize();
size += M515_RAM_SIZE;//system RAM buffer
size += DBVZ_REG_SIZE;//hardware registers
size += DBVZ_TOTAL_MEMORY_BANKS;//bank handlers
size += sizeof(uint32_t) * 4 * DBVZ_CHIP_END;//chip select states
size += sizeof(uint8_t) * 5 * DBVZ_CHIP_END;//chip select states
size += sizeof(uint64_t) * 5;//32.32 fixed point double, timerXCycleCounter and CPU cycle timers
size += sizeof(int8_t);//pllSleepWait
size += sizeof(int8_t);//pllWakeWait
size += sizeof(uint32_t);//clk32Counter
size += sizeof(uint64_t);//pctlrCpuClockDivider
size += sizeof(uint16_t) * 2;//timerStatusReadAcknowledge
size += sizeof(uint8_t);//portDInterruptLastValue
size += sizeof(uint16_t) * 9;//RX 8 * 16 SPI1 FIFO, 1 index is for FIFO full
size += sizeof(uint16_t) * 9;//TX 8 * 16 SPI1 FIFO, 1 index is for FIFO full
size += sizeof(uint8_t) * 5;//spi1(R/T)x(Read/Write)Position / spi1RxOverflowed
size += sizeof(int32_t);//pwm1ClocksToNextSample
size += sizeof(uint8_t) * 6;//pwm1Fifo[6]
size += sizeof(uint8_t) * 2;//pwm1(Read/Write)
size += sizeof(uint8_t) * 7;//palmMisc
size += sizeof(uint32_t) * 4;//palmEmuFeatures.(src/dst/size/value)
size += sizeof(uint64_t);//palmSdCard.command
@@ -352,7 +317,11 @@ bool emulatorSaveState(buffer_t buffer){
return false;//state cant fit
//state validation, wont load states that are not from the same state version
#if defined(EMU_SUPPORT_PALM_OS5)
writeStateValue32(buffer.data + offset, SAVE_STATE_VERSION | (palmEmulatingTungstenC ? SAVE_STATE_FOR_TUNGSTEN_C : 0));
#else
writeStateValue32(buffer.data + offset, SAVE_STATE_VERSION);
#endif
offset += sizeof(uint32_t);
//features, hotpluging emulated hardware is not supported
@@ -369,110 +338,45 @@ bool emulatorSaveState(buffer_t buffer){
writeStateValue16(buffer.data + offset, palmFramebufferHeight);
offset += sizeof(uint16_t);
//chips
flx68000SaveState(buffer.data + offset);
offset += flx68000StateSize();
sed1376SaveState(buffer.data + offset);
offset += sed1376StateSize();
ads7846SaveState(buffer.data + offset);
offset += ads7846StateSize();
pdiUsbD12SaveState(buffer.data + offset);
offset += pdiUsbD12StateSize();
expansionHardwareSaveState(buffer.data + offset);
offset += expansionHardwareStateSize();
#if defined(EMU_SUPPORT_PALM_OS5)
if(palmEmulatingTungstenC){
//chips
pxa255SaveState(buffer.data + offset);
offset += pxa255StateSize();
expansionHardwareSaveState(buffer.data + offset);
offset += expansionHardwareStateSize();
//memory
memcpy(buffer.data + offset, palmRam, TUNGSTEN_C_RAM_SIZE);
swap16BufferIfLittle(buffer.data + offset, TUNGSTEN_C_RAM_SIZE / sizeof(uint16_t));
offset += TUNGSTEN_C_RAM_SIZE;
}
else{
#endif
//chips
dbvzSaveState(buffer.data + offset);
offset += dbvzStateSize();
sed1376SaveState(buffer.data + offset);
offset += sed1376StateSize();
ads7846SaveState(buffer.data + offset);
offset += ads7846StateSize();
pdiUsbD12SaveState(buffer.data + offset);
offset += pdiUsbD12StateSize();
expansionHardwareSaveState(buffer.data + offset);
offset += expansionHardwareStateSize();
//memory
memcpy(buffer.data + offset, palmRam, M515_RAM_SIZE);
swap16BufferIfLittle(buffer.data + offset, M515_RAM_SIZE / sizeof(uint16_t));
offset += M515_RAM_SIZE;
#if defined(EMU_SUPPORT_PALM_OS5)
}
#endif
//sandbox, does nothing when disabled
sandboxSaveState(buffer.data + offset);
offset += sandboxStateSize();
//memory
memcpy(buffer.data + offset, palmRam, M515_RAM_SIZE);
swap16BufferIfLittle(buffer.data + offset, M515_RAM_SIZE / sizeof(uint16_t));
offset += M515_RAM_SIZE;
memcpy(buffer.data + offset, palmReg, DBVZ_REG_SIZE);
swap16BufferIfLittle(buffer.data + offset, DBVZ_REG_SIZE / sizeof(uint16_t));
offset += DBVZ_REG_SIZE;
memcpy(buffer.data + offset, dbvzBankType, DBVZ_TOTAL_MEMORY_BANKS);
offset += DBVZ_TOTAL_MEMORY_BANKS;
for(index = DBVZ_CHIP_BEGIN; index < DBVZ_CHIP_END; index++){
writeStateValue8(buffer.data + offset, dbvzChipSelects[index].enable);
offset += sizeof(uint8_t);
writeStateValue32(buffer.data + offset, dbvzChipSelects[index].start);
offset += sizeof(uint32_t);
writeStateValue32(buffer.data + offset, dbvzChipSelects[index].lineSize);
offset += sizeof(uint32_t);
writeStateValue32(buffer.data + offset, dbvzChipSelects[index].mask);
offset += sizeof(uint32_t);
writeStateValue8(buffer.data + offset, dbvzChipSelects[index].inBootMode);
offset += sizeof(uint8_t);
writeStateValue8(buffer.data + offset, dbvzChipSelects[index].readOnly);
offset += sizeof(uint8_t);
writeStateValue8(buffer.data + offset, dbvzChipSelects[index].readOnlyForProtectedMemory);
offset += sizeof(uint8_t);
writeStateValue8(buffer.data + offset, dbvzChipSelects[index].supervisorOnlyProtectedMemory);
offset += sizeof(uint8_t);
writeStateValue32(buffer.data + offset, dbvzChipSelects[index].unprotectedSize);
offset += sizeof(uint32_t);
}
//timing
writeStateValueDouble(buffer.data + offset, dbvzSysclksPerClk32);
offset += sizeof(uint64_t);
writeStateValueDouble(buffer.data + offset, palmCycleCounter);
offset += sizeof(uint64_t);
writeStateValueDouble(buffer.data + offset, palmClockMultiplier);
offset += sizeof(uint64_t);
writeStateValue8(buffer.data + offset, pllSleepWait);
offset += sizeof(int8_t);
writeStateValue8(buffer.data + offset, pllWakeWait);
offset += sizeof(int8_t);
writeStateValue32(buffer.data + offset, clk32Counter);
offset += sizeof(uint32_t);
writeStateValueDouble(buffer.data + offset, pctlrCpuClockDivider);
offset += sizeof(uint64_t);
writeStateValueDouble(buffer.data + offset, timerCycleCounter[0]);
offset += sizeof(uint64_t);
writeStateValueDouble(buffer.data + offset, timerCycleCounter[1]);
offset += sizeof(uint64_t);
writeStateValue16(buffer.data + offset, timerStatusReadAcknowledge[0]);
offset += sizeof(uint16_t);
writeStateValue16(buffer.data + offset, timerStatusReadAcknowledge[1]);
offset += sizeof(uint16_t);
writeStateValue8(buffer.data + offset, portDInterruptLastValue);
offset += sizeof(uint8_t);
//SPI1
for(index = 0; index < 9; index++){
writeStateValue16(buffer.data + offset, spi1RxFifo[index]);
offset += sizeof(uint16_t);
}
for(index = 0; index < 9; index++){
writeStateValue16(buffer.data + offset, spi1TxFifo[index]);
offset += sizeof(uint16_t);
}
writeStateValue8(buffer.data + offset, spi1RxReadPosition);
offset += sizeof(uint8_t);
writeStateValue8(buffer.data + offset, spi1RxWritePosition);
offset += sizeof(uint8_t);
writeStateValue8(buffer.data + offset, spi1RxOverflowed);
offset += sizeof(uint8_t);
writeStateValue8(buffer.data + offset, spi1TxReadPosition);
offset += sizeof(uint8_t);
writeStateValue8(buffer.data + offset, spi1TxWritePosition);
offset += sizeof(uint8_t);
//PWM1, audio
writeStateValue32(buffer.data + offset, pwm1ClocksToNextSample);
offset += sizeof(int32_t);
for(index = 0; index < 6; index++){
writeStateValue8(buffer.data + offset, pwm1Fifo[index]);
offset += sizeof(uint8_t);
}
writeStateValue8(buffer.data + offset, pwm1ReadPosition);
offset += sizeof(uint8_t);
writeStateValue8(buffer.data + offset, pwm1WritePosition);
offset += sizeof(uint8_t);
//misc
writeStateValue8(buffer.data + offset, palmMisc.powerButtonLed);
offset += sizeof(uint8_t);
@@ -553,8 +457,13 @@ bool emulatorLoadState(buffer_t buffer){
uint8_t* stateSdCardBuffer;
//state validation, wont load states that are not from the same state version
#if defined(EMU_SUPPORT_PALM_OS5)
if(readStateValue32(buffer.data + offset) != (SAVE_STATE_VERSION | (palmEmulatingTungstenC ? SAVE_STATE_FOR_TUNGSTEN_C : 0)))
return false;
#else
if(readStateValue32(buffer.data + offset) != SAVE_STATE_VERSION)
return false;
#endif
offset += sizeof(uint32_t);
//features, hotpluging emulated hardware is not supported
@@ -575,110 +484,45 @@ bool emulatorLoadState(buffer_t buffer){
palmFramebufferHeight = readStateValue16(buffer.data + offset);
offset += sizeof(uint16_t);
//chips
flx68000LoadState(buffer.data + offset);
offset += flx68000StateSize();
sed1376LoadState(buffer.data + offset);
offset += sed1376StateSize();
ads7846LoadState(buffer.data + offset);
offset += ads7846StateSize();
pdiUsbD12LoadState(buffer.data + offset);
offset += pdiUsbD12StateSize();
expansionHardwareLoadState(buffer.data + offset);
offset += expansionHardwareStateSize();
#if defined(EMU_SUPPORT_PALM_OS5)
if(palmEmulatingTungstenC){
//chips
pxa255LoadState(buffer.data + offset);
offset += pxa255StateSize();
expansionHardwareLoadState(buffer.data + offset);
offset += expansionHardwareStateSize();
//memory
memcpy(palmRam, buffer.data + offset, TUNGSTEN_C_RAM_SIZE);
swap16BufferIfLittle(palmRam, TUNGSTEN_C_RAM_SIZE / sizeof(uint16_t));
offset += TUNGSTEN_C_RAM_SIZE;
}
else{
#endif
//chips
dbvzLoadState(buffer.data + offset);
offset += dbvzStateSize();
sed1376LoadState(buffer.data + offset);
offset += sed1376StateSize();
ads7846LoadState(buffer.data + offset);
offset += ads7846StateSize();
pdiUsbD12LoadState(buffer.data + offset);
offset += pdiUsbD12StateSize();
expansionHardwareLoadState(buffer.data + offset);
offset += expansionHardwareStateSize();
//memory
memcpy(palmRam, buffer.data + offset, M515_RAM_SIZE);
swap16BufferIfLittle(palmRam, M515_RAM_SIZE / sizeof(uint16_t));
offset += M515_RAM_SIZE;
#if defined(EMU_SUPPORT_PALM_OS5)
}
#endif
//sandbox, does nothing when disabled
sandboxLoadState(buffer.data + offset);
offset += sandboxStateSize();
//memory
memcpy(palmRam, buffer.data + offset, M515_RAM_SIZE);
swap16BufferIfLittle(palmRam, M515_RAM_SIZE / sizeof(uint16_t));
offset += M515_RAM_SIZE;
memcpy(palmReg, buffer.data + offset, DBVZ_REG_SIZE);
swap16BufferIfLittle(palmReg, DBVZ_REG_SIZE / sizeof(uint16_t));
offset += DBVZ_REG_SIZE;
memcpy(dbvzBankType, buffer.data + offset, DBVZ_TOTAL_MEMORY_BANKS);
offset += DBVZ_TOTAL_MEMORY_BANKS;
for(index = DBVZ_CHIP_BEGIN; index < DBVZ_CHIP_END; index++){
dbvzChipSelects[index].enable = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
dbvzChipSelects[index].start = readStateValue32(buffer.data + offset);
offset += sizeof(uint32_t);
dbvzChipSelects[index].lineSize = readStateValue32(buffer.data + offset);
offset += sizeof(uint32_t);
dbvzChipSelects[index].mask = readStateValue32(buffer.data + offset);
offset += sizeof(uint32_t);
dbvzChipSelects[index].inBootMode = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
dbvzChipSelects[index].readOnly = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
dbvzChipSelects[index].readOnlyForProtectedMemory = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
dbvzChipSelects[index].supervisorOnlyProtectedMemory = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
dbvzChipSelects[index].unprotectedSize = readStateValue32(buffer.data + offset);
offset += sizeof(uint32_t);
}
//timing
dbvzSysclksPerClk32 = readStateValueDouble(buffer.data + offset);
offset += sizeof(uint64_t);
palmCycleCounter = readStateValueDouble(buffer.data + offset);
offset += sizeof(uint64_t);
palmClockMultiplier = readStateValueDouble(buffer.data + offset);
offset += sizeof(uint64_t);
pllSleepWait = readStateValue8(buffer.data + offset);
offset += sizeof(int8_t);
pllWakeWait = readStateValue8(buffer.data + offset);
offset += sizeof(int8_t);
clk32Counter = readStateValue32(buffer.data + offset);
offset += sizeof(uint32_t);
pctlrCpuClockDivider = readStateValueDouble(buffer.data + offset);
offset += sizeof(uint64_t);
timerCycleCounter[0] = readStateValueDouble(buffer.data + offset);
offset += sizeof(uint64_t);
timerCycleCounter[1] = readStateValueDouble(buffer.data + offset);
offset += sizeof(uint64_t);
timerStatusReadAcknowledge[0] = readStateValue16(buffer.data + offset);
offset += sizeof(uint16_t);
timerStatusReadAcknowledge[1] = readStateValue16(buffer.data + offset);
offset += sizeof(uint16_t);
portDInterruptLastValue = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
//SPI1
for(index = 0; index < 9; index++){
spi1RxFifo[index] = readStateValue16(buffer.data + offset);
offset += sizeof(uint16_t);
}
for(index = 0; index < 9; index++){
spi1TxFifo[index] = readStateValue16(buffer.data + offset);
offset += sizeof(uint16_t);
}
spi1RxReadPosition = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
spi1RxWritePosition = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
spi1RxOverflowed = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
spi1TxReadPosition = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
spi1TxWritePosition = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
//PWM1, audio
pwm1ClocksToNextSample = readStateValue32(buffer.data + offset);
offset += sizeof(int32_t);
for(index = 0; index < 6; index++){
pwm1Fifo[index] = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
}
pwm1ReadPosition = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
pwm1WritePosition = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
//misc
palmMisc.powerButtonLed = readStateValue8(buffer.data + offset);
offset += sizeof(uint8_t);
@@ -754,7 +598,7 @@ bool emulatorLoadState(buffer_t buffer){
offset += stateSdCardSize;
//some modules depend on all the state memory being loaded before certian required actions can occur(refreshing cached data, freeing memory blocks)
flx68000LoadStateFinished();
dbvzLoadStateFinished();
return true;
}

7
src/emulator.h
View File

@@ -53,7 +53,11 @@ static void debugLog(char* str, ...){};
#define SD_CARD_BLOCK_DATA_PACKET_SIZE (1 + SD_CARD_BLOCK_SIZE + 2)
#define SD_CARD_RESPONSE_FIFO_SIZE (SD_CARD_BLOCK_DATA_PACKET_SIZE * 3)
#define SD_CARD_NCR_BYTES 1//how many 0xFF bytes come before the R1 response
#define SAVE_STATE_VERSION 0
#define SAVE_STATE_VERSION 0x00000001
#if defined(EMU_SUPPORT_PALM_OS5)
#define SAVE_STATE_FOR_TUNGSTEN_C 0x80000000
#endif
//system constants
#define M515_CRYSTAL_FREQUENCY 32768
@@ -155,7 +159,6 @@ extern bool palmEmulatingTungstenC;//read allowed, but not advised
#endif
extern uint8_t* palmRom;//dont touch
extern uint8_t* palmRam;//access allowed to read save RAM without allocating a giant buffer, but endianness must be taken into account
extern uint8_t* palmReg;//dont touch
extern input_t palmInput;//write allowed
extern sd_card_t palmSdCard;//dont touch
extern misc_hw_t palmMisc;//read/write allowed

2
src/expansionHardware.c
View File

@@ -6,7 +6,7 @@
#include "portability.h"
#include "specs/emuFeatureRegisterSpec.h"
#include "m515Bus.h"
#include "dbvzRegisters.h"
#include "dbvz.h"
#include "silkscreen.h"
#include "sed1376.h"
#include "flx68000.h"

8
src/flx68000.c
View File

@@ -3,7 +3,7 @@
#include "emulator.h"
#include "portability.h"
#include "dbvzRegisters.h"
#include "dbvz.h"
#include "m515Bus.h"
#include "m68k/m68kcpu.h"
@@ -79,7 +79,7 @@ uint32_t m68k_read_pcrelative_32(uint32_t address){
#endif
#endif
void flx68000Init(void){
void flx68000Reset(void){
static bool inited = false;
if(!inited){
@@ -90,11 +90,7 @@ void flx68000Init(void){
inited = true;
}
}
void flx68000Reset(void){
dbvzResetRegisters();
dbvzResetAddressSpace();//address space must be reset after hardware registers because it is dependent on them
m68k_pulse_reset();
}

1
src/flx68000.h
View File

@@ -4,7 +4,6 @@
#include <stdint.h>
#include <stdbool.h>
void flx68000Init(void);
void flx68000Reset(void);
uint32_t flx68000StateSize(void);
void flx68000SaveState(uint8_t* data);

2
src/m515Bus.c
View File

@@ -2,7 +2,7 @@
#include <string.h>
#include "emulator.h"
#include "dbvzRegisters.h"
#include "dbvz.h"
#include "expansionHardware.h"
#include "m515Bus.h"
#include "portability.h"

2
src/makefile.all
View File

@@ -1,7 +1,7 @@
EMU_DEFINES :=
EMU_SOURCES_C := $(EMU_PATH)/emulator.c \
$(EMU_PATH)/m515Bus.c \
$(EMU_PATH)/dbvzRegisters.c \
$(EMU_PATH)/dbvz.c \
$(EMU_PATH)/flx68000.c \
$(EMU_PATH)/sed1376.c \
$(EMU_PATH)/ads7846.c \

2
src/sed1376.c
View File

@@ -3,7 +3,7 @@
#include "emulator.h"
#include "portability.h"
#include "dbvzRegisters.h"
#include "dbvz.h"
#include "flx68000.h"//for flx68000GetPc()
#include "specs/sed1376RegisterSpec.h"