clean up save.c

11 files changed, 282 insertions, 220 deletions

diff --git a/src/engine/clear_save_data_menu.c b/src/engine/clear_save_data_menu.c
index 08fd5cd18..b6053715a 100644
--- a/src/engine/clear_save_data_menu.c
+++ b/src/engine/clear_save_data_menu.c
@@ -73,7 +73,7 @@ static void Task_ProcessMenuInput(u8 taskId)
 
 static void Task_ClearSaveData(u8 taskId)
 {
-    ClearSaveData();
+    Save_EraseAllData();
     DestroyTask(taskId);
     SetMainCallback2(CB2_SoftReset);
 }
diff --git a/src/engine/link.c b/src/engine/link.c
index 34016d607..ec94295d7 100644
--- a/src/engine/link.c
+++ b/src/engine/link.c
@@ -409,7 +409,7 @@ static void LinkTestProcessKeyInput(void)
     if (gMain.newKeys & START_BUTTON)
         SetSuppressLinkErrorMessage(TRUE);
     if (gMain.newKeys & R_BUTTON)
-        TrySavingData(LINK_SAVE);
+        Save_WriteData(SAVE_LINK);
     if (gMain.newKeys & SELECT_BUTTON)
         sub_800832C();
     if (gLinkTestDebugValuesEnabled)
diff --git a/src/engine/main_menu.c b/src/engine/main_menu.c
index a0b8b7020..5a3f55b29 100644
--- a/src/engine/main_menu.c
+++ b/src/engine/main_menu.c
@@ -1,4 +1,6 @@
 #include "global.h"
+#include "constants/songs.h"
+#include "constants/species.h"
 #include "main_menu.h"
 #include "data2.h"
 #include "decompress.h"
@@ -13,9 +15,8 @@
 #include "overworld.h"
 #include "rtc.h"
 #include "save_menu_util.h"
-#include "constants/songs.h"
+#include "save.h"
 #include "sound.h"
-#include "constants/species.h"
 #include "string_util.h"
 #include "strings.h"
 #include "task.h"
@@ -28,8 +29,6 @@
 
 extern struct PaletteFadeControl gPaletteFade;
 
-extern u16 gSaveFileStatus;
-
 extern const u8 gBirchSpeech_Welcome[];
 extern const u8 gBirchSpeech_ThisIsPokemon[];
 extern const u8 gBirchSpeech_WorldInhabitedByPokemon[];
@@ -284,12 +283,11 @@ void Task_MainMenuCheckSave(u8 taskId)
 
     switch (gSaveFileStatus)
     {
-    case 1:
+    case SAVE_STATUS_OK:
         if (IsMysteryGiftEnabled() == TRUE)
             gTasks[taskId].tMenuLayout = HAS_MYSTERY_GIFT;
         else
             gTasks[taskId].tMenuLayout = HAS_SAVED_GAME;
-
         gTasks[taskId].func = Task_MainMenuCheckRtc;
         break;
     case 2:
@@ -300,7 +298,7 @@ void Task_MainMenuCheckSave(u8 taskId)
         gTasks[taskId].tMenuLayout = HAS_NO_SAVED_GAME;
         gTasks[taskId].func = Task_MainMenuWaitForSaveErrorAck;
         break;
-    case 255:
+    case SAVE_STATUS_ERROR:
         Menu_DrawStdWindowFrame(2, 14, 27, 19);
         MenuPrintMessage(gSaveFileCorruptMessage, 3, 15);
         REG_WIN0H = WIN_RANGE(17, 223);
@@ -313,12 +311,12 @@ void Task_MainMenuCheckSave(u8 taskId)
         else
             gTasks[taskId].tMenuLayout = HAS_SAVED_GAME;
         break;
-    case 0:
+    case SAVE_STATUS_EMPTY:
     default:
         gTasks[taskId].tMenuLayout = HAS_NO_SAVED_GAME;
         gTasks[taskId].func = Task_MainMenuCheckRtc;
         break;
-    case 4:
+    case SAVE_STATUS_NO_FLASH:
         Menu_DrawStdWindowFrame(2, 14, 27, 19);
         MenuPrintMessage(gBoardNotInstalledMessage, 3, 15);
         REG_WIN0H = WIN_RANGE(17, 223);
diff --git a/src/engine/mystery_event_menu.c b/src/engine/mystery_event_menu.c
index b7b7c047e..8fad563e6 100644
--- a/src/engine/mystery_event_menu.c
+++ b/src/engine/mystery_event_menu.c
@@ -289,7 +289,7 @@ static void CB2_MysteryEventMenu(void)
         unkVal = RunMysteryEventScript(gSharedMem);
         CpuFill32(0, gSharedMem, 0x7D4);
         if (!GetEventLoadMessage(gStringVar4, unkVal))
-            TrySavingData(NORMAL_SAVE);
+            Save_WriteData(SAVE_NORMAL);
         gMain.state++;
         break;
     case 12:
diff --git a/src/engine/reset_rtc_screen.c b/src/engine/reset_rtc_screen.c
index a8b49a8eb..c7d45e929 100644
--- a/src/engine/reset_rtc_screen.c
+++ b/src/engine/reset_rtc_screen.c
@@ -576,7 +576,7 @@ void Task_ResetRtcScreen(u8 taskId)
         }
         break;
     case 4:
