void GetScienceAndSensorReading(int idx)
{
char str[1024];
printf("=== SCIENCE READING ===\n");
FillKeyboardBufferString("SCI-OV 32 .READINGS\n");
Continue();
sprintf(str, "%i %i SENSE-ADDR 1.5!\n",
planets[idx].instanceoffset&0xFFFF, planets[idx].instanceoffset>>16
);
FillKeyboardBufferString(str);
Continue();
FillKeyboardBufferString("AN-OV\n");
Continue();
// Patch science level
Write16(0xedc9, 0x0f30-2); // 1
Write16(0xedc9+2, 0x1692-2); // EXIT
printf("=== SENSOR READING ===\n");
FillKeyboardBufferString("32 (/ANALYSIS)\n");
Continue();
fflush(stdout);
}
static void WriteHeader (void)
/* Write the header to the library file */
{
/* Seek to position zero */
fseek (NewLib, 0, SEEK_SET);
/* Write the header fields */
Write32 (NewLib, Header.Magic);
Write16 (NewLib, Header.Version);
Write16 (NewLib, Header.Flags);
Write32 (NewLib, Header.IndexOffs);
}
bool ScriptLineBuffer::WriteString(const char* buf)
{
UInt32 len = strlen(buf);
if (len < 0x10000 && Write16(len))
return Write(buf, strlen(buf));
return false;
}
static void WriteIndexEntry (const ObjData* O)
/* Write one index entry */
{
/* Module name/flags/MTime/start/size */
WriteStr (NewLib, O->Name);
Write16 (NewLib, O->Flags & ~OBJ_HAVEDATA);
Write32 (NewLib, O->MTime);
Write32 (NewLib, O->Start);
Write32 (NewLib, O->Size);
}
NS_IMETHODIMP
nsBinaryOutputStream::WriteID(const nsIID& aIID)
{
nsresult rv = Write32(aIID.m0);
NS_ENSURE_SUCCESS(rv, rv);
rv = Write16(aIID.m1);
NS_ENSURE_SUCCESS(rv, rv);
rv = Write16(aIID.m2);
NS_ENSURE_SUCCESS(rv, rv);
for (int i = 0; i < 8; ++i) {
rv = Write8(aIID.m3[i]);
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
void Io::ClearOthers ()
{
// FIXME !! shouldn't we call Write*() ?
// lcd
for (uint8_t i = 0x0; i < 0x56; i += 2)
Write16(i, 0x0000);
// dma
for (uint8_t i = 0xB0; i < 0xE0; i += 4)
Write32(i, 0x0000);
// FIXME : should timers be set to 0 too ? (vba does not)
W8(HALTCNT, 0xFF); // normal mode (internal)
W16(IE, 0x0000);
W16(IF, 0x0000);
W16(IME, 0x0000);
Write16(WAITCNT, 0x0000);
W16(BG2PA, 0x0100);
W16(BG2PD, 0x0100);
W16(BG3PA, 0x0100);
W16(BG3PD, 0x0100);
}
/// writes UTF-8 encoded string
void WriteString(const CString& csz)
{
if (csz.GetLength() > std::numeric_limits<unsigned short>::max())
throw Exception(_T("string too long!"), __FILE__, __LINE__);
Write16(static_cast<unsigned short>(csz.GetLength()));
USES_CONVERSION;
LPCSTR pszaText = T2CA(static_cast<LPCTSTR>(csz));
const unsigned char* p = reinterpret_cast<const unsigned char*>(pszaText);
WriteBlock(p, csz.GetLength());
}
NS_IMETHODIMP
nsBinaryOutputStream::WriteID(const nsIID& aIID)
{
nsresult rv = Write32(aIID.m0);
if (NS_WARN_IF(NS_FAILED(rv)))
return rv;
rv = Write16(aIID.m1);
if (NS_WARN_IF(NS_FAILED(rv)))
return rv;
rv = Write16(aIID.m2);
if (NS_WARN_IF(NS_FAILED(rv)))
return rv;
for (int i = 0; i < 8; ++i) {
rv = Write8(aIID.m3[i]);
if (NS_WARN_IF(NS_FAILED(rv)))
return rv;
}
return NS_OK;
}
void WriteBlock(const VAddr addr, const u8* data, const size_t size) {
u32 offset = 0;
while (offset < (size & ~3)) {
Write32(addr + offset, *(u32*)&data[offset]);
offset += 4;
}
if (size & 2) {
Write16(addr + offset, *(u16*)&data[offset]);
offset += 2;
}
if (size & 1)
Write8(addr + offset, data[offset]);
}
static void write_frame_controller_data()
{
reserve_buffer_space((uint32)((Movie.InputBufferPtr+Movie.BytesPerFrame)-Movie.InputBuffer));
int i;
for(i=0; i<5; ++i)
{
if(Movie.ControllersMask & (1<<i))
{
Write16((uint16)(IPPU.Joypads[i] & 0xffff), Movie.InputBufferPtr);
}
else
{
IPPU.Joypads[i]=0; // pretend the controller is disconnected
}
}
}
static void write_frame_controller_data()
{
reserve_buffer_space((uint32)((Movie.InputBufferPtr+Movie.BytesPerSample)-Movie.InputBuffer));
int i;
for(i=0; i<8; ++i)
{
if(Movie.ControllersMask & (1<<i))
{
Write16((uint16)(MovieGetJoypad(i) & 0xffff), Movie.InputBufferPtr);
}
else
{
MovieSetJoypad(i, 0); // pretend the controller is disconnected
}
}
#ifdef PERIPHERAL_SUPPORT
for(int port=0; port<2; port++)
{
if(Movie.PortType[port] == CTL_MOUSE)
{
uint8 buf [MOUSE_DATA_SIZE];
MovieGetMouse(port, buf);
memcpy(Movie.InputBufferPtr, buf, MOUSE_DATA_SIZE);
Movie.InputBufferPtr += MOUSE_DATA_SIZE;
}
if(Movie.PortType[port] == CTL_SUPERSCOPE)
{
uint8 buf [SCOPE_DATA_SIZE];
MovieGetScope(port, buf);
memcpy(Movie.InputBufferPtr, buf, SCOPE_DATA_SIZE);
Movie.InputBufferPtr += SCOPE_DATA_SIZE;
}
if(Movie.PortType[port] == CTL_JUSTIFIER)
{
uint8 buf [JUSTIFIER_DATA_SIZE];
MovieGetJustifier(port, buf);
memcpy(Movie.InputBufferPtr, buf, JUSTIFIER_DATA_SIZE);
Movie.InputBufferPtr += JUSTIFIER_DATA_SIZE;
}
}
#endif
}
void WriteEhdr(const fs::file& f, Elf32_Ehdr& ehdr)
{
Write32(f, ehdr.e_magic);
Write8(f, ehdr.e_class);
Write8(f, ehdr.e_data);
Write8(f, ehdr.e_curver);
Write8(f, ehdr.e_os_abi);
Write64(f, ehdr.e_abi_ver);
Write16(f, ehdr.e_type);
Write16(f, ehdr.e_machine);
Write32(f, ehdr.e_version);
Write32(f, ehdr.e_entry);
Write32(f, ehdr.e_phoff);
Write32(f, ehdr.e_shoff);
Write32(f, ehdr.e_flags);
Write16(f, ehdr.e_ehsize);
Write16(f, ehdr.e_phentsize);
Write16(f, ehdr.e_phnum);
Write16(f, ehdr.e_shentsize);
Write16(f, ehdr.e_shnum);
Write16(f, ehdr.e_shstrndx);
}
int ExecuteCollisionScript(unsigned int ColScriptSeg, unsigned int ColScriptPos)
{
/* SM64 Collision format
[command][...data...][command][...data...][command][...data...] etc
COMMAND[16bits] DATA DESC
0x0000-0x003F xxxx[aaaabbbbcccc[vvvv*]] Polygons, type is command, number of tris is x, each tri is 6 bytes, two for each tri
v is variable for certain types of polygons, making each poly 8 bytes. see list below
0x0040 xxxx[aaaabbbbcccc] Load x number of verts, each vertex being 6 bytes (3 signed 16 bit x/y/z)
0x0041 NOP
0x0042 End collision data
0x0043 ???? ?
0x0044 xxxx[aaaabbbbccccddddeeeeffff] Water
0x004D aaaabbbbccccdddd ?
0x0045-0x0064 ? ?
0x0065-0x00F8 See Polygons above.
* these polygon types are 8 bytes each: 000E, 002C, 0024, 0025, 0027, 002D
if you don't understand this just breakpoint the start of the collision data, the routines explain it all.
*/
dmsg("\nExecuting collision script for level area 0x%02X...\n", LevelArea);
bool EndOfColScript = false;
bool _0x40read = false;
unsigned int CurrentColCmd = 0;
unsigned int VtxCount;
unsigned short WaterCount;
signed short x1, x2, y, z1, z2;
int i;
while (!(EndOfColScript))
{
CurrentColCmd = Read16(RAMSegment[ColScriptSeg].Data, ColScriptPos);
switch(CurrentColCmd)
{
case 0x0041: // "nop"
ColScriptPos+=2;
break;
case 0x0042: // End marker
ColScriptEnd:
EndOfColScript = true;
break;
case 0x0043: // Special objects?
{
unsigned short CollisionSpecialCount = Read16(RAMSegment[ColScriptSeg].Data, ColScriptPos + 2);
dmsg("- %i Special collision objects [ignored]\n", CollisionSpecialCount);
ColScriptPos += (CollisionSpecialCount << 3) + 2;
// hackish code gtfo
unsigned short CurrHalfWord = 0;
while (1)
{
CurrHalfWord = Read16(RAMSegment[ColScriptSeg].Data, ColScriptPos);
if(CurrHalfWord == 0x0044)
goto ColScriptWater;
if(CurrHalfWord == 0x0042)
goto ColScriptEnd;
ColScriptPos+=2;
}
break;
}
case 0x0044: // Water
{
ColScriptWater:
WaterCount = Read16(RAMSegment[ColScriptSeg].Data, ColScriptPos + 2);
ColScriptPos+=4;
ZWaterCount += WaterCount;
dmsg("- %i Water boxes\n", WaterCount);
for (i = 0; i < WaterCount; i++)
{
ColScriptPos+=2; // ID of mesh
x1 = Read16(RAMSegment[ColScriptSeg].Data, ColScriptPos); ColScriptPos+=2;
z1 = Read16(RAMSegment[ColScriptSeg].Data, ColScriptPos); ColScriptPos+=2;
x2 = Read16(RAMSegment[ColScriptSeg].Data, ColScriptPos); ColScriptPos+=2;
z2 = Read16(RAMSegment[ColScriptSeg].Data, ColScriptPos); ColScriptPos+=2;
y = Read16(RAMSegment[ColScriptSeg].Data, ColScriptPos); ColScriptPos+=2;
x1 /= SCALE;
z1 /= SCALE;
x2 /= SCALE;
z2 /= SCALE;
y /= SCALE;
x2 -= x1;
z2 -= z1;
Write16(ZWaterBuffer, ZWaterOffset, x1);
Write16(ZWaterBuffer, ZWaterOffset+2, y);
Write16(ZWaterBuffer, ZWaterOffset+4, z1);
Write16(ZWaterBuffer, ZWaterOffset+6, x2);
Write16(ZWaterBuffer, ZWaterOffset+8, z2);
ZWaterOffset += 0x10;
dmsg(" - Water Box %d: X1 %5i, X2 %5i, Y %5i, Z1 %5i, Z2 %5i\n", i, x1, x2, y, z1, z2);
}
break;
}
case 0x004D:
ColScriptPos+=0xA;
break;
case 0x0040: // Verts
{
if (_0x40read) ColVtxCount += _ColVtxCount;
_0x40read = true;
VtxCount = Read16(RAMSegment[ColScriptSeg].Data, ColScriptPos + 2);
_ColVtxCount = VtxCount;
unsigned int BufferSize = VtxCount * 6;
memcpy(&ColVtxBuffer[ColVtxCount], &RAMSegment[ColScriptSeg].Data[ColScriptPos + 4], BufferSize);
dmsg("- VtxCount %i ColVtxCount %i\n",VtxCount,ColVtxCount);
// scale verts
for (i=ColVtxCount; i<(ColVtxCount+BufferSize); i+=6)
{
/* Read */
x1 = Read16(ColVtxBuffer, i);
y = Read16(ColVtxBuffer, i+2);
z1 = Read16(ColVtxBuffer, i+4);
/* Scale */
x1 /= SCALE;
y /= SCALE;
z1 /= SCALE;
/* Write */
Write16(ColVtxBuffer, i+0, x1);
Write16(ColVtxBuffer, i+2, y);
Write16(ColVtxBuffer, i+4, z1);
}
ColScriptPos += BufferSize + 4;
break;
}
default:
{
if ((CurrentColCmd < 0x40)||(CurrentColCmd >= 0x65))
{
unsigned short ColType = CurrentColCmd & 0xFFFF;
unsigned short TriCount = Read16(RAMSegment[ColScriptSeg].Data, ColScriptPos + 2);
ColScriptPos += 4;
ColTriCount += TriCount;
unsigned short p1, p2, p3;
int _inc = ((ColType == 0x000E) ||
(ColType == 0x002C) ||
(ColType == 0x0024) ||
(ColType == 0x0025) ||
(ColType == 0x0027) ||
(ColType == 0x002D)) ? 8 : 6;
dmsg("- ColType: 0x%04X ZTriOffset 0x%04X TriCount %04i ColTriCount %04i\n",ColType,ZTriOffset,TriCount,ColTriCount);
for(i = 0; i < TriCount; i++)
{
p1 = ColVtxCount + (Read16(RAMSegment[ColScriptSeg].Data, ColScriptPos));
p2 = ColVtxCount + (Read16(RAMSegment[ColScriptSeg].Data, ColScriptPos + 2));
p3 = ColVtxCount + (Read16(RAMSegment[ColScriptSeg].Data, ColScriptPos + 4));
if((p1>ColVtxCount+_ColVtxCount)||(p2>ColVtxCount+_ColVtxCount)||(p3>ColVtxCount+_ColVtxCount))
{
msg(1, "WARNING: Collision vertex overflow!!!: %04i/%04i/%04i;max %04i", p1, p2, p3, ColVtxCount+_ColVtxCount);
EndOfColScript = true;
return -1; /* i hope this raises an error */
}
Write16(ColTriBuffer, ZTriOffset+2, p1);
Write16(ColTriBuffer, ZTriOffset+4, p2);
Write16(ColTriBuffer, ZTriOffset+6, p3);
ZTriOffset += 16;
ColScriptPos += _inc;
}
}
else
{
dmsg("Unknown collision command: %04X\n", CurrentColCmd);
EndOfColScript= true;
}
break;
}
}
}
ColVtxCount += _ColVtxCount;
return 0;
}
void Io::Write32 (uint32_t add, uint32_t val)
{
//debug ("IO Write32 at " << IOS_ADD << add << " of " << IOS_ADD << val);
switch (add & 0xFF)
{
case DMA1DAD:
case DMA0SAD:
case DMA1SAD:
case DMA2SAD:
case DMA3SAD:
case DMA0DAD:
case DMA2DAD:
case DMA3DAD:
W32(add, val);
break;
case BG0HOFS:
case BG1HOFS:
case BG2HOFS:
case BG3HOFS:
Write16(add, val & 0xFFFF);
Write16(add+2, val >> 16);
break;
case BG2X_L:
W32(add, val & 0x0FFFFFFF);
LCD.UpdateBg2RefX(IO.DRead32(Io::BG2X_L));
break;
case BG2Y_L:
W32(add, val & 0x0FFFFFFF);
LCD.UpdateBg2RefY(IO.DRead32(Io::BG2Y_L));
break;
case BG3X_L:
W32(add, val & 0x0FFFFFFF);
LCD.UpdateBg3RefX(IO.DRead32(Io::BG3X_L));
break;
case BG3Y_L:
W32(add, val & 0x0FFFFFFF);
LCD.UpdateBg3RefY(IO.DRead32(Io::BG3Y_L));
break;
case BG2PA:
case BG2PC:
case BG3PA:
case BG3PC:
case WIN0H:
case WIN0V:
case WININ:
Write16(add, val & 0xFFFF);
Write16(add+2, val >> 16);
break;
case DMA0CNT_L:
case DMA1CNT_L:
case DMA2CNT_L:
case DMA3CNT_L:
Write16(add, val & 0xFFFF);
Write16(add+2, val >> 16);
break;
case FIFO_A:
case FIFO_B:
// TODO
break;
default:
//met_abort("Unknown IO at " << IOS_ADD << add);
//*(uint32_t*)(m_iomem + (add & 0xFFF)) = val;
Write16(add, val & 0xFFFF);
Write16(add+2, val >> 16);
break;
}
}
void setWildPokemonfromAddress( u32 pokemonAddress,
u32 pokemonVariation,
u32 pokemonLevel,
bool enableObtainedCheck,
bool updatePokeRadar)
{
if (PointerOffset != 0x00)
{
unsigned int ZOOffset = Read32(PointerOffset);
//Check for valid pointer
if ((ZOOffset >= 0x08000000) && (ZOOffset < 0x08DF0000))
{
//Check if ZO File contains encounter data
if (Read32(ZOOffset + 0x10) != Read32(ZOOffset + 0x14))
{
unsigned int EncOffset = ZOOffset + Read32(ZOOffset + 0x10) + ByteJump;
int i;
int pokemon=1;
u32 currentEncOffset;
for (i = 0; i < EncDataLength; i += 4)
{
if (Read8(EncOffset + i + 2) != 0x01)
{
currentEncOffset=EncOffset+i;
//setPokemon
if(pokemonAddress>1)
pokemon=Read16(pokemonAddress);
else if(pokemonAddress==1)
pokemon=GetRandomPokemon(enableObtainedCheck);
else
pokemon=Read16(currentEncOffset);
//setPokemonVariation
if(pokemonVariation>1)
pokemon+=0x800 *(Read16(pokemonVariation)-1);
else if(pokemonVariation==1)
pokemon=getRandomVariation(pokemon);
//setPokemonLevel
if(pokemonLevel>1)
{
u8 level=Read8(pokemonLevel);
if(level<2)
level=2;
Write8(currentEncOffset+2, level);
}
else if(pokemonLevel==1)
Write8(currentEncOffset+2, RandMinMax(2,100));
//Write8(EncOffset + i+3, 1); //maybefiller?
Write16(currentEncOffset, pokemon);
}
}
//Update DexNav
if(updatePokeRadar&&curEdition==ORAS)
{
int j;
for (i = 0; i < 96; i++)
{
for (j = 0; j < EncDataLength; j += 4)
{
Write32(0x16B3E7B6 + (0x104 * i) + j, Read32(EncOffset + j));
}
}
}
}
}
}
}
void Patch_EsModule(u32 version)
{
switch (version) {
/** 06/03/09 03:45:06 **/
case 0x4A25F1C2:
/* Signature check */
Write16(0x13A752E6, 0x2000);
/* Identify check */
Write16(0x20100D4A, 0x2803);
Write16(0x20100DC2, 0x2803);
/* Open content permissions */
Write8(0x20104D7A, 0xE0);
Write8(0x20104D9E, 0xE0);
Write8(0x20104DC2, 0xE0);
/* Read content permissions */
Write16(0x20104EBC, 0x46C0);
Write16(0x20104EC0, 0x46C0);
Write8 (0x20104EC4, 0xE0);
/* Close content permissions */
Write16(0x20104F58, 0x46C0);
Write16(0x20104F5C, 0x46C0);
Write8 (0x20104F60, 0xE0);
/* Set UID check */
Write16(0x2010522A, 0x46C0);
/* Title version check */
Write8(0x201027AC, 0xE0);
/* Title delete check */
Write8(0x20107B22, 0xE0);
break;
/** 06/03/09 03:36:55 **/
case 0x4A25EFD7:
/* Signature check */
Write16(0x13A750A6, 0x2000);
/* Identify check */
Write16(0x20100CC8, 0x2803);
Write16(0x20100D40, 0x2803);
/* Open content permissions */
Write8(0x20104B68, 0xE0);
Write8(0x20104B8C, 0xE0);
/* Read content permissions */
Write16(0x20104C84, 0x46C0);
Write16(0x20104C88, 0x46C0);
Write8 (0x20104C8C, 0xE0);
/* Close content permissions */
Write16(0x20104D20, 0x46C0);
Write16(0x20104D24, 0x46C0);
Write8 (0x20104D28, 0xE0);
/* Set UID check */
Write16(0x20104FF2, 0x46C0);
/* Title version check */
Write8(0x20102724, 0xE0);
/* Title delete check */
Write8(0x20107682, 0xE0);
break;
/** 06/03/09 07:46:02 **/
case 0x4A262A3A:
/* Signature check */
Write16(0x13A75626, 0x2000);
/* Identify check */
Write16(0x20100E74, 0x2803);
Write16(0x20100EEC, 0x2803);
/* Open content permissions */
Write8(0x20105290, 0xE0);
Write8(0x201052D0, 0xE0);
Write8(0x201052F4, 0xE0);
/* Read content permissions */
Write16(0x201053FC, 0x46C0);
Write16(0x20105400, 0x46C0);
Write8 (0x20105404, 0xE0);
/* Close content permissions */
Write16(0x20105498, 0x46C0);
Write16(0x2010549C, 0x46C0);
Write8 (0x201054A0, 0xE0);
/* Set UID check */
Write16(0x2010576A, 0x46C0);
/* Title version check */
Write8(0x20102C74, 0xE0);
/* Title delete check */
Write8(0x2010849A, 0xE0);
/* Decrypt check */
Write8(0x2010650C, 0xE0);
break;
/** 11/24/08 15:36:08 **/
case 0x492AC9E8:
/* Signature check */
Write16(0x13A754FA, 0x2000);
Write16(0x13A756A6, 0x2000);
/* Identify check */
Write16(0x20100DA4, 0x2803);
Write16(0x20100E1C, 0x2803);
/* Open content permissions */
Write8(0x20104D60, 0xE0);
Write8(0x20104DA0, 0xE0);
Write8(0x20104DC4, 0xE0);
/* Read content permissions */
Write16(0x20104ECC, 0x46C0);
Write16(0x20104ED0, 0x46C0);
Write8 (0x20104ED4, 0xE0);
/* Close content permissions */
Write16(0x20104F68, 0x46C0);
Write16(0x20104F6C, 0x46C0);
Write8 (0x20104F70, 0xE0);
/* Set UID check */
Write16(0x2010523A, 0x46C0);
/* Title version check */
Write8(0x20102800, 0xE0);
/* Title delete check */
Write8(0x20107B32, 0xE0);
/* Decrypt check */
Write8(0x20105FD0, 0xE0);
break;
/** 03/03/10 10:40:14 **/
case 0x4B8E90EE:
/* Signature check */
Write16(0x13A75626, 0x2000);
/* Identify check */
Write16(0x20100E74, 0x2803);
Write16(0x20100EEC, 0x2803);
/* Open content permissions */
Write8(0x201052E4, 0xE0);
Write8(0x20105324, 0xE0);
Write8(0x20105348, 0xE0);
/* Read content permissions */
Write16(0x20105450, 0x46C0);
Write16(0x20105454, 0x46C0);
Write8 (0x20105458, 0xE0);
/* Close content permissions */
Write16(0x201054A0, 0x46C0);
Write16(0x201054A4, 0x46C0);
Write8 (0x201054A8, 0xE0);
/* Set UID check */
Write16(0x201057BE, 0x46C0);
/* Title version check */
Write8(0x20102CB8, 0xE0);
/* Title delete check */
Write8(0x20108562, 0xE0);
break;
/** 03/01/10 03:26:03 **/
case 0x4B8B882B:
/* Signature check */
Write16(0x13A752E6, 0x2000);
/* Identify check */
Write16(0x20100D46, 0x2803);
Write16(0x20100DBE, 0x2803);
/* Open content permissions */
Write8(0x20104DF6, 0xE0);
Write8(0x20104E1A, 0xE0);
Write8(0x20104E3E, 0xE0);
/* Read content permissions */
Write16(0x20104F38, 0x46C0);
Write16(0x20104F3C, 0x46C0);
Write8 (0x20104F40, 0xE0);
/* Close content permissions */
Write16(0x20104F88, 0x46C0);
Write16(0x20104F8C, 0x46C0);
Write8 (0x20104F90, 0xE0);
/* Set UID check */
Write16(0x201052A6, 0x46C0);
/* Title version check */
Write8(0x20102818, 0xE0);
/* Title delete check */
Write8(0x20107BAA, 0xE0);
break;
/** 03/01/10 03:18:58 **/
case 0x4B8B8682:
/* Signature check */
Write16(0x13A75266, 0x2000);
/* Identify check */
Write16(0x20100CC4, 0x2803);
Write16(0x20100D3C, 0x2803);
/* Open content permissions */
Write8(0x20104B20, 0xE0);
Write8(0x20104B44, 0xE0);
/* Read content permissions */
Write16(0x20104C3C, 0x46C0);
Write16(0x20104C40, 0x46C0);
Write8 (0x20104C44, 0xE0);
/* Close content permissions */
Write16(0x20104C8C, 0x46C0);
Write16(0x20104C90, 0x46C0);
Write8 (0x20104C94, 0xE0);
/* Set UID check */
Write16(0x20104FAA, 0x46C0);
/* Title version check */
Write8(0x201026CC, 0xE0);
/* Title delete check */
Write8(0x20107642, 0xE0);
break;
}
}
void Io::Write8 (uint32_t add, uint8_t val)
{
//debug ("IO Write8 at " << IOS_ADD << add << " of " << IOS_ADD << (int)val);
switch (add & 0xFFF)
{
case NR10+1:
case NR52+1:
case NR52+2:
case NR52+3:
break;
case NR10:
case NR11:
case NR13:
case NR21:
case NR23:
case NR41:
case NR43:
case NR50:
case NR51:
case SOUNDCNT_H:
W8(add, val);
break;
case NR12:
W8(add, val);
if (!(val & (0xF << 4)))
SOUND.ResetSound1Envelope();
break;
case NR14:
W8(add, val & 0xC7);
if (val & (0x1 << 7))
SOUND.ResetSound1();
break;
case NR22:
W8(add, val);
if (!(val & (0xF << 4)))
SOUND.ResetSound2Envelope();
break;
case NR24:
W8(add, val & 0xC7);
if (val & (0x1 << 7))
SOUND.ResetSound2();
break;
case NR42:
W8(add, val);
if (!(val & (0xF << 4)))
SOUND.ResetSound4Envelope();
break;
case NR44:
W8(add, val & 0xC7);
if (val & (0x1 << 7))
SOUND.ResetSound4();
break;
case SOUNDCNT_H+1:
W8(add, val);
SOUND.UpdateCntH1(val);
break;
case NR52:
// this will also reset the sound on flags
W8(add, val & 0x80);
break;
case POSTFLG:
// FIXME is this right, i have no idea about why i should do that
if (val)
val &= 0xFE;
W8(add, val);
break;
case HALTCNT:
W8(add, val);
break;
default:
//W8(add, val);
// TODO make a function which will apply masks to IO memory and trigger
// the update functions, this function will be called by write8 and
// write16
#if 1
add &= 0xFFF;
if (add % 2)
Write16(add & ~0x1, (val << 8) | m_iomem[add & ~0x1]);
else
Write16(add, (m_iomem[add | 0x1] << 8) | val);
#endif
break;
}
}
bool MemoryBase::Write16NN(u64 addr, const u16 data)
{
if(!IsGoodAddr(addr, 2)) return false;
Write16(addr, data);
return true;
}
