Major reformatting, cleaning up black magic

7 files changed, 121 insertions, 1082 deletions

@@ -1,9 +1,9 @@
 /*
- * Pokemon Gen III Data Extractor by hatkirby 2017.
+ * Copyright (C) 2017 hatkirby
+ * Copyright (C) 2017 slipstream/RoL
  *
  * This software may be modified and distributed under the terms
  * of the MIT license.  See the LICENSE file for details.
- *
  */
 #include "gamedata.h"
 
@@ -245,9 +245,10 @@ bool initSaveData(
     }
 
     /// --- FR/LG ---
-    // In FR/LG, the function that initialises the save-block pointers to default does not set up saveblock3.
-    // Which will need to be set up before loading the save if we want boxed Pokémon to not disappear.
-    // Oh, and loadsave() offset is different between FR and LG...
+    // In FR/LG, the function that initialises the save-block pointers to
+    // default does not set up saveblock3. Which will need to be set up before
+    // loading the save if we want boxed Pokémon to not disappear. Oh, and
+    // loadsave() offset is different between FR and LG...
 
     case 'DRPB': // FireRed German
     case 'DGPB': // LeafGreen German
@@ -376,12 +377,14 @@ bool initSaveData(
           {
             // LeafGreen v1.1 Japanese is undumped.
             // Therefore, it is unsupported.
-            // I will make guesses at the offsets in the comments, but I will not actually implement them until LeafGreen v1.1 is dumped.
+            // I will make guesses at the offsets in the comments, but I will
+            // not actually implement them until LeafGreen v1.1 is dumped.
 
             return false;
           }
 
-          loadsave = (void(*)(char)) 0x80db529; // potential LG1.1 address: 0x80db4fd
+          loadsave = (void(*)(char)) 0x80db529;
+          // potential LG1.1 address: 0x80db4fd
           //mainloop = (void(*)()) 0x8000417;
           //titlemid = 0x8078987;
           //load_pokemon = (void(*)()) 0x804b9c5;
@@ -399,8 +402,10 @@ bool initSaveData(
     }
 
     /// --- Emerald ---
-    // In Emerald, the saveblock pointer that isn't set up is saveblock1 (in FR/LG it was saveblock3).
-    // The initial save loading code after the copyright screen is also updated, now it sets up ASLR/crypto here before loading the save.
+    // In Emerald, the saveblock pointer that isn't set up is saveblock1 (in
+    // FR/LG it was saveblock3). The initial save loading code after the
+    // copyright screen is also updated, now it sets up ASLR/crypto here before
+    // loading the save.
 
     case 'DEPB': // Emerald German
     {
@@ -493,42 +498,15 @@ bool initSaveData(
   }
 
   loadsave(0);
-//      sendS32(-1);
+
   // now the save is loaded, we can do what we want with the loaded blocks.
-  // first, we're going to want to decrypt the parts that are crypted, if applicable.
+  // first, we're going to want to decrypt the parts that are crypted, if
+  // applicable.
   decryptSaveStructures(gSaveBlock1,gSaveBlock2,gSaveBlock3);
 
   *SaveBlock1 = gSaveBlock1;
   *SaveBlock2 = gSaveBlock2;
   *SaveBlock3 = gSaveBlock3;
 
-  /*
-  // time to call the payload.
-  payload(gSaveBlock1,gSaveBlock2,gSaveBlock3);
-  // Now, we better call the function that sets the pokemon-related stuff from the structure elements of the loaded save again.
-  // Just in case the payload did something with that.
-  load_pokemon();
-  // In FR/LG/Emerald, just returning to the game is unwise.
-  // The game reloads the savefile.
-  // In FR/LG, this is done at the title screen after setting ASLR/saveblock-crypto up. (probably because at initial save-load, SaveBlock3 ptr isn't set up lol)
-  // So, better bypass the title screen and get the game to return directly to the Continue/New Game screen.
-  // In Emerald, the save reload happens after the Continue option was chosen, so we have no choice but to bypass everything and get the game to go straight to the overworld.
-  // Easiest way to do this is to call into the middle of the function we want, using an ASM wrapper to set up the stack.
-  // Here goes...
-  if (titlemid) {
-    // Function reserves an extra 4 bytes of stack space in FireRed/LeafGreen, and none in Emerald.
-    call_into_middle_of_titlescreen_func(titlemid,(GAME_EM ? 0 : 4));
-  }
-  // Now we've done what we want, time to return to the game.
-  // Can't just return, the game will reload the save.
-  // So let's just call the main-loop directly ;)
-  // turn the sound back on before we head back to the game
-  *(vu16 *)(REG_BASE + 0x84) = 0x8f;
-  // re-enable interrupts
-  REG_IME = 1;
-  mainloop();
-  // Anything past here will not be executed.
-  return 0;
-  */
   return true;
 }
@@ -1,3 +1,10 @@
+/*
+ * Copyright (C) 2017 hatkirby
+ * Copyright (C) 2017 slipstream/RoL
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE file for details.
+ */
 #ifndef _GAMEDATA_H_
 #define _GAMEDATA_H_
 
@@ -1,596 +0,0 @@
-/*
-        libSave
-        Cartridge backup memory save routines. To use, call the required
-        routine with a pointer to an appropriately sized array of data to
-        be read from or written to the cartridge.
-        Data types are from wintermute's gba_types.h libgba library.
-        Original file from SendSave by Chishm
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <gba_dma.h>
-
-#define EEPROM_ADDRESS (0xDFFFF00)
-#define REG_EEPROM *(vu16 *)(EEPROM_ADDRESS)
-#define REG_DMA3CNT_H *(vu16 *)(REG_BASE + 0x0de)
-#define REG_WAITCNT *(vu16 *)(REG_BASE + 0x204)
-
-//-----------------------------------------------------------------------
-// Common EEPROM Routines
-//-----------------------------------------------------------------------
-
-void EEPROM_SendPacket( u16* packet, int size ) 
-{ 
-   REG_WAITCNT = (REG_WAITCNT & 0xF8FF) | 0x0300;
-   REG_DMA3SAD = (u32)packet; 
-   REG_DMA3DAD = EEPROM_ADDRESS; 
-   REG_DMA3CNT = 0x80000000 + size; 
-   while((REG_DMA3CNT_H & 0x8000) != 0) ;
-} 
-
-void EEPROM_ReceivePacket( u16* packet, int size ) 
-{ 
-   REG_WAITCNT = (REG_WAITCNT & 0xF8FF) | 0x0300;
-   REG_DMA3SAD = EEPROM_ADDRESS; 
-   REG_DMA3DAD = (u32)packet; 
-   REG_DMA3CNT = 0x80000000 + size; 
-   while((REG_DMA3CNT_H & 0x8000) != 0) ;
-} 
-
-//-----------------------------------------------------------------------
-// Routines for 512B EEPROM
-//-----------------------------------------------------------------------
-
-void EEPROM_Read_512B( volatile u8 offset, u8* dest ) // dest must point to 8 bytes 
-{ 
-   u16 packet[68]; 
-   u8* out_pos; 
-   u16* in_pos; 
-   u8 out_byte; 
-   int byte, bit; 
-
-   memset( packet, 0, 68*2 );
-
-   // Read request 
-   packet[0] = 1; 
-   packet[1] = 1; 
-
-   // 6 bits eeprom address (MSB first) 
-   packet[2] = (offset>>5)&1; 
-   packet[3] = (offset>>4)&1; 
-   packet[4] = (offset>>3)&1; 
-   packet[5] = (offset>>2)&1; 
-   packet[6] = (offset>>1)&1; 
-   packet[7] = (offset)&1; 
-
-   // End of request 
-   packet[8] = 0; 
-
-   // Do transfers 
-   EEPROM_SendPacket( packet, 9 ); 
-   memset( packet, 0, 68*2 );
-   EEPROM_ReceivePacket( packet, 68 ); 
-   
-   // Extract data 
-   in_pos = &packet[4]; 
-   out_pos = dest; 
-   for( byte = 7; byte >= 0; --byte ) 
-   { 
-      out_byte = 0; 
-      for( bit = 7; bit >= 0; --bit ) 
-      { 
-//         out_byte += (*in_pos++)<<bit; 
-                  out_byte += ((*in_pos++)&1)<<bit;
-      } 
-      *out_pos++ = out_byte ; 
-   } 
-} 
-
-void EEPROM_Write_512B( volatile u8 offset, u8* source ) // source must point to 8 bytes 
-{ 
-   u16 packet[73]; 
-   u8* in_pos; 
-   u16* out_pos; 
-   u8 in_byte; 
-   int byte, bit; 
-
-   memset( packet, 0, 73*2 );
-
-   // Write request 
-   packet[0] = 1; 
-   packet[1] = 0; 
-
-   // 6 bits eeprom address (MSB first) 
-   packet[2] = (offset>>5)&1; 
-   packet[3] = (offset>>4)&1; 
-   packet[4] = (offset>>3)&1; 
-   packet[5] = (offset>>2)&1; 
-   packet[6] = (offset>>1)&1; 
-   packet[7] = (offset)&1; 
-
-   // Extract data 
-   in_pos = source; 
-   out_pos = &packet[8]; 
-   for( byte = 7; byte >= 0; --byte ) 
-   { 
-      in_byte = *in_pos++; 
-      for( bit = 7; bit >= 0; --bit ) 
-      { 
-         *out_pos++ = (in_byte>>bit)&1; 
-      } 
-   } 
-
-   // End of request 
-   packet[72] = 0; 
-
-   // Do transfers 
-   EEPROM_SendPacket( packet, 73 ); 
-
-   // Wait for EEPROM to finish (should timeout after 10 ms) 
-   while( (REG_EEPROM & 1) == 0 ); 
-} 
-
-//---------------------------------------------------------------------------------
-void GetSave_EEPROM_512B(u8* data)
-//---------------------------------------------------------------------------------
-{
-        volatile u8 x;
-        u32 sleep;
-
-    for (x=0;x<64;++x){
-                EEPROM_Read_512B(x,&data[x*8]);
-                for(sleep=0;sleep<512000;sleep++);
-        }
-}
-
-//---------------------------------------------------------------------------------
-void PutSave_EEPROM_512B(u8* data)
-//---------------------------------------------------------------------------------
-{
-        volatile u8 x;
-        u32 sleep;
-
-    for (x=0;x<64;x++){ 
-                EEPROM_Write_512B(x,&data[x*8]);
-                for(sleep=0;sleep<512000;sleep++);
-        }
-}
-//-----------------------------------------------------------------------
-// Routines for 8KB EEPROM
-//-----------------------------------------------------------------------
-
-void EEPROM_Read_8KB( volatile u16 offset, u8* dest ) // dest must point to 8 bytes 
-{ 
-   u16 packet[68]; 
-   u8* out_pos; 
-   u16* in_pos; 
-   u8 out_byte; 
-   int byte, bit; 
-
-   memset( packet, 0, 68*2 );
-
-   // Read request 
-   packet[0] = 1; 
-   packet[1] = 1; 
-
-   // 14 bits eeprom address (MSB first) 
-   packet[2] = (offset>>13)&1; 
-   packet[3] = (offset>>12)&1; 
-   packet[4] = (offset>>11)&1; 
-   packet[5] = (offset>>10)&1; 
-   packet[6] = (offset>>9)&1; 
-   packet[7] = (offset>>8)&1;
-   packet[8] = (offset>>7)&1; 
-   packet[9] = (offset>>6)&1; 
-   packet[10] = (offset>>5)&1; 
-   packet[11] = (offset>>4)&1; 
-   packet[12] = (offset>>3)&1; 
-   packet[13] = (offset>>2)&1;
-   packet[14] = (offset>>1)&1;
-   packet[15] = (offset)&1;
-
-   // End of request 
-   packet[16] = 0; 
-
-   // Do transfers 
-   EEPROM_SendPacket( packet, 17 ); 
-   memset( packet, 0, 68*2 );
-   EEPROM_ReceivePacket( packet, 68 ); 
-   
-   // Extract data 
-   in_pos = &packet[4]; 
-   out_pos = dest; 
-   for( byte = 7; byte >= 0; --byte ) 
-   { 
-      out_byte = 0; 
-      for( bit = 7; bit >= 0; --bit ) 
-      { 
-//         out_byte += (*in_pos++)<<bit; 
-                  out_byte += ((*in_pos++)&1)<<bit;
-      } 
-      *out_pos++ = out_byte; 
-   } 
-
-} 
-
-void EEPROM_Write_8KB( volatile u16 offset, u8* source ) // source must point to 8 bytes 
-{ 
-   u16 packet[81]; 
-   u8* in_pos; 
-   u16* out_pos; 
-   u8 in_byte; 
-   int byte, bit; 
-
-   memset( packet, 0, 81*2 );
-   
-   // Write request 
-   packet[0] = 1; 
-   packet[1] = 0; 
-
-   // 14 bits eeprom address (MSB first) 
-   packet[2] = (offset>>13)&1; 
-   packet[3] = (offset>>12)&1; 
-   packet[4] = (offset>>11)&1; 
-   packet[5] = (offset>>10)&1; 
-   packet[6] = (offset>>9)&1; 
-   packet[7] = (offset>>8)&1;
-   packet[8] = (offset>>7)&1; 
-   packet[9] = (offset>>6)&1; 
-   packet[10] = (offset>>5)&1; 
-   packet[11] = (offset>>4)&1; 
-   packet[12] = (offset>>3)&1; 
-   packet[13] = (offset>>2)&1;
-   packet[14] = (offset>>1)&1;
-   packet[15] = (offset)&1;
-
-   // Extract data 
-   in_pos = source; 
-   out_pos = &packet[16]; 
-   for( byte = 7; byte >= 0; --byte ) 
-   { 
-      in_byte = *in_pos++; 
-      for( bit = 7; bit >= 0; --bit ) 
-      { 
-         *out_pos++ = (in_byte>>bit)&1; 
-      } 
-   } 
-
-   // End of request 
-   packet[80] = 0; 
-
-   // Do transfers 
-   EEPROM_SendPacket( packet, 81 ); 
-
-   // Wait for EEPROM to finish (should timeout after 10 ms) 
-   while( (REG_EEPROM & 1) == 0 ); 
-} 
-
-//---------------------------------------------------------------------------------
-void GetSave_EEPROM_8KB(u8* data)
-//---------------------------------------------------------------------------------
-{
-        volatile u16 x;
-        u32 sleep;
-
-    for (x=0;x<1024;x++){ 
-                EEPROM_Read_8KB(x,&data[x*8]);
-                for(sleep=0;sleep<512000;sleep++);
-        }
-
-}
-
-//---------------------------------------------------------------------------------
-void PutSave_EEPROM_8KB(u8* data)
-//---------------------------------------------------------------------------------
-{
-        volatile u16 x;
-        u32 sleep;
-
-    for (x=0;x<1024;x++){ 
-                EEPROM_Write_8KB(x,&data[x*8]);
-                for(sleep=0;sleep<512000;sleep++);
-        }
-}
-
-//---------------------------------------------------------------------------------
-void GetSave_SRAM_32KB(u8* data)
-//---------------------------------------------------------------------------------
-{
-        volatile u8 *sram= (u8*) 0x0E000000;
-        volatile u16 x;
-
-        for (x = 0; x < 0x8000; ++x)
-        {
-                data[x] = sram[x];
-        }
-
-}
-
-//---------------------------------------------------------------------------------
-void PutSave_SRAM_32KB(u8* data)
-//---------------------------------------------------------------------------------
-{
-        volatile u8 *sram= (u8*) 0x0E000000;
-        volatile u16 x;
-
-        for (x = 0; x < 0x8000; ++x)
-        {
-                sram[x] = data[x];
-        }
-}
-
-//---------------------------------------------------------------------------------
-void GetSave_FLASH_64KB(u8* data)
-//---------------------------------------------------------------------------------
-{
-        volatile u8 *sram= (u8*) 0x0E000000;
-        volatile u32 x;
-
-        for (x = 0; x < 0x10000; ++x)
-        {
-                data[x] = sram[x];
-        }
-}
-
-//---------------------------------------------------------------------------------
-void PutSave_FLASH_64KB(u8* foo)
-//---------------------------------------------------------------------------------
-{
-        volatile u8 *fctrl0 = (u8*) 0xE005555; 
-        volatile u8 *fctrl1 = (u8*) 0xE002AAA; 
-        volatile u8 *fctrl2 = (u8*) 0xE000000; 
-
-        //init flash 
-        *fctrl0 = 0xAA; 
-        *fctrl1 = 0x55; 
-        *fctrl0 = 0x90; 
-        *fctrl2 = 0xF0; 
-
-        //erase chip 
-        *fctrl0 = 0xAA; 
-        *fctrl1 = 0x55; 
-        *fctrl0 = 0x80; 
-        *fctrl0 = 0xAA; 
-        *fctrl1 = 0x55; 
-        *fctrl0 = 0x10; 
-
-        //wait for erase done 
-        u8 val1;
-        u8 val2; 
-        val1 = *fctrl2;
-        val2 = *fctrl2; 
-        while (val1 != val2) {
-                val1 = *fctrl2;
-                val2 = *fctrl2;
-        }
-        val1 = *fctrl2;
-        val2 = *fctrl2; 
-        while (val1 != val2) {
-                val1 = *fctrl2;
-                val2 = *fctrl2; 
-        }
-
-        volatile u8 *data = fctrl2; 
-        u32 i; 
-        //write data 
-        for (i=0; i<65536; i++) { 
-                *fctrl0 = 0xAA; 
-                *fctrl1 = 0x55; 
-                *fctrl0 = 0xA0; 
-                data [i] = foo [ i ]; 
-                val1 = data [ i ]; 
-                val2 = data [ i ]; 
-        
-                while (val1 != val2) {
-                        val1 = data [ i ]; 
-                        val2 = data [ i ]; 
-                }
-                val1 = data [ i ]; 
-                val2 = data [ i ]; 
-                while (val1 != val2) {
-                        val1 = data [ i ];
-                        val2 = data [ i ]; 
-                } 
-                val1 = data [ i ]; 
-                val2 = data [ i ]; 
-                while (val1 != val2) {
-                        val1 = data [ i ]; 
-                        val2 = data [ i ]; 
-                } 
-        }
-}
-
-//---------------------------------------------------------------------------------
-void GetSave_FLASH_128KB(u8* data)
-//---------------------------------------------------------------------------------
-{
-        const u32 size = 0x10000;
-        
-        volatile u8 *fctrl0 = (u8*) 0xE005555; 
-        volatile u8 *fctrl1 = (u8*) 0xE002AAA; 
-        volatile u8 *fctrl2 = (u8*) 0xE000000; 
-        volatile u32 i; 
-        volatile u8 *sram= (u8*) 0x0E000000;
-        
-        //init flash 
-        *fctrl0 = 0xAA; 
-        *fctrl1 = 0x55; 
-        *fctrl0 = 0x90; 
-        *fctrl2 = 0xF0; 
-
-        // read first bank
-        *fctrl0 = 0xAA;
-        *fctrl1 = 0x55;
-        *fctrl0 = 0xB0;
-        *fctrl2 = 0x00;
-        
-        for (i=0; i<size; i++){
-                data[i] = sram[i];
-        }
-
-        // read second bank
-        *fctrl0 = 0xAA;
-        *fctrl1 = 0x55;
-        *fctrl0 = 0xB0;
-        *fctrl2 = 0x01;
-        
-        for (i=0; i<size; i++){
-                data[i + size] = sram[i];
-        }
-
-}
-
-//---------------------------------------------------------------------------------
-void PutSave_FLASH_128KB(u8* foo)
-//---------------------------------------------------------------------------------
-{
-        volatile u8 *fctrl0 = (u8*) 0xE005555; 
-        volatile u8 *fctrl1 = (u8*) 0xE002AAA; 
-        volatile u8 *fctrl2 = (u8*) 0xE000000; 
-
-        u8 val1;
-        u8 val2; 
-
-        //init flash 
-        *fctrl0 = 0xAA; 
-        *fctrl1 = 0x55; 
-        *fctrl0 = 0x90; 
-        *fctrl2 = 0xF0; 
-
-        //erase chip 
-        *fctrl0 = 0xAA; 
-        *fctrl1 = 0x55; 
-        *fctrl0 = 0x80; 
-        *fctrl0 = 0xAA; 
-        *fctrl1 = 0x55; 
-        *fctrl0 = 0x10; 
-        
-        //wait for erase done 
-        val1 = *fctrl2;
-        val2 = *fctrl2; 
-        while (val1 != val2) {
-                val1 = *fctrl2;
-                val2 = *fctrl2;
-        }
-        val1 = *fctrl2;
-        val2 = *fctrl2; 
-        while (val1 != val2) {
-                val1 = *fctrl2;
-                val2 = *fctrl2; 
-        }
-
-        volatile u8 *data = fctrl2; 
-        volatile u32 i; 
-        // change to bank 0
-        *fctrl0 = 0xAA;
-        *fctrl1 = 0x55;
-        *fctrl0 = 0xB0;
-        *fctrl2 = 0x00;
-                
-        //write data 
-        for (i=0; i<65536; i++) { 
-                *fctrl0 = 0xAA; 
-                *fctrl1 = 0x55; 
-                *fctrl0 = 0xA0; 
-                data [i] = foo [ i ]; 
-                val1 = data [ i ]; 
-                val2 = data [ i ]; 
-        
-                while (val1 != val2) {
-                        val1 = data [ i ]; 
-                        val2 = data [ i ]; 
-                }
-                val1 = data [ i ]; 
-                val2 = data [ i ]; 
-                while (val1 != val2) {
-                        val1 = data [ i ];
-                        val2 = data [ i ]; 
-                } 
-                val1 = data [ i ]; 
-                val2 = data [ i ]; 
-                while (val1 != val2) {
-                        val1 = data [ i ]; 
-                        val2 = data [ i ]; 
-                } 
-        }
-
-        // Change to bank 1
-        *fctrl0 = 0xAA;
-        *fctrl1 = 0x55;
-        *fctrl0 = 0xB0;
-        *fctrl2 = 0x01;
-        
-        //write data 
-        for (i=0; i<65536; i++) { 
-                *fctrl0 = 0xAA; 
-                *fctrl1 = 0x55; 
-                *fctrl0 = 0xA0; 
-                data [i] = foo [ i + 0x10000]; 
-                val1 = data [ i ]; 
-                val2 = data [ i ]; 
-        
-                while (val1 != val2) {
-                        val1 = data [ i ]; 
-                        val2 = data [ i ]; 
-                }
-                val1 = data [ i ]; 
-                val2 = data [ i ]; 
-                while (val1 != val2) {
-                        val1 = data [ i ];
-                        val2 = data [ i ]; 
-                } 
-                val1 = data [ i ]; 
-                val2 = data [ i ]; 
-                while (val1 != val2) {
-                        val1 = data [ i ]; 
-                        val2 = data [ i ]; 
-                } 
-        }
-
-}
-
-//---------------------------------------------------------------------------------
-u32 SaveSize(u8* data, s32 gamesize)
-//---------------------------------------------------------------------------------
-{
-        if(gamesize < 0)
-         return 0;
-
-        u32 *pak= ((u32*)0x08000000);
-        s32 x;
-        u16 i;
-        s32 size = gamesize/4;
-
-
-        for (x=size-1;x>=0;x--){
-                switch (pak[x]) {
-                case 0x53414C46:
-                        if (pak[x+1] == 0x5F4D3148){
-                                return 0x20000;                                 // FLASH_128KB
-                        } else if ((pak[x+1] & 0x0000FFFF) == 0x00005F48){
-                                return 0x10000;                                 // FLASH_64KB
-                        } else if (pak[x+1] == 0x32313548){
-                                return 0x10000;                                 // FLASH_64KB
-                        }
-                        break;
-                case 0x52504545:
-                        if ((pak[x+1] & 0x00FFFFFF) == 0x005F4D4F){
-                                GetSave_EEPROM_8KB(data);
-                                for(i = 8; i < 0x800; i += 8) {
-                                        if(memcmp(data, data+i, 8) != 0)
-                                                return 0x2000;                  // EEPROM_8KB
-                                }
-                                return 0x200;                                   // EEPROM_512B
-                        }
-                        break;
-                case 0x4D415253:
-                        if ((pak[x+1] & 0x000000FF) == 0x0000005F){
-                                return 0x8000;                                  // SRAM_32KB
-                        }
-                }
-        }
-        return 0;
-}
-
@@ -1,27 +0,0 @@
-
-
-//---------------------------------------------------------------------------------
-#ifdef __cplusplus
-extern "C" {
-#endif
-//---------------------------------------------------------------------------------
-
-void GetSave_EEPROM_512B(u8* data);
-void PutSave_EEPROM_512B(u8* data);
-void GetSave_EEPROM_8KB(u8* data);
-void PutSave_EEPROM_8KB(u8* data);
-void GetSave_SRAM_32KB(u8* data);
-void PutSave_SRAM_32KB(u8* data);
-void GetSave_FLASH_64KB(u8* data);
-void PutSave_FLASH_64KB(u8* foo);
-void GetSave_FLASH_128KB(u8* data);
-void PutSave_FLASH_128KB(u8* foo);
-
-u32 SaveSize(u8* data, s32 gamesize);
-
-
-//---------------------------------------------------------------------------------
-#ifdef __cplusplus
-}          // extern "C"
-#endif
-//---------------------------------------------------------------------------------
@@ -1,13 +1,20 @@
+/*
+ * Copyright (C) 2017 hatkirby
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE file for details.
+ */
 #include "link.h"
 
 #define JOY_WRITE 2
 #define JOY_READ 4
 #define JOY_RW 6
 
-void waitForWriteAccess()
+void initializeLink()
 {
-  //while ((REG_HS_CTRL & JOY_READ) == 0);
-        while ((REG_HS_CTRL & JOY_WRITE) == 0);
+        REG_HS_CTRL |= JOY_RW;
+        REG_JOYTR = 0;
+  while ((REG_HS_CTRL & JOY_WRITE) == 0);
   REG_HS_CTRL |= JOY_RW;
 }
 
@@ -23,19 +30,9 @@ void waitForAck()
 void sendS32(s32 val)
 {
   REG_JOYTR = val;
-        //waitForWriteAccess();
 }
 
 void sendU32(u32 val)
 {
   REG_JOYTR = val;
-        //waitForWriteAccess();
-}
-
-u32 recieveU32()
-{
-  while ((REG_HS_CTRL & JOY_WRITE) == 0);
-  REG_HS_CTRL |= JOY_RW;
-        return REG_JOYRE;
 }
-
@@ -1,12 +1,17 @@
+/*
+ * Copyright (C) 2017 hatkirby
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE file for details.
+ */
 #ifndef _LINK_H_
 #define _LINK_H_
 
 #include <gba.h>
 
-void waitForWriteAccess();
+void initializeLink();
 void waitForAck();
 void sendS32(s32 val);
 void sendU32(u32 val);
-u32 recieveU32();
 
 #endif
@@ -1,435 +1,110 @@
 /*
- * Copyright (C) 2016 FIX94
+ * Copyright (C) 2017 hatkirby
  *
  * This software may be modified and distributed under the terms
  * of the MIT license.  See the LICENSE file for details.
  */
 #include <gba.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include "libSave.h"
 #include "gamedata.h"
 #include "link.h"
 
-#define REG_WAITCNT *(vu16 *)(REG_BASE + 0x204)
-#define JOY_WRITE 2
-#define JOY_READ 4
-#define JOY_RW 6
-
-u8 save_data[0x20000] __attribute__ ((section (".sbss")));
-
-s32 getGameSize(void)
-{
-  if(*(vu32*)(0x08000004) != 0x51AEFF24)
-    return -1;
-  s32 i;
-  for(i = (1<<20); i < (1<<25); i<<=1)
-  {
-    vu16 *rompos = (vu16*)(0x08000000+i);
-    int j;
-    bool romend = true;
-    for(j = 0; j < 0x1000; j++)
-    {
-      if(rompos[j] != j)
-      {
-        romend = false;
-        break;
-      }
-    }
-    if(romend) break;
-  }
-  return i;
-}
-
-
-// === (from tonc_memdef.h) ===========================================
-
-// --- REG_DISPCNT defines ---
-#define DCNT_MODE0     0x0000
-#define DCNT_MODE1      0x0001
-#define DCNT_MODE2      0x0002
-#define DCNT_MODE3      0x0003
-#define DCNT_MODE4      0x0004
-#define DCNT_MODE5      0x0005
-// layers
-#define DCNT_BG0        0x0100
-#define DCNT_BG1        0x0200
-#define DCNT_BG2        0x0400
-#define DCNT_BG3        0x0800
-#define DCNT_OBJ        0x1000
-typedef u16 COLOR;
-#define MEM_VRAM    0x06000000
-#define SCREEN_WIDTH   240
-#define vid_mem     ((u16*)MEM_VRAM)
-static inline void m3_plot(int x, int y, COLOR clr)
-{   vid_mem[y*SCREEN_WIDTH+x]= clr;    }
-static inline COLOR RGB15(u32 red, u32 green, u32 blue)
-{   return red | (green<<5) | (blue<<10);   }
-void plot_sqr(int x, int y, COLOR clr)
-{
-        /*for (int j=0;j<8; j++)
-        {
-                for (int i=0;i<8; i++)
-                {
-                        vid_mem[(y*8+j+32)*SCREEN_WIDTH+x*8+i+32] = clr;
-                }
-        }
-        vid_mem[(y*8+1+32)*SCREEN_WIDTH+x*8+1+32] = RGB15(31,31,31);*/
-}
-void m3_fill(COLOR clr) 
-{   
-    /*int ii;
-    u32 *dst= (u32*)vid_mem;
-    u32 wd= (clr<<16) | clr;
-
-    for(ii=0; ii<SCREEN_WIDTH/4; ii++)
-        *dst++= wd;*/
-}
-
-//---------------------------------------------------------------------------------
-// Program entry point
-//---------------------------------------------------------------------------------
 int main(void)
 {
-        //REG_IME = 0;
-  //REG_DISPCNT= DCNT_MODE3 | DCNT_BG2;
-        m3_fill(RGB15(31,31,31));
-  plot_sqr( 4, 4, RGB15(31, 0, 0) );    // or CLR_RED
-
-        /*
-        
-  //*(vu16 *)(REG_BASE + 0x84) = 0x8f;
-  //REG_IME = 1;
-  // the vblank interrupt must be enabled for VBlankIntrWait() to work
-  // since the default dispatcher handles the bios flags no vblank handler
-  // is required
-  irqInit();
-  irqEnable(IRQ_VBLANK);
-
-  consoleDemoInit();
-  //REG_JOYTR = 0;
-
-  // ansi escape sequence to set print co-ordinates
-  // /x1b[line;columnH
-  //u32 i;
-  iprintf("\x1b[9;2HPokemon Gen III Data Extractor\n");
-  iprintf("\x1b[10;4HPlease look at the TV\n");
+        initializeLink();
 
-  // disable this, needs power
-  SNDSTAT = 0;
-  SNDBIAS = 0;
-
-  // Set up waitstates for EEPROM access etc.
-  REG_WAITCNT = 0x0317;
-        
-        s32 gamesize = getGameSize();
-                                u32 savesize = SaveSize(save_data,gamesize);
-  switch (savesize){
-    case 0x200:
-      GetSave_EEPROM_512B(save_data);
-      break;
-    case 0x2000:
-      GetSave_EEPROM_8KB(save_data);
-      break;
-    case 0x8000:
-      GetSave_SRAM_32KB(save_data);
-      break;
-    case 0x10000:
-      GetSave_FLASH_64KB(save_data);
-      break;
-    case 0x20000:
-      GetSave_FLASH_128KB(save_data);
-      break;
-    default:
-      break;
-  }*/
-
-  //clear out previous messages
-  REG_HS_CTRL |= JOY_RW;
-        sendU32(0);
-  plot_sqr( 4, 5, RGB15( 0,31, 0) );    // or CLR_LIME
-  while (1)
+  // Identify the host game.
+  if (GAME_RUBY)
   {
-                waitForWriteAccess();
-                //while (recieveU32() != 0);
-                //waitForAck();
-  plot_sqr( 4, 6, RGB15( 0, 0,31) );    // or CLR_BLUE
-    // Send game size to acknowledge that an actual cart is inserted.
-    //s32 gamesize = getGameSize();
-    //sendS32(gamesize);
-    //waitForAck();
-
-    // If the game size is illegal, start over.
-    //if (gamesize == -1)
-    //{
-    //  sendS32(0);
-                //
-    //  continue;
-    //}
-
-    // Identify the inserted game.
-    if (GAME_RUBY)
-    {
-      sendS32(1);
-    } else if (GAME_SAPP)
-    {
-      sendS32(2);
-    } else if (GAME_FR)
-    {
-      sendS32(3);
-    } else if (GAME_LG)
-    {
-      sendS32(4);
-    } else if (GAME_EM)
-    {
-      sendS32(5);
-    } else {
-      sendS32(-1);
-      waitForAck();
-
-      sendS32(0);
+    sendS32(1);
+  } else if (GAME_SAPP)
+  {
+    sendS32(2);
+  } else if (GAME_FR)
+  {
+    sendS32(3);
+  } else if (GAME_LG)
+  {
+    sendS32(4);
+  } else if (GAME_EM)
+  {
+    sendS32(5);
+  } else {
+    sendS32(-1);
+                waitForAck();
 
-      continue;
-    }
-  plot_sqr( 5, 4, RGB15( 31, 0,31) );
-    waitForAck();
-  plot_sqr( 5, 5, RGB15( 16, 16,16) );
+                return 0;
+  }
 
-    // Get access to save data.
-    pSaveBlock1 SaveBlock1;
-    pSaveBlock2 SaveBlock2;
-    pSaveBlock3 SaveBlock3;
-                //iprintf("gonna check thing\n");
-    if (!initSaveData(&SaveBlock1, &SaveBlock2, &SaveBlock3))
-    {
-      // Unsupported game version.
-      //iprintf("Unsupported game version\n");
-      sendS32(-1);
-      waitForAck();
+  waitForAck();
 
-      sendS32(0);
+  // Get access to save data.
+  pSaveBlock1 SaveBlock1;
+  pSaveBlock2 SaveBlock2;
+  pSaveBlock3 SaveBlock3;
 
-      continue;
-    }
-                //iprintf("success\n");
-  plot_sqr( 5, 6, RGB15( 0, 31,16) );
-    sendS32(1);
-    waitForAck();
-                
-    // Send trainer name.
-    u8* trainerName = 0;
+  if (!initSaveData(&SaveBlock1, &SaveBlock2, &SaveBlock3))
+  {
+    // Unsupported game version.
+    sendS32(-1);
+                waitForAck();
 
-    if (GAME_RS)
-    {
-      trainerName = SaveBlock2->rs.playerName;
-    } else if (GAME_FRLG)
-    {
-      trainerName = SaveBlock2->frlg.playerName;
-    } else if (GAME_EM)
-    {
-      trainerName = SaveBlock2->e.playerName;
-    }
+                return 0;
+  }
 
-    u32 tn1 =
-        (trainerName[0] << 24)
-      | (trainerName[1] << 16)
-      | (trainerName[2] << 8)
-      | (trainerName[3]);
+  sendS32(1);
+  waitForAck();
 
-    u32 tn2 =
-        (trainerName[4] << 24)
-      | (trainerName[5] << 16)
-      | (trainerName[6] << 8)
-      | (trainerName[7]);
+  // Send trainer name.
+  u8* trainerName = 0;
 
-    sendU32(tn1);
-    waitForAck();
+  if (GAME_RS)
+  {
+    trainerName = SaveBlock2->rs.playerName;
+  } else if (GAME_FRLG)
+  {
+    trainerName = SaveBlock2->frlg.playerName;
+  } else if (GAME_EM)
+  {
+    trainerName = SaveBlock2->e.playerName;
+  }
 
-    sendU32(tn2);
-    waitForAck();
+  u32 tn1 =
+      (trainerName[0] << 24)
+    | (trainerName[1] << 16)
+    | (trainerName[2] << 8)
+    | (trainerName[3]);
 
-    // Send trainer ID.
-                
-    u8* trainerId = 0;
-    if (GAME_RS)
-    {
-      trainerId = SaveBlock2->rs.playerTrainerId;
-    } else if (GAME_FRLG)
-    {
-      trainerId = SaveBlock2->frlg.playerTrainerId;
-    } else if (GAME_EM)
-    {
-      trainerId = SaveBlock2->e.playerTrainerId;
-    }
+  u32 tn2 =
+      (trainerName[4] << 24)
+    | (trainerName[5] << 16)
+    | (trainerName[6] << 8)
+    | (trainerName[7]);
 
-    u32 tti =
-        (trainerId[1] << 8)
-      | (trainerId[0]);
+  sendU32(tn1);
+  waitForAck();
 
-                //iprintf("sending trainer id %ld\n", tti);
-    sendU32(tti);
-    waitForAck();
+  sendU32(tn2);
+  waitForAck();
 
-    // Restart, because we're just testing.
-    sendS32(0);
-    //continue;
-                break;
+  // Send trainer ID.
+  u8* trainerId = 0;
+  if (GAME_RS)
+  {
+    trainerId = SaveBlock2->rs.playerTrainerId;
+  } else if (GAME_FRLG)
+  {
+    trainerId = SaveBlock2->frlg.playerTrainerId;
+  } else if (GAME_EM)
+  {
+    trainerId = SaveBlock2->e.playerTrainerId;
+  }
 
-/*
+  u32 tti =
+      (trainerId[1] << 8)
+    | (trainerId[0]);
 
+  sendU32(tti);
+  waitForAck();
 
-      //game in, send header
-      for(i = 0; i < 0xC0; i+=4)
-      {
-        REG_JOYTR = *(vu32*)(0x08000000+i);
-        while((REG_HS_CTRL&JOY_READ) == 0) ;
-        REG_HS_CTRL |= JOY_RW;
-      }
-      REG_JOYTR = 0;
-      //wait for other side to choose
-      while((REG_HS_CTRL&JOY_WRITE) == 0) ;
-      REG_HS_CTRL |= JOY_RW;
-      u32 choseval = REG_JOYRE;
-      if(choseval == 0)
-      {
-        REG_JOYTR = 0;
-        continue; //nothing to read
-      }
-      else if(choseval == 1)
-      {
-        //disable interrupts
-        u32 prevIrqMask = REG_IME;
-        REG_IME = 0;
-        //dump the game
-        for(i = 0; i < gamesize; i+=4)
-        {
-          REG_JOYTR = *(vu32*)(0x08000000+i);
-          while((REG_HS_CTRL&JOY_READ) == 0) ;
-          REG_HS_CTRL |= JOY_RW;
-        }
-        //restore interrupts
-        REG_IME = prevIrqMask;
-      }
-      else if(choseval == 2)
-      {
-        //disable interrupts
-        u32 prevIrqMask = REG_IME;
-        REG_IME = 0;
-        //backup save
-        switch (savesize){
-          case 0x200:
-            GetSave_EEPROM_512B(save_data);
-            break;
-          case 0x2000:
-            GetSave_EEPROM_8KB(save_data);
-            break;
-          case 0x8000:
-            GetSave_SRAM_32KB(save_data);
-            break;
-          case 0x10000:
-            GetSave_FLASH_64KB(save_data);
-            break;
-          case 0x20000:
-            GetSave_FLASH_128KB(save_data);
-            break;
-          default:
-            break;
-        }
-        //restore interrupts
-        REG_IME = prevIrqMask;
-        //say gc side we read it
-        REG_JOYTR = savesize;
-        //wait for a cmd receive for safety
-        while((REG_HS_CTRL&JOY_WRITE) == 0) ;
-        REG_HS_CTRL |= JOY_RW;
-        //send the save
-        for(i = 0; i < savesize; i+=4)
-        {
-          REG_JOYTR = *(vu32*)(save_data+i);
-          while((REG_HS_CTRL&JOY_READ) == 0) ;
-          REG_HS_CTRL |= JOY_RW;
-        }
-      }
-      else if(choseval == 3 || choseval == 4)
-      {
-        REG_JOYTR = savesize;
-        if(choseval == 3)
-        {
-          //receive the save
-          for(i = 0; i < savesize; i+=4)
-          {
-            while((REG_HS_CTRL&JOY_WRITE) == 0) ;
-            REG_HS_CTRL |= JOY_RW;
-            *(vu32*)(save_data+i) = REG_JOYRE;
-          }
-        }
-        else
-        {
-          //clear the save
-          for(i = 0; i < savesize; i+=4)
-            *(vu32*)(save_data+i) = 0;
-        }
-        //disable interrupts
-        u32 prevIrqMask = REG_IME;
-        REG_IME = 0;
-        //write it
-        switch (savesize){
-          case 0x200:
-            PutSave_EEPROM_512B(save_data);
-            break;
-          case 0x2000:
-            PutSave_EEPROM_8KB(save_data);
-            break;
-          case 0x8000:
-            PutSave_SRAM_32KB(save_data);
-            break;
-          case 0x10000:
-            PutSave_FLASH_64KB(save_data);
-            break;
-          case 0x20000:
-            PutSave_FLASH_128KB(save_data);
-            break;
-          default:
-            break;
-        }
-        //restore interrupts
-        REG_IME = prevIrqMask;
-        //say gc side we're done
-        REG_JOYTR = 0;
-        //wait for a cmd receive for safety
-        while((REG_HS_CTRL&JOY_WRITE) == 0) ;
-        REG_HS_CTRL |= JOY_RW;
-      }
-      REG_JOYTR = 0;
-    }
-    } else if(REG_HS_CTRL&JOY_WRITE)
-    {
-      REG_HS_CTRL |= JOY_RW;
-      u32 choseval = REG_JOYRE;
-      if(choseval == 5)
-      {
-        //disable interrupts
-        u32 prevIrqMask = REG_IME;
-        REG_IME = 0;
-        //dump BIOS
-        for (i = 0; i < 0x4000; i+=4)
-        {
-          // the lower bits are inaccurate, so just get it four times :)
-          u32 a = MidiKey2Freq((WaveData *)(i-4), 180-12, 0) * 2;
-          u32 b = MidiKey2Freq((WaveData *)(i-3), 180-12, 0) * 2;
-          u32 c = MidiKey2Freq((WaveData *)(i-2), 180-12, 0) * 2;
-          u32 d = MidiKey2Freq((WaveData *)(i-1), 180-12, 0) * 2;
-          REG_JOYTR = ((a>>24<<24) | (d>>24<<16) | (c>>24<<8) | (b>>24));
-          while((REG_HS_CTRL&JOY_READ) == 0) ;
-          REG_HS_CTRL |= JOY_RW;
-        }
-        //restore interrupts
-        REG_IME = prevIrqMask;
-      }
-      REG_JOYTR = 0;
-    }*/
-    Halt();
-  }
+        // Halt();
 }
-
-