Minimal ED64 support

Makefile

@@ -32,6 +32,9 @@ SRCS = \
 	flashcart/flashcart.c \
 	flashcart/sc64/sc64_ll.c \
 	flashcart/sc64/sc64.c \
+	flashcart/ed64/ed64_ll.c \
+	flashcart/ed64/ed64_state.c \
+	flashcart/ed64/ed64.c \
 	libs/libspng/spng/spng.c \
 	libs/mini.c/src/mini.c \
 	libs/miniz/miniz_tdef.c \

README.md

@@ -74,10 +74,12 @@ If required, you can manually adjust the file on the SD card using your computer
 * Download the latest `menu.bin` file from the [releases](https://github.com/Polprzewodnikowy/N64FlashcartMenu/releases/) page, then put it in the root directory of your SD card.
 
 
-### ED64 & ED64P
-Currently not supported, but work is in progress (See [PR's](https://github.com/Polprzewodnikowy/N64FlashcartMenu/pulls)).
+### ED64
+#### ED64 (V or X series)
+Download the `OS64.v64` ROM from the latest action run assets and place it in the `/ED64` folder.
 
-The aim is to replace [Altra64](https://github.com/networkfusion/altra64) and [ED64-UnofficialOS](https://github.com/n64-tools/ED64-UnofficialOS-binaries).
+#### ED64 (P clone)
+Download the `OS64P.v64` ROM from the latest action run assets and place it in the `/ED64P` folder.
 
 
 # Open source software and licenses used

src/flashcart/ed64/README.md

@@ -0,0 +1 @@
+This folder allows support for the ED64(P) flashcart when using V series hardware.

src/flashcart/ed64/ed64.c

@@ -0,0 +1,322 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <fatfs/ff.h>
+#include <libdragon.h>
+#include <libcart/cart.h>
+
+#include "utils/fs.h"
+#include "utils/utils.h"
+
+#include "../flashcart_utils.h"
+#include "ed64_ll.h"
+#include "ed64.h"
+#include "ed64_state.h"
+
+#define ED64_STATE_FILE  "ed64_state.ini"
+
+#ifndef ED64_OS_DIRECTORY
+#define ED64_OS_DIRECTORY  "/ED64"
+#endif
+
+static ed64_pseudo_writeback_t current_state;
+
+extern int ed_exit (void);
+
+static flashcart_err_t ed64_init (void) {
+
+    // TODO: partly already done, see https://github.com/DragonMinded/libdragon/blob/4ec469d26b6dc4e308caf3d5b86c2b340b708bbd/src/libcart/cart.c#L1064
+
+    // FIXME: Update firmware if needed.
+    // FIXME: Enable RTC if available.
+
+    // older everdrives cannot save during gameplay so we need to the reset method.
+    // works by checking if a file exists.
+
+    // FIXME: should put the file in the OS dir (ED64_OS_DIRECTORY), but different if a clone (ED64P).
+    char *state_path = "sd:/menu/"ED64_STATE_FILE;
+    ed64_state_init(state_path);
+    ed64_state_load(&current_state);
+
+    if (current_state.is_expecting_save_writeback == true) {
+
+        // make sure next boot does not trigger the check changing its state.
+        current_state.is_expecting_save_writeback = false;
+        ed64_state_save(&current_state);
+
+        // Now save the content back to the SD card!
+        FIL fil;
+        UINT bw;
+        uint8_t cartsave_data[KiB(128)];
+
+        // find the path to last save
+        if (file_exists(strip_fs_prefix(current_state.last_save_path))) {
+
+            int save_size = file_get_size(current_state.last_save_path);
+
+            if ((f_open(&fil, strip_fs_prefix(current_state.last_save_path), FA_CREATE_ALWAYS | FA_WRITE)) != FR_OK) {
+                return FLASHCART_ERR_LOAD;
+            }
+
+            // everdrive doesn't care about the save type other than flash sram and eeprom
+            // so minus flashram we can just check the size
+            if (current_state.is_fram_save_type == true) { // flashram is bugged atm
+               ed64_ll_get_fram(cartsave_data, save_size);
+              // deletes flag
+              current_state.is_fram_save_type = false;
+              ed64_state_save(&current_state);
+            }
+            else if (save_size > KiB(2)) { // sram
+               ed64_ll_get_sram(cartsave_data, save_size);
+            }
+            else { // eeprom
+               ed64_ll_get_eeprom(cartsave_data, save_size);
+            }
+
+            if (f_write(&fil, cartsave_data, save_size, &bw) != FR_OK) {
+                return FLASHCART_ERR_LOAD;
+            }
+
+            if (f_close(&fil) != FR_OK) {
+                return FLASHCART_ERR_LOAD;
+            }
+        }
+        else {
+            current_state.is_expecting_save_writeback = false;
+            current_state.is_fram_save_type = false;
+            current_state.last_save_path = "";
+            ed64_state_save(&current_state);
+        }
+    }
+    return FLASHCART_OK;
+}
+
+static flashcart_err_t ed64_deinit (void) {
+
+    // save the state file.
+    ed64_state_save(&current_state);
+    // For the moment, just use libCart exit.
+    ed_exit();
+
+    return FLASHCART_OK;
+}
+
+static bool ed64_has_feature (flashcart_features_t feature) {
+    switch (feature) {
+        case FLASHCART_FEATURE_64DD:
+        // FIXME: this is not valid for the V3, as does contain them:
+        case FLASHCART_FEATURE_RTC:
+        case FLASHCART_FEATURE_USB:
+            return false;
+        default:
+            return false;
+    }
+}
+
+static flashcart_err_t ed64_load_rom (char *rom_path, flashcart_progress_callback_t *progress) {
+
+    FIL fil;
+    UINT br;
+
+    if (f_open(&fil, strip_fs_prefix(rom_path), FA_READ) != FR_OK) {
+        return FLASHCART_ERR_LOAD;
+    }
+
+    fatfs_fix_file_size(&fil);
+
+    size_t rom_size = f_size(&fil);
+
+    // FIXME: if the cart is not V3 or X5 or X7, we need probably need to - 128KiB for save compatibility.
+    // Or somehow warn that certain ROM's will have corruption due to the address space being used for saves.
+    // Conker's Bad Fur Day doesn't have this issue because eeprom data is at a fixed address in pif ram.
+    if (rom_size > MiB(64)) {
+        f_close(&fil);
+        return FLASHCART_ERR_LOAD;
+    }
+
+    // FIXME: is this actually needed?
+    /*
+    if (rom_size == MiB(64)) {
+        ed64_save_type_t type = ed64_ll_get_save_type();
+        switch (type) {
+            case SAVE_TYPE_SRAM:
+                rom_size -= KiB(32);
+                break;
+            case SAVE_TYPE_SRAM_128K:
+            case SAVE_TYPE_FLASHRAM:
+                rom_size -= KiB(128);
+                break;
+            case SAVE_TYPE_DD64_CART_PORT:
+                break;
+            default:
+                break;
+        }
+    }
+    */
+
+    size_t sdram_size = rom_size;
+
+    size_t chunk_size = MiB(1);
+    for (int offset = 0; offset < sdram_size; offset += chunk_size)
+    {
+        size_t block_size = MIN(sdram_size - offset, chunk_size);
+        if (f_read(&fil, (void *)(ROM_ADDRESS + offset), block_size, &br) != FR_OK) {
+            f_close(&fil);
+            return FLASHCART_ERR_LOAD;
+        }
+        if (progress) {
+            progress(f_tell(&fil) / (float)(f_size(&fil)));
+        }
+    }
+
+    if (f_close(&fil) != FR_OK) {
+        return FLASHCART_ERR_LOAD;
+    }
+
+    return FLASHCART_OK;
+}
+
+static flashcart_err_t ed64_load_file (char *file_path, uint32_t rom_offset, uint32_t file_offset)
+{
+    FIL fil;
+    UINT br;
+
+    if (f_open(&fil, strip_fs_prefix(file_path), FA_READ) != FR_OK) {
+        return FLASHCART_ERR_LOAD;
+    }
+
+    fatfs_fix_file_size(&fil);
+
+    size_t file_size = f_size(&fil) - file_offset;
+
+    // FIXME: if the cart is not V3 or X5 or X7, we need probably need to - 128KiB for save compatibility.
+    // Or somehow warn that certain ROM's will have corruption due to the address space being used for saves.
+
+    if (file_size > (MiB(64) - rom_offset)) {
+        f_close(&fil);
+        return FLASHCART_ERR_ARGS;
+    }
+
+    if (f_lseek(&fil, file_offset) != FR_OK) {
+        f_close(&fil);
+        return FLASHCART_ERR_LOAD;
+    }
+
+    if (f_read(&fil, (void *)(ROM_ADDRESS + rom_offset), file_size, &br) != FR_OK) {
+        f_close(&fil);
+        return FLASHCART_ERR_LOAD;
+    }
+    if (br != file_size) {
+        f_close(&fil);
+        return FLASHCART_ERR_LOAD;
+    }
+
+    if (f_close(&fil) != FR_OK) {
+        return FLASHCART_ERR_LOAD;
+    }
+
+    return FLASHCART_OK;
+}
+
+static flashcart_err_t ed64_load_save (char *save_path) {
+
+    FIL fil;
+    UINT br;
+
+    if (f_open(&fil, strip_fs_prefix(save_path), FA_READ) != FR_OK) {
+        return FLASHCART_ERR_LOAD;
+    }
+
+    size_t save_size = file_get_size(save_path);
+    uint8_t cartsave_data[save_size];
+
+    if (f_read(&fil, cartsave_data, save_size, &br) != FR_OK) {
+        f_close(&fil);
+        return FLASHCART_ERR_LOAD;
+    }
+
+    if (br != save_size) {
+        return FLASHCART_ERR_LOAD;
+    }
+
+    current_state.is_fram_save_type = false;
+
+    ed64_save_type_t type = ed64_ll_get_save_type();
+    switch (type) {
+        case SAVE_TYPE_EEPROM_4K:
+        case SAVE_TYPE_EEPROM_16K:
+            ed64_ll_set_eeprom(cartsave_data, save_size);
+            break;
+        case SAVE_TYPE_SRAM:
+        case SAVE_TYPE_SRAM_128K:
+            ed64_ll_set_sram(cartsave_data, save_size);
+            break;
+        case SAVE_TYPE_FLASHRAM:
+            ed64_ll_set_fram(cartsave_data, save_size);
+            // a cold and warm boot has no way of seeing save types and most types can be determined by size
+            // this tells the cart to use flash instead of sram 128 since they are the same size
+            current_state.is_fram_save_type = true;
+            ed64_state_save(&current_state);
+            break;
+        default:
+            break;
+    }
+
+
+    current_state.last_save_path = save_path;
+    current_state.is_expecting_save_writeback = true;
+    ed64_state_save(&current_state);
+
+    return FLASHCART_OK;
+}
+
+static flashcart_err_t ed64_set_save_type (flashcart_save_type_t save_type) {
+    ed64_save_type_t type;
+
+    switch (save_type) {
+    case FLASHCART_SAVE_TYPE_NONE:
+        type = SAVE_TYPE_NONE;
+        break;
+    case FLASHCART_SAVE_TYPE_EEPROM_4KBIT:
+        type = SAVE_TYPE_EEPROM_4K;
+        break;
+    case FLASHCART_SAVE_TYPE_EEPROM_16KBIT:
+        type = SAVE_TYPE_EEPROM_16K;
+        break;
+    case FLASHCART_SAVE_TYPE_SRAM_256KBIT:
+        type = SAVE_TYPE_SRAM;
+        break;
+    case FLASHCART_SAVE_TYPE_SRAM_BANKED:
+    case FLASHCART_SAVE_TYPE_SRAM_1MBIT:
+        type = SAVE_TYPE_SRAM_128K;
+        break;
+    case FLASHCART_SAVE_TYPE_FLASHRAM_PKST2:
+    case FLASHCART_SAVE_TYPE_FLASHRAM_1MBIT:
+        type = SAVE_TYPE_FLASHRAM;
+        break;
+    default:
+        return FLASHCART_ERR_ARGS;
+    }
+
+    ed64_ll_set_save_type(type);
+
+    return FLASHCART_OK;
+}
+
+static flashcart_t flashcart_ed64 = {
+    .init = ed64_init,
+    .deinit = ed64_deinit,
+    .has_feature = ed64_has_feature,
+    .load_rom = ed64_load_rom,
+    .load_file = ed64_load_file,
+    .load_save = ed64_load_save,
+    .load_64dd_ipl = NULL,
+    .load_64dd_disk = NULL,
+    .set_save_type = ed64_set_save_type,
+    .set_save_writeback = NULL,
+};
+
+flashcart_t *ed64_get_flashcart (void) {
+    return &flashcart_ed64;
+}

src/flashcart/ed64/ed64.h

@@ -0,0 +1,24 @@
+/**
+ * @file flashcart.h
+ * @brief ED64 Flashcart Utilities
+ * @ingroup flashcart 
+ */
+
+#ifndef FLASHCART_ED64_H__
+#define FLASHCART_ED64_H__
+
+
+#include "../flashcart.h"
+
+
+/**
+ * @addtogroup ed64
+ * @{
+ */
+
+flashcart_t *ed64_get_flashcart (void);
+
+/** @} */ /* ed64 */
+
+
+#endif