The-Homebrew-Cloud/N64FlashcartMenu
2
0
Fork 0
mirror of https://github.com/Polprzewodnikowy/N64FlashcartMenu.git synced 2024-11-25 03:56:54 +01:00
Code Issues Packages Projects Releases Wiki Activity

Code style

Browse Source 
Also fixes ed64_ll_set_ram_bank
This commit is contained in:
Robin Jones 2023-10-20 22:08:53 +01:00
parent d0875e4a36
commit 0f17c610e0
3 changed files with 115 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
src/flashcart/ed64/ed64.c
View File

@ -26,10 +26,10 @@
#define FLASHRAM_CHECK_FILE_PATH "/menu/flashram.tmp" #define FLASHRAM_CHECK_FILE_PATH "/menu/flashram.tmp"
#endif #endif
extern int ed_exit(void); extern int ed_exit (void);
static flashcart_err_t ed64_init (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 // TODO: partly already done, see https://github.com/DragonMinded/libdragon/blob/4ec469d26b6dc4e308caf3d5b86c2b340b708bbd/src/libcart/cart.c#L1064
// FIXME: Update firmware if needed. // FIXME: Update firmware if needed.
@ -38,8 +38,7 @@ static flashcart_err_t ed64_init(void)
// older everdrives cannot save during gameplay so we need to the reset method. // older everdrives cannot save during gameplay so we need to the reset method.
// works by checking if a file exists. // works by checking if a file exists.
if (file_exists(strip_sd_prefix(RESET_CHECK_FILE_PATH))) if (file_exists(strip_sd_prefix(RESET_CHECK_FILE_PATH))) {
{
// make sure next boot doesnt trigger the check by deleting the reset file // make sure next boot doesnt trigger the check by deleting the reset file
f_unlink(strip_sd_prefix(RESET_CHECK_FILE_PATH)); f_unlink(strip_sd_prefix(RESET_CHECK_FILE_PATH));
@ -48,8 +47,7 @@ static flashcart_err_t ed64_init(void)
FIL lrp_fil; FIL lrp_fil;
UINT lrp_br; UINT lrp_br;
if (f_open(&lrp_fil, strip_sd_prefix(LAST_SAVE_FILE_PATH), FA_READ) != FR_OK) if (f_open(&lrp_fil, strip_sd_prefix(LAST_SAVE_FILE_PATH), FA_READ) != FR_OK) {
{
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
@ -57,14 +55,12 @@ static flashcart_err_t ed64_init(void)
TCHAR lrp_path[lrp_size++]; TCHAR lrp_path[lrp_size++];
if (f_read(&lrp_fil, lrp_path, lrp_size, &lrp_br) != FR_OK) if (f_read(&lrp_fil, lrp_path, lrp_size, &lrp_br) != FR_OK) {
{
f_close(&lrp_fil); f_close(&lrp_fil);
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
if (f_close(&lrp_fil) != FR_OK) if (f_close(&lrp_fil) != FR_OK) {
{
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
@ -74,40 +70,33 @@ static flashcart_err_t ed64_init(void)
uint8_t cartsave_data[KiB(128)]; uint8_t cartsave_data[KiB(128)];
// find the path to last save // find the path to last save
if (file_exists(strip_sd_prefix(lrp_path))) if (file_exists(strip_sd_prefix(lrp_path))) {
{
int save_size = file_get_size(strip_sd_prefix(lrp_path)); int save_size = file_get_size(strip_sd_prefix(lrp_path));
if ((f_open(&fil, strip_sd_prefix(lrp_path), FA_CREATE_ALWAYS | FA_READ | FA_WRITE)) != FR_OK) if ((f_open(&fil, strip_sd_prefix(lrp_path), FA_CREATE_ALWAYS | FA_READ | FA_WRITE)) != FR_OK) {
{
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
// everdrive doesn't care about the save type other than flash sram and eeprom // everdrive doesn't care about the save type other than flash sram and eeprom
// so minus flashram we can just check the size // so minus flashram we can just check the size
if (file_exists(strip_sd_prefix(FLASHRAM_CHECK_FILE_PATH))) if (file_exists(strip_sd_prefix(FLASHRAM_CHECK_FILE_PATH))) { // flashram is bugged atm
{ // flashram is bugged atm
ed64_ll_get_fram(cartsave_data, save_size); ed64_ll_get_fram(cartsave_data, save_size);
// deletes flag // deletes flag
f_unlink(strip_sd_prefix(FLASHRAM_CHECK_FILE_PATH)); f_unlink(strip_sd_prefix(FLASHRAM_CHECK_FILE_PATH));
} }
else if (save_size > KiB(2)) else if (save_size > KiB(2)) { // sram
{ // sram
ed64_ll_get_sram(cartsave_data, save_size); ed64_ll_get_sram(cartsave_data, save_size);
} }
else else { // eeprom
{ // eeprom
ed64_ll_get_eeprom(cartsave_data, save_size); ed64_ll_get_eeprom(cartsave_data, save_size);
} }
if (f_write(&fil, cartsave_data, save_size, &br) != FR_OK) if (f_write(&fil, cartsave_data, save_size, &br) != FR_OK) {
{
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
if (f_close(&fil) != FR_OK) if (f_close(&fil) != FR_OK) {
{
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
} }
@ -115,8 +104,7 @@ static flashcart_err_t ed64_init(void)
return FLASHCART_OK; return FLASHCART_OK;
} }
static flashcart_err_t ed64_deinit(void) static flashcart_err_t ed64_deinit (void) {
{
// For the moment, just use libCart exit. // For the moment, just use libCart exit.
ed_exit(); ed_exit();
@ -124,10 +112,8 @@ static flashcart_err_t ed64_deinit(void)
return FLASHCART_OK; return FLASHCART_OK;
} }
static bool ed64_has_feature(flashcart_features_t feature) static bool ed64_has_feature (flashcart_features_t feature) {
{ switch (feature) {
switch (feature)
{
case FLASHCART_FEATURE_64DD: case FLASHCART_FEATURE_64DD:
return false; return false;
default: default:
@ -135,13 +121,12 @@ static bool ed64_has_feature(flashcart_features_t feature)
} }
} }
static flashcart_err_t ed64_load_rom(char *rom_path, flashcart_progress_callback_t *progress) static flashcart_err_t ed64_load_rom (char *rom_path, flashcart_progress_callback_t *progress) {
{
FIL fil; FIL fil;
UINT br; UINT br;
if (f_open(&fil, strip_sd_prefix(rom_path), FA_READ) != FR_OK) if (f_open(&fil, strip_sd_prefix(rom_path), FA_READ) != FR_OK) {
{
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
@ -152,14 +137,12 @@ static flashcart_err_t ed64_load_rom(char *rom_path, flashcart_progress_callback
// FIXME: if the cart is not V3 or X5 or X7, we need probably need to - 128KiB for save compatibility. // 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. // 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. // 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)) if (rom_size > MiB(64)) {
{
f_close(&fil); f_close(&fil);
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
if (rom_size == MiB(64)) if (rom_size == MiB(64)) {
{
rom_size -= KiB(128); rom_size -= KiB(128);
} }
@ -169,37 +152,32 @@ static flashcart_err_t ed64_load_rom(char *rom_path, flashcart_progress_callback
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); 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); f_close(&fil);
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
if (progress) 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); f_close(&fil);
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
}*/ }*/
if (f_close(&fil) != FR_OK) if (f_close(&fil) != FR_OK) {
{
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
return FLASHCART_OK; 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; FIL fil;
UINT br; UINT br;
if (f_open(&fil, strip_sd_prefix(file_path), FA_READ) != FR_OK) if (f_open(&fil, strip_sd_prefix(file_path), FA_READ) != FR_OK) {
{
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
@ -210,45 +188,38 @@ static flashcart_err_t ed64_load_file(char *file_path, uint32_t rom_offset, uint
// FIXME: if the cart is not V3 or X5 or X7, we need probably need to - 128KiB for save compatibility. // 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. // 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)) if (file_size > (MiB(64) - rom_offset)) {
{
f_close(&fil); f_close(&fil);
return FLASHCART_ERR_ARGS; return FLASHCART_ERR_ARGS;
} }
if (f_lseek(&fil, file_offset) != FR_OK) if (f_lseek(&fil, file_offset) != FR_OK) {
{
f_close(&fil); f_close(&fil);
return FLASHCART_ERR_LOAD; 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); f_close(&fil);
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
if (br != file_size) if (br != file_size) {
{
f_close(&fil); f_close(&fil);
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
if (f_close(&fil) != FR_OK) if (f_close(&fil) != FR_OK) {
{
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
return FLASHCART_OK; return FLASHCART_OK;
} }
static flashcart_err_t ed64_load_save(char *save_path) static flashcart_err_t ed64_load_save (char *save_path) {
{
FIL fil; FIL fil;
UINT br; UINT br;
if (f_open(&fil, strip_sd_prefix(save_path), FA_READ) != FR_OK) if (f_open(&fil, strip_sd_prefix(save_path), FA_READ) != FR_OK) {
{
f_close(&fil); f_close(&fil);
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
@ -256,20 +227,17 @@ static flashcart_err_t ed64_load_save(char *save_path)
size_t save_size = file_get_size(strip_sd_prefix(save_path)); size_t save_size = file_get_size(strip_sd_prefix(save_path));
uint8_t cartsave_data[save_size]; uint8_t cartsave_data[save_size];
if (f_read(&fil, cartsave_data, save_size, &br) != FR_OK) if (f_read(&fil, cartsave_data, save_size, &br) != FR_OK) {
{
f_close(&fil); f_close(&fil);
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
if (f_close(&fil) != FR_OK) if (f_close(&fil) != FR_OK) {
{
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
ed64_save_type_t type = ed64_ll_get_save_type(); ed64_save_type_t type = ed64_ll_get_save_type();
switch (type) switch (type) {
{
case SAVE_TYPE_EEPROM_4K: case SAVE_TYPE_EEPROM_4K:
case SAVE_TYPE_EEPROM_16K: case SAVE_TYPE_EEPROM_16K:
ed64_ll_set_eeprom(cartsave_data, save_size); ed64_ll_set_eeprom(cartsave_data, save_size);
@ -283,14 +251,12 @@ static flashcart_err_t ed64_load_save(char *save_path)
// a cold and warm boot has no way of seeing save types and most types can be determined by 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 // this tells the cart to use flash instead of sram 128 since they are the same size
FIL flashfil; FIL flashfil;
if (f_open(&flashfil, strip_sd_prefix(FLASHRAM_CHECK_FILE_PATH), FA_CREATE_ALWAYS) != FR_OK) if (f_open(&flashfil, strip_sd_prefix(FLASHRAM_CHECK_FILE_PATH), FA_CREATE_ALWAYS) != FR_OK) {
{
f_close(&flashfil); f_close(&flashfil);
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
if (f_close(&flashfil) != FR_OK) if (f_close(&flashfil) != FR_OK) {
{
return FLASHCART_OK; return FLASHCART_OK;
} }
break; break;
@ -302,18 +268,15 @@ static flashcart_err_t ed64_load_save(char *save_path)
FIL lsp_fil; FIL lsp_fil;
UINT lsp_bw; UINT lsp_bw;
if (f_open(&lsp_fil, strip_sd_prefix(LAST_SAVE_FILE_PATH), FA_WRITE | FA_CREATE_ALWAYS) != FR_OK) if (f_open(&lsp_fil, strip_sd_prefix(LAST_SAVE_FILE_PATH), FA_WRITE | FA_CREATE_ALWAYS) != FR_OK) {
{
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
if (f_write(&lsp_fil, strip_sd_prefix(save_path), strlen(save_path), &lsp_bw) != FR_OK) if (f_write(&lsp_fil, strip_sd_prefix(save_path), strlen(save_path), &lsp_bw) != FR_OK) {
{
f_close(&lsp_fil); f_close(&lsp_fil);
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
if (f_close(&lsp_fil) != FR_OK) if (f_close(&lsp_fil) != FR_OK) {
{
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
@ -321,26 +284,22 @@ static flashcart_err_t ed64_load_save(char *save_path)
// simulate a unix touch command to create a file as it only needs to exist to detect a reset // simulate a unix touch command to create a file as it only needs to exist to detect a reset
if (f_open(&rsfil, strip_sd_prefix(RESET_CHECK_FILE_PATH), FA_CREATE_ALWAYS) != FR_OK) if (f_open(&rsfil, strip_sd_prefix(RESET_CHECK_FILE_PATH), FA_CREATE_ALWAYS) != FR_OK) {
{
f_close(&rsfil); f_close(&rsfil);
return FLASHCART_ERR_LOAD; return FLASHCART_ERR_LOAD;
} }
if (f_close(&rsfil) != FR_OK) if (f_close(&rsfil) != FR_OK) {
{
return FLASHCART_OK; return FLASHCART_OK;
} }
return FLASHCART_OK; return FLASHCART_OK;
} }
static flashcart_err_t ed64_set_save_type(flashcart_save_type_t save_type) static flashcart_err_t ed64_set_save_type (flashcart_save_type_t save_type) {
{
ed64_save_type_t type; ed64_save_type_t type;
switch (save_type) switch (save_type) {
{
case FLASHCART_SAVE_TYPE_NONE: case FLASHCART_SAVE_TYPE_NONE:
type = SAVE_TYPE_NONE; type = SAVE_TYPE_NONE;
break; break;
@ -383,7 +342,6 @@ static flashcart_t flashcart_ed64 = {
.set_save_writeback = NULL, .set_save_writeback = NULL,
}; };
flashcart_t *ed64_get_flashcart(void) flashcart_t *ed64_get_flashcart (void) {
{
return &flashcart_ed64; return &flashcart_ed64;
} }

94
src/flashcart/ed64/ed64_ll.c
View File

@ -24,17 +24,15 @@ typedef enum {
} ed64_registers_t; } ed64_registers_t;
void pi_initialize(void); void pi_initialize (void);
void pi_initialize_sram(void); void pi_initialize_sram (void);
void pi_dma_from_cart(void* dest, void* src, unsigned long size); 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_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_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_to_sram (void* src, unsigned long offset, unsigned long size);
void pi_dma_from_cart_safe(void *dest, void *src, unsigned long size); void pi_dma_from_cart_safe (void *dest, void *src, unsigned long size);
void ed64_ll_set_sdcard_timing(void); void ed64_ll_set_sdcard_timing (void);
void ed64_ll_set_sdcard_timing(void);
#define SAV_EEP_ON 1 #define SAV_EEP_ON 1
@ -45,20 +43,21 @@ void ed64_ll_set_sdcard_timing(void);
#define SAV_RAM_BANK 128 #define SAV_RAM_BANK 128
#define SAV_RAM_BANK_APPLY 32768 #define SAV_RAM_BANK_APPLY 32768
uint32_t ed64_ll_reg_read(uint32_t reg); uint32_t ed64_ll_reg_read (uint32_t reg);
void ed64_ll_reg_write(uint32_t reg, uint32_t data); void ed64_ll_reg_write (uint32_t reg, uint32_t data);
uint8_t ed64_ll_sram_bank; uint8_t ed64_ll_sram_bank;
ed64_save_type_t ed64_ll_save_type; 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); *(volatile uint32_t *) (ED64_CONFIG_REGS_BASE);
return *(volatile uint32_t *) (ED64_CONFIG_REGS_BASE + reg * 4); 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);
*(volatile uint32_t *) (ED64_CONFIG_REGS_BASE + reg * 4) = data; *(volatile uint32_t *) (ED64_CONFIG_REGS_BASE + reg * 4) = data;
@ -67,12 +66,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; 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; uint16_t save_cfg;
uint8_t eeprom_on, sram_on, eeprom_size, sram_size, ram_bank; uint8_t eeprom_on, sram_on, eeprom_size, sram_size, ram_bank;
@ -121,71 +121,79 @@ 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; ed64_ll_sram_bank = bank == 0 ? 0 : 1;
} }
void pi_initialize(void) { void pi_initialize (void) {
dma_wait(); dma_wait();
io_write(PI_STATUS_REG, 0x03); io_write(PI_STATUS_REG, 0x03);
} }
// Inits PI for sram transfer // Inits PI for sram transfer
void pi_initialize_sram(void) { void pi_initialize_sram (void) {
io_write(PI_BSD_DOM2_LAT_REG, 0x05); io_write(PI_BSD_DOM2_LAT_REG, 0x05);
io_write(PI_BSD_DOM2_PWD_REG, 0x0C); io_write(PI_BSD_DOM2_PWD_REG, 0x0C);
io_write(PI_BSD_DOM2_PGS_REG, 0x0D); io_write(PI_BSD_DOM2_PGS_REG, 0x0D);
io_write(PI_BSD_DOM2_RLS_REG, 0x02); io_write(PI_BSD_DOM2_RLS_REG, 0x02);
} }
void pi_dma_from_sram(void *dest, unsigned long offset, unsigned long size) { 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_DRAM_ADDR_REG, K1_TO_PHYS(dest));
io_write(PI_CART_ADDR_REG, (0xA8000000 + offset)); io_write(PI_CART_ADDR_REG, (0xA8000000 + offset));
asm volatile ("" : : : "memory"); asm volatile ("" : : : "memory");
io_write(PI_WR_LEN_REG, (size - 1)); io_write(PI_WR_LEN_REG, (size - 1));
asm volatile ("" : : : "memory"); asm volatile ("" : : : "memory");
} }
void pi_dma_to_sram(void *src, unsigned long offset, unsigned long size) { //void* void pi_dma_to_sram (void *src, unsigned long offset, unsigned long size) {
dma_wait(); dma_wait();
io_write(PI_STATUS_REG, 2); io_write(PI_STATUS_REG, 2);
io_write(PI_DRAM_ADDR_REG, K1_TO_PHYS(src)); io_write(PI_DRAM_ADDR_REG, K1_TO_PHYS(src));
io_write(PI_CART_ADDR_REG, (0xA8000000 + offset)); io_write(PI_CART_ADDR_REG, (0xA8000000 + offset));
io_write(PI_RD_LEN_REG, (size - 1)); io_write(PI_RD_LEN_REG, (size - 1));
} }
void pi_dma_from_cart(void* dest, void* src, unsigned long size) { void pi_dma_from_cart (void* dest, void* src, unsigned long size) {
dma_wait(); dma_wait();
io_write(PI_STATUS_REG, 0x03); io_write(PI_STATUS_REG, 0x03);
io_write(PI_DRAM_ADDR_REG, K1_TO_PHYS(dest)); io_write(PI_DRAM_ADDR_REG, K1_TO_PHYS(dest));
io_write(PI_CART_ADDR_REG, K0_TO_PHYS(src)); io_write(PI_CART_ADDR_REG, K0_TO_PHYS(src));
io_write(PI_WR_LEN_REG, (size - 1)); io_write(PI_WR_LEN_REG, (size - 1));
} }
void pi_dma_to_cart(void* dest, void* src, unsigned long size) { void pi_dma_to_cart (void* dest, void* src, unsigned long size) {
dma_wait(); dma_wait();
io_write(PI_STATUS_REG, 0x02); io_write(PI_STATUS_REG, 0x02);
io_write(PI_DRAM_ADDR_REG, K1_TO_PHYS(src)); io_write(PI_DRAM_ADDR_REG, K1_TO_PHYS(src));
io_write(PI_CART_ADDR_REG, K0_TO_PHYS(dest)); io_write(PI_CART_ADDR_REG, K0_TO_PHYS(dest));
io_write(PI_RD_LEN_REG, (size - 1)); io_write(PI_RD_LEN_REG, (size - 1));
} }
// Wrapper to support unaligned access to memory // Wrapper to support unaligned access to memory
void pi_dma_from_cart_safe(void *dest, void *src, unsigned long size) { void pi_dma_from_cart_safe (void *dest, void *src, unsigned long size) {
if (!dest || !src || !size) return; if (!dest || !src || !size) return;
unsigned long unalignedSrc = ((unsigned long)src) % 2; unsigned long unalignedSrc = ((unsigned long)src) % 2;
@ -209,10 +217,12 @@ void pi_dma_from_cart_safe(void *dest, void *src, unsigned long size) {
memcpy(dest, (buffer + unalignedSrc), size); memcpy(dest, (buffer + unalignedSrc), size);
free(buffer); free(buffer);
} }
int ed64_ll_get_sram( uint8_t *buffer, int size){ int ed64_ll_get_sram (uint8_t *buffer, int size) {
dma_wait(); dma_wait();
io_write(PI_BSD_DOM2_LAT_REG, 0x05); io_write(PI_BSD_DOM2_LAT_REG, 0x05);
@ -236,19 +246,23 @@ int ed64_ll_get_sram( uint8_t *buffer, int size){
io_write(PI_BSD_DOM2_RLS_REG, 0x03); io_write(PI_BSD_DOM2_RLS_REG, 0x03);
return 1; return 1;
} }
int ed64_ll_get_eeprom( uint8_t *buffer, int size){ int ed64_ll_get_eeprom (uint8_t *buffer, int size) {
int blocks=size/8; int blocks=size/8;
for( int b = 0; b < blocks; b++ ) { for( int b = 0; b < blocks; b++ ) {
eeprom_read( b, &buffer[b * 8] ); eeprom_read( b, &buffer[b * 8] );
} }
return 1; return 1;
} }
int ed64_ll_get_fram( uint8_t *buffer, int size){ int ed64_ll_get_fram (uint8_t *buffer, int size) {
ed64_ll_set_save_type(SAVE_TYPE_SRAM_128K); //2 ed64_ll_set_save_type(SAVE_TYPE_SRAM_128K); //2
dma_wait(); dma_wait();
@ -259,13 +273,15 @@ int ed64_ll_get_fram( uint8_t *buffer, int size){
ed64_ll_set_save_type(SAVE_TYPE_FLASHRAM); ed64_ll_set_save_type(SAVE_TYPE_FLASHRAM);
return 1; return 1;
} }
/* /*
sram upload sram upload
*/ */
int ed64_ll_set_sram( uint8_t *buffer, int size){ int ed64_ll_set_sram (uint8_t *buffer, int size) {
//half working
//half working
dma_wait(); dma_wait();
//Timing //Timing
pi_initialize_sram(); pi_initialize_sram();
@ -285,19 +301,23 @@ int ed64_ll_set_sram( uint8_t *buffer, int size){
ed64_ll_set_sdcard_timing(); ed64_ll_set_sdcard_timing();
return 1; return 1;
} }
int ed64_ll_set_eeprom(uint8_t *buffer, int size){ int ed64_ll_set_eeprom (uint8_t *buffer, int size) {
int blocks=size/8; int blocks=size/8;
for( int b = 0; b < blocks; b++ ) { for( int b = 0; b < blocks; b++ ) {
eeprom_write( b, &buffer[b * 8] ); eeprom_write( b, &buffer[b * 8] );
} }
return 1; return 1;
} }
int ed64_ll_set_fram(uint8_t *buffer, int size){ int ed64_ll_set_fram (uint8_t *buffer, int size) {
ed64_ll_set_save_type(SAVE_TYPE_SRAM_128K); ed64_ll_set_save_type(SAVE_TYPE_SRAM_128K);
dma_wait(); dma_wait();
@ -308,10 +328,11 @@ int ed64_ll_set_fram(uint8_t *buffer, int size){
ed64_ll_set_save_type(SAVE_TYPE_FLASHRAM); ed64_ll_set_save_type(SAVE_TYPE_FLASHRAM);
return 1; return 1;
} }
void ed64_ll_set_sdcard_timing(void){ void ed64_ll_set_sdcard_timing (void) {
io_write(PI_BSD_DOM1_LAT_REG, 0x40); io_write(PI_BSD_DOM1_LAT_REG, 0x40);
io_write(PI_BSD_DOM1_PWD_REG, 0x12); io_write(PI_BSD_DOM1_PWD_REG, 0x12);
@ -322,4 +343,5 @@ void ed64_ll_set_sdcard_timing(void){
io_write(PI_BSD_DOM2_PWD_REG, 0x12); io_write(PI_BSD_DOM2_PWD_REG, 0x12);
io_write(PI_BSD_DOM2_PGS_REG, 0x07); io_write(PI_BSD_DOM2_PGS_REG, 0x07);
io_write(PI_BSD_DOM2_RLS_REG, 0x03); io_write(PI_BSD_DOM2_RLS_REG, 0x03);
} }

18
src/flashcart/ed64/ed64_ll.h
View File

@ -65,17 +65,17 @@ typedef enum {
#define ROM_ADDRESS (0xB0000000) #define ROM_ADDRESS (0xB0000000)
/* Save functions */ /* Save functions */
void ed64_ll_set_ram_bank(uint8_t bank); void ed64_ll_set_sram_bank (uint8_t bank);
ed64_save_type_t ed64_ll_get_save_type(); ed64_save_type_t ed64_ll_get_save_type ();
void ed64_ll_set_save_type(ed64_save_type_t type); void ed64_ll_set_save_type (ed64_save_type_t type);
int ed64_ll_get_sram( 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_eeprom (uint8_t *buffer, int size);
int ed64_ll_get_fram( uint8_t *buffer, int size); int ed64_ll_get_fram (uint8_t *buffer, int size);
int ed64_ll_set_sram( 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_eeprom (uint8_t *buffer, int size);
int ed64_ll_set_fram( uint8_t *buffer, int size); int ed64_ll_set_fram (uint8_t *buffer, int size);
/** @} */ /* ed64 */ /** @} */ /* ed64 */
#endif #endif