-        if (TrySavingData(0) == TRUE)
+        if (Save_WriteData(0) == SAVE_STATUS_OK)
         {
             ResetRtcScreen_ShowMessage(gSystemText_SaveCompleted);
             PlaySE(SE_PINPON);
diff --git a/src/engine/save.c b/src/engine/save.c
index d5de2e408..f1010c69e 100644
--- a/src/engine/save.c
+++ b/src/engine/save.c
@@ -7,10 +7,53 @@
 #include "save_failed_screen.h"
 #include "ewram.h"
 
-#define GETVALIDSTATUSBITFIELD ((1 << ARRAY_COUNT(gSaveSectionLocations)) - 1)
-#define GETCHUNKSIZE(chunk, n) ((sizeof(chunk) - (0xF80 * (n - 1))) >= 0xF80 ? 0xF80 : (sizeof(chunk) - (0xF80 * (n - 1))))
-#define GETBLOCKOFFSET(n) (0xF80 * (n - 1))
-#define TOTALNUMSECTORS ((ARRAY_COUNT(gSaveSectionLocations) * 2) + (ARRAY_COUNT(gHallOfFameSaveSectionLocations) * 2)) // there are 2 slots, so double each array count and get the sum.
+#define FILE_SIGNATURE 0x08012025  // signature value to determine if a sector is in use
+
+#define TOTALNUMSECTORS ((ARRAY_COUNT(sSaveBlockChunks) * 2) + (ARRAY_COUNT(sHallOfFameChunks) * 2)) // there are 2 slots, so double each array count and get the sum.
+
+struct SaveBlockChunk
+{
+    u8 *data;
+    u16 size;
+};
+
+struct SaveSection
+{
+    u8 data[0xFF4];
+    u16 id;
+    u16 checksum;
+    u32 signature;
+    u32 counter;
+}; // size is 0x1000
+
+// headless save section?
+struct UnkSaveSection
+{
+    u8 data[0xFF4];
+    u32 signature;
+}; // size is 0xFF8
+
+static u8 WriteChunk(u16, const struct SaveBlockChunk *);
+static u8 HandleWriteSectorNBytes(u8 sector, u8 *data, u16 size);
+static u8 TryWriteSector(u8, u8 *);
+static u32 RestoreSaveBackupVarsAndIncrement(const struct SaveBlockChunk *location);
+static u32 RestoreSaveBackupVars(const struct SaveBlockChunk *location);
+static u8 sub_812550C(u16 a1, const struct SaveBlockChunk *location);
+static u8 sub_812556C(u16 a1, const struct SaveBlockChunk *location);
+static u8 sub_81255B8(u16, const struct SaveBlockChunk *location);
+static u8 sub_8125758(u16 a1, const struct SaveBlockChunk *location);
+static u8 sub_81257F0(u16 a1, const struct SaveBlockChunk *location);
+static u8 sub_812587C(u16 a1, const struct SaveBlockChunk *location);
+static u8 sub_81258BC(u16, const struct SaveBlockChunk *location);
+static u8 GetSaveValidStatus(const struct SaveBlockChunk *location);
+static u8 sub_8125B88(u8 a1, u8 *data, u16 size);
+static u8 DoReadFlashWholeSection(u8, struct SaveSection *);
+static u16 CalculateChecksum(void *, u16);
+bool8 unref_sub_8125F4C(struct UnkSaveSection *a1);
+u8 unref_sub_8125FA0(void);
+u8 unref_sub_8125FF0(u8 *data, u16 size);
+u8 unref_sub_8126068(u8 sector, u8 *data, u32 size);
+u8 unref_sub_8126080(u8 sector, u8 *data);
 
 u16 gLastWrittenSector;
 u32 gLastSaveCounter;
@@ -26,33 +69,47 @@ extern struct PokemonStorage gPokemonStorage;
 
 static EWRAM_DATA u32 gLastSaveSectorStatus = 0; // used but in an unferenced function, so unused
 
-const struct SaveSectionLocation gSaveSectionLocations[] =
-{
-    {((u8 *) &gSaveBlock2) + GETBLOCKOFFSET(1), GETCHUNKSIZE(gSaveBlock2, 1)},
-    {((u8 *) &gSaveBlock1) + GETBLOCKOFFSET(1), GETCHUNKSIZE(gSaveBlock1, 1)},
-    {((u8 *) &gSaveBlock1) + GETBLOCKOFFSET(2), GETCHUNKSIZE(gSaveBlock1, 2)},
-    {((u8 *) &gSaveBlock1) + GETBLOCKOFFSET(3), GETCHUNKSIZE(gSaveBlock1, 3)},
-    {((u8 *) &gSaveBlock1) + GETBLOCKOFFSET(4), GETCHUNKSIZE(gSaveBlock1, 4)},
-    {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(1), GETCHUNKSIZE(gPokemonStorage, 1)},
-    {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(2), GETCHUNKSIZE(gPokemonStorage, 2)},
-    {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(3), GETCHUNKSIZE(gPokemonStorage, 3)},
-    {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(4), GETCHUNKSIZE(gPokemonStorage, 4)},
-    {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(5), GETCHUNKSIZE(gPokemonStorage, 5)},
-    {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(6), GETCHUNKSIZE(gPokemonStorage, 6)},
-    {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(7), GETCHUNKSIZE(gPokemonStorage, 7)},
-    {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(8), GETCHUNKSIZE(gPokemonStorage, 8)},
-    {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(9), GETCHUNKSIZE(gPokemonStorage, 9)}
+// Each 4 KiB flash sector contains 3968 bytes of actual data followed by a 128 byte footer
+#define SECTOR_DATA_SIZE 3968
+#define SECTOR_FOOTER_SIZE 128
+
+// Divide save blocks into individual chunks to be written to flash sectors
+
+#define SAVEBLOCK_CHUNK(structure, chunkNum)                                \
+{                                                                           \
+    (u8 *)&structure + chunkNum * SECTOR_DATA_SIZE,                         \
+    min(sizeof(structure) - chunkNum * SECTOR_DATA_SIZE, SECTOR_DATA_SIZE)  \
+}                                                                           \
+
+static const struct SaveBlockChunk sSaveBlockChunks[] =
+{
+    SAVEBLOCK_CHUNK(gSaveBlock2, 0),
+
+    SAVEBLOCK_CHUNK(gSaveBlock1, 0),
+    SAVEBLOCK_CHUNK(gSaveBlock1, 1),
+    SAVEBLOCK_CHUNK(gSaveBlock1, 2),
+    SAVEBLOCK_CHUNK(gSaveBlock1, 3),
+
+    SAVEBLOCK_CHUNK(gPokemonStorage, 0),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 1),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 2),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 3),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 4),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 5),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 6),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 7),
+    SAVEBLOCK_CHUNK(gPokemonStorage, 8),
 };
 
-const struct SaveSectionLocation gHallOfFameSaveSectionLocations[] =
+static const struct SaveBlockChunk sHallOfFameChunks[] =
 {
-    {((u8 *) eHallOfFame) + GETBLOCKOFFSET(1), GETCHUNKSIZE(struct HallOfFame, 1)}, // eHallOfFame is not a proper sym, so the struct must be used.
-    {((u8 *) eHallOfFame) + GETBLOCKOFFSET(2), GETCHUNKSIZE(struct HallOfFame, 2)}
+    SAVEBLOCK_CHUNK(*eHallOfFame, 0),
+    SAVEBLOCK_CHUNK(*eHallOfFame, 1),
 };
 
 const u8 gFlashSectors[] = { 0x1E, 0x1F };
 
