690 lines
21 KiB
C++
690 lines
21 KiB
C++
#include <core/mmio/PIF.hpp>
|
|
#include <core/Mem.hpp>
|
|
#include <core/registers/Registers.hpp>
|
|
#include <log.hpp>
|
|
#include <SDL_keyboard.h>
|
|
#include <cic_nus_6105/n64_cic_nus_6105.hpp>
|
|
#include <cassert>
|
|
#include <MupenMovie.hpp>
|
|
|
|
#define MEMPAK_SIZE 32768
|
|
|
|
namespace n64 {
|
|
void PIF::LoadMempak(fs::path path) {
|
|
if (mempak)
|
|
free(mempak);
|
|
mempak = (u8*)calloc(MEMPAK_SIZE, 1);
|
|
mempakPath = path.replace_extension(".mempak").string();
|
|
FILE* f = fopen(mempakPath.c_str(), "rb");
|
|
if (!f) {
|
|
f = fopen(mempakPath.c_str(), "wb");
|
|
fwrite(mempak, 1, MEMPAK_SIZE, f);
|
|
fclose(f);
|
|
f = fopen(mempakPath.c_str(), "rb");
|
|
}
|
|
|
|
fseek(f, 0, SEEK_END);
|
|
size_t actualSize = ftell(f);
|
|
fseek(f, 0, SEEK_SET);
|
|
if (actualSize != MEMPAK_SIZE) {
|
|
Util::panic("Corrupt mempak!\n");
|
|
}
|
|
|
|
fread(mempak, 1, MEMPAK_SIZE, f);
|
|
fclose(f);
|
|
}
|
|
|
|
inline size_t getSaveSize(SaveType saveType) {
|
|
switch (saveType) {
|
|
case SAVE_NONE:
|
|
return 0;
|
|
case SAVE_EEPROM_4k:
|
|
return 512;
|
|
case SAVE_EEPROM_16k:
|
|
return 2048;
|
|
case SAVE_SRAM_256k:
|
|
return 32768;
|
|
case SAVE_FLASH_1m:
|
|
return 131072;
|
|
default:
|
|
Util::panic("Unknown save type!\n");
|
|
}
|
|
}
|
|
|
|
void PIF::LoadEeprom(SaveType saveType, fs::path path) {
|
|
if (eeprom)
|
|
free(eeprom);
|
|
|
|
eepromSize = getSaveSize(saveType);
|
|
eeprom = (u8*)calloc(eepromSize, 1);
|
|
eepromPath = path.replace_extension(".eeprom").string();
|
|
FILE* f = fopen(eepromPath.c_str(), "rb");
|
|
if (!f) {
|
|
f = fopen(eepromPath.c_str(), "wb");
|
|
fwrite(eeprom, 1, eepromSize, f);
|
|
fclose(f);
|
|
f = fopen(eepromPath.c_str(), "rb");
|
|
}
|
|
|
|
fseek(f, 0, SEEK_END);
|
|
size_t actualSize = ftell(f);
|
|
fseek(f, 0, SEEK_SET);
|
|
if (actualSize != eepromSize) {
|
|
Util::panic("Corrupt eeprom!\n");
|
|
}
|
|
|
|
fread(eeprom, 1, eepromSize, f);
|
|
fclose(f);
|
|
}
|
|
|
|
PIF::~PIF() {
|
|
FILE* f = fopen(mempakPath.c_str(), "wb");
|
|
fwrite(mempak, 1, MEMPAK_SIZE, f);
|
|
fclose(f);
|
|
f = fopen(eepromPath.c_str(), "wb");
|
|
fwrite(eeprom, 1, eepromSize, f);
|
|
fclose(f);
|
|
}
|
|
|
|
enum CMDIndexes {
|
|
CMD_LEN = 0,
|
|
CMD_RES_LEN,
|
|
CMD_IDX,
|
|
CMD_START
|
|
};
|
|
|
|
void PIF::CICChallenge() {
|
|
u8 challenge[30];
|
|
u8 response[30];
|
|
|
|
// Split 15 bytes into 30 nibbles
|
|
for (int i = 0; i < 15; i++) {
|
|
challenge[i * 2 + 0] = (ram[0x30 + i] >> 4) & 0x0F;
|
|
challenge[i * 2 + 1] = (ram[0x30 + i] >> 0) & 0x0F;
|
|
}
|
|
|
|
n64_cic_nus_6105((char*)challenge, (char*)response, CHL_LEN - 2);
|
|
|
|
for (int i = 0; i < 15; i++) {
|
|
ram[0x30 + i] = (response[i * 2] << 4) + response[i * 2 + 1];
|
|
}
|
|
}
|
|
|
|
inline u8 data_crc(const u8* data) {
|
|
u8 crc = 0;
|
|
for (int i = 0; i <= 32; i++) {
|
|
for (int j = 7; j >= 0; j--) {
|
|
u8 xor_val = ((crc & 0x80) != 0) ? 0x85 : 0x00;
|
|
|
|
crc <<= 1;
|
|
if (i < 32) {
|
|
if ((data[i] & (1 << j)) != 0) {
|
|
crc |= 1;
|
|
}
|
|
}
|
|
|
|
crc ^= xor_val;
|
|
}
|
|
}
|
|
|
|
return crc;
|
|
}
|
|
|
|
void PIF::ProcessCommands(Mem &mem) {
|
|
u8 control = ram[63];
|
|
if (control & 1) {
|
|
channel = 0;
|
|
int i = 0;
|
|
while (i < 63) {
|
|
u8* cmd = &ram[i++];
|
|
u8 cmdlen = cmd[CMD_LEN] & 0x3F;
|
|
|
|
if (cmdlen == 0) {
|
|
channel++;
|
|
} else if (cmdlen == 0x3D) {
|
|
channel++;
|
|
} else if (cmdlen == 0x3E) {
|
|
break;
|
|
} else if (cmdlen == 0x3F) {
|
|
continue;
|
|
} else {
|
|
u8 r = ram[i++];
|
|
if (r == 0xFE) {
|
|
break;
|
|
}
|
|
u8 reslen = r & 0x3F;
|
|
u8* res = &ram[i + cmdlen];
|
|
|
|
switch (cmd[CMD_IDX]) {
|
|
case 0xff:
|
|
ControllerID(res);
|
|
channel++;
|
|
break;
|
|
case 0:
|
|
ControllerID(res);
|
|
channel++;
|
|
break;
|
|
case 1:
|
|
UpdateController();
|
|
if(!ReadButtons(res)) {
|
|
cmd[1] |= 0x80;
|
|
}
|
|
channel++;
|
|
break;
|
|
case 2:
|
|
MempakRead(cmd, res);
|
|
break;
|
|
case 3:
|
|
MempakWrite(cmd, res);
|
|
break;
|
|
case 4:
|
|
EepromRead(cmd, res, mem);
|
|
break;
|
|
case 5:
|
|
EepromWrite(cmd, res, mem);
|
|
break;
|
|
default:
|
|
Util::panic("Invalid PIF command: {:X}", cmd[2]);
|
|
}
|
|
|
|
i += cmdlen + reslen;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (control & 0x02) {
|
|
CICChallenge();
|
|
ram[63] &= ~2;
|
|
}
|
|
|
|
if (control & 0x08) {
|
|
ram[63] &= ~8;
|
|
}
|
|
|
|
if (control & 0x30) {
|
|
ram[63] = 0x80;
|
|
}
|
|
}
|
|
|
|
void PIF::MempakRead(u8* cmd, u8* res) const {
|
|
u16 offset = cmd[3] << 8;
|
|
offset |= cmd[4];
|
|
|
|
// low 5 bits are the CRC
|
|
//byte crc = offset & 0x1F;
|
|
// offset must be 32-byte aligned
|
|
offset &= ~0x1F;
|
|
|
|
switch (getAccessoryType()) {
|
|
case ACCESSORY_NONE:
|
|
break;
|
|
case ACCESSORY_MEMPACK:
|
|
if (offset <= MEMPAK_SIZE - 0x20) {
|
|
for (int i = 0; i < 32; i++) {
|
|
res[i] = mempak[offset + i];
|
|
}
|
|
}
|
|
break;
|
|
case ACCESSORY_RUMBLE_PACK:
|
|
for (int i = 0; i < 32; i++) {
|
|
res[i] = 0x80;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// CRC byte
|
|
res[32] = data_crc(&res[0]);
|
|
}
|
|
|
|
void PIF::MempakWrite(u8* cmd, u8* res) const {
|
|
// First two bytes in the command are the offset
|
|
u16 offset = cmd[3] << 8;
|
|
offset |= cmd[4];
|
|
|
|
// low 5 bits are the CRC
|
|
//byte crc = offset & 0x1F;
|
|
// offset must be 32-byte aligned
|
|
offset &= ~0x1F;
|
|
|
|
switch (getAccessoryType()) {
|
|
case ACCESSORY_NONE:
|
|
break;
|
|
case ACCESSORY_MEMPACK:
|
|
if (offset <= MEMPAK_SIZE - 0x20) {
|
|
for (int i = 0; i < 32; i++) {
|
|
mempak[offset + i] = cmd[5 + i];
|
|
}
|
|
}
|
|
break;
|
|
case ACCESSORY_RUMBLE_PACK: break;
|
|
}
|
|
// CRC byte
|
|
res[0] = data_crc(&cmd[5]);
|
|
}
|
|
|
|
void PIF::EepromRead(u8* cmd, u8* res, const Mem& mem) const {
|
|
assert(mem.saveType == SAVE_EEPROM_4k || mem.saveType == SAVE_EEPROM_16k);
|
|
if (channel == 4) {
|
|
u8 offset = cmd[3];
|
|
if ((offset * 8) >= getSaveSize(mem.saveType)) {
|
|
Util::panic("Out of range EEPROM read! offset: {:02X}", offset);
|
|
}
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
res[i] = eeprom[(offset * 8) + i];
|
|
}
|
|
}
|
|
else {
|
|
Util::panic("EEPROM read on bad channel {}", channel);
|
|
}
|
|
}
|
|
|
|
void PIF::EepromWrite(u8* cmd, u8* res, const Mem& mem) const {
|
|
assert(mem.saveType == SAVE_EEPROM_4k || mem.saveType == SAVE_EEPROM_16k);
|
|
if (channel == 4) {
|
|
u8 offset = cmd[3];
|
|
if ((offset * 8) >= getSaveSize(mem.saveType)) {
|
|
Util::panic("Out of range EEPROM write! offset: {:02X}\n", offset);
|
|
}
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
eeprom[(offset * 8) + i] = cmd[4 + i];
|
|
}
|
|
|
|
res[0] = 0; // Error byte, I guess it always succeeds?
|
|
}
|
|
else {
|
|
Util::panic("EEPROM write on bad channel {}", channel);
|
|
}
|
|
}
|
|
|
|
#define GET_BUTTON(gamecontroller, i) SDL_GameControllerGetButton(gamecontroller, i)
|
|
#define GET_AXIS(gamecontroller, axis) SDL_GameControllerGetAxis(gamecontroller, axis)
|
|
|
|
void PIF::UpdateController() {
|
|
if(gamepadConnected) {
|
|
bool A = GET_BUTTON(gamepad, SDL_CONTROLLER_BUTTON_A);
|
|
bool B = GET_BUTTON(gamepad, SDL_CONTROLLER_BUTTON_X);
|
|
bool Z = GET_AXIS(gamepad, SDL_CONTROLLER_AXIS_TRIGGERLEFT) == SDL_JOYSTICK_AXIS_MAX;
|
|
bool START = GET_BUTTON(gamepad, SDL_CONTROLLER_BUTTON_START);
|
|
bool DUP = GET_BUTTON(gamepad, SDL_CONTROLLER_BUTTON_DPAD_UP);
|
|
bool DDOWN = GET_BUTTON(gamepad, SDL_CONTROLLER_BUTTON_DPAD_DOWN);
|
|
bool DLEFT = GET_BUTTON(gamepad, SDL_CONTROLLER_BUTTON_DPAD_LEFT);
|
|
bool DRIGHT = GET_BUTTON(gamepad, SDL_CONTROLLER_BUTTON_DPAD_RIGHT);
|
|
bool L = GET_BUTTON(gamepad, SDL_CONTROLLER_BUTTON_LEFTSHOULDER);
|
|
bool R = GET_BUTTON(gamepad, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER);
|
|
bool CUP = GET_AXIS(gamepad, SDL_CONTROLLER_AXIS_RIGHTY) <= -127;
|
|
bool CDOWN = GET_AXIS(gamepad, SDL_CONTROLLER_AXIS_RIGHTY) >= 127;
|
|
bool CLEFT = GET_AXIS(gamepad, SDL_CONTROLLER_AXIS_RIGHTX) <= -127;
|
|
bool CRIGHT = GET_AXIS(gamepad, SDL_CONTROLLER_AXIS_RIGHTX) >= 127;
|
|
|
|
joybusDevices[channel].controller.a = A;
|
|
joybusDevices[channel].controller.b = B;
|
|
joybusDevices[channel].controller.z = Z;
|
|
joybusDevices[channel].controller.start = START;
|
|
joybusDevices[channel].controller.dp_up = DUP;
|
|
joybusDevices[channel].controller.dp_down = DDOWN;
|
|
joybusDevices[channel].controller.dp_left = DLEFT;
|
|
joybusDevices[channel].controller.dp_right = DRIGHT;
|
|
joybusDevices[channel].controller.joy_reset = L && R && START;
|
|
joybusDevices[channel].controller.l = L;
|
|
joybusDevices[channel].controller.r = R;
|
|
joybusDevices[channel].controller.c_up = CUP;
|
|
joybusDevices[channel].controller.c_down = CDOWN;
|
|
joybusDevices[channel].controller.c_left = CLEFT;
|
|
joybusDevices[channel].controller.c_right = CRIGHT;
|
|
|
|
float xclamped = GET_AXIS(gamepad, SDL_CONTROLLER_AXIS_LEFTX);
|
|
if(xclamped < 0) {
|
|
xclamped /= float(std::abs(SDL_JOYSTICK_AXIS_MIN));
|
|
} else {
|
|
xclamped /= SDL_JOYSTICK_AXIS_MAX;
|
|
}
|
|
|
|
xclamped *= 86;
|
|
|
|
float yclamped = GET_AXIS(gamepad, SDL_CONTROLLER_AXIS_LEFTY);
|
|
if(yclamped < 0) {
|
|
yclamped /= float(std::abs(SDL_JOYSTICK_AXIS_MIN));
|
|
} else {
|
|
yclamped /= SDL_JOYSTICK_AXIS_MAX;
|
|
}
|
|
|
|
yclamped *= 86;
|
|
|
|
joybusDevices[channel].controller.joy_x = xclamped;
|
|
joybusDevices[channel].controller.joy_y = -yclamped;
|
|
|
|
if (joybusDevices[channel].controller.joy_reset) {
|
|
joybusDevices[channel].controller.start = false;
|
|
joybusDevices[channel].controller.joy_x = 0;
|
|
joybusDevices[channel].controller.joy_y = 0;
|
|
}
|
|
} else {
|
|
const uint8_t* state = SDL_GetKeyboardState(nullptr);
|
|
joybusDevices[channel].controller.a = state[SDL_SCANCODE_X];
|
|
joybusDevices[channel].controller.b = state[SDL_SCANCODE_C];
|
|
joybusDevices[channel].controller.z = state[SDL_SCANCODE_Z];
|
|
joybusDevices[channel].controller.start = state[SDL_SCANCODE_RETURN];
|
|
joybusDevices[channel].controller.dp_up = state[SDL_SCANCODE_KP_8];
|
|
joybusDevices[channel].controller.dp_down = state[SDL_SCANCODE_KP_5];
|
|
joybusDevices[channel].controller.dp_left = state[SDL_SCANCODE_KP_4];
|
|
joybusDevices[channel].controller.dp_right = state[SDL_SCANCODE_KP_6];
|
|
joybusDevices[channel].controller.joy_reset = state[SDL_SCANCODE_RETURN] && state[SDL_SCANCODE_A] && state[SDL_SCANCODE_S];
|
|
joybusDevices[channel].controller.l = state[SDL_SCANCODE_A];
|
|
joybusDevices[channel].controller.r = state[SDL_SCANCODE_S];
|
|
joybusDevices[channel].controller.c_up = state[SDL_SCANCODE_I];
|
|
joybusDevices[channel].controller.c_down = state[SDL_SCANCODE_J];
|
|
joybusDevices[channel].controller.c_left = state[SDL_SCANCODE_K];
|
|
joybusDevices[channel].controller.c_right = state[SDL_SCANCODE_L];
|
|
|
|
s16 xaxis = 0, yaxis = 0;
|
|
if (state[SDL_SCANCODE_LEFT]) {
|
|
xaxis = -86;
|
|
} else if (state[SDL_SCANCODE_RIGHT]) {
|
|
xaxis = 86;
|
|
}
|
|
|
|
if (state[SDL_SCANCODE_DOWN]) {
|
|
yaxis = -86;
|
|
} else if (state[SDL_SCANCODE_UP]) {
|
|
yaxis = 86;
|
|
}
|
|
|
|
joybusDevices[channel].controller.joy_x = xaxis;
|
|
joybusDevices[channel].controller.joy_y = yaxis;
|
|
|
|
if (joybusDevices[channel].controller.joy_reset) {
|
|
joybusDevices[channel].controller.start = false;
|
|
joybusDevices[channel].controller.joy_x = 0;
|
|
joybusDevices[channel].controller.joy_y = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PIF::DoPIFHLE(Mem& mem, Registers& regs, bool pal, CICType cicType) {
|
|
mem.Write32(regs, PIF_RAM_REGION_START + 0x24, cicSeeds[cicType]);
|
|
|
|
switch(cicType) {
|
|
case UNKNOWN_CIC_TYPE:
|
|
Util::warn("Unknown CIC type!\n");
|
|
break;
|
|
case CIC_NUS_6101:
|
|
regs.gpr[0] = 0x0000000000000000;
|
|
regs.gpr[1] = 0x0000000000000000;
|
|
regs.gpr[2] = 0xFFFFFFFFDF6445CC;
|
|
regs.gpr[3] = 0xFFFFFFFFDF6445CC;
|
|
regs.gpr[4] = 0x00000000000045CC;
|
|
regs.gpr[5] = 0x0000000073EE317A;
|
|
regs.gpr[6] = 0xFFFFFFFFA4001F0C;
|
|
regs.gpr[7] = 0xFFFFFFFFA4001F08;
|
|
regs.gpr[8] = 0x00000000000000C0;
|
|
regs.gpr[9] = 0x0000000000000000;
|
|
regs.gpr[10] = 0x0000000000000040;
|
|
regs.gpr[11] = 0xFFFFFFFFA4000040;
|
|
regs.gpr[12] = 0xFFFFFFFFC7601FAC;
|
|
regs.gpr[13] = 0xFFFFFFFFC7601FAC;
|
|
regs.gpr[14] = 0xFFFFFFFFB48E2ED6;
|
|
regs.gpr[15] = 0xFFFFFFFFBA1A7D4B;
|
|
regs.gpr[16] = 0x0000000000000000;
|
|
regs.gpr[17] = 0x0000000000000000;
|
|
regs.gpr[18] = 0x0000000000000000;
|
|
regs.gpr[19] = 0x0000000000000000;
|
|
regs.gpr[20] = 0x0000000000000001;
|
|
regs.gpr[21] = 0x0000000000000000;
|
|
regs.gpr[23] = 0x0000000000000001;
|
|
regs.gpr[24] = 0x0000000000000002;
|
|
regs.gpr[25] = 0xFFFFFFFF905F4718;
|
|
regs.gpr[26] = 0x0000000000000000;
|
|
regs.gpr[27] = 0x0000000000000000;
|
|
regs.gpr[28] = 0x0000000000000000;
|
|
regs.gpr[29] = 0xFFFFFFFFA4001FF0;
|
|
regs.gpr[30] = 0x0000000000000000;
|
|
regs.gpr[31] = 0xFFFFFFFFA4001550;
|
|
|
|
regs.lo = 0xFFFFFFFFBA1A7D4B;
|
|
regs.hi = 0xFFFFFFFF997EC317;
|
|
break;
|
|
case CIC_NUS_7102:
|
|
regs.gpr[0] = 0x0000000000000000;
|
|
regs.gpr[1] = 0x0000000000000001;
|
|
regs.gpr[2] = 0x000000001E324416;
|
|
regs.gpr[3] = 0x000000001E324416;
|
|
regs.gpr[4] = 0x0000000000004416;
|
|
regs.gpr[5] = 0x000000000EC5D9AF;
|
|
regs.gpr[6] = 0xFFFFFFFFA4001F0C;
|
|
regs.gpr[7] = 0xFFFFFFFFA4001F08;
|
|
regs.gpr[8] = 0x00000000000000C0;
|
|
regs.gpr[9] = 0x0000000000000000;
|
|
regs.gpr[10] = 0x0000000000000040;
|
|
regs.gpr[11] = 0xFFFFFFFFA4000040;
|
|
regs.gpr[12] = 0x00000000495D3D7B;
|
|
regs.gpr[13] = 0xFFFFFFFF8B3DFA1E;
|
|
regs.gpr[14] = 0x000000004798E4D4;
|
|
regs.gpr[15] = 0xFFFFFFFFF1D30682;
|
|
regs.gpr[16] = 0x0000000000000000;
|
|
regs.gpr[17] = 0x0000000000000000;
|
|
regs.gpr[18] = 0x0000000000000000;
|
|
regs.gpr[19] = 0x0000000000000000;
|
|
regs.gpr[20] = 0x0000000000000000;
|
|
regs.gpr[21] = 0x0000000000000000;
|
|
regs.gpr[22] = 0x000000000000003F;
|
|
regs.gpr[23] = 0x0000000000000007;
|
|
regs.gpr[24] = 0x0000000000000000;
|
|
regs.gpr[25] = 0x0000000013D05CAB;
|
|
regs.gpr[26] = 0x0000000000000000;
|
|
regs.gpr[27] = 0x0000000000000000;
|
|
regs.gpr[28] = 0x0000000000000000;
|
|
regs.gpr[29] = 0xFFFFFFFFA4001FF0;
|
|
regs.gpr[30] = 0x0000000000000000;
|
|
regs.gpr[31] = 0xFFFFFFFFA4001554;
|
|
|
|
regs.lo = 0xFFFFFFFFF1D30682;
|
|
regs.hi = 0x0000000010054A98;
|
|
break;
|
|
case CIC_NUS_6102_7101:
|
|
regs.gpr[0] = 0x0000000000000000;
|
|
regs.gpr[1] = 0x0000000000000001;
|
|
regs.gpr[2] = 0x000000000EBDA536;
|
|
regs.gpr[3] = 0x000000000EBDA536;
|
|
regs.gpr[4] = 0x000000000000A536;
|
|
regs.gpr[5] = 0xFFFFFFFFC0F1D859;
|
|
regs.gpr[6] = 0xFFFFFFFFA4001F0C;
|
|
regs.gpr[7] = 0xFFFFFFFFA4001F08;
|
|
regs.gpr[8] = 0x00000000000000C0;
|
|
regs.gpr[9] = 0x0000000000000000;
|
|
regs.gpr[10] = 0x0000000000000040;
|
|
regs.gpr[11] = 0xFFFFFFFFA4000040;
|
|
regs.gpr[12] = 0xFFFFFFFFED10D0B3;
|
|
regs.gpr[13] = 0x000000001402A4CC;
|
|
regs.gpr[14] = 0x000000002DE108EA;
|
|
regs.gpr[15] = 0x000000003103E121;
|
|
regs.gpr[16] = 0x0000000000000000;
|
|
regs.gpr[17] = 0x0000000000000000;
|
|
regs.gpr[18] = 0x0000000000000000;
|
|
regs.gpr[19] = 0x0000000000000000;
|
|
regs.gpr[20] = 0x0000000000000001;
|
|
regs.gpr[21] = 0x0000000000000000;
|
|
regs.gpr[23] = 0x0000000000000000;
|
|
regs.gpr[24] = 0x0000000000000000;
|
|
regs.gpr[25] = 0xFFFFFFFF9DEBB54F;
|
|
regs.gpr[26] = 0x0000000000000000;
|
|
regs.gpr[27] = 0x0000000000000000;
|
|
regs.gpr[28] = 0x0000000000000000;
|
|
regs.gpr[29] = 0xFFFFFFFFA4001FF0;
|
|
regs.gpr[30] = 0x0000000000000000;
|
|
regs.gpr[31] = 0xFFFFFFFFA4001550;
|
|
|
|
regs.hi = 0x000000003FC18657;
|
|
regs.lo = 0x000000003103E121;
|
|
|
|
if (pal) {
|
|
regs.gpr[20] = 0x0000000000000000;
|
|
regs.gpr[23] = 0x0000000000000006;
|
|
regs.gpr[31] = 0xFFFFFFFFA4001554;
|
|
}
|
|
break;
|
|
case CIC_NUS_6103_7103:
|
|
regs.gpr[0] = 0x0000000000000000;
|
|
regs.gpr[1] = 0x0000000000000001;
|
|
regs.gpr[2] = 0x0000000049A5EE96;
|
|
regs.gpr[3] = 0x0000000049A5EE96;
|
|
regs.gpr[4] = 0x000000000000EE96;
|
|
regs.gpr[5] = 0xFFFFFFFFD4646273;
|
|
regs.gpr[6] = 0xFFFFFFFFA4001F0C;
|
|
regs.gpr[7] = 0xFFFFFFFFA4001F08;
|
|
regs.gpr[8] = 0x00000000000000C0;
|
|
regs.gpr[9] = 0x0000000000000000;
|
|
regs.gpr[10] = 0x0000000000000040;
|
|
regs.gpr[11] = 0xFFFFFFFFA4000040;
|
|
regs.gpr[12] = 0xFFFFFFFFCE9DFBF7;
|
|
regs.gpr[13] = 0xFFFFFFFFCE9DFBF7;
|
|
regs.gpr[14] = 0x000000001AF99984;
|
|
regs.gpr[15] = 0x0000000018B63D28;
|
|
regs.gpr[16] = 0x0000000000000000;
|
|
regs.gpr[17] = 0x0000000000000000;
|
|
regs.gpr[18] = 0x0000000000000000;
|
|
regs.gpr[19] = 0x0000000000000000;
|
|
regs.gpr[20] = 0x0000000000000001;
|
|
regs.gpr[21] = 0x0000000000000000;
|
|
regs.gpr[23] = 0x0000000000000000;
|
|
regs.gpr[24] = 0x0000000000000000;
|
|
regs.gpr[25] = 0xFFFFFFFF825B21C9;
|
|
regs.gpr[26] = 0x0000000000000000;
|
|
regs.gpr[27] = 0x0000000000000000;
|
|
regs.gpr[28] = 0x0000000000000000;
|
|
regs.gpr[29] = 0xFFFFFFFFA4001FF0;
|
|
regs.gpr[30] = 0x0000000000000000;
|
|
regs.gpr[31] = 0xFFFFFFFFA4001550;
|
|
|
|
regs.lo = 0x0000000018B63D28;
|
|
regs.hi = 0x00000000625C2BBE;
|
|
|
|
if (pal) {
|
|
regs.gpr[20] = 0x0000000000000000;
|
|
regs.gpr[23] = 0x0000000000000006;
|
|
regs.gpr[31] = 0xFFFFFFFFA4001554;
|
|
}
|
|
break;
|
|
case CIC_NUS_6105_7105:
|
|
regs.gpr[0] = 0x0000000000000000;
|
|
regs.gpr[1] = 0x0000000000000000;
|
|
regs.gpr[2] = 0xFFFFFFFFF58B0FBF;
|
|
regs.gpr[3] = 0xFFFFFFFFF58B0FBF;
|
|
regs.gpr[4] = 0x0000000000000FBF;
|
|
regs.gpr[5] = 0xFFFFFFFFDECAAAD1;
|
|
regs.gpr[6] = 0xFFFFFFFFA4001F0C;
|
|
regs.gpr[7] = 0xFFFFFFFFA4001F08;
|
|
regs.gpr[8] = 0x00000000000000C0;
|
|
regs.gpr[9] = 0x0000000000000000;
|
|
regs.gpr[10] = 0x0000000000000040;
|
|
regs.gpr[11] = 0xFFFFFFFFA4000040;
|
|
regs.gpr[12] = 0xFFFFFFFF9651F81E;
|
|
regs.gpr[13] = 0x000000002D42AAC5;
|
|
regs.gpr[14] = 0x00000000489B52CF;
|
|
regs.gpr[15] = 0x0000000056584D60;
|
|
regs.gpr[16] = 0x0000000000000000;
|
|
regs.gpr[17] = 0x0000000000000000;
|
|
regs.gpr[18] = 0x0000000000000000;
|
|
regs.gpr[19] = 0x0000000000000000;
|
|
regs.gpr[20] = 0x0000000000000001;
|
|
regs.gpr[21] = 0x0000000000000000;
|
|
regs.gpr[23] = 0x0000000000000000;
|
|
regs.gpr[24] = 0x0000000000000002;
|
|
regs.gpr[25] = 0xFFFFFFFFCDCE565F;
|
|
regs.gpr[26] = 0x0000000000000000;
|
|
regs.gpr[27] = 0x0000000000000000;
|
|
regs.gpr[28] = 0x0000000000000000;
|
|
regs.gpr[29] = 0xFFFFFFFFA4001FF0;
|
|
regs.gpr[30] = 0x0000000000000000;
|
|
regs.gpr[31] = 0xFFFFFFFFA4001550;
|
|
|
|
regs.lo = 0x0000000056584D60;
|
|
regs.hi = 0x000000004BE35D1F;
|
|
|
|
if (pal) {
|
|
regs.gpr[20] = 0x0000000000000000;
|
|
regs.gpr[23] = 0x0000000000000006;
|
|
regs.gpr[31] = 0xFFFFFFFFA4001554;
|
|
}
|
|
|
|
mem.Write32(regs, IMEM_REGION_START + 0x00, 0x3C0DBFC0);
|
|
mem.Write32(regs, IMEM_REGION_START + 0x04, 0x8DA807FC);
|
|
mem.Write32(regs, IMEM_REGION_START + 0x08, 0x25AD07C0);
|
|
mem.Write32(regs, IMEM_REGION_START + 0x0C, 0x31080080);
|
|
mem.Write32(regs, IMEM_REGION_START + 0x10, 0x5500FFFC);
|
|
mem.Write32(regs, IMEM_REGION_START + 0x14, 0x3C0DBFC0);
|
|
mem.Write32(regs, IMEM_REGION_START + 0x18, 0x8DA80024);
|
|
mem.Write32(regs, IMEM_REGION_START + 0x1C, 0x3C0BB000);
|
|
break;
|
|
case CIC_NUS_6106_7106:
|
|
regs.gpr[0] = 0x0000000000000000;
|
|
regs.gpr[1] = 0x0000000000000000;
|
|
regs.gpr[2] = 0xFFFFFFFFA95930A4;
|
|
regs.gpr[3] = 0xFFFFFFFFA95930A4;
|
|
regs.gpr[4] = 0x00000000000030A4;
|
|
regs.gpr[5] = 0xFFFFFFFFB04DC903;
|
|
regs.gpr[6] = 0xFFFFFFFFA4001F0C;
|
|
regs.gpr[7] = 0xFFFFFFFFA4001F08;
|
|
regs.gpr[8] = 0x00000000000000C0;
|
|
regs.gpr[9] = 0x0000000000000000;
|
|
regs.gpr[10] = 0x0000000000000040;
|
|
regs.gpr[11] = 0xFFFFFFFFA4000040;
|
|
regs.gpr[12] = 0xFFFFFFFFBCB59510;
|
|
regs.gpr[13] = 0xFFFFFFFFBCB59510;
|
|
regs.gpr[14] = 0x000000000CF85C13;
|
|
regs.gpr[15] = 0x000000007A3C07F4;
|
|
regs.gpr[16] = 0x0000000000000000;
|
|
regs.gpr[17] = 0x0000000000000000;
|
|
regs.gpr[18] = 0x0000000000000000;
|
|
regs.gpr[19] = 0x0000000000000000;
|
|
regs.gpr[20] = 0x0000000000000001;
|
|
regs.gpr[21] = 0x0000000000000000;
|
|
regs.gpr[23] = 0x0000000000000000;
|
|
regs.gpr[24] = 0x0000000000000002;
|
|
regs.gpr[25] = 0x00000000465E3F72;
|
|
regs.gpr[26] = 0x0000000000000000;
|
|
regs.gpr[27] = 0x0000000000000000;
|
|
regs.gpr[28] = 0x0000000000000000;
|
|
regs.gpr[29] = 0xFFFFFFFFA4001FF0;
|
|
regs.gpr[30] = 0x0000000000000000;
|
|
regs.gpr[31] = 0xFFFFFFFFA4001550;
|
|
regs.lo = 0x000000007A3C07F4;
|
|
regs.hi = 0x0000000023953898;
|
|
|
|
if (pal) {
|
|
regs.gpr[20] = 0x0000000000000000;
|
|
regs.gpr[23] = 0x0000000000000006;
|
|
regs.gpr[31] = 0xFFFFFFFFA4001554;
|
|
}
|
|
break;
|
|
}
|
|
|
|
regs.gpr[22] = (cicSeeds[cicType] >> 8) & 0xFF;
|
|
regs.cop0.Reset();
|
|
mem.Write32(regs, 0x04300004, 0x01010101);
|
|
memcpy(mem.mmio.rsp.dmem, mem.rom.cart, 0x1000);
|
|
regs.SetPC32(0xA4000040);
|
|
}
|
|
|
|
void PIF::ExecutePIF(Mem& mem, Registers& regs) {
|
|
CICType cicType = mem.rom.cicType;
|
|
bool pal = mem.rom.pal;
|
|
mem.Write32(regs, PIF_RAM_REGION_START + 0x24, cicSeeds[cicType]);
|
|
switch(cicType) {
|
|
case UNKNOWN_CIC_TYPE:
|
|
Util::warn("Unknown CIC type!\n");
|
|
break;
|
|
case CIC_NUS_6101 ... CIC_NUS_6103_7103:
|
|
mem.Write32(regs, 0x318, RDRAM_SIZE);
|
|
break;
|
|
case CIC_NUS_6105_7105:
|
|
mem.Write32(regs, 0x3F0, RDRAM_SIZE);
|
|
break;
|
|
case CIC_NUS_6106_7106:
|
|
break;
|
|
}
|
|
|
|
DoPIFHLE(mem, regs, pal, cicType);
|
|
}
|
|
} |