403 lines
12 KiB
C
403 lines
12 KiB
C
#define VUEAPI
|
|
#include <vue.h>
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
* Macros *
|
|
*****************************************************************************/
|
|
|
|
/* Sign-extend a value */
|
|
#define SIGN_EXTEND(bits, value) \
|
|
((value) & 1 << (bits - 1) ? (value) | (~(1 << bits) + 1) : (value))
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
* Constants *
|
|
*****************************************************************************/
|
|
|
|
/* Memory access type sizes */
|
|
static const uint32_t TYPE_SIZES[] = { 1, 1, 2, 2, 4 };
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
* Component Includes *
|
|
*****************************************************************************/
|
|
|
|
#include "cpu.c"
|
|
#include "gamepak.c"
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
* Module Functions *
|
|
*****************************************************************************/
|
|
|
|
/* Read a value from a byte buffer */
|
|
static int32_t readBuffer(uint8_t *data, uint32_t datlen, uint32_t address,
|
|
int32_t type) {
|
|
uint32_t size = TYPE_SIZES[type]; /* Size of data type */
|
|
int32_t value = 0;
|
|
|
|
/* Error checking */
|
|
if (data == NULL)
|
|
return 0;
|
|
|
|
/* Common processing */
|
|
address &= (~size + 1) & (datlen - 1);
|
|
|
|
/* The host is little-endian */
|
|
#ifndef VUE_BIGENDIAN
|
|
switch (type) {
|
|
case VUE_S8 : value = *( int8_t *)&data[address]; break;
|
|
case VUE_U8 : value = *(uint8_t *)&data[address]; break;
|
|
case VUE_S16: value = *( int16_t *)&data[address]; break;
|
|
case VUE_U16: value = *(uint16_t *)&data[address]; break;
|
|
case VUE_S32: value = *( int32_t *)&data[address]; break;
|
|
}
|
|
|
|
/* The host is big-endian */
|
|
#else
|
|
switch (type) {
|
|
case VUE_S32: value =
|
|
data[address + 3] << 24 |
|
|
(data[address + 2] & 0xFF) << 16;
|
|
/* Fallthrough */
|
|
case VUE_S16: /* Fallthrough */
|
|
case VUE_U16: value |=
|
|
(data[address + 1] & 0xFF) << 8;
|
|
/* Fallthrough */
|
|
case VUE_S8 : /* Fallthrough */
|
|
case VUE_U8 : value |=
|
|
data[address ] & 0xFF;
|
|
}
|
|
|
|
/* Sign-extend the value if appropriate */
|
|
if ((type & 1) == 0) {
|
|
size <<= 3;
|
|
value = SIGN_EXTEND(size, value);
|
|
}
|
|
#endif
|
|
|
|
return value;
|
|
}
|
|
|
|
/* Read bytes from a byte buffer */
|
|
static void readBytes(uint8_t *data, uint32_t datlen, uint32_t address,
|
|
uint8_t *dest, uint32_t length) {
|
|
|
|
/* The source does not exist */
|
|
if (data == NULL) {
|
|
while (length--)
|
|
*dest++ = 0;
|
|
return;
|
|
}
|
|
|
|
/* Transfer bytes from the source as a circular buffer */
|
|
while (length--)
|
|
*dest++ = data[address++ & (datlen - 1)];
|
|
}
|
|
|
|
/* Write a value to a byte buffer */
|
|
static void writeBuffer(uint8_t *data, uint32_t datlen, uint32_t address,
|
|
int32_t type, int32_t value) {
|
|
uint32_t size = TYPE_SIZES[type]; /* Size of data type */
|
|
|
|
/* Error checking */
|
|
if (data == NULL)
|
|
return;
|
|
|
|
/* Common processing */
|
|
address &= (~size + 1) & (datlen - 1);
|
|
|
|
/* The host is big-endian */
|
|
#ifdef VUE_BIGENDIAN
|
|
switch (type) {
|
|
case VUE_S32:
|
|
value = (value >> 16 & 0x0000FFFF) | value << 16;
|
|
/* Fallthrough */
|
|
case VUE_S16: /* Fallthrough */
|
|
case VUE_U16:
|
|
value = (value >> 8 & 0x00FF00FF) | (value << 8 & 0xFF00FF00);
|
|
}
|
|
#endif
|
|
|
|
/* Processing by data type */
|
|
switch (type) {
|
|
case VUE_S8 : /* Fallthrough */
|
|
case VUE_U8 : *(int8_t *)&data[address] = (int8_t ) value; break;
|
|
case VUE_S16: /* Fallthrough */
|
|
case VUE_U16: *(int16_t *)&data[address] = (int16_t ) value; break;
|
|
case VUE_S32: *(int32_t *)&data[address] = (int32_t ) value; break;
|
|
}
|
|
|
|
}
|
|
|
|
/* Write bytes to a byte buffer */
|
|
static void writeBytes(uint8_t *data, uint32_t datlen, uint32_t address,
|
|
uint8_t *src, uint32_t length) {
|
|
|
|
/* The destination does not exist */
|
|
if (data == NULL)
|
|
return;
|
|
|
|
/* Transfer bytes to the destination as a circular buffer */
|
|
while (length--)
|
|
data[address++ & (datlen - 1)] = *src++;
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
* Library Functions *
|
|
*****************************************************************************/
|
|
|
|
/* Process the simulation */
|
|
int32_t vueEmulate(Vue *vue, int32_t maxCycles) {
|
|
int32_t cycles; /* Number of cycles to process */
|
|
|
|
/* Process up to the given number of cycles */
|
|
do {
|
|
|
|
/* Determine the number of cycles during which nothing will happen */
|
|
cycles = -1;
|
|
/*cycles = padUntil (vue, cycles);*/
|
|
/*cycles = linkUntil (vue, cycles);*/
|
|
/*cycles = timerUntil(vue, cycles);*/
|
|
/*cycles = vipUntil (vue, cycles);*/
|
|
/*cycles = vsuUntil (vue, cycles);*/
|
|
cycles = cpuUntil (vue, cycles);
|
|
|
|
/* Range checking */
|
|
if (cycles == -1) /* No activity on any component */
|
|
break;
|
|
if (maxCycles >= 0) /* Restrict to given number of cycles */
|
|
cycles = cycles < maxCycles ? cycles : maxCycles;
|
|
|
|
/* Process all system components */
|
|
vue->breakCode = 0;
|
|
/*padEmulate (vue, cycles);*/
|
|
/*pakEmulate (vue, cycles);*/
|
|
/*linkEmulate (vue, cycles);*/
|
|
/*timerEmulate(vue, cycles);*/
|
|
/*vipEmulate (vue, cycles);*/
|
|
/*vsuEmulate (vue, cycles);*/
|
|
cpuEmulate (vue, cycles);
|
|
|
|
/* An application break was requested */
|
|
if (vue->breakCode != 0)
|
|
break;
|
|
|
|
/* Update the number of cycles remaining */
|
|
if (maxCycles >= 0)
|
|
maxCycles -= cycles;
|
|
} while (maxCycles != 0);
|
|
|
|
/* A break condition has occurred */
|
|
return maxCycles;
|
|
}
|
|
|
|
/* Retrieve the application break code */
|
|
int32_t vueGetBreakCode(Vue *vue) {
|
|
return vue == NULL ? 0 : vue->breakCode;
|
|
}
|
|
|
|
/* Retrieve the value of a register */
|
|
int32_t vueGetRegister(Vue *vue, int32_t index, vbool system) {
|
|
|
|
/* Error checking */
|
|
if (vue == NULL)
|
|
return 0;
|
|
|
|
/* Non-indexed registers */
|
|
if (system && index < 0) switch (index) {
|
|
case VUE_JUMP_FROM:
|
|
return vue->cpu.jumpFrom[vue->cpu.psw_np ? 2 : vue->cpu.psw_ep];
|
|
case VUE_JUMP_TO :
|
|
return vue->cpu.jumpTo [vue->cpu.psw_np ? 2 : vue->cpu.psw_ep];
|
|
case VUE_PC : return vue->cpu.pc;
|
|
}
|
|
|
|
/* Indexed registers */
|
|
return
|
|
index < 0 || index > 31 ? 0 :
|
|
system ? cpuGetSystemRegister(vue, index) :
|
|
vue->cpu.program[index]
|
|
;
|
|
}
|
|
|
|
/* Prepare an emulation state context for use */
|
|
void vueInitialize(Vue *vue) {
|
|
if (vue == NULL)
|
|
return;
|
|
vue->onException = NULL;
|
|
vue->onExecute = NULL;
|
|
vue->onRead = NULL;
|
|
vue->onWrite = NULL;
|
|
vue->pak.ram = NULL;
|
|
vue->pak.rom = NULL;
|
|
}
|
|
|
|
/* Read a value from the CPU bus */
|
|
int32_t vueRead(Vue *vue, uint32_t address, int32_t type) {
|
|
|
|
/* Error checking */
|
|
if (vue == NULL)
|
|
return 0;
|
|
|
|
/* Perform the operation */
|
|
switch (address >> 24 & 7) {
|
|
case 5: return readBuffer(vue->wram , 0x10000,address,type);
|
|
case 6: return readBuffer(vue->pak.ram,vue->pak.ramSize,address,type);
|
|
case 7: return readBuffer(vue->pak.rom,vue->pak.romSize,address,type);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Read bytes from the CPU bus */
|
|
vbool vueReadBytes(Vue *vue, uint32_t address, uint8_t *dest, uint32_t length){
|
|
uint32_t count; /* Bytes to read in one iteration */
|
|
|
|
/* Error checking */
|
|
if (vue == NULL || dest == NULL)
|
|
return VUE_FALSE;
|
|
|
|
/* Perform the operation */
|
|
while (length > 0) {
|
|
count = 0x01000000 - (address & 0x00FFFFFF);
|
|
if (length < count)
|
|
count = length;
|
|
switch (address >> 24 & 7) {
|
|
case 5: readBytes(vue->wram , 0x10000,
|
|
address, dest, count); break;
|
|
case 6: readBytes(vue->pak.ram, vue->pak.ramSize,
|
|
address, dest, count); break;
|
|
case 7: readBytes(vue->pak.rom, vue->pak.romSize,
|
|
address, dest, count); break;
|
|
default:
|
|
for (address += count, length -= count; count--;)
|
|
*dest++ = 0;
|
|
continue;
|
|
}
|
|
address += count;
|
|
length -= count;
|
|
dest += count;
|
|
}
|
|
return VUE_TRUE;
|
|
}
|
|
|
|
/* Initialize all system components */
|
|
void vueReset(Vue *vue) {
|
|
uint32_t x; /* Iterator */
|
|
|
|
/* Error checking */
|
|
if (vue == NULL)
|
|
return;
|
|
|
|
/* Reset state */
|
|
cpuReset(vue);
|
|
pakReset(vue);
|
|
for (x = 0; x < 0x1000; x++)
|
|
vue->wram[x] = 0;
|
|
}
|
|
|
|
/* Specify an exception breakpoint callback */
|
|
void vueSetException(Vue *vue, VueOnException callback) {
|
|
if (vue != NULL)
|
|
vue->onException = callback;
|
|
}
|
|
|
|
/* Specify an execute breakpoint callback */
|
|
void vueSetExecute(Vue *vue, VueOnExecute callback) {
|
|
if (vue != NULL)
|
|
vue->onExecute = callback;
|
|
}
|
|
|
|
/* Specify a read breakpoint callback */
|
|
void vueSetRead(Vue *vue, VueOnRead callback) {
|
|
if (vue != NULL)
|
|
vue->onRead = callback;
|
|
}
|
|
|
|
/* Specify a value for a register */
|
|
int32_t vueSetRegister(Vue *vue, int32_t index, vbool system, int32_t value) {
|
|
return vue == NULL ? 0 :
|
|
index == VUE_PC && system ? vue->cpu.pc = value & 0xFFFFFFFE :
|
|
index < 0 || index > 31 ? 0 :
|
|
system ? cpuSetSystemRegister(vue, index, value, VUE_TRUE) :
|
|
index == 0 ? 0 : (vue->cpu.program[index] = value)
|
|
;
|
|
}
|
|
|
|
/* Specify a new ROM buffer */
|
|
vbool vueSetROM(Vue *vue, uint8_t *rom, uint32_t size) {
|
|
|
|
/* Error checking */
|
|
if (
|
|
vue == NULL ||
|
|
rom == NULL ||
|
|
size < 1024 || size > 0x01000000 ||
|
|
(size & (size - 1)) != 0
|
|
) return VUE_FALSE;
|
|
|
|
/* Accept the new ROM buffer */
|
|
vue->pak.rom = rom;
|
|
vue->pak.romSize = size;
|
|
return VUE_TRUE;
|
|
}
|
|
|
|
/* Specify a write breakpoint callback */
|
|
void vueSetWrite(Vue *vue, VueOnRead callback) {
|
|
if (vue != NULL)
|
|
vue->onWrite = callback;
|
|
}
|
|
|
|
/* Write a value to the CPU bus */
|
|
void vueWrite(Vue *vue, uint32_t address, int32_t type, int32_t value) {
|
|
|
|
/* Error checking */
|
|
if (vue == NULL)
|
|
return;
|
|
|
|
/* Perform the operation */
|
|
switch (address >> 24 & 7) {
|
|
case 5: writeBuffer(vue->wram , 0x1000,
|
|
address, type, value); break;
|
|
case 6: writeBuffer(vue->pak.ram, vue->pak.ramSize,
|
|
address, type, value); break;
|
|
case 7: writeBuffer(vue->pak.rom, vue->pak.romSize,
|
|
address, type, value); break;
|
|
}
|
|
|
|
}
|
|
|
|
/* Write bytes to the CPU bus */
|
|
vbool vueWriteBytes(Vue *vue, uint32_t address, uint8_t *src, uint32_t length){
|
|
uint32_t count; /* Bytes to write in one iteration */
|
|
|
|
/* Error checking */
|
|
if (vue == NULL || src == NULL)
|
|
return VUE_FALSE;
|
|
|
|
/* Perform the operation */
|
|
while (length > 0) {
|
|
count = 0x01000000 - (address & 0x00FFFFFF);
|
|
if (length < count)
|
|
count = length;
|
|
switch (address >> 24 & 7) {
|
|
case 5: writeBytes(vue->wram , 0x10000,
|
|
address, src, count); break;
|
|
case 6: writeBytes(vue->pak.ram, vue->pak.ramSize,
|
|
address, src, count); break;
|
|
case 7: writeBytes(vue->pak.rom, vue->pak.ramSize,
|
|
address, src, count); break;
|
|
}
|
|
address += count;
|
|
length -= count;
|
|
src += count;
|
|
}
|
|
return VUE_TRUE;
|
|
}
|