-void ClearSaveData(void)
+void Save_EraseAllData(void)
 {
     u16 i;
 
@@ -60,27 +117,34 @@ void ClearSaveData(void)
         EraseFlashSector(i);
 }
 
-void ResetSaveCounters(void)
+void Save_ResetSaveCounters(void)
 {
     gSaveCounter = 0;
     gLastWrittenSector = 0;
     gDamagedSaveSectors = 0;
 }
 
-bool32 SetDamagedSectorBits(u8 op, u8 bit)
+enum
+{
+    ENABLE,
+    DISABLE,
+    CHECK // unused
+};
+
+static bool32 SetSectorDamagedStatus(u8 op, u8 sectorNum)
 {
     bool32 retVal = FALSE;
 
     switch (op)
     {
     case ENABLE:
-        gDamagedSaveSectors |= (1 << bit);
+        gDamagedSaveSectors |= (1 << sectorNum);
         break;
     case DISABLE:
-        gDamagedSaveSectors &= ~(1 << bit);
+        gDamagedSaveSectors &= ~(1 << sectorNum);
         break;
     case CHECK: // unused
-        if (gDamagedSaveSectors & (1 << bit))
+        if (gDamagedSaveSectors & (1 << sectorNum))
             retVal = TRUE;
         break;
     }
@@ -88,7 +152,7 @@ bool32 SetDamagedSectorBits(u8 op, u8 bit)
     return retVal;
 }
 
