diff --git a/Makefile b/Makefile index b8a84b61..daad90af 100644 --- a/Makefile +++ b/Makefile @@ -24,6 +24,7 @@ SRCS = \ 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 \ diff --git a/src/flashcart/ed64/ed64.c b/src/flashcart/ed64/ed64.c index 056a34f7..8d3abf89 100644 --- a/src/flashcart/ed64/ed64.c +++ b/src/flashcart/ed64/ed64.c @@ -4,6 +4,7 @@ #include #include +#include #include "utils/fs.h" #include "utils/utils.h" @@ -11,17 +12,12 @@ #include "../flashcart_utils.h" #include "ed64_ll.h" #include "ed64.h" +#include "ed64_state.h" -// #include "../menu/settings.h" +static ed64_pseudo_writeback_t current_state; -// // This is a trial hack before using the settings API. -// #ifndef LAST_ROM_FILE_PATH -// #define LAST_ROM_FILE_PATH "/ed64/last_rom.txt" -// #endif - - -extern int ed_exit(void); +extern int ed_exit (void); static flashcart_err_t ed64_init (void) { @@ -30,27 +26,64 @@ static flashcart_err_t ed64_init (void) { // FIXME: Update firmware if needed. // FIXME: Enable RTC if available. - // FIXME: Retrive a config file from the SD card that might have been set. - // This should include the location of the ROM and its save type. - // Then, if it is valid, perform a save. - // FIL lrp_fil; - // UINT lrp_br; + // older everdrives cannot save during gameplay so we need to the reset method. + // works by checking if a file exists. - // if (f_open(&lrp_fil, LAST_ROM_PATH_FILE, FA_READ) != FR_OK) { - // return FLASHCART_ERR_LOAD; - // } + ed64_state_load(¤t_state); - // if (f_read(&lrp_fil, lrp_path, 1024, &lrp_br) != FR_OK) { - // f_close(&lrp_fil); - // return FLASHCART_ERR_LOAD; - // } + if (current_state.is_expecting_save_writeback == true) { - // if (f_close(&lrp_fil) != FR_OK) { - // return FLASHCART_ERR_LOAD; - // } + // make sure next boot doesnt trigger the check changing its state. + current_state.is_expecting_save_writeback = false; + ed64_state_save(¤t_state); - // Now save the content back to the SD! - + // 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_sd_prefix(current_state.last_save_path))) { + + int save_size = file_get_size(strip_sd_prefix(current_state.last_save_path)); + + if ((f_open(&fil, strip_sd_prefix(current_state.last_save_path), FA_CREATE_ALWAYS | FA_READ | 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(¤t_state); + } + else if (save_size > KiB(32)) { // sram 128 + ed64_ll_get_sram(cartsave_data, save_size); + } + 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(¤t_state); + } + } return FLASHCART_OK; } @@ -64,12 +97,15 @@ static flashcart_err_t ed64_deinit (void) { static bool ed64_has_feature (flashcart_features_t feature) { switch (feature) { - case FLASHCART_FEATURE_64DD: return false; - default: return false; + case FLASHCART_FEATURE_64DD: + return false; + default: + return false; } } static flashcart_err_t ed64_load_rom (char *rom_path, flashcart_progress_callback_t *progress) { + FIL fil; UINT br; @@ -83,58 +119,54 @@ static flashcart_err_t ed64_load_rom (char *rom_path, flashcart_progress_callbac // 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; } + 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) - KiB(16); + case SAVE_TYPE_SRAM_128K: + case SAVE_TYPE_FLASHRAM: + rom_size -= KiB(128) - KiB(16); + 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) { + 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) { + 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))); + progress(f_tell(&fil) / (float)(f_size(&fil))); } } - if (f_tell(&fil) != sdram_size) { + /*if (f_tell(&fil) != sdram_size) { f_close(&fil); return FLASHCART_ERR_LOAD; - } - + }*/ if (f_close(&fil) != FR_OK) { return FLASHCART_ERR_LOAD; } - - // Set the required actions for retriving the save file later. - // Given there is no good place in RAM... - // This would involve creating some content to a file on the SD card that includes: - // the ROM name and location and possibly its save type. This information will be used on init to perform a "save writeback". - // Actually, we should be using the settings API, so this is just a trial hack. - // FIL lrp_fil; - // UINT lrp_bw; - - // if (f_open(&lrp_fil, LAST_ROM_FILE_PATH, FA_CREATE_ALWAYS) != FR_OK) { - // return FLASHCART_ERR_LOAD; - // } - // if (f_write(&lrp_fil, rom_path, strlen(rom_path) + 1, &lrp_bw) != FR_OK) { - // f_close(&lrp_fil); - // return FLASHCART_ERR_LOAD; - // } - // if (f_close(&lrp_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) { +static flashcart_err_t ed64_load_file (char *file_path, uint32_t rom_offset, uint32_t file_offset) +{ FIL fil; UINT br; @@ -148,6 +180,7 @@ static flashcart_err_t ed64_load_file (char *file_path, uint32_t rom_offset, uin // 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; @@ -158,7 +191,7 @@ static flashcart_err_t ed64_load_file (char *file_path, uint32_t rom_offset, uin return FLASHCART_ERR_LOAD; } - if (f_read(&fil, (void *) (ROM_ADDRESS + rom_offset), file_size, &br) != FR_OK) { + if (f_read(&fil, (void *)(ROM_ADDRESS + rom_offset), file_size, &br) != FR_OK) { f_close(&fil); return FLASHCART_ERR_LOAD; } @@ -175,32 +208,19 @@ static flashcart_err_t ed64_load_file (char *file_path, uint32_t rom_offset, uin } static flashcart_err_t ed64_load_save (char *save_path) { - void *address = NULL; - ed64_save_type_t type = ed64_ll_get_save_type(); - - switch (type) { - case SAVE_TYPE_EEPROM_4K: - case SAVE_TYPE_EEPROM_16K: - case SAVE_TYPE_SRAM: - case SAVE_TYPE_SRAM_128K: - case SAVE_TYPE_FLASHRAM: - address = (void *) (SRAM_ADDRESS); - break; - case SAVE_TYPE_NONE: - default: - return FLASHCART_ERR_ARGS; - } - + FIL fil; UINT br; if (f_open(&fil, strip_sd_prefix(save_path), FA_READ) != FR_OK) { + f_close(&fil); return FLASHCART_ERR_LOAD; } - size_t save_size = f_size(&fil); + size_t save_size = file_get_size(strip_sd_prefix(save_path)); + uint8_t cartsave_data[save_size]; - if (f_read(&fil, address, save_size, &br) != FR_OK) { + if (f_read(&fil, cartsave_data, save_size, &br) != FR_OK) { f_close(&fil); return FLASHCART_ERR_LOAD; } @@ -209,10 +229,35 @@ static flashcart_err_t ed64_load_save (char *save_path) { 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: + ed64_ll_set_sram(cartsave_data, save_size); + case SAVE_TYPE_SRAM_128K: + ed64_ll_set_sram_128(cartsave_data, KiB(128)); + break; + case SAVE_TYPE_FLASHRAM: + ed64_ll_set_fram(cartsave_data, KiB(128)); + // 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(¤t_state); + break; + default: + break; } + + current_state.last_save_path = save_path; + current_state.is_expecting_save_writeback = true; + ed64_state_save(¤t_state); + return FLASHCART_OK; } @@ -220,28 +265,28 @@ 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_4K: - type = SAVE_TYPE_EEPROM_4K; - break; - case FLASHCART_SAVE_TYPE_EEPROM_16K: - type = SAVE_TYPE_EEPROM_16K; - break; - case FLASHCART_SAVE_TYPE_SRAM: - type = SAVE_TYPE_SRAM; - break; - case FLASHCART_SAVE_TYPE_SRAM_BANKED: - case FLASHCART_SAVE_TYPE_SRAM_128K: - type = SAVE_TYPE_SRAM_128K; - break; - case FLASHCART_SAVE_TYPE_FLASHRAM_PKST2: - case FLASHCART_SAVE_TYPE_FLASHRAM: - type = SAVE_TYPE_FLASHRAM; - break; - default: - return FLASHCART_ERR_ARGS; + case FLASHCART_SAVE_TYPE_NONE: + type = SAVE_TYPE_NONE; + break; + case FLASHCART_SAVE_TYPE_EEPROM_4K: + type = SAVE_TYPE_EEPROM_4K; + break; + case FLASHCART_SAVE_TYPE_EEPROM_16K: + type = SAVE_TYPE_EEPROM_16K; + break; + case FLASHCART_SAVE_TYPE_SRAM: + type = SAVE_TYPE_SRAM; + break; + case FLASHCART_SAVE_TYPE_SRAM_BANKED: + case FLASHCART_SAVE_TYPE_SRAM_128K: + type = SAVE_TYPE_SRAM_128K; + break; + case FLASHCART_SAVE_TYPE_FLASHRAM_PKST2: + case FLASHCART_SAVE_TYPE_FLASHRAM: + type = SAVE_TYPE_FLASHRAM; + break; + default: + return FLASHCART_ERR_ARGS; } ed64_ll_set_save_type(type); @@ -249,7 +294,6 @@ static flashcart_err_t ed64_set_save_type (flashcart_save_type_t save_type) { return FLASHCART_OK; } - static flashcart_t flashcart_ed64 = { .init = ed64_init, .deinit = ed64_deinit, @@ -263,7 +307,6 @@ static flashcart_t flashcart_ed64 = { .set_save_writeback = NULL, }; - flashcart_t *ed64_get_flashcart (void) { return &flashcart_ed64; } diff --git a/src/flashcart/ed64/ed64_ll.c b/src/flashcart/ed64/ed64_ll.c index 3eaa70b1..1dd5d7b9 100644 --- a/src/flashcart/ed64/ed64_ll.c +++ b/src/flashcart/ed64/ed64_ll.c @@ -1,8 +1,10 @@ +#include #include - +#include "utils/utils.h" #include "ed64_ll.h" + /* ED64 configuration registers base address */ #define ED64_CONFIG_REGS_BASE (0xA8040000) @@ -23,6 +25,16 @@ typedef enum { } ed64_registers_t; +void pi_initialize (void); +void pi_initialize_sram (void); +void pi_dma_from_cart (void* dest, void* src, unsigned long size); +void pi_dma_to_cart (void* dest, void* src, unsigned long size); +void pi_dma_from_sram (void *dest, unsigned long offset, unsigned long size); +void pi_dma_to_sram (void* src, unsigned long offset, unsigned long size); +void pi_dma_from_cart_safe (void *dest, void *src, unsigned long size); + +void ed64_ll_set_sdcard_timing (void); + #define SAV_EEP_ON 1 #define SAV_SRM_ON 2 @@ -32,20 +44,21 @@ typedef enum { #define SAV_RAM_BANK 128 #define SAV_RAM_BANK_APPLY 32768 -uint32_t ed64_ll_reg_read(uint32_t reg); -void ed64_ll_reg_write(uint32_t reg, uint32_t data); +uint32_t ed64_ll_reg_read (uint32_t reg); +void ed64_ll_reg_write (uint32_t reg, uint32_t data); uint8_t ed64_ll_sram_bank; ed64_save_type_t ed64_ll_save_type; -uint32_t ed64_ll_reg_read(uint32_t reg) { +uint32_t ed64_ll_reg_read (uint32_t reg) { *(volatile uint32_t *) (ED64_CONFIG_REGS_BASE); return *(volatile uint32_t *) (ED64_CONFIG_REGS_BASE + reg * 4); + } -void ed64_ll_reg_write(uint32_t reg, uint32_t data) { +void ed64_ll_reg_write (uint32_t reg, uint32_t data) { *(volatile uint32_t *) (ED64_CONFIG_REGS_BASE); *(volatile uint32_t *) (ED64_CONFIG_REGS_BASE + reg * 4) = data; @@ -54,12 +67,13 @@ void ed64_ll_reg_write(uint32_t reg, uint32_t data) { } -ed64_save_type_t ed64_ll_get_save_type() { +ed64_save_type_t ed64_ll_get_save_type (void) { return ed64_ll_save_type; + } -void ed64_ll_set_save_type(ed64_save_type_t type) { +void ed64_ll_set_save_type (ed64_save_type_t type) { uint16_t save_cfg; uint8_t eeprom_on, sram_on, eeprom_size, sram_size, ram_bank; @@ -97,7 +111,6 @@ void ed64_ll_set_save_type(ed64_save_type_t type) { break; } - save_cfg = 0; if (eeprom_on)save_cfg |= SAV_EEP_ON; if (sram_on)save_cfg |= SAV_SRM_ON; if (eeprom_size)save_cfg |= SAV_EEP_SIZE; @@ -109,8 +122,284 @@ void ed64_ll_set_save_type(ed64_save_type_t type) { } -void ed64_ll_set_sram_bank(uint8_t bank) { +void ed64_ll_set_sram_bank (uint8_t bank) { ed64_ll_sram_bank = bank == 0 ? 0 : 1; } + + +void pi_initialize (void) { + + dma_wait(); + io_write(PI_STATUS_REG, 0x03); + +} + +// Inits PI for sram transfer +void pi_initialize_sram (void) { + + io_write(PI_BSD_DOM2_LAT_REG, 0x05); + io_write(PI_BSD_DOM2_PWD_REG, 0x0C); + io_write(PI_BSD_DOM2_PGS_REG, 0x0D); + io_write(PI_BSD_DOM2_RLS_REG, 0x02); + +} + +void pi_dma_from_sram (void *dest, unsigned long offset, unsigned long size) { + + io_write(PI_DRAM_ADDR_REG, K1_TO_PHYS(dest)); + io_write(PI_CART_ADDR_REG, (0xA8000000 + offset)); + asm volatile ("" : : : "memory"); + io_write(PI_WR_LEN_REG, (size - 1)); + asm volatile ("" : : : "memory"); + +} + + +void pi_dma_to_sram (void *src, unsigned long offset, unsigned long size) { + + dma_wait(); + + io_write(PI_STATUS_REG, 2); + io_write(PI_DRAM_ADDR_REG, K1_TO_PHYS(src)); + io_write(PI_CART_ADDR_REG, (0xA8000000 + offset)); + io_write(PI_RD_LEN_REG, (size - 1)); + +} + +void pi_dma_from_cart (void* dest, void* src, unsigned long size) { + + dma_wait(); + + io_write(PI_STATUS_REG, 0x03); + io_write(PI_DRAM_ADDR_REG, K1_TO_PHYS(dest)); + io_write(PI_CART_ADDR_REG, K0_TO_PHYS(src)); + io_write(PI_WR_LEN_REG, (size - 1)); + +} + + +void pi_dma_to_cart (void* dest, void* src, unsigned long size) { + + dma_wait(); + + io_write(PI_STATUS_REG, 0x02); + io_write(PI_DRAM_ADDR_REG, K1_TO_PHYS(src)); + io_write(PI_CART_ADDR_REG, K0_TO_PHYS(dest)); + io_write(PI_RD_LEN_REG, (size - 1)); + +} + + +// Wrapper to support unaligned access to memory +void pi_dma_from_cart_safe (void *dest, void *src, unsigned long size) { + + if (!dest || !src || !size) return; + + unsigned long unalignedSrc = ((unsigned long)src) % 2; + unsigned long unalignedDest = ((unsigned long)dest) % 8; + + //FIXME: Do i really need to check if size is 16bit aligned? + if (!unalignedDest && !unalignedSrc && !(size % 2)) { + pi_dma_from_cart(dest, src, size); + dma_wait(); + + return; + } + + void* newSrc = (void*)(((unsigned long)src) - unalignedSrc); + unsigned long newSize = (size + unalignedSrc) + ((size + unalignedSrc) % 2); + + unsigned char *buffer = memalign(8, newSize); + pi_dma_from_cart(buffer, newSrc, newSize); + dma_wait(); + + memcpy(dest, (buffer + unalignedSrc), size); + + free(buffer); + +} + + +int ed64_ll_get_sram_128 (uint8_t *buffer, int size) { + + dma_wait(); + + io_write(PI_BSD_DOM2_LAT_REG, 0x05); + io_write(PI_BSD_DOM2_PWD_REG, 0x0C); + io_write(PI_BSD_DOM2_PGS_REG, 0x0D); + io_write(PI_BSD_DOM2_RLS_REG, 0x02); + + dma_wait(); + + pi_initialize(); + + dma_wait(); + + pi_dma_from_sram(buffer, -(size - KiB(16)), size) ; + + dma_wait(); + + io_write(PI_BSD_DOM2_LAT_REG, 0x40); + io_write(PI_BSD_DOM2_PWD_REG, 0x12); + io_write(PI_BSD_DOM2_PGS_REG, 0x07); + io_write(PI_BSD_DOM2_RLS_REG, 0x03); + + return 1; + +} + + +int ed64_ll_get_sram (uint8_t *buffer, int size) { + + dma_wait(); + + io_write(PI_BSD_DOM2_LAT_REG, 0x05); + io_write(PI_BSD_DOM2_PWD_REG, 0x0C); + io_write(PI_BSD_DOM2_PGS_REG, 0x0D); + io_write(PI_BSD_DOM2_RLS_REG, 0x02); + + dma_wait(); + + pi_initialize(); + + dma_wait(); + + pi_dma_from_sram(buffer, 0, size) ; + + dma_wait(); + + io_write(PI_BSD_DOM2_LAT_REG, 0x40); + io_write(PI_BSD_DOM2_PWD_REG, 0x12); + io_write(PI_BSD_DOM2_PGS_REG, 0x07); + io_write(PI_BSD_DOM2_RLS_REG, 0x03); + + return 1; + +} + +int ed64_ll_get_eeprom (uint8_t *buffer, int size) { + + int blocks=size/8; + for( int b = 0; b < blocks; b++ ) { + eeprom_read( b, &buffer[b * 8] ); + } + + return 1; + +} + + +int ed64_ll_get_fram (uint8_t *buffer, int size) { + + ed64_ll_set_save_type(SAVE_TYPE_SRAM_128K); //2 + dma_wait(); + + ed64_ll_get_sram_128(buffer, size); + data_cache_hit_writeback_invalidate(buffer, size); + + dma_wait(); + ed64_ll_set_save_type(SAVE_TYPE_FLASHRAM); + + return 1; + +} + +/* +sram upload +*/ + + +int ed64_ll_set_sram_128 (uint8_t *buffer, int size) { + + //half working + dma_wait(); + //Timing + pi_initialize_sram(); + + //Readmode + pi_initialize(); + + data_cache_hit_writeback_invalidate(buffer,size); + dma_wait(); + + pi_dma_to_sram(buffer, -(size - KiB(16)), size); + data_cache_hit_writeback_invalidate(buffer,size); + + //Wait + dma_wait(); + //Restore evd Timing + ed64_ll_set_sdcard_timing(); + + return 1; + +} + + +int ed64_ll_set_sram (uint8_t *buffer, int size) { + + //half working + dma_wait(); + //Timing + pi_initialize_sram(); + + //Readmode + pi_initialize(); + + data_cache_hit_writeback_invalidate(buffer,size); + dma_wait(); + + pi_dma_to_sram(buffer, 0, size); + data_cache_hit_writeback_invalidate(buffer,size); + + //Wait + dma_wait(); + //Restore evd Timing + ed64_ll_set_sdcard_timing(); + + return 1; + +} + + +int ed64_ll_set_eeprom (uint8_t *buffer, int size) { + + int blocks=size/8; + for( int b = 0; b < blocks; b++ ) { + eeprom_write( b, &buffer[b * 8] ); + } + + return 1; + +} + +int ed64_ll_set_fram (uint8_t *buffer, int size) { + + ed64_ll_set_save_type(SAVE_TYPE_SRAM_128K); + dma_wait(); + + ed64_ll_set_sram_128(buffer, size); + data_cache_hit_writeback_invalidate(buffer, size); + + dma_wait(); + ed64_ll_set_save_type(SAVE_TYPE_FLASHRAM); + + return 1; + +} + + +void ed64_ll_set_sdcard_timing (void) { + + io_write(PI_BSD_DOM1_LAT_REG, 0x40); + io_write(PI_BSD_DOM1_PWD_REG, 0x12); + io_write(PI_BSD_DOM1_PGS_REG, 0x07); + io_write(PI_BSD_DOM1_RLS_REG, 0x03); + + io_write(PI_BSD_DOM2_LAT_REG, 0x40); + io_write(PI_BSD_DOM2_PWD_REG, 0x12); + io_write(PI_BSD_DOM2_PGS_REG, 0x07); + io_write(PI_BSD_DOM2_RLS_REG, 0x03); + +} diff --git a/src/flashcart/ed64/ed64_ll.h b/src/flashcart/ed64/ed64_ll.h index 1e8f3cf0..0f36618d 100644 --- a/src/flashcart/ed64/ed64_ll.h +++ b/src/flashcart/ed64/ed64_ll.h @@ -7,11 +7,44 @@ #ifndef FLASHCART_ED64_LL_H__ #define FLASHCART_ED64_LL_H__ - +#include #include #include #include +// FIXME: redefined because its in a .c instead of a .h +#define PI_BASE_REG 0x04600000 +/////////////////////////////////////////////////////// + +#define PIF_RAM_START 0x1FC007C0 +#define PI_STATUS_ERROR 0x04 +#define PI_STATUS_IO_BUSY 0x02 +#define PI_STATUS_DMA_BUSY 0x01 + +#define PI_STATUS_REG (PI_BASE_REG+0x10) +#define PI_DRAM_ADDR_REG (PI_BASE_REG+0x00) /* DRAM address */ +#define PI_CART_ADDR_REG (PI_BASE_REG+0x04) +#define PI_RD_LEN_REG (PI_BASE_REG+0x08) +#define PI_WR_LEN_REG (PI_BASE_REG+0x0C) + +// FIXME: redefined because its in a .c instead of a .h +#define PI_BSD_DOM1_LAT_REG (PI_BASE_REG+0x14) +#define PI_BSD_DOM1_PWD_REG (PI_BASE_REG+0x18) +#define PI_BSD_DOM1_PGS_REG (PI_BASE_REG+0x1C) +#define PI_BSD_DOM1_RLS_REG (PI_BASE_REG+0x20) +#define PI_BSD_DOM2_LAT_REG (PI_BASE_REG+0x24) +#define PI_BSD_DOM2_PWD_REG (PI_BASE_REG+0x28) +#define PI_BSD_DOM2_PGS_REG (PI_BASE_REG+0x2C) +#define PI_BSD_DOM2_RLS_REG (PI_BASE_REG+0x30) +/////////////////////////////////////////////////////// + +#define PHYS_TO_K0(x) ((unsigned long)(x)|0x80000000) /* physical to kseg0 */ +#define K0_TO_PHYS(x) ((unsigned long)(x)&0x1FFFFFFF) /* kseg0 to physical */ +#define PHYS_TO_K1(x) ((unsigned long)(x)|0xA0000000) /* physical to kseg1 */ +#define K1_TO_PHYS(x) ((unsigned long)(x)&0x1FFFFFFF) /* kseg1 to physical */ + + + /** * @addtogroup ed64 * @{ @@ -29,15 +62,22 @@ typedef enum { SAVE_TYPE_DD64 = 16, } ed64_save_type_t; - -#define SRAM_ADDRESS (0x1FFE2000) #define ROM_ADDRESS (0xB0000000) /* Save functions */ -void ed64_ll_set_ram_bank(uint8_t bank); -ed64_save_type_t ed64_ll_get_save_type(); -void ed64_ll_set_save_type(ed64_save_type_t type); +void ed64_ll_set_sram_bank (uint8_t bank); +ed64_save_type_t ed64_ll_get_save_type (); +void ed64_ll_set_save_type (ed64_save_type_t type); + +int ed64_ll_get_sram_128 (uint8_t *buffer, int size); +int ed64_ll_get_sram (uint8_t *buffer, int size); +int ed64_ll_get_eeprom (uint8_t *buffer, int size); +int ed64_ll_get_fram (uint8_t *buffer, int size); + +int ed64_ll_set_sram_128 (uint8_t *buffer, int size); +int ed64_ll_set_sram (uint8_t *buffer, int size); +int ed64_ll_set_eeprom (uint8_t *buffer, int size); +int ed64_ll_set_fram (uint8_t *buffer, int size); /** @} */ /* ed64 */ - #endif diff --git a/src/flashcart/ed64/ed64_state.c b/src/flashcart/ed64/ed64_state.c new file mode 100644 index 00000000..ee29bab7 --- /dev/null +++ b/src/flashcart/ed64/ed64_state.c @@ -0,0 +1,42 @@ +#include +#include + +#include "ed64_state.h" +#include "utils/fs.h" + +#ifndef ED64_STATE_FILE_PATH +#define ED64_STATE_FILE_PATH "sd:/menu/ed64_state.ini" +#endif + +static ed64_pseudo_writeback_t init = { + .is_expecting_save_writeback = false, + .is_fram_save_type = false, + .last_save_path = "" +}; + + +void ed64_state_load (ed64_pseudo_writeback_t *state) { + if (!file_exists(ED64_STATE_FILE_PATH)) { + ed64_state_save(&init); + } + + mini_t *ini = mini_try_load(ED64_STATE_FILE_PATH); + + state->is_expecting_save_writeback = mini_get_bool(ini, "ed64", "is_expecting_save_writeback", init.is_expecting_save_writeback); + state->is_fram_save_type = mini_get_bool(ini, "ed64", "is_fram_save_type", init.is_fram_save_type); + state->last_save_path = strdup(mini_get_string(ini, "ed64", "last_save_path", init.last_save_path)); + + mini_free(ini); +} + +void ed64_state_save (ed64_pseudo_writeback_t *state) { + mini_t *ini = mini_create(ED64_STATE_FILE_PATH); + + mini_set_bool(ini, "ed64", "is_expecting_save_writeback", state->is_expecting_save_writeback); + mini_set_bool(ini, "ed64", "is_fram_save_type", state->is_fram_save_type); + mini_set_string(ini, "ed64", "last_save_path", state->last_save_path); + + mini_save(ini); + + mini_free(ini); +} diff --git a/src/flashcart/ed64/ed64_state.h b/src/flashcart/ed64/ed64_state.h new file mode 100644 index 00000000..3f53a148 --- /dev/null +++ b/src/flashcart/ed64/ed64_state.h @@ -0,0 +1,24 @@ +/** + * @file e664_state.h + * @brief ED64 state + * @ingroup flashcart + */ + +#ifndef FLASHCART_ED64_STATE_H__ +#define FLASHCART_ED64_STATE_H__ + +/** @brief ED64 Pseudo Writeback Structure */ +typedef struct { +/** @brief The reset button was used */ + bool is_expecting_save_writeback; +/** @brief The last save type was flash ram */ + bool is_fram_save_type; +/** @brief The path to the last loaded ROM */ + char *last_save_path; +} ed64_pseudo_writeback_t; + +void ed64_state_load (ed64_pseudo_writeback_t *state); +void ed64_state_save (ed64_pseudo_writeback_t *state); + + +#endif \ No newline at end of file