The-Homebrew-Cloud/N64FlashcartMenu
2
0
Fork 0
mirror of https://github.com/Polprzewodnikowy/N64FlashcartMenu.git synced 2024-11-22 02:29:19 +01:00
Code Issues Packages Projects Releases Wiki Activity

SC64 flashcart code fixes + cleanup

Browse Source
This commit is contained in:
Mateusz Faderewski 2023-08-10 21:20:02 +02:00
parent 420eb8b3ff
commit ac63083089
6 changed files with 101 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@ -18,7 +18,7 @@ SRCS = \
boot/reboot.S \ boot/reboot.S \
flashcart/flashcart_utils.c \ flashcart/flashcart_utils.c \
flashcart/flashcart.c \ flashcart/flashcart.c \
flashcart/sc64/sc64_internal.c \ flashcart/sc64/sc64_ll.c \
flashcart/sc64/sc64.c \ flashcart/sc64/sc64.c \
libs/libspng/spng/spng.c \ libs/libspng/spng/spng.c \
libs/mini.c/src/mini.c \ libs/mini.c/src/mini.c \
@ -44,8 +44,8 @@ SRCS = \
menu/views/fault.c \ menu/views/fault.c \
menu/views/file_info.c \ menu/views/file_info.c \
menu/views/image_viewer.c \ menu/views/image_viewer.c \
menu/views/load.c \
menu/views/load_emulator.c \ menu/views/load_emulator.c \
menu/views/load.c \
menu/views/music_player.c \ menu/views/music_player.c \
menu/views/startup.c \ menu/views/startup.c \
menu/views/system_info.c \ menu/views/system_info.c \

10
src/flashcart/flashcart.c
View File

@ -43,6 +43,11 @@ flashcart_error_t flashcart_init (void) {
bool sd_initialized; bool sd_initialized;
flashcart_error_t error; flashcart_error_t error;
#ifndef MENU_RELEASE
// NOTE: Some flashcarts doesn't have USB port, can't throw error here
debug_init_usblog();
#endif
// HACK: Because libcart reads PI config from address 0x10000000 when initializing // HACK: Because libcart reads PI config from address 0x10000000 when initializing
// we need to write safe value before running any libcart function. // we need to write safe value before running any libcart function.
// Data in SDRAM can be undefined on some flashcarts at this point // Data in SDRAM can be undefined on some flashcarts at this point
@ -77,11 +82,6 @@ flashcart_error_t flashcart_init (void) {
return FLASHCART_ERROR_SD_CARD; return FLASHCART_ERROR_SD_CARD;
} }
#ifndef MENU_RELEASE
// NOTE: Some flashcarts doesn't have USB port, can't throw error here
debug_init_usblog();
#endif
return FLASHCART_OK; return FLASHCART_OK;
} }

70
src/flashcart/sc64/sc64.c
View File

