The-Homebrew-Cloud/SummerCart64
2
0
Fork 0
mirror of https://github.com/Polprzewodnikowy/SummerCart64.git synced 2024-11-22 14:09:16 +01:00
Code Issues Packages Projects Releases Wiki Activity
e2c100ae7f
SummerCart64/sw/bootloader/src/sc64.c

618 lines
18 KiB
C
Raw Blame History

#include "error.h"
#include "io.h"
#include "sc64.h"
typedef struct {
io32_t SCR;
io32_t DATA[2];
io32_t IDENTIFIER;
io32_t KEY;
io32_t IRQ;
io32_t AUX;
} sc64_regs_t;
#define SC64_REGS_BASE (0x1FFF0000UL)
#define SC64_REGS ((sc64_regs_t *) SC64_REGS_BASE)
#define SC64_SCR_CPU_BUSY (1 << 31)
#define SC64_SCR_CMD_ERROR (1 << 30)
#define SC64_SCR_BTN_IRQ_PENDING (1 << 29)
#define SC64_SCR_BTN_IRQ_MASK (1 << 28)
#define SC64_SCR_CMD_IRQ_PENDING (1 << 27)
#define SC64_SCR_CMD_IRQ_MASK (1 << 26)
#define SC64_SCR_USB_IRQ_PENDING (1 << 25)
#define SC64_SCR_USB_IRQ_MASK (1 << 24)
#define SC64_SCR_AUX_IRQ_PENDING (1 << 23)
#define SC64_SCR_AUX_IRQ_MASK (1 << 22)
#define SC64_SCR_CMD_IRQ_REQUEST (1 << 8)
#define SC64_V2_IDENTIFIER (0x53437632)
#define SC64_KEY_RESET (0x00000000UL)
#define SC64_KEY_UNLOCK_1 (0x5F554E4CUL)
#define SC64_KEY_UNLOCK_2 (0x4F434B5FUL)
#define SC64_KEY_LOCK (0xFFFFFFFFUL)
#define SC64_IRQ_BTN_CLEAR (1 << 31)
#define SC64_IRQ_CMD_CLEAR (1 << 30)
#define SC64_IRQ_USB_CLEAR (1 << 29)
#define SC64_IRQ_AUX_CLEAR (1 << 28)
#define SC64_IRQ_USB_DISABLE (1 << 11)
#define SC64_IRQ_USB_ENABLE (1 << 10)
#define SC64_IRQ_AUX_DISABLE (1 << 9)
#define SC64_IRQ_AUX_ENABLE (1 << 8)
typedef enum {
CMD_ID_IDENTIFIER_GET = 'v',
CMD_ID_VERSION_GET = 'V',
CMD_ID_CONFIG_GET = 'c',
CMD_ID_CONFIG_SET = 'C',
CMD_ID_SETTING_GET = 'a',
CMD_ID_SETTING_SET = 'A',
CMD_ID_TIME_GET = 't',
CMD_ID_TIME_SET = 'T',
CMD_ID_USB_READ = 'm',
CMD_ID_USB_WRITE = 'M',
CMD_ID_USB_READ_STATUS = 'u',
CMD_ID_USB_WRITE_STATUS = 'U',
CMD_ID_SD_CARD_OP = 'i',
CMD_ID_SD_SECTOR_SET = 'I',
CMD_ID_SD_READ = 's',
CMD_ID_SD_WRITE = 'S',
CMD_ID_DISK_MAPPING_SET = 'D',
CMD_ID_WRITEBACK_PENDING = 'w',
CMD_ID_WRITEBACK_SD_INFO = 'W',
CMD_ID_FLASH_PROGRAM = 'K',
CMD_ID_FLASH_WAIT_BUSY = 'p',
CMD_ID_FLASH_ERASE_BLOCK = 'P',
CMD_ID_DIAGNOSTIC_GET = '%',
} sc64_cmd_id_t;
typedef enum {
SD_CARD_OP_DEINIT = 0,
SD_CARD_OP_INIT = 1,
SD_CARD_OP_GET_STATUS = 2,
SD_CARD_OP_GET_INFO = 3,
SD_CARD_OP_BYTE_SWAP_ON = 4,
SD_CARD_OP_BYTE_SWAP_OFF = 5,
} sd_card_op_t;
typedef struct {
sc64_cmd_id_t id;
uint32_t arg[2];
uint32_t rsp[2];
} sc64_cmd_t;
static bool use_cmd_irq = false;
static volatile bool wait_cmd_irq = false;
static sc64_error_t sc64_execute_cmd (sc64_cmd_t *cmd) {
uint32_t sr;
pi_io_write(&SC64_REGS->DATA[0], cmd->arg[0]);
pi_io_write(&SC64_REGS->DATA[1], cmd->arg[1]);
if (use_cmd_irq) {
wait_cmd_irq = true;
pi_io_write(&SC64_REGS->SCR, (SC64_SCR_CMD_IRQ_REQUEST | (cmd->id & 0xFF)));
while (wait_cmd_irq);
sr = pi_io_read(&SC64_REGS->SCR);
if (sr & SC64_SCR_CPU_BUSY) {
error_display("[Unexpected] SC64 CMD busy flag set");
}
} else {
pi_io_write(&SC64_REGS->SCR, (cmd->id & 0xFF));
do {
sr = pi_io_read(&SC64_REGS->SCR);
} while (sr & SC64_SCR_CPU_BUSY);
}
if (sr & SC64_SCR_CMD_ERROR) {
return (sc64_error_t) (pi_io_read(&SC64_REGS->DATA[0]));
}
cmd->rsp[0] = pi_io_read(&SC64_REGS->DATA[0]);
cmd->rsp[1] = pi_io_read(&SC64_REGS->DATA[1]);
return SC64_OK;
}
static void sc64_btn_irq_callback (void) {
error_display("[Unexpected] SC64 button pressed interrupt received");
}
static void sc64_cmd_irq_callback (void) {
if (wait_cmd_irq) {
wait_cmd_irq = false;
} else {
error_display("[Unexpected] SC64 command finish interrupt received");
}
}
static void sc64_usb_irq_callback (void) {
error_display("[Unexpected] SC64 USB not empty interrupt received");
}
static void sc64_aux_irq_callback (void) {
error_display("[Unexpected] SC64 AUX not empty interrupt received");
}
const char *sc64_error_description (sc64_error_t error) {
if (error == SC64_OK) {
return "No error";
}
sc64_error_type_t type = (sc64_error_type_t) ((error >> 24) & 0xFF);
error &= 0xFFFFFF;
if (type == ERROR_TYPE_CFG) {
switch ((sc64_cfg_error_t) (error)) {
case CFG_OK: return "No error (CFG)";
case CFG_ERROR_UNKNOWN_COMMAND: return "Unknown command";
case CFG_ERROR_INVALID_ARGUMENT: return "Invalid argument";
case CFG_ERROR_INVALID_ADDRESS: return "Invalid address";
case CFG_ERROR_INVALID_ID: return "Invalid ID";
default: return "Unknown error (CFG)";
}
}
if (type == ERROR_TYPE_SD_CARD) {
switch ((sc64_sd_error_t) (error)) {
case SD_OK: return "No error (SD)";
case SD_ERROR_NO_CARD_IN_SLOT: return "No SD card in the slot";
case SD_ERROR_NOT_INITIALIZED: return "SD card is not initialized";
case SD_ERROR_INVALID_ARGUMENT: return "Invalid argument (SD)";
case SD_ERROR_INVALID_ADDRESS: return "Invalid address (SD)";
case SD_ERROR_INVALID_OPERATION: return "Invalid operation (SD)";
case SD_ERROR_CMD2_IO: return "CMD2 I/O";
case SD_ERROR_CMD3_IO: return "CMD3 I/O";
case SD_ERROR_CMD6_CHECK_IO: return "CMD6 I/O (check)";
case SD_ERROR_CMD6_CHECK_CRC: return "CMD6 CRC (check)";
case SD_ERROR_CMD6_CHECK_TIMEOUT: return "CMD6 timeout (check)";
case SD_ERROR_CMD6_CHECK_RESPONSE: return "CMD6 invalid response (check)";
case SD_ERROR_CMD6_SWITCH_IO: return "CMD6 I/O (switch)";
case SD_ERROR_CMD6_SWITCH_CRC: return "CMD6 CRC (switch)";
case SD_ERROR_CMD6_SWITCH_TIMEOUT: return "CMD6 timeout (switch)";
case SD_ERROR_CMD6_SWITCH_RESPONSE: return "CMD6 invalid response (switch)";
case SD_ERROR_CMD7_IO: return "CMD7 I/O";
case SD_ERROR_CMD8_IO: return "CMD8 I/O";
case SD_ERROR_CMD9_IO: return "CMD9 I/O";
case SD_ERROR_CMD10_IO: return "CMD10 I/O";
case SD_ERROR_CMD18_IO: return "CMD18 I/O";
case SD_ERROR_CMD18_CRC: return "CMD18 CRC";
case SD_ERROR_CMD18_TIMEOUT: return "CMD18 timeout";
case SD_ERROR_CMD25_IO: return "CMD25 I/O";
case SD_ERROR_CMD25_CRC: return "CMD25 CRC";
case SD_ERROR_CMD25_TIMEOUT: return "CMD25 timeout";
case SD_ERROR_ACMD6_IO: return "ACMD6 I/O";
case SD_ERROR_ACMD41_IO: return "ACMD41 I/O";
case SD_ERROR_ACMD41_OCR: return "ACMD41 OCR";
case SD_ERROR_ACMD41_TIMEOUT: return "ACMD41 timeout";
case SD_ERROR_LOCKED: return "SD card is locked by the PC side";
default: return "Unknown error (SD)";
}
}
return "Unknown error (type)";
}
void sc64_unlock (void) {
pi_io_write(&SC64_REGS->KEY, SC64_KEY_RESET);
pi_io_write(&SC64_REGS->KEY, SC64_KEY_UNLOCK_1);
pi_io_write(&SC64_REGS->KEY, SC64_KEY_UNLOCK_2);
}
void sc64_lock (void) {
pi_io_write(&SC64_REGS->KEY, SC64_KEY_RESET);
pi_io_write(&SC64_REGS->KEY, SC64_KEY_LOCK);
}
bool sc64_check_presence (void) {
bool detected = (pi_io_read(&SC64_REGS->IDENTIFIER) == SC64_V2_IDENTIFIER);
if (detected) {
while (pi_io_read(&SC64_REGS->SCR) & SC64_SCR_CPU_BUSY);
}
return detected;
}
void sc64_cmd_irq_enable (bool enable) {
use_cmd_irq = enable;
}
void sc64_usb_irq_enable (bool enable) {
pi_io_write(&SC64_REGS->IRQ, enable ? SC64_IRQ_USB_ENABLE : SC64_IRQ_USB_DISABLE);
}
void sc64_aux_irq_enable (bool enable) {
pi_io_write(&SC64_REGS->IRQ, enable ? SC64_IRQ_AUX_ENABLE : SC64_IRQ_AUX_DISABLE);
}
sc64_irq_t sc64_irq_pending (void) {
uint32_t sr = pi_io_read(&SC64_REGS->SCR);
sc64_irq_t irq = SC64_IRQ_NONE;
if ((sr & SC64_SCR_BTN_IRQ_MASK) && (sr & SC64_SCR_BTN_IRQ_PENDING)) {
irq |= SC64_IRQ_BTN;
}
if ((sr & SC64_SCR_CMD_IRQ_MASK) && (sr & SC64_SCR_CMD_IRQ_PENDING)) {
irq |= SC64_IRQ_CMD;
}
if ((sr & SC64_SCR_USB_IRQ_MASK) && (sr & SC64_SCR_USB_IRQ_PENDING)) {
irq |= SC64_IRQ_USB;
}
if ((sr & SC64_SCR_AUX_IRQ_MASK) && (sr & SC64_SCR_AUX_IRQ_PENDING)) {
irq |= SC64_IRQ_AUX;
}
return irq;
}
void sc64_irq_callback (sc64_irq_t irq) {
uint32_t clear = 0;
if (irq & SC64_IRQ_BTN) {
clear |= SC64_IRQ_BTN_CLEAR;
}
if (irq & SC64_IRQ_CMD) {
clear |= SC64_IRQ_CMD_CLEAR;
}
if (irq & SC64_IRQ_USB) {
clear |= SC64_IRQ_USB_CLEAR;
}
if (irq & SC64_IRQ_AUX) {
clear |= SC64_IRQ_AUX_CLEAR;
}
pi_io_write(&SC64_REGS->IRQ, clear);
if (irq & SC64_IRQ_BTN) {
sc64_btn_irq_callback();
}
if (irq & SC64_IRQ_CMD) {
sc64_cmd_irq_callback();
}
if (irq & SC64_IRQ_USB) {
sc64_usb_irq_callback();
}
if (irq & SC64_IRQ_AUX) {
sc64_aux_irq_callback();
}
while (pi_busy());
}
sc64_error_t sc64_get_identifier (uint32_t *identifier) {
sc64_cmd_t cmd = {
.id = CMD_ID_IDENTIFIER_GET
};
sc64_error_t error = sc64_execute_cmd(&cmd);
*identifier = cmd.rsp[0];
return error;
}
sc64_error_t sc64_get_version (uint16_t *major, uint16_t *minor, uint32_t *revision) {
sc64_cmd_t cmd = {
.id = CMD_ID_VERSION_GET
};
sc64_error_t error = sc64_execute_cmd(&cmd);
*major = ((cmd.rsp[0] >> 16) & 0xFFFF);
*minor = (cmd.rsp[0] & 0xFFFF);
*revision = cmd.rsp[1];
return error;
}
sc64_error_t sc64_get_config (sc64_cfg_id_t id, uint32_t *value) {
sc64_cmd_t cmd = {
.id = CMD_ID_CONFIG_GET,
.arg = { id }
};
sc64_error_t error = sc64_execute_cmd(&cmd);
*value = cmd.rsp[1];
return error;
}
sc64_error_t sc64_set_config (sc64_cfg_id_t id, uint32_t value) {
sc64_cmd_t cmd = {
.id = CMD_ID_CONFIG_SET,
.arg = { id, value }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_get_setting (sc64_setting_id_t id, uint32_t *value) {
sc64_cmd_t cmd = {
.id = CMD_ID_SETTING_GET,
.arg = { id }
};
sc64_error_t error = sc64_execute_cmd(&cmd);
*value = cmd.rsp[1];
return error;
}
sc64_error_t sc64_set_setting (sc64_setting_id_t id, uint32_t value) {
sc64_cmd_t cmd = {
.id = CMD_ID_SETTING_SET,
.arg = { id, value }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_get_boot_params (sc64_boot_params_t *params) {
sc64_error_t error;
uint32_t value;
if ((error = sc64_get_config(CFG_ID_BOOT_MODE, &value)) != SC64_OK) {
return error;
}
params->boot_mode = value;
if (params->boot_mode != BOOT_MODE_MENU) {
if ((error = sc64_get_config(CFG_ID_CIC_SEED, &value)) != SC64_OK) {
return error;
}
params->cic_seed = value;
if ((error = sc64_get_config(CFG_ID_TV_TYPE, &value)) != SC64_OK) {
return error;
}
params->tv_type = value;
} else {
params->cic_seed = CIC_SEED_AUTO;
params->tv_type = TV_TYPE_PASSTHROUGH;
}
return SC64_OK;
}
sc64_error_t sc64_get_time (sc64_rtc_time_t *t) {
sc64_cmd_t cmd = {
.id = CMD_ID_TIME_GET
};
sc64_error_t error = sc64_execute_cmd(&cmd);
t->weekday = ((cmd.rsp[0] >> 24) & 0xFF);
t->hour = ((cmd.rsp[0] >> 16) & 0xFF);
t->minute = ((cmd.rsp[0] >> 8) & 0xFF);
t->second = (cmd.rsp[0] & 0xFF);
t->century = ((cmd.rsp[1] >> 24) & 0xFF);
t->year = ((cmd.rsp[1] >> 16) & 0xFF);
t->month = ((cmd.rsp[1] >> 8) & 0xFF);
t->day = (cmd.rsp[1] & 0xFF);
return error;
}
sc64_error_t sc64_set_time (sc64_rtc_time_t *t) {
uint32_t time[2] = {(
((t->weekday << 24) & 0xFF) |
((t->hour << 16) & 0xFF) |
((t->minute << 8) & 0xFF) |
(t->second & 0xFF)
), (
((t->century << 24) & 0xFF) |
((t->year << 16) & 0xFF) |
((t->month << 8) & 0xFF) |
(t->day & 0xFF)
)};
sc64_cmd_t cmd = {
.id = CMD_ID_TIME_SET,
.arg = { time[0], time[1] }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_usb_get_status (bool *reset_state, bool *cable_unplugged) {
sc64_cmd_t cmd = {
.id = CMD_ID_USB_READ_STATUS,
};
sc64_error_t error = sc64_execute_cmd(&cmd);
*reset_state = (bool) (cmd.rsp[0] & (1 << 30));
*cable_unplugged = (bool) (cmd.rsp[0] & (1 << 29));
return error;
}
sc64_error_t sc64_usb_read_info (uint8_t *type, uint32_t *length) {
sc64_cmd_t cmd = {
.id = CMD_ID_USB_READ_STATUS,
};
sc64_error_t error = sc64_execute_cmd(&cmd);
*type = (cmd.rsp[0] & 0xFF);
*length = cmd.rsp[1];
return error;
}
sc64_error_t sc64_usb_read_busy (bool *read_busy) {
sc64_cmd_t cmd = {
.id = CMD_ID_USB_READ_STATUS,
};
sc64_error_t error = sc64_execute_cmd(&cmd);
*read_busy = (bool) (cmd.rsp[0] & (1 << 31));
return error;
}
sc64_error_t sc64_usb_write_busy (bool *write_busy) {
sc64_cmd_t cmd = {
.id = CMD_ID_USB_WRITE_STATUS,
};
sc64_error_t error = sc64_execute_cmd(&cmd);
*write_busy = (bool) (cmd.rsp[0] & (1 << 31));
return error;
}
sc64_error_t sc64_usb_read (void *address, uint32_t length) {
sc64_cmd_t cmd = {
.id = CMD_ID_USB_READ,
.arg = { (uint32_t) (address), length }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_usb_write (void *address, uint8_t type, uint32_t length) {
sc64_cmd_t cmd = {
.id = CMD_ID_USB_WRITE,
.arg = { (uint32_t) (address), ((type << 24) | (length & 0xFFFFFF)) }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_sd_card_init (void) {
sc64_cmd_t cmd = {
.id = CMD_ID_SD_CARD_OP,
.arg = { (uint32_t) (NULL), SD_CARD_OP_INIT }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_sd_card_deinit (void) {
sc64_cmd_t cmd = {
.id = CMD_ID_SD_CARD_OP,
.arg = { (uint32_t) (NULL), SD_CARD_OP_DEINIT }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_sd_card_get_status (sc64_sd_card_status_t *sd_card_status) {
sc64_cmd_t cmd = {
.id = CMD_ID_SD_CARD_OP,
.arg = { (uint32_t) (NULL), SD_CARD_OP_GET_STATUS }
};
sc64_error_t error = sc64_execute_cmd(&cmd);
*sd_card_status = (sc64_sd_card_status_t) (cmd.rsp[1]);
return error;
}
sc64_error_t sc64_sd_card_get_info (void *address) {
sc64_cmd_t cmd = {
.id = CMD_ID_SD_CARD_OP,
.arg = { (uint32_t) (address), SD_CARD_OP_GET_INFO }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_sd_set_byte_swap (bool enabled) {
sc64_cmd_t cmd = {
.id = CMD_ID_SD_CARD_OP,
.arg = { (uint32_t) (NULL), enabled ? SD_CARD_OP_BYTE_SWAP_ON : SD_CARD_OP_BYTE_SWAP_OFF }
};
return sc64_execute_cmd(&cmd);
}
static sc64_error_t sc64_sd_sector_set (uint32_t sector) {
sc64_cmd_t cmd = {
.id = CMD_ID_SD_SECTOR_SET,
.arg = { sector }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_sd_read_sectors (void *address, uint32_t sector, uint32_t count) {
sc64_error_t error;
if ((error = sc64_sd_sector_set(sector)) != SC64_OK) {
return error;
}
sc64_cmd_t cmd = {
.id = CMD_ID_SD_READ,
.arg = { (uint32_t) (address), count }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_sd_write_sectors (void *address, uint32_t sector, uint32_t count) {
sc64_error_t error;
if ((error = sc64_sd_sector_set(sector)) != SC64_OK) {
return error;
}
sc64_cmd_t cmd = {
.id = CMD_ID_SD_WRITE,
.arg = { (uint32_t) (address), count }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_set_disk_mapping (void *address, uint32_t length) {
sc64_cmd_t cmd = {
.id = CMD_ID_DISK_MAPPING_SET,
.arg = { (uint32_t) (address), length }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_writeback_pending (bool *pending) {
sc64_cmd_t cmd = {
.id = CMD_ID_WRITEBACK_PENDING
};
sc64_error_t error = sc64_execute_cmd(&cmd);
*pending = (cmd.rsp[0] != 0);
return error;
}
sc64_error_t sc64_writeback_enable (void *address) {
sc64_cmd_t cmd = {
.id = CMD_ID_WRITEBACK_SD_INFO,
.arg = { (uint32_t) (address) }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_writeback_disable (void) {
sc64_error_t error;
uint32_t save_type;
if ((error = sc64_get_config(CFG_ID_SAVE_TYPE, &save_type)) != SC64_OK) {
return error;
}
return sc64_set_config(CFG_ID_SAVE_TYPE, save_type);
}
sc64_error_t sc64_flash_program (void *address, uint32_t length) {
sc64_cmd_t cmd = {
.id = CMD_ID_FLASH_PROGRAM,
.arg = { (uint32_t) (address), length }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_flash_wait_busy (void) {
sc64_cmd_t cmd = {
.id = CMD_ID_FLASH_WAIT_BUSY,
.arg = { true }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_flash_get_erase_block_size (size_t *erase_block_size) {
sc64_cmd_t cmd = {
.id = CMD_ID_FLASH_WAIT_BUSY,
.arg = { false }
};
sc64_error_t error = sc64_execute_cmd(&cmd);
*erase_block_size = (size_t) (cmd.rsp[0]);
return error;
}
sc64_error_t sc64_flash_erase_block (void *address) {
sc64_cmd_t cmd = {
.id = CMD_ID_FLASH_ERASE_BLOCK,
.arg = { (uint32_t) (address) }
};
return sc64_execute_cmd(&cmd);
}
sc64_error_t sc64_get_diagnostic (sc64_diagnostic_id_t id, uint32_t *value) {
sc64_cmd_t cmd = {
.id = CMD_ID_DIAGNOSTIC_GET,
.arg = { id }
};
sc64_error_t error = sc64_execute_cmd(&cmd);
*value = cmd.rsp[1];
return error;
}
Reference in New Issue View Git Blame Copy Permalink