-u8 save_write_to_flash(u16 a1, const struct SaveSectionLocation *location)
+static u8 WriteSaveBlockChunks(u16 a1, const struct SaveBlockChunk *chunks)
 {
     u32 retVal;
     u16 i;
@@ -97,23 +161,24 @@ u8 save_write_to_flash(u16 a1, const struct SaveSectionLocation *location)
 
     if (a1 != 0xFFFF) // for link
     {
-        retVal = HandleWriteSector(a1, location);
+        retVal = WriteChunk(a1, chunks);
     }
     else
     {
         gLastKnownGoodSector = gLastWrittenSector; // backup the current written sector before attempting to write.
         gLastSaveCounter = gSaveCounter;
         gLastWrittenSector++;
-        gLastWrittenSector = gLastWrittenSector % ARRAY_COUNT(gSaveSectionLocations);
+        gLastWrittenSector %= ARRAY_COUNT(sSaveBlockChunks);
         gSaveCounter++;
-        retVal = 1;
+        retVal = SAVE_STATUS_OK;
 
-        for (i = 0; i < ARRAY_COUNT(gSaveSectionLocations); i++)
-            HandleWriteSector(i, location);
+        for (i = 0; i < ARRAY_COUNT(sSaveBlockChunks); i++)
+            WriteChunk(i, chunks);
 
+        // Check for any bad sectors
         if (gDamagedSaveSectors != 0) // skip the damaged sector.
         {
-            retVal = 0xFF;
+            retVal = SAVE_STATUS_ERROR;
             gLastWrittenSector = gLastKnownGoodSector;
             gSaveCounter = gLastSaveCounter;
         }
@@ -122,36 +187,35 @@ u8 save_write_to_flash(u16 a1, const struct SaveSectionLocation *location)
     return retVal;
 }
 
-u8 HandleWriteSector(u16 a1, const struct SaveSectionLocation *location)
+static u8 WriteChunk(u16 chunkId, const struct SaveBlockChunk *chunks)
 {
     u16 i;
-    u16 sector;
+    u16 sectorNum;
     u8 *data;
     u16 size;
 
-    sector = a1 + gLastWrittenSector;
-    sector %= ARRAY_COUNT(gSaveSectionLocations);
-    sector += ARRAY_COUNT(gSaveSectionLocations) * (gSaveCounter % 2);
+    sectorNum = chunkId + gLastWrittenSector;
+    sectorNum %= ARRAY_COUNT(sSaveBlockChunks);
+    sectorNum += ARRAY_COUNT(sSaveBlockChunks) * (gSaveCounter % 2);
 
-    data = location[a1].data;
-    size = location[a1].size;
+    data = chunks[chunkId].data;
+    size = chunks[chunkId].size;
 
     // clear save section.
     for (i = 0; i < sizeof(struct SaveSection); i++)
-        ((char *)gFastSaveSection)[i] = 0;
+        ((u8 *)gFastSaveSection)[i] = 0;
 
-    gFastSaveSection->id = a1;
-    gFastSaveSection->security = UNKNOWN_CHECK_VALUE;
+    gFastSaveSection->id = chunkId;
+    gFastSaveSection->signature = FILE_SIGNATURE;
     gFastSaveSection->counter = gSaveCounter;
-
     for (i = 0; i < size; i++)
         gFastSaveSection->data[i] = data[i];
-
     gFastSaveSection->checksum = CalculateChecksum(data, size);
-    return TryWriteSector(sector, gFastSaveSection->data);
+
+    return TryWriteSector(sectorNum, gFastSaveSection->data);
 }
 
-u8 HandleWriteSectorNBytes(u8 sector, u8 *data, u16 size)
+static u8 HandleWriteSectorNBytes(u8 sectorNum, u8 *data, u16 size)
 {
     u16 i;
     struct SaveSection *section = eSaveSection;
@@ -159,43 +223,42 @@ u8 HandleWriteSectorNBytes(u8 sector, u8 *data, u16 size)
     for (i = 0; i < sizeof(struct SaveSection); i++)
         ((char *)section)[i] = 0;
 
-    section->security = UNKNOWN_CHECK_VALUE;
-
+    section->signature = FILE_SIGNATURE;
     for (i = 0; i < size; i++)
         section->data[i] = data[i];
-
     section->id = CalculateChecksum(data, size); // though this appears to be incorrect, it might be some sector checksum instead of a whole save checksum and only appears to be relevent to HOF data, if used.
-    return TryWriteSector(sector, section->data);
+
+    return TryWriteSector(sectorNum, section->data);
 }
 
-u8 TryWriteSector(u8 sector, u8 *data)
+static u8 TryWriteSector(u8 sectorNum, u8 *data)
 {
-    if (ProgramFlashSectorAndVerify(sector, data) != 0) // is damaged?
+    if (ProgramFlashSectorAndVerify(sectorNum, data) != 0) // is damaged?
     {
-        SetDamagedSectorBits(ENABLE, sector); // set damaged sector bits.
-        return 0xFF;
+        SetSectorDamagedStatus(ENABLE, sectorNum); // set damaged sector bits.
+        return SAVE_STATUS_ERROR;
     }
     else
     {
-        SetDamagedSectorBits(DISABLE, sector); // unset damaged sector bits. it's safe now.
-        return 1;
+        SetSectorDamagedStatus(DISABLE, sectorNum); // unset damaged sector bits. it's safe now.
+        return SAVE_STATUS_OK;
     }
 }
 
-u32 RestoreSaveBackupVarsAndIncrement(const struct SaveSectionLocation *location) // location is unused
+static u32 RestoreSaveBackupVarsAndIncrement(const struct SaveBlockChunk *chunk) // chunk is unused
 {
     gFastSaveSection = eSaveSection;
     gLastKnownGoodSector = gLastWrittenSector;
     gLastSaveCounter = gSaveCounter;
     gLastWrittenSector++;
-    gLastWrittenSector = gLastWrittenSector % ARRAY_COUNT(gSaveSectionLocations);
+    gLastWrittenSector = gLastWrittenSector % ARRAY_COUNT(sSaveBlockChunks);
     gSaveCounter++;
     gUnknown_03005EB4 = 0;
     gDamagedSaveSectors = 0;
     return 0;
 }
 
-u32 RestoreSaveBackupVars(const struct SaveSectionLocation *location) // only ever called once, and gSaveBlock2 is passed to this function. location is unused
+static u32 RestoreSaveBackupVars(const struct SaveBlockChunk *chunk) // only ever called once, and gSaveBlock2 is passed to this function. chunk is unused
 {
     gFastSaveSection = eSaveSection;
     gLastKnownGoodSector = gLastWrittenSector;
@@ -205,14 +268,14 @@ u32 RestoreSaveBackupVars(const struct SaveSectionLocation *location) // only ev
     return 0;
 }
 
-u8 sub_812550C(u16 a1, const struct SaveSectionLocation *location)
+static u8 sub_812550C(u16 a1, const struct SaveBlockChunk *chunk)
 {
     u8 retVal;
 
     if (gUnknown_03005EB4 < a1 - 1)
     {
         retVal = 1;
-        HandleWriteSector(gUnknown_03005EB4, location);
+        WriteChunk(gUnknown_03005EB4, chunk);
         gUnknown_03005EB4++;
         if (gDamagedSaveSectors)
         {
@@ -229,11 +292,11 @@ u8 sub_812550C(u16 a1, const struct SaveSectionLocation *location)
     return retVal;
 }
 
-u8 sub_812556C(u16 a1, const struct SaveSectionLocation *location)
+static u8 sub_812556C(u16 a1, const struct SaveBlockChunk *chunk)
 {
     u8 retVal = 1;
 
-    sub_81255B8(a1 - 1, location);
+    sub_81255B8(a1 - 1, chunk);
 
     if (gDamagedSaveSectors)
     {
@@ -244,7 +307,7 @@ u8 sub_812556C(u16 a1, const struct SaveSectionLocation *location)
     return retVal;
 }
 
-u8 sub_81255B8(u16 a1, const struct SaveSectionLocation *location)
+static u8 sub_81255B8(u16 chunkId, const struct SaveBlockChunk *chunks)
 {
     u16 i;
     u16 sector;
@@ -252,19 +315,19 @@ u8 sub_81255B8(u16 a1, const struct SaveSectionLocation *location)
     u16 size;
     u8 status;
 
-    sector = a1 + gLastWrittenSector;
-    sector %= ARRAY_COUNT(gSaveSectionLocations);
-    sector += ARRAY_COUNT(gSaveSectionLocations) * (gSaveCounter % 2);
+    sector = chunkId + gLastWrittenSector;
+    sector %= ARRAY_COUNT(sSaveBlockChunks);
+    sector += ARRAY_COUNT(sSaveBlockChunks) * (gSaveCounter % 2);
 
-    data = location[a1].data;
-    size = location[a1].size;
+    data = chunks[chunkId].data;
+    size = chunks[chunkId].size;
 
     // clear temp save section.
     for (i = 0; i < sizeof(struct SaveSection); i++)
         ((char *)gFastSaveSection)[i] = 0;
 
-    gFastSaveSection->id = a1;
-    gFastSaveSection->security = UNKNOWN_CHECK_VALUE;
+    gFastSaveSection->id = chunkId;
+    gFastSaveSection->signature = FILE_SIGNATURE;
     gFastSaveSection->counter = gSaveCounter;
 
     // set temp section's data.
@@ -289,7 +352,7 @@ u8 sub_81255B8(u16 a1, const struct SaveSectionLocation *location)
 
     if (status == 0xFF)
     {
-        SetDamagedSectorBits(ENABLE, sector);
+        SetSectorDamagedStatus(ENABLE, sector);
         return 0xFF;
     }
     else
@@ -307,224 +370,220 @@ u8 sub_81255B8(u16 a1, const struct SaveSectionLocation *location)
 
         if (status == 0xFF)
         {
-            SetDamagedSectorBits(ENABLE, sector);
+            SetSectorDamagedStatus(ENABLE, sector);
             return 0xFF;
         }
         else
         {
-            SetDamagedSectorBits(DISABLE, sector);
+            SetSectorDamagedStatus(DISABLE, sector);
             return 1;
         }
     }
 }
 
-u8 sub_8125758(u16 a1, const struct SaveSectionLocation *location)
+static u8 sub_8125758(u16 a1, const struct SaveBlockChunk *chunk)
 {
     u16 sector;
 
     sector = a1 + gLastWrittenSector - 1;
-    sector %= ARRAY_COUNT(gSaveSectionLocations);
-    sector += ARRAY_COUNT(gSaveSectionLocations) * (gSaveCounter % 2);
+    sector %= ARRAY_COUNT(sSaveBlockChunks);
+    sector += ARRAY_COUNT(sSaveBlockChunks) * (gSaveCounter % 2);
 
     if (ProgramFlashByte(sector, sizeof(struct UnkSaveSection), ((u8 *)gFastSaveSection)[sizeof(struct UnkSaveSection)]))
     {
         // sector is damaged, so enable the bit in gDamagedSaveSectors and restore the last written sector and save counter.
-        SetDamagedSectorBits(ENABLE, sector);
+        SetSectorDamagedStatus(ENABLE, sector);
         gLastWrittenSector = gLastKnownGoodSector;
         gSaveCounter = gLastSaveCounter;
-        return 0xFF;
+        return SAVE_STATUS_ERROR;
     }
     else
     {
-        SetDamagedSectorBits(DISABLE, sector);
-        return 1;
+        SetSectorDamagedStatus(DISABLE, sector);
+        return SAVE_STATUS_OK;
     }
 }
 
-u8 sub_81257F0(u16 a1, const struct SaveSectionLocation *location)
+static u8 sub_81257F0(u16 a1, const struct SaveBlockChunk *chunk)
 {
     u16 sector;
 
     sector = a1 + gLastWrittenSector - 1;
-    sector %= ARRAY_COUNT(gSaveSectionLocations);
-    sector += ARRAY_COUNT(gSaveSectionLocations) * (gSaveCounter % 2);
+    sector %= ARRAY_COUNT(sSaveBlockChunks);
+    sector += ARRAY_COUNT(sSaveBlockChunks) * (gSaveCounter % 2);
 
     if (ProgramFlashByte(sector, sizeof(struct UnkSaveSection), 0x25))
     {
         // sector is damaged, so enable the bit in gDamagedSaveSectors and restore the last written sector and save counter.
-        SetDamagedSectorBits(ENABLE, sector);
+        SetSectorDamagedStatus(ENABLE, sector);
         gLastWrittenSector = gLastKnownGoodSector;
         gSaveCounter = gLastSaveCounter;
-        return 0xFF;
+        return SAVE_STATUS_ERROR;
     }
     else
     {
-        SetDamagedSectorBits(DISABLE, sector);
-        return 1;
+        SetSectorDamagedStatus(DISABLE, sector);
+        return SAVE_STATUS_OK;
     }
 }
 
-u8 sub_812587C(u16 a1, const struct SaveSectionLocation *location)
+static u8 sub_812587C(u16 a1, const struct SaveBlockChunk *chunk)
 {
     u8 retVal;
     gFastSaveSection = eSaveSection;
     if (a1 != 0xFFFF)
     {
-        retVal = 0xFF;
+        retVal = SAVE_STATUS_ERROR;
     }
     else
     {
-        retVal = GetSaveValidStatus(location);
-        sub_81258BC(0xFFFF, location);
+        retVal = GetSaveValidStatus(chunk);
+        sub_81258BC(0xFFFF, chunk);
     }
 
     return retVal;
 }
 
-u8 sub_81258BC(u16 a1, const struct SaveSectionLocation *location)
+static u8 sub_81258BC(u16 a1, const struct SaveBlockChunk *chunks)
 {
     u16 i;
     u16 checksum;
-    u16 v3 = ARRAY_COUNT(gSaveSectionLocations) * (gSaveCounter % 2);
+    u16 v3 = ARRAY_COUNT(sSaveBlockChunks) * (gSaveCounter % 2);
     u16 id;
 
-    for (i = 0; i < ARRAY_COUNT(gSaveSectionLocations); i++)
+    for (i = 0; i < ARRAY_COUNT(sSaveBlockChunks); i++)
     {
         DoReadFlashWholeSection(i + v3, gFastSaveSection);
         id = gFastSaveSection->id;
         if (id == 0)
             gLastWrittenSector = i;
-        checksum = CalculateChecksum(gFastSaveSection->data, location[id].size);
-        if (gFastSaveSection->security == UNKNOWN_CHECK_VALUE
+        checksum = CalculateChecksum(gFastSaveSection->data, chunks[id].size);
+        if (gFastSaveSection->signature == FILE_SIGNATURE
          && gFastSaveSection->checksum == checksum)
         {
             u16 j;
-            for (j = 0; j < location[id].size; j++)
-                location[id].data[j] = gFastSaveSection->data[j];
+            for (j = 0; j < chunks[id].size; j++)
+                chunks[id].data[j] = gFastSaveSection->data[j];
         }
     }
 
     return 1;
 }
 
-u8 GetSaveValidStatus(const struct SaveSectionLocation *location)
+static u8 GetSaveValidStatus(const struct SaveBlockChunk *chunks)
 {
     u16 i;
+    bool8 signatureValid;
     u16 checksum;
     u32 saveSlot1Counter = 0;
     u32 saveSlot2Counter = 0;
-    u32 slotCheckField = 0;
-    bool8 securityPassed = FALSE;
-    u8 saveSlot1Status;
-    u8 saveSlot2Status;
+    u8 slot1Status;
+    u8 slot2Status;
+    u32 validChunks;
+    const u32 ALL_CHUNKS = (1 << ARRAY_COUNT(sSaveBlockChunks)) - 1;  // bitmask of all saveblock chunks
 
     // check save slot 1.
-    for (i = 0; i < ARRAY_COUNT(gSaveSectionLocations); i++)
+    validChunks = 0;
+    signatureValid = FALSE;
+    for (i = 0; i < ARRAY_COUNT(sSaveBlockChunks); i++)
     {
         DoReadFlashWholeSection(i, gFastSaveSection);
-        if (gFastSaveSection->security == UNKNOWN_CHECK_VALUE)
+        if (gFastSaveSection->signature == FILE_SIGNATURE)
         {
-            securityPassed = TRUE;
-            checksum = CalculateChecksum(gFastSaveSection->data, location[gFastSaveSection->id].size);
+            signatureValid = TRUE;
+            checksum = CalculateChecksum(gFastSaveSection->data, chunks[gFastSaveSection->id].size);
             if (gFastSaveSection->checksum == checksum)
             {
                 saveSlot1Counter = gFastSaveSection->counter;
-                slotCheckField |= 1 << gFastSaveSection->id;
+                validChunks |= 1 << gFastSaveSection->id;
             }
         }
     }
 
-    if (securityPassed)
+    if (signatureValid)
     {
-        if (slotCheckField == GETVALIDSTATUSBITFIELD)
-            saveSlot1Status = 1;
+        if (validChunks == ALL_CHUNKS)
+            slot1Status = SAVE_STATUS_OK;
         else
-            saveSlot1Status = 255;
+            slot1Status = SAVE_STATUS_ERROR;
     }
     else
     {
-        saveSlot1Status = 0;
+        slot1Status = SAVE_STATUS_EMPTY;
     }
 
-    slotCheckField = 0;
-    securityPassed = FALSE;
-
     // check save slot 2.
-    for (i = 0; i < ARRAY_COUNT(gSaveSectionLocations); i++)
+    validChunks = 0;
+    signatureValid = FALSE;
+    for (i = 0; i < ARRAY_COUNT(sSaveBlockChunks); i++)
     {
-        DoReadFlashWholeSection(i + ARRAY_COUNT(gSaveSectionLocations), gFastSaveSection);
-        if (gFastSaveSection->security == UNKNOWN_CHECK_VALUE)
+        DoReadFlashWholeSection(i + ARRAY_COUNT(sSaveBlockChunks), gFastSaveSection);
+        if (gFastSaveSection->signature == FILE_SIGNATURE)
         {
-            securityPassed = TRUE;
-            checksum = CalculateChecksum(gFastSaveSection->data, location[gFastSaveSection->id].size);
+            signatureValid = TRUE;
+            checksum = CalculateChecksum(gFastSaveSection->data, chunks[gFastSaveSection->id].size);
             if (gFastSaveSection->checksum == checksum)
             {
                 saveSlot2Counter = gFastSaveSection->counter;
-                slotCheckField |= 1 << gFastSaveSection->id;
+                validChunks |= 1 << gFastSaveSection->id;
             }
         }
     }
 
-    if (securityPassed)
+    if (signatureValid)
     {
-        if (slotCheckField == GETVALIDSTATUSBITFIELD)
-            saveSlot2Status = 1;
+        if (validChunks == ALL_CHUNKS)
+            slot2Status = SAVE_STATUS_OK;
         else
-            saveSlot2Status = 255;
+            slot2Status = SAVE_STATUS_ERROR;
     }
     else
     {
-        saveSlot2Status = 0;
+        slot2Status = SAVE_STATUS_EMPTY;
     }
 
-    if (saveSlot1Status == 1 && saveSlot2Status == 1)
+    if (slot1Status == SAVE_STATUS_OK && slot2Status == SAVE_STATUS_OK)
     {
         if ((saveSlot1Counter == -1 && saveSlot2Counter == 0) || (saveSlot1Counter == 0 && saveSlot2Counter == -1))
         {
             if ((unsigned)(saveSlot1Counter + 1) < (unsigned)(saveSlot2Counter + 1))
-            {
                 gSaveCounter = saveSlot2Counter;
-            }
             else
-            {
                 gSaveCounter = saveSlot1Counter;
-            }
         }
         else
         {
             if (saveSlot1Counter < saveSlot2Counter)
-            {
                 gSaveCounter = saveSlot2Counter;
-            }
             else
-            {
                 gSaveCounter = saveSlot1Counter;
-            }
         }
-        return 1;
+        return SAVE_STATUS_OK;
     }
 
-    if (saveSlot1Status == 1)
+    if (slot1Status == SAVE_STATUS_OK)
     {
         gSaveCounter = saveSlot1Counter;
-        if (saveSlot2Status == 255)
-            return 255;
-        return 1;
+        if (slot2Status == SAVE_STATUS_ERROR)
+            return SAVE_STATUS_ERROR;
+        else
+            return SAVE_STATUS_OK;
     }
 
-    if (saveSlot2Status == 1)
+    if (slot2Status == SAVE_STATUS_OK)
     {
         gSaveCounter = saveSlot2Counter;
-        if (saveSlot1Status == 255)
-            return 255;
-        return 1;
+        if (slot1Status == SAVE_STATUS_ERROR)
+            return SAVE_STATUS_ERROR;
+        else
+            return SAVE_STATUS_OK;
     }
 
-    if (saveSlot1Status == 0 && saveSlot2Status == 0)
+    if (slot1Status == SAVE_STATUS_EMPTY && slot2Status == SAVE_STATUS_EMPTY)
     {
         gSaveCounter = 0;
         gLastWrittenSector = 0;
-        return 0;
+        return SAVE_STATUS_EMPTY;
     }
 
     gSaveCounter = 0;
@@ -532,12 +591,13 @@ u8 GetSaveValidStatus(const struct SaveSectionLocation *location)
     return 2;
 }
 
-u8 sub_8125B88(u8 a1, u8 *data, u16 size)
+static u8 sub_8125B88(u8 a1, u8 *data, u16 size)
 {
     u16 i;
     struct SaveSection *section = eSaveSection;
+
     DoReadFlashWholeSection(a1, section);
-    if (section->security == UNKNOWN_CHECK_VALUE)
+    if (section->signature == FILE_SIGNATURE)
     {
         u16 checksum = CalculateChecksum(section->data, size);
         if (section->id == checksum)
@@ -557,13 +617,13 @@ u8 sub_8125B88(u8 a1, u8 *data, u16 size)
     }
 }
 
-u8 DoReadFlashWholeSection(u8 sector, struct SaveSection *section)
+static u8 DoReadFlashWholeSection(u8 sector, struct SaveSection *section)
 {
     ReadFlash(sector, 0, section->data, sizeof(struct SaveSection));
     return 1;
 }
 
-u16 CalculateChecksum(void *data, u16 size)
+static u16 CalculateChecksum(void *data, u16 size)
 {
     u16 i;
     u32 checksum = 0;
@@ -574,55 +634,59 @@ u16 CalculateChecksum(void *data, u16 size)
     return ((checksum >> 16) + checksum);
 }
 
-u8 HandleSavingData(u8 saveType)
+u8 Save_WriteDataInternal(u8 saveType)
 {
     u8 i;
+
     switch (saveType)
     {
-    case HOF_DELETE_SAVE: // deletes HOF before overwriting HOF completely. unused
-        for (i = (ARRAY_COUNT(gSaveSectionLocations) * 2 + 0); i < TOTALNUMSECTORS; i++)
+    case SAVE_HALL_OF_FAME_ERASE_BEFORE: // wipes all normal save data, then saves hall of fame, unused
+        for (i = (ARRAY_COUNT(sSaveBlockChunks) * 2 + 0); i < TOTALNUMSECTORS; i++)
             EraseFlashSector(i);
-    case HOF_SAVE: // hall of fame.
+        // fall through
+    case SAVE_HALL_OF_FAME: // hall of fame.
         if (GetGameStat(10) < 999)
             IncrementGameStat(10);
-        for (i = 0; i < ARRAY_COUNT(gHallOfFameSaveSectionLocations); i++)
-            HandleWriteSectorNBytes((ARRAY_COUNT(gSaveSectionLocations) * 2 + 0) + i, gHallOfFameSaveSectionLocations[i].data, gHallOfFameSaveSectionLocations[i].size);
+        for (i = 0; i < ARRAY_COUNT(sHallOfFameChunks); i++)
+            HandleWriteSectorNBytes((ARRAY_COUNT(sSaveBlockChunks) * 2 + 0) + i, sHallOfFameChunks[i].data, sHallOfFameChunks[i].size);
         SaveSerializedGame();
-        save_write_to_flash(0xFFFF, gSaveSectionLocations);
+        WriteSaveBlockChunks(0xFFFF, sSaveBlockChunks);
         break;
-    case NORMAL_SAVE: // normal save. also called by overwriting your own save.
+    case SAVE_NORMAL: // normal save. also called by overwriting your own save.
     default:
         SaveSerializedGame();
-        save_write_to_flash(0xFFFF, gSaveSectionLocations);
+        WriteSaveBlockChunks(0xFFFF, sSaveBlockChunks);
         break;
-    case LINK_SAVE: // link save. updates only gSaveBlock1 and gSaveBlock2.
+    case SAVE_LINK: // link save. updates only gSaveBlock1 and gSaveBlock2.
         SaveSerializedGame();
         for (i = 0; i < 5; i++)
-            save_write_to_flash(i, gSaveSectionLocations);
+            WriteSaveBlockChunks(i, sSaveBlockChunks);
         break;
-    case EREADER_SAVE: // used in mossdeep "game corner" before/after battling old man e-reader trainer
+    case SAVE_EREADER: // used in mossdeep "game corner" before/after battling old man e-reader trainer
         SaveSerializedGame();
-        save_write_to_flash(0, gSaveSectionLocations);
+        WriteSaveBlockChunks(0, sSaveBlockChunks);
         break;
-    case DIFFERENT_FILE_SAVE: // there is a different file, so erase the file and overwrite it completely.
-        for (i = (ARRAY_COUNT(gSaveSectionLocations) * 2 + 0); i < TOTALNUMSECTORS; i++)
+    case SAVE_OVERWRITE_DIFFERENT_FILE: // there is a different file, so erase the file and overwrite it completely.
+        for (i = (ARRAY_COUNT(sSaveBlockChunks) * 2 + 0); i < TOTALNUMSECTORS; i++)
             EraseFlashSector(i); // erase HOF.
         SaveSerializedGame();
-        save_write_to_flash(0xFFFF, gSaveSectionLocations);
+        WriteSaveBlockChunks(0xFFFF, sSaveBlockChunks);
         break;
     }
     return 0;
 }
 
-u8 TrySavingData(u8 saveType) // TrySave
+u8 Save_WriteData(u8 saveType) // TrySave
 {
     if (gFlashMemoryPresent != TRUE)
-        return 0xFF;
-    HandleSavingData(saveType);
+        return SAVE_STATUS_ERROR;
+
+    Save_WriteDataInternal(saveType);
     if (!gDamagedSaveSectors)
-        return 1;
+        return SAVE_STATUS_OK;
+
     DoSaveFailedScreen(saveType);
-    return 0xFF;
+    return SAVE_STATUS_ERROR;
 }
 
 u8 sub_8125D80(void) // trade.s save
@@ -630,16 +694,16 @@ u8 sub_8125D80(void) // trade.s save
     if (gFlashMemoryPresent != TRUE)
         return 1;
     SaveSerializedGame();
-    RestoreSaveBackupVarsAndIncrement(gSaveSectionLocations);
+    RestoreSaveBackupVarsAndIncrement(sSaveBlockChunks);
     return 0;
 }
 
 bool8 sub_8125DA8(void) // trade.s save
 {
-    u8 retVal = sub_812550C(ARRAY_COUNT(gSaveSectionLocations), gSaveSectionLocations);
+    u8 retVal = sub_812550C(ARRAY_COUNT(sSaveBlockChunks), sSaveBlockChunks);
     if (gDamagedSaveSectors)
         DoSaveFailedScreen(0);
-    if (retVal == 0xFF)
+    if (retVal == SAVE_STATUS_ERROR)
         return 1;
     else
         return 0;
@@ -647,7 +711,7 @@ bool8 sub_8125DA8(void) // trade.s save
 
 u8 sub_8125DDC(void) // trade.s save
 {
-    sub_812556C(ARRAY_COUNT(gSaveSectionLocations), gSaveSectionLocations);
+    sub_812556C(ARRAY_COUNT(sSaveBlockChunks), sSaveBlockChunks);
     if (gDamagedSaveSectors)
         DoSaveFailedScreen(0);
     return 0;
@@ -655,7 +719,7 @@ u8 sub_8125DDC(void) // trade.s save
 
 u8 sub_8125E04(void) // trade.s save
 {
-    sub_8125758(ARRAY_COUNT(gSaveSectionLocations), gSaveSectionLocations);
+    sub_8125758(ARRAY_COUNT(sSaveBlockChunks), sSaveBlockChunks);
     if (gDamagedSaveSectors)
         DoSaveFailedScreen(0);
     return 0;
@@ -667,8 +731,8 @@ u8 sub_8125E2C(void)
         return 1;
 
     SaveSerializedGame();
-    RestoreSaveBackupVars(gSaveSectionLocations);
-    sub_812556C(gUnknown_03005EB4 + 1, gSaveSectionLocations);
+    RestoreSaveBackupVars(sSaveBlockChunks);
+    sub_812556C(gUnknown_03005EB4 + 1, sSaveBlockChunks);
     return 0;
 }
 
@@ -678,12 +742,12 @@ bool8 sub_8125E6C(void)
     u16 val = ++gUnknown_03005EB4;
     if (val <= 4)
     {
-        sub_812556C(gUnknown_03005EB4 + 1, gSaveSectionLocations);
-        sub_81257F0(val, gSaveSectionLocations);
+        sub_812556C(gUnknown_03005EB4 + 1, sSaveBlockChunks);
+        sub_81257F0(val, sSaveBlockChunks);
     }
     else
     {
-        sub_81257F0(val, gSaveSectionLocations);
+        sub_81257F0(val, sSaveBlockChunks);
         retVal = TRUE;
     }
     if (gDamagedSaveSectors)
@@ -697,23 +761,23 @@ u8 sub_8125EC8(u8 a1)
 
     if (gFlashMemoryPresent != TRUE)
     {
-        gSaveFileStatus = 4;
-        return 0xFF;
+        gSaveFileStatus = SAVE_STATUS_NO_FLASH;
+        return SAVE_STATUS_ERROR;
     }
 
     switch (a1)
     {
     case 0:
     default:
-        result = sub_812587C(0xFFFF, gSaveSectionLocations);
+        result = sub_812587C(0xFFFF, sSaveBlockChunks);
         LoadSerializedGame();
         gSaveFileStatus = result;
         gGameContinueCallback = 0;
         break;
     case 3:
-        result = sub_8125B88((ARRAY_COUNT(gSaveSectionLocations) * 2 + 0), gHallOfFameSaveSectionLocations[0].data, gHallOfFameSaveSectionLocations[0].size);
+        result = sub_8125B88((ARRAY_COUNT(sSaveBlockChunks) * 2 + 0), sHallOfFameChunks[0].data, sHallOfFameChunks[0].size);
         if (result == 1)
-            result = sub_8125B88((ARRAY_COUNT(gSaveSectionLocations) * 2 + 1), gHallOfFameSaveSectionLocations[1].data, gHallOfFameSaveSectionLocations[1].size);
+            result = sub_8125B88((ARRAY_COUNT(sSaveBlockChunks) * 2 + 1), sHallOfFameChunks[1].data, sHallOfFameChunks[1].size);
         break;
     }
 
@@ -730,7 +794,7 @@ bool8 unref_sub_8125F4C(struct UnkSaveSection *a1)
 
     ReadFlash(gFlashSectors[0], 0, a1->data, 4096);
 
-    if (a1->security != UNKNOWN_CHECK_VALUE)
+    if (a1->signature != FILE_SIGNATURE)
         return FALSE;
 
     return TRUE;
@@ -739,7 +803,7 @@ bool8 unref_sub_8125F4C(struct UnkSaveSection *a1)
 u8 unref_sub_8125FA0(void)
 {
     u16 i;
-    u8 v0 = TrySavingData(0);
+    u8 v0 = Save_WriteData(0);
 
     for (i = 0; i < 2; i++)
         EraseFlashSector(gFlashSectors[i]);
@@ -767,7 +831,7 @@ u8 unref_sub_8125FF0(u8 *data, u16 size)
     for (i = 0; i < sizeof(struct SaveSection); i++)
         ((char *)section)[i] = 0;
 
-    section->security = UNKNOWN_CHECK_VALUE;
+    section->signature = FILE_SIGNATURE;
 
     for (i = 0; i < size; i++)
         section->data[i] = data[i];
@@ -775,17 +839,17 @@ u8 unref_sub_8125FF0(u8 *data, u16 size)
     gLastSaveSectorStatus = ProgramFlashSectorAndVerifyNBytes(gFlashSectors[0], section, sizeof(struct SaveSection));
 
     if (gLastSaveSectorStatus)
-        return 0xFF;
+        return SAVE_STATUS_ERROR;
     else
-        return 1;
+        return SAVE_STATUS_OK;
 }
 
 u8 unref_sub_8126068(u8 sector, u8 *data, u32 size)
 {
     if (ProgramFlashSectorAndVerify(sector, data))
-        return 255;
+        return SAVE_STATUS_ERROR;
     else
-        return 1;
+        return SAVE_STATUS_OK;
 }
 
 u8 unref_sub_8126080(u8 sector, u8 *data)
diff --git a/src/engine/save_failed_screen.c b/src/engine/save_failed_screen.c
index 64b84a2f7..74a1e9612 100644
--- a/src/engine/save_failed_screen.c
+++ b/src/engine/save_failed_screen.c
@@ -166,7 +166,7 @@ static void CB2_WipeSave(void)
 
         Menu_DrawStdWindowFrame(1, MSG_WIN_TOP, 28, 19);
         Menu_PrintText(gSystemText_CheckCompleteSaveAttempt, 2, MSG_WIN_TOP + 1);
-        HandleSavingData(gSaveFailedType);
+        Save_WriteDataInternal(gSaveFailedType);
 
         if (gDamagedSaveSectors != 0)
         {
diff --git a/src/field/battle_tower.c b/src/field/battle_tower.c
index 11c05e478..ab2a818a7 100644
--- a/src/field/battle_tower.c
+++ b/src/field/battle_tower.c
@@ -1895,7 +1895,7 @@ void SaveBattleTowerProgress(void)
 
     VarSet(VAR_TEMP_0, 0);
     gSaveBlock2.battleTower.unk_554 = 1;
-    TrySavingData(EREADER_SAVE);
+    Save_WriteData(SAVE_EREADER);
 }
 
 void BattleTower_SoftReset(void)
diff --git a/src/field/start_menu.c b/src/field/start_menu.c
index 2f6f1e7dd..87597eb6a 100644
--- a/src/field/start_menu.c
+++ b/src/field/start_menu.c
@@ -664,20 +664,20 @@ static u8 SaveDialogCB_DisplaySavingMessage(void)
 
 static u8 SaveDialogCB_DoSave(void)
 {
-    bool8 saveSucceeded;
+    u8 saveStatus;
 
     IncrementGameStat(0);
     if (gDifferentSaveFile == TRUE)
     {
-        saveSucceeded = TrySavingData(DIFFERENT_FILE_SAVE);
+        saveStatus = Save_WriteData(SAVE_OVERWRITE_DIFFERENT_FILE);
         gDifferentSaveFile = FALSE;
     }
     else
     {
-        saveSucceeded = TrySavingData(NORMAL_SAVE);
+        saveStatus = Save_WriteData(SAVE_NORMAL);
     }
 
-    if (saveSucceeded == TRUE)
+    if (saveStatus == SAVE_STATUS_OK)
     {
         //"(Player) saved the game."
         DisplaySaveMessageWithCallback(gSaveText_PlayerSavedTheGame, SaveDialogCB_SaveSuccess);
diff --git a/src/scene/hall_of_fame.c b/src/scene/hall_of_fame.c
index 303dcf3e0..9e7e50d43 100644
--- a/src/scene/hall_of_fame.c
+++ b/src/scene/hall_of_fame.c
@@ -566,7 +566,7 @@ static void sub_814217C(u8 taskID)
 static void sub_8142274(u8 taskID)
 {
     gGameContinueCallback = sub_8141FC4;
-    TrySavingData(3);
+    Save_WriteData(3);
     PlaySE(SE_SAVE);
     gTasks[taskID].func = sub_81422B8;
     gTasks[taskID].tFrameCount = 32;
diff --git a/src/scene/intro.c b/src/scene/intro.c
index d7d772a40..d680e4a98 100644
--- a/src/scene/intro.c
+++ b/src/scene/intro.c
@@ -930,7 +930,7 @@ void CB2_InitCopyrightScreenAfterBootup(void)
     if (!SetUpCopyrightScreen())
     {
         sub_8052E4C();
-        ResetSaveCounters();
+        Save_ResetSaveCounters();
         sub_8125EC8(0);
         if (gSaveFileStatus == 0 || gSaveFileStatus == 2)
             ClearSav2();