@ -9,7 +9,7 @@
#include "utils/utils.h" #include "utils/utils.h"
#include "../flashcart_utils.h" #include "../flashcart_utils.h"
#include "sc64_internal.h" #include "sc64_ll.h"
#include "sc64.h" #include "sc64.h"
@ -21,6 +21,7 @@
#define SUPPORTED_MAJOR_VERSION (2) #define SUPPORTED_MAJOR_VERSION (2)
#define SUPPORTED_MINOR_VERSION (16) #define SUPPORTED_MINOR_VERSION (16)
#define SUPPORTED_REVISION (0)
static flashcart_error_t load_to_flash (FIL *fil, void *address, size_t size, UINT *br, flashcart_progress_callback_t *progress) { static flashcart_error_t load_to_flash (FIL *fil, void *address, size_t size, UINT *br, flashcart_progress_callback_t *progress) {
@ -29,19 +30,19 @@ static flashcart_error_t load_to_flash (FIL *fil, void *address, size_t size, UI
*br = 0; *br = 0;
if (sc64_flash_get_erase_block_size(&erase_block_size) != SC64_OK) { if (sc64_ll_flash_get_erase_block_size(&erase_block_size) != SC64_OK) {
return FLASHCART_ERROR_INT; return FLASHCART_ERROR_INT;
} }
while (size > 0) { while (size > 0) {
size_t program_size = MIN(size, erase_block_size); size_t program_size = MIN(size, erase_block_size);
if (sc64_flash_erase_block(address) != SC64_OK) { if (sc64_ll_flash_erase_block(address) != SC64_OK) {
return FLASHCART_ERROR_INT; return FLASHCART_ERROR_INT;
} }
if (f_read(fil, address, program_size, &bp) != FR_OK) { if (f_read(fil, address, program_size, &bp) != FR_OK) {
return FLASHCART_ERROR_LOAD; return FLASHCART_ERROR_LOAD;
} }
if (sc64_flash_wait_busy() != SC64_OK) { if (sc64_ll_flash_wait_busy() != SC64_OK) {
return FLASHCART_ERROR_INT; return FLASHCART_ERROR_INT;
} }
if (progress) { if (progress) {
@ -60,7 +61,7 @@ static flashcart_error_t sc64_init (void) {
uint16_t minor; uint16_t minor;
uint32_t revision; uint32_t revision;
if (sc64_get_version(&major, &minor, &revision) != SC64_OK) { if (sc64_ll_get_version(&major, &minor, &revision) != SC64_OK) {
return FLASHCART_ERROR_OUTDATED; return FLASHCART_ERROR_OUTDATED;
} }
if (major != SUPPORTED_MAJOR_VERSION) { if (major != SUPPORTED_MAJOR_VERSION) {
@ -68,37 +69,39 @@ static flashcart_error_t sc64_init (void) {
} }
if (minor < SUPPORTED_MINOR_VERSION) { if (minor < SUPPORTED_MINOR_VERSION) {
return FLASHCART_ERROR_OUTDATED; return FLASHCART_ERROR_OUTDATED;
} else if (minor == SUPPORTED_MINOR_VERSION && revision < SUPPORTED_REVISION) {
return FLASHCART_ERROR_OUTDATED;
} }
bool writeback_pending; bool writeback_pending;
do { do {
if (sc64_writeback_pending(&writeback_pending) != SC64_OK) { if (sc64_ll_writeback_pending(&writeback_pending) != SC64_OK) {
return FLASHCART_ERROR_INT; return FLASHCART_ERROR_INT;
} }
} while (writeback_pending); } while (writeback_pending);
const struct { const struct {
sc64_cfg_t id; sc64_cfg_id_t id;
uint32_t value; uint32_t value;
} default_config[] = { } default_config[] = {
{ CFG_BOOTLOADER_SWITCH, false }, { CFG_ID_BOOTLOADER_SWITCH, false },
{ CFG_ROM_WRITE_ENABLE, false }, { CFG_ID_ROM_WRITE_ENABLE, false },
{ CFG_ROM_SHADOW_ENABLE, false }, { CFG_ID_ROM_SHADOW_ENABLE, false },
{ CFG_DD_MODE, DD_MODE_DISABLED }, { CFG_ID_DD_MODE, DD_MODE_DISABLED },
{ CFG_ISV_ADDRESS, 0x00000000 }, { CFG_ID_ISV_ADDRESS, 0x00000000 },
{ CFG_BOOT_MODE, BOOT_MODE_MENU }, { CFG_ID_BOOT_MODE, BOOT_MODE_MENU },
{ CFG_SAVE_TYPE, SAVE_TYPE_NONE }, { CFG_ID_SAVE_TYPE, SAVE_TYPE_NONE },
{ CFG_CIC_SEED, CIC_SEED_AUTO }, { CFG_ID_CIC_SEED, CIC_SEED_AUTO },
{ CFG_TV_TYPE, TV_TYPE_PASSTHROUGH }, { CFG_ID_TV_TYPE, TV_TYPE_PASSTHROUGH },
{ CFG_DD_SD_ENABLE, false }, { CFG_ID_DD_SD_ENABLE, false },
{ CFG_DD_DRIVE_TYPE, DRIVE_TYPE_RETAIL }, { CFG_ID_DD_DRIVE_TYPE, DRIVE_TYPE_RETAIL },
{ CFG_DD_DISK_STATE, DISK_STATE_EJECTED }, { CFG_ID_DD_DISK_STATE, DISK_STATE_EJECTED },
{ CFG_BUTTON_MODE, BUTTON_MODE_NONE }, { CFG_ID_BUTTON_MODE, BUTTON_MODE_NONE },
{ CFG_ROM_EXTENDED_ENABLE, false }, { CFG_ID_ROM_EXTENDED_ENABLE, false },
}; };
for (int i = 0; i < sizeof(default_config) / sizeof(default_config[0]); i++) { for (int i = 0; i < sizeof(default_config) / sizeof(default_config[0]); i++) {
if (sc64_set_config(default_config[i].id, default_config[i].value) != SC64_OK) { if (sc64_ll_set_config(default_config[i].id, default_config[i].value) != SC64_OK) {
return FLASHCART_ERROR_INT; return FLASHCART_ERROR_INT;
} }
} }
@ -107,7 +110,7 @@ static flashcart_error_t sc64_init (void) {
} }
static flashcart_error_t sc64_deinit (void) { static flashcart_error_t sc64_deinit (void) {
sc64_lock(); sc64_ll_lock();
return FLASHCART_OK; return FLASHCART_OK;
} }
@ -152,7 +155,7 @@ static flashcart_error_t sc64_load_rom (char *rom_path, flashcart_progress_callb
return FLASHCART_ERROR_LOAD; return FLASHCART_ERROR_LOAD;
} }
if (sc64_set_config(CFG_ROM_SHADOW_ENABLE, shadow_enabled) != SC64_OK) { if (sc64_ll_set_config(CFG_ID_ROM_SHADOW_ENABLE, shadow_enabled) != SC64_OK) {
f_close(&fil); f_close(&fil);
return FLASHCART_ERROR_INT; return FLASHCART_ERROR_INT;
} }
@ -169,7 +172,7 @@ static flashcart_error_t sc64_load_rom (char *rom_path, flashcart_progress_callb
} }
} }
if (sc64_set_config(CFG_ROM_EXTENDED_ENABLE, extended_enabled) != SC64_OK) { if (sc64_ll_set_config(CFG_ID_ROM_EXTENDED_ENABLE, extended_enabled) != SC64_OK) {
f_close(&fil); f_close(&fil);
return FLASHCART_ERROR_INT; return FLASHCART_ERROR_INT;
} }
@ -197,7 +200,7 @@ static flashcart_error_t sc64_load_file (char *file_path, uint32_t start_offset_
FIL fil; FIL fil;
UINT br; UINT br;
if (f_open(&fil, file_path, FA_READ) != FR_OK) { if (f_open(&fil, strip_sd_prefix(file_path), FA_READ) != FR_OK) {
return FLASHCART_ERROR_LOAD; return FLASHCART_ERROR_LOAD;
} }
@ -205,19 +208,24 @@ static flashcart_error_t sc64_load_file (char *file_path, uint32_t start_offset_
size_t file_size = f_size(&fil); size_t file_size = f_size(&fil);
if (file_size > MiB(8)) { // FIXME: should be checked with the start offset address. if (file_size > (MiB(64) - start_offset_address)) {
f_close(&fil); f_close(&fil);
return FLASHCART_ERROR_LOAD; return FLASHCART_ERROR_ARGS;
} }
if (f_read(&fil, (void *) (ROM_ADDRESS + start_offset_address), file_size, &br) != FR_OK) { if (f_read(&fil, (void *) (ROM_ADDRESS + start_offset_address), file_size, &br) != FR_OK) {
f_close(&fil); f_close(&fil);
return FLASHCART_ERROR_LOAD; return FLASHCART_ERROR_LOAD;
} }
if (br != file_size) {
f_close(&fil);
return FLASHCART_ERROR_LOAD;
}
if (f_close(&fil) != FR_OK) { if (f_close(&fil) != FR_OK) {
return FLASHCART_ERROR_LOAD; return FLASHCART_ERROR_LOAD;
} }
return FLASHCART_OK; return FLASHCART_OK;
} }
@ -225,7 +233,7 @@ static flashcart_error_t sc64_load_save (char *save_path) {
void *address = NULL; void *address = NULL;
uint32_t value; uint32_t value;
if (sc64_get_config(CFG_SAVE_TYPE, &value) != SC64_OK) { if (sc64_ll_get_config(CFG_ID_SAVE_TYPE, &value) != SC64_OK) {
return FLASHCART_ERROR_INT; return FLASHCART_ERROR_INT;
} }
@ -300,7 +308,7 @@ static flashcart_error_t sc64_set_save_type (flashcart_save_type_t save_type) {
return FLASHCART_ERROR_ARGS; return FLASHCART_ERROR_ARGS;
} }
if (sc64_set_config(CFG_SAVE_TYPE, type) != SC64_OK) { if (sc64_ll_set_config(CFG_ID_SAVE_TYPE, type) != SC64_OK) {
return FLASHCART_ERROR_INT; return FLASHCART_ERROR_INT;
} }
@ -310,7 +318,7 @@ static flashcart_error_t sc64_set_save_type (flashcart_save_type_t save_type) {
static flashcart_error_t sc64_set_save_writeback (uint32_t *sectors) { static flashcart_error_t sc64_set_save_writeback (uint32_t *sectors) {
pi_dma_write_data(sectors, SC64_BUFFERS->BUFFER, 1024); pi_dma_write_data(sectors, SC64_BUFFERS->BUFFER, 1024);
if (sc64_writeback_enable(SC64_BUFFERS->BUFFER) != SC64_OK) { if (sc64_ll_writeback_enable(SC64_BUFFERS->BUFFER) != SC64_OK) {
return FLASHCART_ERROR_INT; return FLASHCART_ERROR_INT;
} }

7
src/flashcart/sc64/sc64.h
View File

@ -1,6 +1,6 @@
/** /**
* @file flashcart.h * @file sc64.h
* @brief SC64 Flashcart Utilities * @brief SC64 flashcart support
* @ingroup flashcart * @ingroup flashcart
*/ */
@ -10,14 +10,15 @@
#include "../flashcart.h" #include "../flashcart.h"
/** /**
* @addtogroup sc64 * @addtogroup sc64
* @{ * @{
*/ */
flashcart_t *sc64_get_flashcart (void); flashcart_t *sc64_get_flashcart (void);
/** @} */ /* sc64 */ /** @} */ /* sc64 */
#endif #endif

38
src/flashcart/sc64/sc64_internal.c → src/flashcart/sc64/sc64_ll.c
View File

@ -1,6 +1,6 @@
#include <libdragon.h> #include <libdragon.h>
#include "sc64_internal.h" #include "sc64_ll.h"
typedef struct { typedef struct {
@ -36,7 +36,7 @@ typedef struct {
} sc64_cmd_t; } sc64_cmd_t;
static sc64_error_t sc64_execute_cmd (sc64_cmd_t *cmd) { static sc64_error_t sc64_ll_execute_cmd (sc64_cmd_t *cmd) {
io_write((uint32_t) (&SC64_REGS->DATA[0]), cmd->arg[0]); io_write((uint32_t) (&SC64_REGS->DATA[0]), cmd->arg[0]);
io_write((uint32_t) (&SC64_REGS->DATA[1]), cmd->arg[1]); io_write((uint32_t) (&SC64_REGS->DATA[1]), cmd->arg[1]);
@ -58,78 +58,78 @@ static sc64_error_t sc64_execute_cmd (sc64_cmd_t *cmd) {
} }
void sc64_lock (void) { void sc64_ll_lock (void) {
io_write((uint32_t) (&SC64_REGS->KEY), SC64_KEY_LOCK); io_write((uint32_t) (&SC64_REGS->KEY), SC64_KEY_LOCK);
} }
sc64_error_t sc64_get_version (uint16_t *major, uint16_t *minor, uint32_t *revision) { sc64_error_t sc64_ll_get_version (uint16_t *major, uint16_t *minor, uint32_t *revision) {
sc64_cmd_t cmd = { sc64_cmd_t cmd = {
.id = CMD_ID_VERSION_GET .id = CMD_ID_VERSION_GET
}; };
sc64_error_t error = sc64_execute_cmd(&cmd); sc64_error_t error = sc64_ll_execute_cmd(&cmd);
*major = ((cmd.rsp[0] >> 16) & 0xFFFF); *major = ((cmd.rsp[0] >> 16) & 0xFFFF);
*minor = (cmd.rsp[0] & 0xFFFF); *minor = (cmd.rsp[0] & 0xFFFF);
*revision = cmd.rsp[1]; *revision = cmd.rsp[1];
return error; return error;
} }
sc64_error_t sc64_get_config (sc64_cfg_t id, uint32_t *value) { sc64_error_t sc64_ll_get_config (sc64_cfg_id_t id, uint32_t *value) {
sc64_cmd_t cmd = { sc64_cmd_t cmd = {
.id = CMD_ID_CONFIG_GET, .id = CMD_ID_CONFIG_GET,
.arg = { id } .arg = { id }
}; };
sc64_error_t error = sc64_execute_cmd(&cmd); sc64_error_t error = sc64_ll_execute_cmd(&cmd);
*value = cmd.rsp[1]; *value = cmd.rsp[1];
return error; return error;
} }
sc64_error_t sc64_set_config (sc64_cfg_t id, uint32_t value) { sc64_error_t sc64_ll_set_config (sc64_cfg_id_t id, uint32_t value) {
sc64_cmd_t cmd = { sc64_cmd_t cmd = {
.id = CMD_ID_CONFIG_SET, .id = CMD_ID_CONFIG_SET,
.arg = { id, value } .arg = { id, value }
}; };
return sc64_execute_cmd(&cmd); return sc64_ll_execute_cmd(&cmd);
} }
sc64_error_t sc64_writeback_pending (bool *pending) { sc64_error_t sc64_ll_writeback_pending (bool *pending) {
sc64_cmd_t cmd = { sc64_cmd_t cmd = {
.id = CMD_ID_WRITEBACK_PENDING .id = CMD_ID_WRITEBACK_PENDING
}; };
sc64_error_t error = sc64_execute_cmd(&cmd); sc64_error_t error = sc64_ll_execute_cmd(&cmd);
*pending = (cmd.rsp[0] != 0); *pending = (cmd.rsp[0] != 0);
return error; return error;
} }
sc64_error_t sc64_writeback_enable (void *address) { sc64_error_t sc64_ll_writeback_enable (void *address) {
sc64_cmd_t cmd = { sc64_cmd_t cmd = {
.id = CMD_ID_WRITEBACK_SD_INFO, .id = CMD_ID_WRITEBACK_SD_INFO,
.arg = { (uint32_t) (address) } .arg = { (uint32_t) (address) }
}; };
return sc64_execute_cmd(&cmd); return sc64_ll_execute_cmd(&cmd);
} }
sc64_error_t sc64_flash_wait_busy (void) { sc64_error_t sc64_ll_flash_wait_busy (void) {
sc64_cmd_t cmd = { sc64_cmd_t cmd = {
.id = CMD_ID_FLASH_WAIT_BUSY, .id = CMD_ID_FLASH_WAIT_BUSY,
.arg = { true } .arg = { true }
}; };
return sc64_execute_cmd(&cmd); return sc64_ll_execute_cmd(&cmd);
} }
sc64_error_t sc64_flash_get_erase_block_size (size_t *erase_block_size) { sc64_error_t sc64_ll_flash_get_erase_block_size (size_t *erase_block_size) {
sc64_cmd_t cmd = { sc64_cmd_t cmd = {
.id = CMD_ID_FLASH_WAIT_BUSY, .id = CMD_ID_FLASH_WAIT_BUSY,
.arg = { false } .arg = { false }
}; };
sc64_error_t error = sc64_execute_cmd(&cmd); sc64_error_t error = sc64_ll_execute_cmd(&cmd);
*erase_block_size = (size_t) (cmd.rsp[0]); *erase_block_size = (size_t) (cmd.rsp[0]);
return error; return error;
} }
sc64_error_t sc64_flash_erase_block (void *address) { sc64_error_t sc64_ll_flash_erase_block (void *address) {
sc64_cmd_t cmd = { sc64_cmd_t cmd = {
.id = CMD_ID_FLASH_ERASE_BLOCK, .id = CMD_ID_FLASH_ERASE_BLOCK,
.arg = { (uint32_t) (address) } .arg = { (uint32_t) (address) }
}; };
return sc64_execute_cmd(&cmd); return sc64_ll_execute_cmd(&cmd);
} }

62
src/flashcart/sc64/sc64_internal.h → src/flashcart/sc64/sc64_ll.h
View File

@ -1,16 +1,17 @@
/** /**
* @file flashcart.h * @file sc64_ll.h
* @brief SC64 Flashcart Internal Utilities * @brief SC64 flashcart low level access
* @ingroup flashcart * @ingroup flashcart
*/ */
#ifndef FLASHCART_SC64_INTERNAL_H__ #ifndef FLASHCART_SC64_LL_H__
#define FLASHCART_SC64_INTERNAL_H__ #define FLASHCART_SC64_LL_H__
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
/** /**
* @addtogroup sc64 * @addtogroup sc64
* @{ * @{
@ -38,22 +39,22 @@ typedef enum {
} sc64_error_t; } sc64_error_t;
typedef enum { typedef enum {
CFG_BOOTLOADER_SWITCH, CFG_ID_BOOTLOADER_SWITCH,
CFG_ROM_WRITE_ENABLE, CFG_ID_ROM_WRITE_ENABLE,
CFG_ROM_SHADOW_ENABLE, CFG_ID_ROM_SHADOW_ENABLE,
CFG_DD_MODE, CFG_ID_DD_MODE,
CFG_ISV_ADDRESS, CFG_ID_ISV_ADDRESS,
CFG_BOOT_MODE, CFG_ID_BOOT_MODE,
CFG_SAVE_TYPE, CFG_ID_SAVE_TYPE,
CFG_CIC_SEED, CFG_ID_CIC_SEED,
CFG_TV_TYPE, CFG_ID_TV_TYPE,
CFG_DD_SD_ENABLE, CFG_ID_DD_SD_ENABLE,
CFG_DD_DRIVE_TYPE, CFG_ID_DD_DRIVE_TYPE,
CFG_DD_DISK_STATE, CFG_ID_DD_DISK_STATE,
CFG_BUTTON_STATE, CFG_ID_BUTTON_STATE,
CFG_BUTTON_MODE, CFG_ID_BUTTON_MODE,
CFG_ROM_EXTENDED_ENABLE, CFG_ID_ROM_EXTENDED_ENABLE,
} sc64_cfg_t; } sc64_cfg_id_t;
typedef enum { typedef enum {
DD_MODE_DISABLED = 0, DD_MODE_DISABLED = 0,
@ -110,16 +111,17 @@ typedef enum {
} sc64_button_mode_t; } sc64_button_mode_t;
void sc64_lock (void); void sc64_ll_lock (void);
sc64_error_t sc64_get_version (uint16_t *major, uint16_t *minor, uint32_t *revision); sc64_error_t sc64_ll_get_version (uint16_t *major, uint16_t *minor, uint32_t *revision);
sc64_error_t sc64_get_config (sc64_cfg_t cfg, uint32_t *value); sc64_error_t sc64_ll_get_config (sc64_cfg_id_t cfg, uint32_t *value);
sc64_error_t sc64_set_config (sc64_cfg_t cfg, uint32_t value); sc64_error_t sc64_ll_set_config (sc64_cfg_id_t cfg, uint32_t value);
sc64_error_t sc64_writeback_pending (bool *pending); sc64_error_t sc64_ll_writeback_pending (bool *pending);
sc64_error_t sc64_writeback_enable (void *address); sc64_error_t sc64_ll_writeback_enable (void *address);
sc64_error_t sc64_flash_wait_busy (void); sc64_error_t sc64_ll_flash_wait_busy (void);
sc64_error_t sc64_flash_get_erase_block_size (size_t *erase_block_size); sc64_error_t sc64_ll_flash_get_erase_block_size (size_t *erase_block_size);
sc64_error_t sc64_flash_erase_block (void *address); sc64_error_t sc64_ll_flash_erase_block (void *address);
/** @} */ /* sc64 */ /** @} */ /* sc64 */
#endif #endif