static void ModuleDoSimpleCommand (int cmd)
{
if(cmd == MDFN_MSC_RESET)
{
EmuReset();
}
else if(cmd == MDFN_MSC_POWER)
{
EmuReset();
}
}
int main(int argc, char *argv[])
{
xenon_make_it_faster(XENON_SPEED_FULL);
InitVideo();
usb_init();
usb_do_poll();
xenon_ata_init();
xenon_sound_init();
SetupPads();
mount_all_devices();
// Set defaults
DefaultSettings();
// Initialize font system
InitFreeType((u8*)font_ttf, font_ttf_size);
browserList = (BROWSERENTRY *)malloc(sizeof(BROWSERENTRY)*MAX_BROWSER_SIZE);
while (1) // main loop
{
MainMenu(MENU_GAMESELECTION);
EmuLaunch();
if(EmuRunning)
MainMenu(MENU_GAME);
else
MainMenu(MENU_GAMESELECTION);
if(EmuRunning)
EmuResume();
else
EmuLaunch();
if(EmuConfigRequested) {
EmuConfigRequested = 0;
break;
}
if(EmuResetRequested) {
EmuResetRequested = 0;
EmuReset();
}
}
return 0;
}
void SysReset() {
// rearmed hack: EmuReset() runs some code when real BIOS is used,
// but we usually do reset from menu while GPU is not open yet,
// so we need to prevent updateLace() call..
void *real_lace = GPU_updateLace;
GPU_updateLace = dummy_lace;
g_emu_resetting = 1;
// reset can run code, timing must be set
pl_timing_prepare(Config.PsxType);
EmuReset();
// hmh core forgets this
CDR_stop();
GPU_updateLace = real_lace;
g_emu_resetting = 0;
}
void SysReset( void )
{
LOG_ENTER();
// rearmed hack: EmuReset() runs some code when real BIOS is used,
// but we usually do reset from menu while GPU is not open yet,
// so we need to prevent updateLace() call..
void* real_lace = GPUupdateLace;
GPU_updateLace = dummy_lace;
LOG_STEP();
EmuReset();
LOG_STEP();
// hmh core forgets this
CDR_stop();
GPU_updateLace = real_lace;
LOG_LEAVE();
}
static int ModuleLoad ()
{
//Load the BIOS
MDFNFILE biosFile;
if(biosFile.Open(MDFN_MakeFName(MDFNMKF_FIRMWARE, 0, MDFN_GetSettingS("pcsxr.bios").c_str()).c_str(), 0))
{
if(biosFile.size == 512 * 1024)
{
memcpy(BiosBuffer, biosFile.data, 512 * 1024);
}
else
{
MDFN_printf("pcsxr: BIOS file size incorrect\n");
}
}
else
{
MDFN_printf("pcsxr: Failed to load bios\n");
return 0;
}
//Setup the config structure
memset(&Config, 0, sizeof(Config));
Config.PsxAuto = 1;
Config.Cpu = MDFN_GetSettingB("pcsxr.recompiler") ? CPU_DYNAREC : CPU_INTERPRETER;
Config.SlowBoot = MDFN_GetSettingB("pcsxr.slowboot");
strcpy(Config.PluginsDir, "builtin");
strcpy(Config.Gpu, "builtin");
strcpy(Config.Spu, "builtin");
strcpy(Config.Pad1, "builtin");
strcpy(Config.Pad2, "builtin");
strcpy(Config.Cdr, "builtin");
strcpy(Config.Net, "Disabled");
strncpy(Config.Mcd1, MDFN_MakeFName(MDFNMKF_SAV, 0, "sav").c_str(), MAXPATHLEN);
strncpy(Config.Mcd2, MDFN_MakeFName(MDFNMKF_SAV, 0, "sav2").c_str(), MAXPATHLEN);
//Init psx cpu emulator and memory mapping
EmuInit();
//Open and initialize all of the plugins
OpenPlugins();
//Load memory cards
LoadMcds(Config.Mcd1, Config.Mcd2);
//Get cdrom ID and init PPF support...
CheckCdrom();
//Reset the emulated CPU and Memory
EmuReset();
//Prepares the game to run, either runs the CPU thru the bios or finds and loads the game EXE if using the emulated bios
LoadCdrom();
//TODO: Set the clock if the machine is PAL
//Just say two 1M pages, for fun not profit
MDFNMP_Init(1024 * 1024, 2);
MDFNMP_AddRAM(1024 * 1024 * 2, 0, (uint8_t*)psxM);
return 1;
}
void SysReset() {
EmuReset();
}
/*
PCIInitDev
*/
static PVRSRV_ERROR PCIInitDev(PLAT_DATA *psPlatData)
{
PVRSRV_DEVICE_CONFIG *psDevice = &sSysConfig.pasDevices[0];
PVRSRV_ERROR eError;
#if defined (LMA)
IMG_UINT32 uiLMACpuPAddr;
IMG_UINT32 uiLMASize;
#endif
psPlatData->hRGXPCI = OSPCIAcquireDev(SYS_RGX_DEV_VENDOR_ID,
SYS_RGX_DEV_DEVICE_ID,
HOST_PCI_INIT_FLAG_BUS_MASTER | HOST_PCI_INIT_FLAG_MSI);
if (!psPlatData->hRGXPCI)
{
psPlatData->hRGXPCI = OSPCIAcquireDev(SYS_RGX_DEV_VENDOR_ID,
SYS_RGX_DEV1_DEVICE_ID,
HOST_PCI_INIT_FLAG_BUS_MASTER | HOST_PCI_INIT_FLAG_MSI);
}
if (!psPlatData->hRGXPCI)
{
PVR_DPF((PVR_DBG_ERROR,"PCIInitDev: Failed to acquire PCI device"));
eError = PVRSRV_ERROR_PCI_DEVICE_NOT_FOUND;
goto e0;
}
psPlatData->uiICRCpuPAddr = OSPCIAddrRangeStart(psPlatData->hRGXPCI, EMULATOR_RGX_ICR_PCI_BASENUM);
psPlatData->uiICRSize = OSPCIAddrRangeLen(psPlatData->hRGXPCI, EMULATOR_RGX_ICR_PCI_BASENUM);
/* Check the address range is large enough. */
if (psPlatData->uiICRSize < EMULATOR_RGX_ICR_PCI_REGION_SIZE)
{
PVR_DPF((PVR_DBG_ERROR,"PCIInitDev: Device memory region isn't big enough (Emu reg) (was 0x%08x, required 0x%08x)",
psPlatData->uiICRSize, EMULATOR_RGX_ICR_PCI_REGION_SIZE));
eError = PVRSRV_ERROR_PCI_REGION_TOO_SMALL;
goto e1;
}
/* Reserve the address range */
if (OSPCIRequestAddrRange(psPlatData->hRGXPCI, EMULATOR_RGX_ICR_PCI_BASENUM)
!= PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PCIInitDev: Device memory region not available (Emu reg)"));
eError = PVRSRV_ERROR_PCI_REGION_UNAVAILABLE;
goto e1;
}
psDevice->sRegsCpuPBase.uiAddr = OSPCIAddrRangeStart(psPlatData->hRGXPCI, EMULATOR_RGX_REG_PCI_BASENUM);
psDevice->ui32RegsSize = OSPCIAddrRangeLen(psPlatData->hRGXPCI, EMULATOR_RGX_REG_PCI_BASENUM);
/* Check the address range is large enough. */
if (psDevice->ui32RegsSize < EMULATOR_RGX_REG_SIZE)
{
PVR_DPF((PVR_DBG_ERROR,"PCIInitDev: Device memory region isn't big enough (RGX reg) (was 0x%08x, required 0x%08x)",
psDevice->ui32RegsSize, EMULATOR_RGX_REG_SIZE));
eError = PVRSRV_ERROR_PCI_REGION_TOO_SMALL;
goto e2;
}
/* Reserve the address range */
if (OSPCIRequestAddrRange(psPlatData->hRGXPCI, EMULATOR_RGX_REG_PCI_BASENUM) != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PCIInitDev: Device memory region not available (RGX reg) "));
eError = PVRSRV_ERROR_PCI_REGION_UNAVAILABLE;
goto e2;
}
#if defined (LMA)
uiLMACpuPAddr = OSPCIAddrRangeStart(psPlatData->hRGXPCI, EMULATOR_RGX_MEM_PCI_BASENUM);
uiLMASize = OSPCIAddrRangeLen(psPlatData->hRGXPCI, EMULATOR_RGX_MEM_PCI_BASENUM);
/* Setup the RGX heap */
gsPhysHeapConfig[0].sStartAddr.uiAddr = uiLMACpuPAddr;
gsPhysHeapConfig[0].uiSize = uiLMASize - RESERVE_DC_MEM_SIZE;
/* Setup the DC heap */
gsPhysHeapConfig[1].sStartAddr.uiAddr = uiLMACpuPAddr + gsPhysHeapConfig[0].uiSize;
gsPhysHeapConfig[1].uiSize = RESERVE_DC_MEM_SIZE;
/* Check the address range is large enough. */
if (uiLMASize < EMULATOR_RGX_MEM_REGION_SIZE)
{
PVR_DPF((PVR_DBG_ERROR,"PCIInitDev: Device memory region isn't big enough (was 0x%08x, required 0x%08x)",
uiLMASize, EMULATOR_RGX_MEM_REGION_SIZE));
eError = PVRSRV_ERROR_PCI_REGION_TOO_SMALL;
goto e3;
}
/* Reserve the address range */
if (OSPCIRequestAddrRange(psPlatData->hRGXPCI, EMULATOR_RGX_MEM_PCI_BASENUM) != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PCIInitDev: Device memory region not available"));
eError = PVRSRV_ERROR_PCI_REGION_UNAVAILABLE;
goto e3;
}
#endif
if (OSPCIIRQ(psPlatData->hRGXPCI, &psDevice->ui32IRQ) != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PCIInitDev: Couldn't get IRQ"));
eError = PVRSRV_ERROR_INVALID_DEVICE;
goto e4;
}
#if defined (LMA)
/* Save this info for later use */
psPlatData->uiLMACpuPAddr = uiLMACpuPAddr;
psPlatData->uiLMASize = uiLMASize;
#endif
/*
Reset the emulator design
*/
eError = EmuReset(psDevice->sRegsCpuPBase);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PCIInitDev: Couldn't reset emulator"));
goto e4;
}
/*
Init IRC IRQ_CTRL register
*/
Init_IRQ_CTRL(psPlatData);
return PVRSRV_OK;
e4:
#if defined (LMA)
OSPCIReleaseAddrRange(psPlatData->hRGXPCI, EMULATOR_RGX_MEM_PCI_BASENUM);
e3:
#endif
OSPCIReleaseAddrRange(psPlatData->hRGXPCI, EMULATOR_RGX_REG_PCI_BASENUM);
e2:
OSPCIReleaseAddrRange(psPlatData->hRGXPCI, EMULATOR_RGX_ICR_PCI_BASENUM);
e1:
OSPCIReleaseDev(psPlatData->hRGXPCI);
e0:
return eError;
}
void cpuReset() {
EmuReset();
}