summaryrefslogtreecommitdiff
path: root/arm9/lib
diff options
context:
space:
mode:
Diffstat (limited to 'arm9/lib')
-rw-r--r--arm9/lib/include/CARD_backup.h27
-rw-r--r--arm9/lib/include/CARD_common.h37
-rw-r--r--arm9/lib/src/CARD_backup.c160
-rw-r--r--arm9/lib/src/CARD_common.c1
4 files changed, 205 insertions, 20 deletions
diff --git a/arm9/lib/include/CARD_backup.h b/arm9/lib/include/CARD_backup.h
index 7cb5f820..465d6d2e 100644
--- a/arm9/lib/include/CARD_backup.h
+++ b/arm9/lib/include/CARD_backup.h
@@ -1,28 +1,17 @@
-#ifndef NITRO_CARD_BACKUP_H_
-#define NITRO_CARD_BACKUP_H_
+#ifndef POKEDIAMOND_CARD_BACKUP_H
+#define POKEDIAMOND_CARD_BACKUP_H
#include "nitro/types.h"
#include "MI_dma.h"
#include "CARD_common.h"
-BOOL CARD_TryWaitBackupAsync(void);
+BOOL CARDi_RequestStreamCommand(u32 src, u32 dst, u32 len, MIDmaCallback callback, void *arg, BOOL is_async,
+ CARDRequest req_type, int req_retry, CARDRequestMode req_mode);
+u32 CARD_GetBackupSectorSize(void);;
+BOOL CARD_IdentifyBackup(CARDBackupType type);
BOOL CARD_WaitBackupAsync(void);
+BOOL CARD_TryWaitBackupAsync(void);
void CARD_CancelBackupAsync(void);
-void CARD_UnlockBackup(u16 lock_id);
-void CARD_LockBackup(u16 lock_id);
-BOOL CARD_IdentifyBackup(u16 lock_id);
-
-BOOL CARDi_RequestStreamCommand(
- u32 src,
- u32 dst,
- u32 len,
- MIDmaCallback callback,
- void * arg,
- BOOL is_async,
- CARDRequest req_type,
- int req_retry,
- CARDRequestMode req_mode
-);
static inline BOOL CARDi_ReadBackup(u32 src, void * dst, u32 len, MIDmaCallback callback, void * arg, BOOL is_async)
{
@@ -39,4 +28,4 @@ static inline BOOL CARDi_WriteAndVerifyBackup(u32 dst, void * src, u32 len, MIDm
return CARDi_RequestStreamCommand((u32)src, (u32)dst, len, callback, arg, is_async, CARD_REQ_WRITE_BACKUP, CARD_RETRY_COUNT_MAX, CARD_REQUEST_MODE_SEND_VERIFY);
}
-#endif //NITRO_CARD_BACKUP_H_
+#endif //POKEDIAMOND_CARD_BACKUP_H
diff --git a/arm9/lib/include/CARD_common.h b/arm9/lib/include/CARD_common.h
index 051923ce..292b9066 100644
--- a/arm9/lib/include/CARD_common.h
+++ b/arm9/lib/include/CARD_common.h
@@ -3,6 +3,7 @@
#include "nitro/types.h"
#include "OS_thread.h"
+#include "OS_system.h"
#include "MI_dma.h"
#define CARD_THREAD_PRIORITY_DEFAULT 4
@@ -152,6 +153,42 @@ typedef struct CARDiCommon
u8 backup_cache_page_buf[256] ALIGN(32);
} CARDiCommon;
+static inline void CARDi_EndTask(CARDiCommon *p, BOOL is_own_task)
+{
+ const MIDmaCallback func = p->callback;
+ void *const arg = p->callback_arg;
+
+ {
+ OSIntrMode bak_psr = OS_DisableInterrupts();
+
+ p->flag &= ~(CARD_STAT_BUSY | CARD_STAT_TASK | CARD_STAT_CANCEL);
+ OS_WakeupThread(p->busy_q);
+ if ((p->flag & CARD_STAT_RECV) != 0)
+ {
+ OS_WakeupThreadDirect(p->thread);
+ }
+ (void)OS_RestoreInterrupts(bak_psr);
+ }
+
+ if (is_own_task && func)
+ {
+ (*func)(arg);
+ }
+}
+
+static inline void CARDi_WaitTask(CARDiCommon *p, MIDmaCallback callback, void *callback_arg)
+{
+ OSIntrMode bak_psr = OS_DisableInterrupts();
+ while ((p->flag & CARD_STAT_BUSY) != 0)
+ {
+ OS_SleepThread(p->busy_q);
+ }
+ p->flag |= CARD_STAT_BUSY;
+ p->callback = callback;
+ p->callback_arg = callback_arg;
+ (void)OS_RestoreInterrupts(bak_psr);
+}
+
void CARDi_SetTask(void (*task) (CARDiCommon *));
void CARDi_InitCommon(void);
BOOL CARD_IsEnabled(void);
diff --git a/arm9/lib/src/CARD_backup.c b/arm9/lib/src/CARD_backup.c
new file mode 100644
index 00000000..fa39fa0f
--- /dev/null
+++ b/arm9/lib/src/CARD_backup.c
@@ -0,0 +1,160 @@
+#include "CARD_backup.h"
+#include "function_target.h"
+#include "CARD_common.h"
+#include "OS_cache.h"
+#include "MI_memory.h"
+#include "OS_terminate_proc.h"
+#include "OS_system.h"
+
+extern void OSi_ReferSymbol(void *symbol);
+extern char _SDK_NintendoBackup[];
+
+extern BOOL CARDi_Request(CARDiCommon * p, int req_type, int retry_count);
+extern void CARDi_IdentifyBackupCore(CARDBackupType type);
+
+extern CARDiCommon cardi_common;
+
+static void CARDi_RequestStreamCommandCore(CARDiCommon *p);
+
+ARM_FUNC static void CARDi_RequestStreamCommandCore(CARDiCommon *p)
+{
+ const int req_type = p->req_type;
+ const int req_mode = p->req_mode;
+ const int retry_count = p->req_retry;
+ u32 size = sizeof(p->backup_cache_page_buf);
+
+ OSi_ReferSymbol((void *)_SDK_NintendoBackup);
+
+ if (req_type == CARD_REQ_ERASE_SECTOR_BACKUP)
+ {
+ size = CARD_GetBackupSectorSize();
+ }
+ do
+ {
+ const u32 len = (size < p->len) ? size : p->len;
+ p->cmd->len = len;
+
+ if ((p->flag & CARD_STAT_CANCEL) != 0)
+ {
+ p->flag &= ~CARD_STAT_CANCEL;
+ p->cmd->result = CARD_RESULT_CANCELED;
+ break;
+ }
+ switch (req_mode)
+ {
+ case CARD_REQUEST_MODE_RECV:
+ DC_InvalidateRange(p->backup_cache_page_buf, len);
+ p->cmd->src = (u32)p->src;
+ p->cmd->dest = (u32)p->backup_cache_page_buf;
+ break;
+ case CARD_REQUEST_MODE_SEND:
+ case CARD_REQUEST_MODE_SEND_VERIFY:
+ MI_CpuCopy8((const void *)p->src, p->backup_cache_page_buf, len);
+ DC_FlushRange(p->backup_cache_page_buf, len);
+ DC_WaitWriteBufferEmpty();
+ p->cmd->src = (u32)p->backup_cache_page_buf;
+ p->cmd->dest = (u32)p->dst;
+ break;
+ case CARD_REQUEST_MODE_SPECIAL:
+ p->cmd->src = (u32)p->src;
+ p->cmd->dest = (u32)p->dst;
+ break;
+ }
+
+ if (!CARDi_Request(p, req_type, retry_count))
+ {
+ break;
+ }
+
+ if (req_mode == CARD_REQUEST_MODE_SEND_VERIFY)
+ {
+ if (!CARDi_Request(p, CARD_REQ_VERIFY_BACKUP, 1))
+ {
+ break;
+ }
+ }
+ else if (req_mode == CARD_REQUEST_MODE_RECV)
+ {
+ MI_CpuCopy8(p->backup_cache_page_buf, (void *)p->dst, len);
+ }
+ p->src += len;
+ p->dst += len;
+ p->len -= len;
+ }
+ while (p->len > 0);
+ CARDi_EndTask(p, TRUE);
+}
+
+ARM_FUNC BOOL CARDi_RequestStreamCommand(u32 src, u32 dst, u32 len, MIDmaCallback callback, void *arg, BOOL is_async,
+ CARDRequest req_type, int req_retry, CARDRequestMode req_mode)
+{
+ CARDiCommon *const p = &cardi_common;
+
+ OSi_ReferSymbol((void *)_SDK_NintendoBackup);
+
+ CARDi_WaitTask(p, callback, arg);
+ p->src = src;
+ p->dst = dst;
+ p->len = len;
+ p->req_type = req_type;
+ p->req_retry = req_retry;
+ p->req_mode = req_mode;
+ if (is_async)
+ {
+ CARDi_SetTask(CARDi_RequestStreamCommandCore);
+ return TRUE;
+ }
+ else
+ {
+ cardi_common.cur_th = OS_GetCurrentThread();
+ CARDi_RequestStreamCommandCore(p);
+ return (p->cmd->result == CARD_RESULT_SUCCESS);
+ }
+}
+
+ARM_FUNC u32 CARD_GetBackupSectorSize(void)
+{
+ return cardi_common.cmd->spec.sect_size;
+}
+
+ARM_FUNC BOOL CARD_IdentifyBackup(CARDBackupType type)
+{
+ CARDiCommon *const p = &cardi_common;
+
+ OSi_ReferSymbol((void *)_SDK_NintendoBackup);
+ if (type == CARD_BACKUP_TYPE_NOT_USE)
+ {
+ OS_Terminate();
+ }
+
+ CARD_CheckEnabled();
+
+ CARDi_WaitTask(p, NULL, NULL);
+ CARDi_IdentifyBackupCore(type);
+ cardi_common.cur_th = OS_GetCurrentThread();
+ (void)CARDi_Request(p, CARD_REQ_IDENTIFY, 1);
+
+ p->cmd->src = 0;
+ p->cmd->dest = (u32)p->backup_cache_page_buf;
+ p->cmd->len = 1;
+ (void)CARDi_Request(p, CARD_REQ_READ_BACKUP, 1);
+ CARDi_EndTask(p, TRUE);
+ return (p->cmd->result == CARD_RESULT_SUCCESS);
+}
+
+ARM_FUNC BOOL CARD_WaitBackupAsync(void)
+{
+ return CARDi_WaitAsync();
+}
+
+ARM_FUNC BOOL CARD_TryWaitBackupAsync(void)
+{
+ return CARDi_TryWaitAsync();
+}
+
+ARM_FUNC void CARD_CancelBackupAsync(void)
+{
+ OSIntrMode bak_cpsr = OS_DisableInterrupts();
+ cardi_common.flag |= CARD_STAT_CANCEL;
+ (void)OS_RestoreInterrupts(bak_cpsr);
+}
diff --git a/arm9/lib/src/CARD_common.c b/arm9/lib/src/CARD_common.c
index f02d10e2..c6bae9a1 100644
--- a/arm9/lib/src/CARD_common.c
+++ b/arm9/lib/src/CARD_common.c
@@ -2,7 +2,6 @@
#include "consts.h"
#include "function_target.h"
#include "MI_memory.h"
-#include "OS_system.h"
#include "OS_terminate_proc.h"
#include "OS_spinLock.h"
#include "OS_cache.h"
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-26 10:57:18 +0000