mirror of
https://github.com/RetroDECK/Supermodel.git
synced 2024-11-23 06:15:37 +00:00
313 lines
7.6 KiB
C
313 lines
7.6 KiB
C
/**
|
|
** Supermodel
|
|
** A Sega Model 3 Arcade Emulator.
|
|
** Copyright 2011 Bart Trzynadlowski
|
|
**
|
|
** This file is part of Supermodel.
|
|
**
|
|
** Supermodel is free software: you can redistribute it and/or modify it under
|
|
** the terms of the GNU General Public License as published by the Free
|
|
** Software Foundation, either version 3 of the License, or (at your option)
|
|
** any later version.
|
|
**
|
|
** Supermodel is distributed in the hope that it will be useful, but WITHOUT
|
|
** ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
** FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
** more details.
|
|
**
|
|
** You should have received a copy of the GNU General Public License along
|
|
** with Supermodel. If not, see <http://www.gnu.org/licenses/>.
|
|
**/
|
|
|
|
/*
|
|
* 68K.h
|
|
*
|
|
* Header file for 68K CPU interface. Caution: 68K emulator is not thread-safe.
|
|
*
|
|
* TO-DO List:
|
|
* -----------
|
|
* - Optimize things, perhaps by using FASTCALL
|
|
*/
|
|
|
|
#ifndef INCLUDED_68K_H
|
|
#define INCLUDED_68K_H
|
|
|
|
#include <cstring>
|
|
#include "Types.h"
|
|
#include "Musashi/m68k.h"
|
|
#include "CPU/Bus.h"
|
|
|
|
// This doesn't work for now (needs to be added to the prototypes in m68k.h for m68k_read_memory*)
|
|
//#ifndef FASTCALL
|
|
#undef FASTCALL
|
|
#define FASTCALL
|
|
//#endif
|
|
|
|
|
|
/******************************************************************************
|
|
Definitions
|
|
******************************************************************************/
|
|
|
|
// IRQ callback special return values
|
|
#define M68K_IRQ_AUTOVECTOR M68K_INT_ACK_AUTOVECTOR // signals an autovectored interrupt
|
|
#define M68K_IRQ_SPURIOUS M68K_INT_ACK_SPURIOUS // signals a spurious interrupt
|
|
|
|
|
|
/******************************************************************************
|
|
CPU Context
|
|
******************************************************************************/
|
|
|
|
/*
|
|
* M68KCtx:
|
|
*
|
|
* Complete state of a single 68K. Do NOT manipulate these directly. Set the
|
|
* context and then use the M68K* functions below to attach a bus and IRQ
|
|
* callback to the active context.
|
|
*/
|
|
typedef struct SM68KCtx
|
|
{
|
|
public:
|
|
CBus *Bus; // memory handlers
|
|
int (*IRQAck)(int); // IRQ acknowledge callback
|
|
unsigned char *musashiCtx; // holds CPU state
|
|
|
|
SM68KCtx(void)
|
|
{
|
|
Bus = NULL;
|
|
IRQAck = NULL;
|
|
musashiCtx = new unsigned char[m68k_context_size()];
|
|
memset(musashiCtx, 0, m68k_context_size()); // very important! garbage in context at reset can cause very strange bugs
|
|
}
|
|
|
|
~SM68KCtx(void)
|
|
{
|
|
Bus = NULL;
|
|
IRQAck = NULL;
|
|
delete [] musashiCtx;
|
|
}
|
|
} M68KCtx;
|
|
|
|
|
|
/******************************************************************************
|
|
68K Interface
|
|
|
|
Unless otherwise noted, all functions operate on the active context.
|
|
******************************************************************************/
|
|
|
|
/*
|
|
* M68KGetDRegister(int n):
|
|
*
|
|
* Parameters:
|
|
* n Register number (0-7).
|
|
*
|
|
* Returns:
|
|
* Register An.
|
|
*/
|
|
extern UINT32 M68KGetARegister(int n);
|
|
|
|
/*
|
|
* M68KGetDRegister(int n):
|
|
*
|
|
* Parameters:
|
|
* n Register number (0-7).
|
|
*
|
|
* Returns:
|
|
* Register Dn.
|
|
*/
|
|
extern UINT32 M68KGetDRegister(int reg);
|
|
|
|
/*
|
|
* M68KGetPC():
|
|
*
|
|
* Returns:
|
|
* Current program counter.
|
|
*/
|
|
extern UINT32 M68KGetPC(void);
|
|
|
|
/*
|
|
* M68KSaveState(StateFile, name):
|
|
*
|
|
* Saves the CPU state to the block file.
|
|
*
|
|
* Parameters:
|
|
* StateFile Block file.
|
|
* name Name of block to create (e.g. "Main 68K"), to facilitate
|
|
* multiple 68K states in the same file.
|
|
*/
|
|
extern void M68KSaveState(CBlockFile *StateFile, const char *name);
|
|
|
|
/*
|
|
* M68KLoadState(StateFile, name):
|
|
*
|
|
* Loads the CPU state.
|
|
*
|
|
* Parameters:
|
|
* StateFile Block file.
|
|
* name Name of block to load.
|
|
*/
|
|
extern void M68KLoadState(CBlockFile *StateFile, const char *name);
|
|
|
|
/*
|
|
* M68KSetIRQ(irqLevel):
|
|
*
|
|
* Sets the interrupt level (IPL2-IPL0 pins).
|
|
*
|
|
* Parameters:
|
|
* irqLevel The interrupt level (1-7) or 0 to clear the interrupt.
|
|
*/
|
|
extern void M68KSetIRQ(int irqLevel);
|
|
|
|
/*
|
|
* M68KRun(numCycles):
|
|
*
|
|
* Runs the 68K.
|
|
*
|
|
* Parameters:
|
|
* numCycles Number of cycles to run.
|
|
*
|
|
* Returns:
|
|
* Number of cycles executed.
|
|
*/
|
|
extern int M68KRun(int numCycles);
|
|
|
|
/*
|
|
* M68KReset():
|
|
*
|
|
* Resets the 68K.
|
|
*/
|
|
extern void M68KReset(void);
|
|
|
|
/*
|
|
* M68KSetIRQCallback(F):
|
|
*
|
|
* Installs an interrupt acknowledge callback for the currently active CPU. The
|
|
* default behavior is to always assume autovectored interrupts.
|
|
*
|
|
* Parameters:
|
|
* F Callback function.
|
|
*/
|
|
extern void M68KSetIRQCallback(int (*F)(int));
|
|
|
|
/*
|
|
* M68KAttachBus(CBus *BusPtr):
|
|
*
|
|
* Attaches a bus object to the 68K, which will be used to perform all address
|
|
* space accesses. The 8, 16, and 32-bit read and write handlers are used.
|
|
* This must be set up before any 68K-related emulation functions are invoked
|
|
* or the program will crash!
|
|
*
|
|
* Parameters:
|
|
* BusPtr Pointer to bus object to use for all address space accesses.
|
|
*/
|
|
extern void M68KAttachBus(CBus *BusPtr);
|
|
|
|
/*
|
|
* M68KInit():
|
|
*
|
|
* Initializes the 68K emulator. Must be called once per program session prior
|
|
* to any 68K emulation functions. A context must be mapped before calling
|
|
* this.
|
|
*
|
|
* Returns:
|
|
* Always returns OKAY.
|
|
*/
|
|
extern BOOL M68KInit(void);
|
|
|
|
/*
|
|
* M68KGetContext(M68KCtx *Dest):
|
|
*
|
|
* Copies the internal (active) 68K context back to the destination.
|
|
*
|
|
* Parameters:
|
|
* Dest Location to which to copy 68K context.
|
|
*/
|
|
extern void M68KGetContext(M68KCtx *Dest);
|
|
|
|
/*
|
|
* M68KSetContext(M68KCtx *Src):
|
|
*
|
|
* Sets the specified 68K context by copying it to the internal context.
|
|
*
|
|
* Parameters:
|
|
* Src Location from which to copy 68K context.
|
|
*/
|
|
extern void M68KSetContext(M68KCtx *Src);
|
|
|
|
|
|
/******************************************************************************
|
|
68K Handlers
|
|
|
|
Intended for use directly by the 68K core.
|
|
******************************************************************************/
|
|
|
|
extern "C" {
|
|
|
|
/*
|
|
* M68KIRQCallback(nIRQ):
|
|
*
|
|
* Interrupt acknowledge callback. Called when an interrupt is being serviced.
|
|
* Actually implemented by calling a user-supplied callback.
|
|
*
|
|
* Parameters:
|
|
* nIRQ IRQ level (1-7).
|
|
*
|
|
* Returns:
|
|
* The interrupt vector to use, M68K_IRQ_AUTOVECTOR, or
|
|
* M68K_IRQ_SPURIOUS. If no callback has been installed, the default
|
|
* callback is used and always returns M68K_IRQ_AUTOVECTOR.
|
|
*/
|
|
extern int M68KIRQCallback(int nIRQ);
|
|
|
|
/*
|
|
* M68KFetch8(a):
|
|
* M68KFetch16(a):
|
|
* M68KFetch32(a):
|
|
*
|
|
* Read data from the program address space.
|
|
*
|
|
* Parameters:
|
|
* a Address to read from.
|
|
*
|
|
* Returns:
|
|
* The 8, 16, or 32-bit value read.
|
|
*/
|
|
unsigned int FASTCALL M68KFetch8(unsigned int a);
|
|
unsigned int FASTCALL M68KFetch16(unsigned int a);
|
|
unsigned int FASTCALL M68KFetch32(unsigned int a);
|
|
|
|
/*
|
|
* M68KRead8(a):
|
|
* M68KRead16(a):
|
|
* M68KRead32(a):
|
|
*
|
|
* Read data from the data address space.
|
|
*
|
|
* Parameters:
|
|
* a Address to read from.
|
|
*
|
|
* Returns:
|
|
* The 8, 16, or 32-bit value read.
|
|
*/
|
|
unsigned int FASTCALL M68KRead8(unsigned int a);
|
|
unsigned int FASTCALL M68KRead16(unsigned int a);
|
|
unsigned int FASTCALL M68KRead32(unsigned int a);
|
|
|
|
/*
|
|
* M68KWrite8(a, d):
|
|
* M68KWrite16(a, d):
|
|
* M68KWrite32(a, d):
|
|
*
|
|
* Writes to the data address space.
|
|
*
|
|
* Parameters:
|
|
* a Address to write to.
|
|
* d Data to write.
|
|
*/
|
|
void FASTCALL M68KWrite8(unsigned int a, unsigned int d);
|
|
void FASTCALL M68KWrite16(unsigned int a, unsigned int d);
|
|
void FASTCALL M68KWrite32(unsigned int a, unsigned int d);
|
|
|
|
} // extern "C"
|
|
|
|
|
|
#endif // INCLUDED_68K_H
|