308 lines
8.1 KiB
C
308 lines
8.1 KiB
C
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// sega - Top-level emulation for Saturn and DC
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef EMU_COMPILE
|
|
#error "Hi I forgot to set EMU_COMPILE"
|
|
#endif
|
|
|
|
#include "sega.h"
|
|
|
|
#include "satsound.h"
|
|
#include "dcsound.h"
|
|
#include "arm.h"
|
|
#include "yam.h"
|
|
#ifdef USE_STARSCREAM
|
|
#include "Starscream/starcpu.h"
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Static init for the whole library
|
|
//
|
|
static uint8 library_was_initialized = 0;
|
|
|
|
//
|
|
// Deliberately create a NULL dereference
|
|
// Useful for calling attention to show-stopper problems like forgetting to
|
|
// call sega_init() or compiling with the wrong byte order
|
|
//
|
|
static void sega_hang(const char *message) {
|
|
for(;;) { *((volatile char*)0) = *message; }
|
|
}
|
|
|
|
//
|
|
// Endian check
|
|
//
|
|
static void sega_endian_check(void) {
|
|
uint32 num = 0x61626364;
|
|
// Big
|
|
if(!memcmp(&num, "abcd", 4)) {
|
|
#ifdef SEGA_BIG_ENDIAN
|
|
return;
|
|
#endif
|
|
sega_hang("endian check");
|
|
}
|
|
// Little
|
|
if(!memcmp(&num, "dcba", 4)) {
|
|
#ifndef SEGA_BIG_ENDIAN
|
|
return;
|
|
#endif
|
|
sega_hang("endian check");
|
|
}
|
|
// Don't know what!
|
|
sega_hang("endian check");
|
|
}
|
|
|
|
//
|
|
// Data type size check
|
|
//
|
|
static void sega_size_check(void) {
|
|
if(sizeof(uint8 ) != 1) sega_hang("size check");
|
|
if(sizeof(uint16) != 2) sega_hang("size check");
|
|
if(sizeof(uint32) != 4) sega_hang("size check");
|
|
if(sizeof(uint64) != 8) sega_hang("size check");
|
|
if(sizeof(sint8 ) != 1) sega_hang("size check");
|
|
if(sizeof(sint16) != 2) sega_hang("size check");
|
|
if(sizeof(sint32) != 4) sega_hang("size check");
|
|
if(sizeof(sint64) != 8) sega_hang("size check");
|
|
}
|
|
|
|
sint32 EMU_CALL sega_init(void) {
|
|
sint32 r;
|
|
sega_endian_check();
|
|
sega_size_check();
|
|
|
|
if(library_was_initialized) return 0;
|
|
|
|
#ifndef DISABLE_SSF
|
|
r = satsound_init(); if(r) return r;
|
|
#endif
|
|
r = dcsound_init(); if(r) return r;
|
|
r = arm_init(); if(r) return r;
|
|
r = yam_init(); if(r) return r;
|
|
#ifndef DISABLE_SSF
|
|
#ifdef USE_STARSCREAM
|
|
r = s68000_init(); if(r) return r;
|
|
#endif
|
|
#endif
|
|
|
|
library_was_initialized = 1;
|
|
return 0;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Version information
|
|
//
|
|
const char* EMU_CALL sega_getversion(void) {
|
|
static const char s[] = "SegaCore0001 (built " __DATE__ ")";
|
|
static char rv[500];
|
|
int sl = (int)strlen(s);
|
|
memcpy(rv, s, sl);
|
|
#ifndef DISABLE_SSF
|
|
rv[sl] = '\n';
|
|
#ifdef USE_STARSCREAM
|
|
strcpy(rv+sl+1, s68000_get_version());
|
|
#elif defined(USE_M68K)
|
|
strcpy(rv+sl+1, "M68K");
|
|
#else
|
|
strcpy(rv+sl+1, "C68K");
|
|
#endif
|
|
#endif
|
|
|
|
return rv;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// State information
|
|
//
|
|
|
|
struct SEGA_STATE {
|
|
uint32 offset_to_dcsound;
|
|
uint32 offset_to_satsound;
|
|
};
|
|
|
|
#define SEGASTATE ((struct SEGA_STATE*)(state))
|
|
#define DCSOUNDSTATE ((void*)(((char*)(state))+(SEGASTATE->offset_to_dcsound)))
|
|
#define SATSOUNDSTATE ((void*)(((char*)(state))+(SEGASTATE->offset_to_satsound)))
|
|
|
|
#define HAVE_DCSOUND (SEGASTATE->offset_to_dcsound!=0)
|
|
#define HAVE_SATSOUND (SEGASTATE->offset_to_satsound!=0)
|
|
|
|
uint32 EMU_CALL sega_get_state_size(uint8 version) {
|
|
uint32 size = 0;
|
|
if(version != 2) version = 1;
|
|
size += sizeof(struct SEGA_STATE);
|
|
#ifndef DISABLE_SSF
|
|
if(version == 1) size += satsound_get_state_size();
|
|
#endif
|
|
if(version == 2) size += dcsound_get_state_size();
|
|
return size;
|
|
}
|
|
|
|
void EMU_CALL sega_clear_state(void *state, uint8 version) {
|
|
uint32 offset;
|
|
|
|
if(version != 2) version = 1;
|
|
//
|
|
// If we haven't initialized, we really SHOULD have.
|
|
//
|
|
if(!library_was_initialized) sega_hang("library not initialized");
|
|
|
|
// Clear local struct
|
|
memset(state, 0, sizeof(struct SEGA_STATE));
|
|
// Set up offsets
|
|
offset = sizeof(struct SEGA_STATE);
|
|
#ifndef DISABLE_SSF
|
|
if(version == 1) { SEGASTATE->offset_to_satsound = offset; offset += satsound_get_state_size(); }
|
|
#endif
|
|
if(version == 2) { SEGASTATE->offset_to_dcsound = offset; offset += dcsound_get_state_size(); }
|
|
//
|
|
// Take care of substructures
|
|
//
|
|
#ifndef DISABLE_SSF
|
|
if(HAVE_SATSOUND) satsound_clear_state(SATSOUNDSTATE);
|
|
#endif
|
|
if(HAVE_DCSOUND) dcsound_clear_state(DCSOUNDSTATE);
|
|
// Done
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Obtain substates
|
|
//
|
|
void* EMU_CALL sega_get_satsound_state(void *state) {
|
|
#ifdef DISABLE_SSF
|
|
return NULL;
|
|
#else
|
|
if(!(HAVE_SATSOUND)) return NULL;
|
|
return SATSOUNDSTATE;
|
|
#endif
|
|
}
|
|
|
|
void* EMU_CALL sega_get_dcsound_state(void *state) {
|
|
if(!(HAVE_DCSOUND)) return NULL;
|
|
return DCSOUNDSTATE;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Executes the given number of cycles or the given number of samples
|
|
// (whichever is less)
|
|
//
|
|
// Sets *sound_samples to the number of samples actually generated,
|
|
// which may be ZERO or LESS than the number requested, but never more.
|
|
//
|
|
// Return value:
|
|
// >= 0 The number of cycles actually executed, which may be ZERO, MORE,
|
|
// or LESS than the number requested
|
|
// <= -1 Unrecoverable error
|
|
//
|
|
sint32 EMU_CALL sega_execute(
|
|
void *state,
|
|
sint32 cycles,
|
|
sint16 *sound_buf,
|
|
uint32 *sound_samples
|
|
) {
|
|
#ifndef DISABLE_SSF
|
|
if(HAVE_SATSOUND) {
|
|
return satsound_execute(SATSOUNDSTATE, cycles, sound_buf, sound_samples);
|
|
} else
|
|
#endif
|
|
if(HAVE_DCSOUND) {
|
|
return dcsound_execute(DCSOUNDSTATE, cycles, sound_buf, sound_samples);
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
static uint32 get32lsb(uint8 *src) {
|
|
return
|
|
((((uint32)(src[0])) & 0xFF) << 0) |
|
|
((((uint32)(src[1])) & 0xFF) << 8) |
|
|
((((uint32)(src[2])) & 0xFF) << 16) |
|
|
((((uint32)(src[3])) & 0xFF) << 24);
|
|
}
|
|
|
|
#if 0
|
|
static uint32 get32msb(uint8 *src) {
|
|
return
|
|
((((uint32)(src[3])) & 0xFF) << 0) |
|
|
((((uint32)(src[2])) & 0xFF) << 8) |
|
|
((((uint32)(src[1])) & 0xFF) << 16) |
|
|
((((uint32)(src[0])) & 0xFF) << 24);
|
|
}
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Upload program - must INCLUDE the 4-byte header.
|
|
// Returns nonzero on error.
|
|
//
|
|
sint32 EMU_CALL sega_upload_program(void *state, void *program, uint32 size) {
|
|
uint32 start;
|
|
if(size < 5) return -1;
|
|
start = get32lsb((uint8*)program);
|
|
#ifndef DISABLE_SSF
|
|
if(HAVE_SATSOUND) {
|
|
satsound_upload_to_ram(SATSOUNDSTATE, start, ((uint8*)program) + 4, size - 4);
|
|
} else
|
|
#endif
|
|
if(HAVE_DCSOUND) {
|
|
dcsound_upload_to_ram(DCSOUNDSTATE, start, ((uint8*)program) + 4, size - 4);
|
|
} else {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Get the current program counter
|
|
//
|
|
uint32 EMU_CALL sega_get_pc(void *state) {
|
|
#ifndef DISABLE_SSF
|
|
if(HAVE_SATSOUND) return satsound_get_pc(SATSOUNDSTATE);
|
|
#endif
|
|
if(HAVE_DCSOUND) return dcsound_get_pc(DCSOUNDSTATE);
|
|
return 0;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
static void *getyamstate(struct SEGA_STATE *state) {
|
|
void *yamstate = NULL;
|
|
#ifndef DISABLE_SSF
|
|
if(HAVE_SATSOUND) { yamstate = satsound_get_yam_state(SATSOUNDSTATE); }
|
|
#endif
|
|
if(HAVE_DCSOUND) { yamstate = dcsound_get_yam_state(DCSOUNDSTATE); }
|
|
return yamstate;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Enable or disable various things
|
|
//
|
|
void EMU_CALL sega_enable_dry(void *state, uint8 enable) {
|
|
void *yamstate = getyamstate(SEGASTATE);
|
|
if(yamstate) yam_enable_dry(yamstate, enable);
|
|
}
|
|
|
|
void EMU_CALL sega_enable_dsp(void *state, uint8 enable) {
|
|
void *yamstate = getyamstate(SEGASTATE);
|
|
if(yamstate) yam_enable_dsp(yamstate, enable);
|
|
}
|
|
|
|
void EMU_CALL sega_enable_dsp_dynarec(void *state, uint8 enable) {
|
|
void *yamstate = getyamstate(SEGASTATE);
|
|
if(yamstate) yam_enable_dsp_dynarec(yamstate, enable);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|