From 3c458e8b4893866639734a572a7d8e5ce6c7c1ce Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Tue, 5 May 2020 20:13:17 -0400 Subject: Decompile GF funcs responsible for overlays --- arm9/lib/include/CARD_rom.h | 11 +++ arm9/lib/include/FS_archive.h | 90 ++++++++++++++++++++++ arm9/lib/include/FS_file.h | 164 +++++++++++++++++++++++++++++++++++++++++ arm9/lib/include/FS_overlay.h | 42 +++++++++++ arm9/lib/include/MI_exMemory.h | 9 +++ arm9/lib/include/OS_system.h | 1 + arm9/lib/include/OS_thread.h | 8 ++ arm9/lib/include/mmap.h | 2 + arm9/lib/include/mmap_global.h | 4 + 9 files changed, 331 insertions(+) create mode 100644 arm9/lib/include/CARD_rom.h create mode 100644 arm9/lib/include/FS_archive.h create mode 100644 arm9/lib/include/FS_file.h create mode 100644 arm9/lib/include/FS_overlay.h create mode 100644 arm9/lib/include/MI_exMemory.h create mode 100644 arm9/lib/include/mmap_global.h (limited to 'arm9/lib') diff --git a/arm9/lib/include/CARD_rom.h b/arm9/lib/include/CARD_rom.h new file mode 100644 index 00000000..327bc995 --- /dev/null +++ b/arm9/lib/include/CARD_rom.h @@ -0,0 +1,11 @@ +#ifndef NITRO_CARD_ROM_H_ +#define NITRO_CARD_ROM_H_ + +typedef struct +{ + u32 offset; + u32 length; +} +CARDRomRegion; + +#endif //NITRO_CARD_ROM_H_ diff --git a/arm9/lib/include/FS_archive.h b/arm9/lib/include/FS_archive.h new file mode 100644 index 00000000..65bb2ea1 --- /dev/null +++ b/arm9/lib/include/FS_archive.h @@ -0,0 +1,90 @@ +#ifndef NITRO_FS_ARCHIVE_H_ +#define NITRO_FS_ARCHIVE_H_ + +#include "nitro.h" + +#include "OS_thread.h" + +struct FSFile; +struct FSArchive; + +typedef enum { + FS_COMMAND_ASYNC_BEGIN = 0, + FS_COMMAND_READFILE = FS_COMMAND_ASYNC_BEGIN, + FS_COMMAND_WRITEFILE, + FS_COMMAND_ASYNC_END, + + FS_COMMAND_SYNC_BEGIN = FS_COMMAND_ASYNC_END, + FS_COMMAND_SEEKDIR = FS_COMMAND_SYNC_BEGIN, + FS_COMMAND_READDIR, + FS_COMMAND_FINDPATH, + FS_COMMAND_GETPATH, + FS_COMMAND_OPENFILEFAST, + FS_COMMAND_OPENFILEDIRECT, + FS_COMMAND_CLOSEFILE, + FS_COMMAND_SYNC_END, + + FS_COMMAND_STATUS_BEGIN = FS_COMMAND_SYNC_END, + FS_COMMAND_ACTIVATE = FS_COMMAND_STATUS_BEGIN, + FS_COMMAND_IDLE, + FS_COMMAND_SUSPEND, + FS_COMMAND_RESUME, + FS_COMMAND_STATUS_END, + + FS_COMMAND_INVALID +} FSCommandType; + +typedef enum { + FS_RESULT_SUCCESS = 0, + FS_RESULT_FAILURE, + FS_RESULT_BUSY, + FS_RESULT_CANCELED, + FS_RESULT_CANCELLED = FS_RESULT_CANCELED, // SDK alias + FS_RESULT_UNSUPPORTED, + FS_RESULT_ERROR, + FS_RESULT_PROC_ASYNC, + FS_RESULT_PROC_DEFAULT, + FS_RESULT_PROC_UNKNOWN +} +FSResult; + +typedef FSResult (*FS_ARCHIVE_READ_FUNC) (struct FSArchive *p, void *dst, u32 pos, u32 size); +typedef FSResult (*FS_ARCHIVE_WRITE_FUNC) (struct FSArchive *p, const void *src, u32 pos, u32 size); +typedef FSResult (*FS_ARCHIVE_PROC_FUNC) (struct FSFile *, FSCommandType); + +typedef struct +{ + struct FSFile * prev; + struct FSFile * next; +} +FSFileLink; + +typedef struct FSArchive +{ + union + { + char ptr[4]; + u32 pack; + } name; + struct FSArchive * prev; + struct FSArchive * next; + OSThreadQueue sync_q; + OSThreadQueue stat_q; + u32 flag; + FSFileLink list; + u32 base; + u32 fat; + u32 fat_size; + u32 fnt; + u32 fnt_size; + u32 fat_bak; + u32 fnt_bak; + void * load_mem; + FS_ARCHIVE_READ_FUNC read_func; + FS_ARCHIVE_WRITE_FUNC write_func; + FS_ARCHIVE_READ_FUNC table_func; + FS_ARCHIVE_PROC_FUNC proc; + u32 proc_flag; +} FSArchive; + +#endif //NITRO_FS_ARCHIVE_H_ diff --git a/arm9/lib/include/FS_file.h b/arm9/lib/include/FS_file.h new file mode 100644 index 00000000..08a698d0 --- /dev/null +++ b/arm9/lib/include/FS_file.h @@ -0,0 +1,164 @@ +#ifndef NITRO_FS_FILE_H_ +#define NITRO_FS_FILE_H_ + +#include "nitro.h" + +#include "FS_archive.h" + +struct FSFile; + +#define FS_DMA_NOT_USE ((u32)~0) + +typedef struct FSDirPos +{ + struct FSArchive *arc; + u16 own_id; + u16 index; + u32 pos; +} +FSDirPos; + +typedef struct FSFileID +{ + struct FSArchive *arc; + u32 file_id; +} +FSFileID; + +typedef struct +{ + union + { + FSFileID file_id; + FSDirPos dir_id; + }; + u32 is_directory; + u32 name_len; + char name[128]; +} +FSDirEntry; + + +typedef struct +{ + FSDirPos pos; +} +FSSeekDirInfo; + + +typedef struct +{ + FSDirEntry *p_entry; + BOOL skip_string; +} +FSReadDirInfo; + + +typedef struct +{ + FSDirPos pos; + const char *path; + BOOL find_directory; + union + { + FSFileID *file; + FSDirPos *dir; + } + result; +} +FSFindPathInfo; + + +typedef struct +{ + u8 *buf; + u32 buf_len; + u16 total_len; + u16 dir_id; +} +FSGetPathInfo; + + +typedef struct +{ + FSFileID id; +} +FSOpenFileFastInfo; + + +typedef struct +{ + u32 top; + u32 bottom; + u32 index; +} +FSOpenFileDirectInfo; + + +typedef struct +{ + u32 reserved; +} +FSCloseFileInfo; + + +typedef struct +{ + void *dst; + u32 len_org; + u32 len; +} +FSReadFileInfo; + + +typedef struct +{ + const void *src; + u32 len_org; + u32 len; +} +FSWriteFileInfo; + +typedef struct FSFile +{ + FSFileLink link; + struct FSArchive *arc; + u32 stat; + FSCommandType command; + FSResult error; + OSThreadQueue queue[1]; + u32 filler; // Figure out what this actually is + union { + struct + { + u32 own_id; + u32 top; + u32 bottom; + u32 pos; + } file; + struct + { + FSDirPos pos; + u32 parent; + } dir; + } prop; + + union { + FSReadFileInfo readfile; + FSWriteFileInfo writefile; + + FSSeekDirInfo seekdir; + FSReadDirInfo readdir; + FSFindPathInfo findpath; + FSGetPathInfo getpath; + FSOpenFileFastInfo openfilefast; + FSOpenFileDirectInfo openfiledirect; + FSCloseFileInfo closefile; + }; +} +FSFile; + +u32 FS_SetDefaultDMA(u32 dma_no); // returns the previous selection +void FS_InitFile(FSFile * p_file); + +#endif //NITRO_FS_FILE_H_ diff --git a/arm9/lib/include/FS_overlay.h b/arm9/lib/include/FS_overlay.h new file mode 100644 index 00000000..967169aa --- /dev/null +++ b/arm9/lib/include/FS_overlay.h @@ -0,0 +1,42 @@ +#ifndef NITRO_FS_OVERLAY_H_ +#define NITRO_FS_OVERLAY_H_ + +#include "nitro.h" +#include "MI_exMemory.h" +#include "FS_file.h" +#include "CARD_rom.h" + +typedef u32 FSOverlayID; + +typedef void (*FSOverlayInitFunc) (void); + +typedef struct FSOverlayInfoHeader +{ + u32 id; + u8 *ram_address; + u32 ram_size; + u32 bss_size; + FSOverlayInitFunc *sinit_init; + FSOverlayInitFunc *sinit_init_end; + u32 file_id; + u32 compressed:24; + u32 flag:8; +} FSOverlayInfoHeader; + +typedef struct FSOverlayInfo +{ + FSOverlayInfoHeader header; + MIProcessor target; + CARDRomRegion file_pos; +} FSOverlayInfo; + +BOOL FS_LoadOverlayInfo(FSOverlayInfo *p_ovi, MIProcessor target, FSOverlayID id); +BOOL FS_LoadOverlay(MIProcessor target, FSOverlayID id); +BOOL FS_UnloadOverlay(MIProcessor target, FSOverlayID id); +BOOL FS_LoadOverlayImage(FSOverlayInfo *p_ovi); +void FS_StartOverlay(FSOverlayInfo *p_ovi); +BOOL FS_LoadOverlayImageAsync(FSOverlayInfo *p_ovi, FSFile *p_file); +void FS_WaitAsync(FSFile *p_file); +void FS_CloseFile(FSFile *p_file); + +#endif //NITRO_FS_OVERLAY_H_ diff --git a/arm9/lib/include/MI_exMemory.h b/arm9/lib/include/MI_exMemory.h new file mode 100644 index 00000000..4a8a10a8 --- /dev/null +++ b/arm9/lib/include/MI_exMemory.h @@ -0,0 +1,9 @@ +#ifndef NITRO_MI_EXMEMORY_H_ +#define NITRO_MI_EXMEMORY_H_ + +typedef enum { + MI_PROCESSOR_ARM9 = 0, + MI_PROCESSOR_ARM7 = 1 +} MIProcessor; + +#endif //NITRO_MI_EXMEMORY_H_ diff --git a/arm9/lib/include/OS_system.h b/arm9/lib/include/OS_system.h index 93903315..794e16d2 100644 --- a/arm9/lib/include/OS_system.h +++ b/arm9/lib/include/OS_system.h @@ -5,6 +5,7 @@ #ifndef POKEDIAMOND_OS_SYSTEM_H #define POKEDIAMOND_OS_SYSTEM_H +#include "function_target.h" #include "consts.h" typedef enum { diff --git a/arm9/lib/include/OS_thread.h b/arm9/lib/include/OS_thread.h index 4fb70bf7..207dac1b 100644 --- a/arm9/lib/include/OS_thread.h +++ b/arm9/lib/include/OS_thread.h @@ -7,6 +7,14 @@ typedef struct _OSThread OSThread; +struct _OSThreadQueue +{ + OSThread *head; + OSThread *tail; +}; + +typedef struct _OSThreadQueue OSThreadQueue; + typedef struct OSThreadInfo { u16 isNeedRescheduling; u16 irqDepth; diff --git a/arm9/lib/include/mmap.h b/arm9/lib/include/mmap.h index d94df843..56ae08c8 100644 --- a/arm9/lib/include/mmap.h +++ b/arm9/lib/include/mmap.h @@ -12,8 +12,10 @@ extern u32 SDK_AUTOLOAD_DTCM_START[]; #define HW_MAIN_MEM_SHARED_SIZE 0x00001000 #define HW_MAIN_MEM_DEBUGGER_OFFSET 0x00700000 +#define HW_ITCM_IMAGE 0x01000000 #define HW_ITCM 0x01FF8000 #define HW_ITCM_SIZE 0x00008000 +#define HW_ITCM_END (HW_ITCM + HW_ITCM_SIZE) #define HW_WRAM 0x037F8000 diff --git a/arm9/lib/include/mmap_global.h b/arm9/lib/include/mmap_global.h new file mode 100644 index 00000000..e657e46f --- /dev/null +++ b/arm9/lib/include/mmap_global.h @@ -0,0 +1,4 @@ +#ifndef NITRO_MMAP_GLOBAL_H_ +#define NITRO_MMAP_GLOBAL_H_ + +#endif //NITRO_MMAP_GLOBAL_H_ -- cgit v1.2.3 From cd5559a2093c2be1167eba2f2ef38eedb32a8a1d Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Tue, 5 May 2020 21:59:23 -0400 Subject: Decompile FS_file.c --- arm9/lib/include/FS_archive.h | 23 ++++ arm9/lib/include/FS_file.h | 19 ++- arm9/lib/include/FS_rom.h | 6 + arm9/lib/include/MI_byteAccess.h | 9 ++ arm9/lib/include/OS_thread.h | 6 + arm9/lib/src/FS_file.c | 258 +++++++++++++++++++++++++++++++++++++++ 6 files changed, 319 insertions(+), 2 deletions(-) create mode 100644 arm9/lib/include/FS_rom.h create mode 100644 arm9/lib/include/MI_byteAccess.h create mode 100644 arm9/lib/src/FS_file.c (limited to 'arm9/lib') diff --git a/arm9/lib/include/FS_archive.h b/arm9/lib/include/FS_archive.h index 65bb2ea1..66840b32 100644 --- a/arm9/lib/include/FS_archive.h +++ b/arm9/lib/include/FS_archive.h @@ -8,6 +8,19 @@ struct FSFile; struct FSArchive; +#define FS_ARCHIVE_NAME_LEN_MAX 3 + +#define FS_ARCHIVE_FLAG_REGISTER 0x00000001 +#define FS_ARCHIVE_FLAG_LOADED 0x00000002 +#define FS_ARCHIVE_FLAG_TABLE_LOAD 0x00000004 +#define FS_ARCHIVE_FLAG_SUSPEND 0x00000008 +#define FS_ARCHIVE_FLAG_RUNNING 0x00000010 +#define FS_ARCHIVE_FLAG_CANCELING 0x00000020 +#define FS_ARCHIVE_FLAG_SUSPENDING 0x00000040 +#define FS_ARCHIVE_FLAG_UNLOADING 0x00000080 +#define FS_ARCHIVE_FLAG_IS_ASYNC 0x00000100 +#define FS_ARCHIVE_FLAG_IS_SYNC 0x00000200 + typedef enum { FS_COMMAND_ASYNC_BEGIN = 0, FS_COMMAND_READFILE = FS_COMMAND_ASYNC_BEGIN, @@ -87,4 +100,14 @@ typedef struct FSArchive u32 proc_flag; } FSArchive; +FSArchive * const FS_FindArchive(const char * path, int offset); + +static inline BOOL FS_IsArchiveLoaded(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_LOADED) ? TRUE : FALSE; +} + +BOOL FSi_SendCommand(struct FSFile * file, FSCommandType command); +BOOL FSi_ExecuteSyncCommand(struct FSFile * file); + #endif //NITRO_FS_ARCHIVE_H_ diff --git a/arm9/lib/include/FS_file.h b/arm9/lib/include/FS_file.h index 08a698d0..4871b660 100644 --- a/arm9/lib/include/FS_file.h +++ b/arm9/lib/include/FS_file.h @@ -5,6 +5,21 @@ #include "FS_archive.h" +#define FS_FILE_STATUS_BUSY 0x00000001 +#define FS_FILE_STATUS_CANCEL 0x00000002 +#define FS_FILE_STATUS_SYNC 0x00000004 +#define FS_FILE_STATUS_ASYNC 0x00000008 +#define FS_FILE_STATUS_IS_FILE 0x00000010 +#define FS_FILE_STATUS_IS_DIR 0x00000020 +#define FS_FILE_STATUS_OPERATING 0x00000040 + +typedef enum FSSeekFileMode +{ + FS_SEEK_SET = 0, + FS_SEEK_CUR, + FS_SEEK_END +} FSSeekFileMode; + struct FSFile; #define FS_DMA_NOT_USE ((u32)~0) @@ -127,7 +142,6 @@ typedef struct FSFile FSCommandType command; FSResult error; OSThreadQueue queue[1]; - u32 filler; // Figure out what this actually is union { struct { @@ -154,11 +168,12 @@ typedef struct FSFile FSOpenFileFastInfo openfilefast; FSOpenFileDirectInfo openfiledirect; FSCloseFileInfo closefile; - }; + } arg; } FSFile; u32 FS_SetDefaultDMA(u32 dma_no); // returns the previous selection void FS_InitFile(FSFile * p_file); +BOOL FS_WaitAsync(FSFile * p_file); #endif //NITRO_FS_FILE_H_ diff --git a/arm9/lib/include/FS_rom.h b/arm9/lib/include/FS_rom.h new file mode 100644 index 00000000..fc62b579 --- /dev/null +++ b/arm9/lib/include/FS_rom.h @@ -0,0 +1,6 @@ +#ifndef NITRO_FS_ROM_H_ +#define NITRO_FS_ROM_H_ + +void FSi_InitRom(u32 default_dma_no); + +#endif //NITRO_FS_ROM_H_ diff --git a/arm9/lib/include/MI_byteAccess.h b/arm9/lib/include/MI_byteAccess.h new file mode 100644 index 00000000..10dae4c9 --- /dev/null +++ b/arm9/lib/include/MI_byteAccess.h @@ -0,0 +1,9 @@ +#ifndef NITRO_MI_BYTEACCESS_H_ +#define NITRO_MI_BYTEACCESS_H_ + +static inline u8 MI_ReadByte(const void *address) +{ + return *(u8 *)address; +} + +#endif //NITRO_MI_BYTEACCESS_H_ diff --git a/arm9/lib/include/OS_thread.h b/arm9/lib/include/OS_thread.h index 207dac1b..8820a7a0 100644 --- a/arm9/lib/include/OS_thread.h +++ b/arm9/lib/include/OS_thread.h @@ -28,4 +28,10 @@ struct _OSThread u8 padding[0x80]; //todo: not the correct size but idfk }; +void OS_SleepThread(OSThreadQueue * queue); +static inline void OS_InitThreadQueue(OSThreadQueue * queue) +{ + queue->head = queue->tail = NULL; +} + #endif //POKEDIAMOND_OS_THREAD_H diff --git a/arm9/lib/src/FS_file.c b/arm9/lib/src/FS_file.c new file mode 100644 index 00000000..8ca89af8 --- /dev/null +++ b/arm9/lib/src/FS_file.c @@ -0,0 +1,258 @@ +#include "nitro.h" +#include "MI_byteAccess.h" +#include "FS_rom.h" +#include "FS_file.h" + +extern FSDirPos current_dir_pos; +BOOL is_init = FALSE; + +static inline BOOL FSi_IsSlash(u32 c) +{ + return (c == '/') || (c == '\\'); +} + +static inline BOOL FS_IsBusy(volatile const FSFile * p_file) +{ + return p_file->stat & FS_FILE_STATUS_BUSY ? TRUE : FALSE; +} + +static inline BOOL FS_IsSucceeded(volatile const FSFile * p_file) +{ + return p_file->error == FS_RESULT_SUCCESS ? TRUE : FALSE; +} + +void FS_Init(u32 default_dma_no) +{ + if (!is_init) + { + is_init = TRUE; + FSi_InitRom(default_dma_no); + } +} + +BOOL FS_IsAvailable(void) +{ + return is_init; +} + +void FS_InitFile(FSFile * p_file) +{ + p_file->link.next = p_file->link.prev = NULL; + OS_InitThreadQueue(p_file->queue); + p_file->arc = NULL; + p_file->command = FS_COMMAND_INVALID; + p_file->stat = 0; +} + +static BOOL FSi_FindPath(FSFile * p_dir, const char * path, FSFileID * p_file_id, FSDirPos * p_dir_pos) +{ + FSDirPos pos; + if (FSi_IsSlash(MI_ReadByte(path))) + { + pos.arc = current_dir_pos.arc; + pos.own_id = 0; + pos.pos = 0; + pos.index = 0; + path++; + } + else + { + int i; + pos = current_dir_pos; + for (i = 0; i <= FS_ARCHIVE_NAME_LEN_MAX; ++i) + { + u32 c = MI_ReadByte(path + i); + if (!c || FSi_IsSlash(c)) + break; + else if (c == ':') + { + FSArchive * const p_arc = FS_FindArchive(path, i); + if (!p_arc) + { + return FALSE; + } + else if (!FS_IsArchiveLoaded(p_arc)) + { + return FALSE; + } + pos.arc = p_arc; + pos.pos = 0; + pos.index = 0; + pos.own_id = 0; + path += i + 1; + if (FSi_IsSlash(MI_ReadByte(path))) + ++path; + break; + } + } + } + p_dir->arc = pos.arc; + p_dir->arg.findpath.path = path; + p_dir->arg.findpath.pos = pos; + if (p_dir_pos) + { + p_dir->arg.findpath.find_directory = TRUE; + p_dir->arg.findpath.result.dir = p_dir_pos; + } + else + { + p_dir->arg.findpath.find_directory = FALSE; + p_dir->arg.findpath.result.file = p_file_id; + } + return FSi_SendCommand(p_dir, FS_COMMAND_FINDPATH); +} + +int FSi_ReadFileCore(FSFile * p_file, void * dst, s32 len, BOOL async) +{ + { + const s32 pos = (s32)p_file->prop.file.pos; + const s32 rest = (s32)p_file->prop.file.bottom - pos; + const u32 org = (u32)len; + if (len > rest) + len = rest; + if (len < 0) + len = 0; + p_file->arg.readfile.dst = dst; + p_file->arg.readfile.len_org = org; + p_file->arg.readfile.len = (u32)(len); + if (!async) + p_file->stat |= FS_FILE_STATUS_SYNC; + (void)FSi_SendCommand(p_file, FS_COMMAND_READFILE); + if (!async) + { + if (FS_WaitAsync(p_file)) + len = (s32)p_file->prop.file.pos - pos; + else + len = -1; + } + } + return len; +} + +BOOL FS_ConvertPathToFileID(FSFileID * p_file_id, const char * path) +{ + FSFile dir; + FS_InitFile(&dir); + if (!FSi_FindPath(&dir, path, p_file_id, NULL)) + return FALSE; + return TRUE; +} + +BOOL FS_OpenFileDirect(FSFile * p_file, FSArchive * p_arc, u32 image_top, u32 image_bottom, u32 file_index) +{ + p_file->arc = p_arc; + p_file->arg.openfiledirect.index = file_index; + p_file->arg.openfiledirect.top = image_top; + p_file->arg.openfiledirect.bottom = image_bottom; + if (!FSi_SendCommand(p_file, FS_COMMAND_OPENFILEDIRECT)) + return FALSE; + p_file->stat |= FS_FILE_STATUS_IS_FILE; + p_file->stat &= ~FS_FILE_STATUS_IS_DIR; + return TRUE; +} + +BOOL FS_OpenFileFast(FSFile * p_file, FSFileID file_id) +{ + if (!file_id.arc) + return FALSE; + p_file->arc = file_id.arc; + p_file->arg.openfilefast.id = file_id; + if (!FSi_SendCommand(p_file, FS_COMMAND_OPENFILEFAST)) + return FALSE; + p_file->stat |= FS_FILE_STATUS_IS_FILE; + p_file->stat &= ~FS_FILE_STATUS_IS_DIR; + return TRUE; +} + +BOOL FS_OpenFile(FSFile * p_file, const char * path) +{ + FSFileID file_id; + return FS_ConvertPathToFileID(&file_id, path) && FS_OpenFileFast(p_file, file_id); +} + +BOOL FS_CloseFile(FSFile * p_file) +{ + if (!FSi_SendCommand(p_file, FS_COMMAND_CLOSEFILE)) + return FALSE; + p_file->arc = NULL; + p_file->command = FS_COMMAND_INVALID; + p_file->stat &= ~(FS_FILE_STATUS_IS_FILE | FS_FILE_STATUS_IS_DIR); + return TRUE; +} + +BOOL FS_WaitAsync(FSFile * p_file) +{ + BOOL is_owner = FALSE; + OSIntrMode bak_par = OS_DisableInterrupts(); + if (FS_IsBusy(p_file)) + { + is_owner = !(p_file->stat & (FS_FILE_STATUS_SYNC | FS_FILE_STATUS_OPERATING)); + if (is_owner) + { + p_file->stat |= FS_FILE_STATUS_SYNC; + do + { + OS_SleepThread(p_file->queue); + } while (!(p_file->stat & FS_FILE_STATUS_OPERATING)); + } + else + { + do + { + OS_SleepThread(p_file->queue); + } while (FS_IsBusy(p_file)); + } + } + (void)OS_RestoreInterrupts(bak_par); + if (is_owner) + { + return FSi_ExecuteSyncCommand(p_file); + } + + return FS_IsSucceeded(p_file); +} + +int FS_ReadFileAsync(FSFile * p_file, void * dst, s32 len) +{ + return FSi_ReadFileCore(p_file, dst, len, TRUE); +} + +int FS_ReadFile(FSFile * p_file, void * dst, s32 len) +{ + return FSi_ReadFileCore(p_file, dst, len, FALSE); +} + +BOOL FS_SeekFile(FSFile * p_file, int offset, FSSeekFileMode origin) +{ + switch (origin) + { + case FS_SEEK_SET: + offset += p_file->prop.file.top; + break; + case FS_SEEK_CUR: + offset += p_file->prop.file.pos; + break; + case FS_SEEK_END: + offset += p_file->prop.file.bottom; + break; + default: + return FALSE; + } + if (offset < (s32)p_file->prop.file.top) + offset = (s32)p_file->prop.file.top; + if (offset > (s32)p_file->prop.file.bottom) + offset = (s32)p_file->prop.file.bottom; + p_file->prop.file.pos = offset; + return TRUE; +} + +BOOL FS_ChangeDir(const char * path) +{ + FSDirPos pos; + FSFile dir; + FS_InitFile(&dir); + if (!FSi_FindPath(&dir, path, NULL, &pos)) + return FALSE; + current_dir_pos = pos; + return TRUE; +} -- cgit v1.2.3 From c8230ac1a65a367f7796a2c8afed9533ba135faf Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Tue, 5 May 2020 22:08:55 -0400 Subject: Fix matching --- arm9/lib/include/FS_overlay.h | 1 - 1 file changed, 1 deletion(-) (limited to 'arm9/lib') diff --git a/arm9/lib/include/FS_overlay.h b/arm9/lib/include/FS_overlay.h index 967169aa..c2634509 100644 --- a/arm9/lib/include/FS_overlay.h +++ b/arm9/lib/include/FS_overlay.h @@ -36,7 +36,6 @@ BOOL FS_UnloadOverlay(MIProcessor target, FSOverlayID id); BOOL FS_LoadOverlayImage(FSOverlayInfo *p_ovi); void FS_StartOverlay(FSOverlayInfo *p_ovi); BOOL FS_LoadOverlayImageAsync(FSOverlayInfo *p_ovi, FSFile *p_file); -void FS_WaitAsync(FSFile *p_file); void FS_CloseFile(FSFile *p_file); #endif //NITRO_FS_OVERLAY_H_ -- cgit v1.2.3 From 9f3c697d9dee85da8c9bf4f708a340d5023194ec Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Wed, 6 May 2020 18:14:26 -0400 Subject: FS_overlay.c --- arm9/lib/include/CARD_rom.h | 9 ++ arm9/lib/include/DGT_common.h | 6 + arm9/lib/include/DGT_dgt.h | 6 + arm9/lib/include/FS_file.h | 13 ++ arm9/lib/include/FS_mw_dtor.h | 16 +++ arm9/lib/include/FS_overlay.h | 15 ++ arm9/lib/include/FS_rom.h | 7 + arm9/lib/include/MI_memory.h | 10 ++ arm9/lib/include/MI_uncompress.h | 6 + arm9/lib/include/OS_cache.h | 9 ++ arm9/lib/include/OS_system.h | 5 + arm9/lib/src/FS_overlay.c | 297 +++++++++++++++++++++++++++++++++++++++ 12 files changed, 399 insertions(+) create mode 100644 arm9/lib/include/DGT_common.h create mode 100644 arm9/lib/include/DGT_dgt.h create mode 100644 arm9/lib/include/FS_mw_dtor.h create mode 100644 arm9/lib/include/MI_memory.h create mode 100644 arm9/lib/include/MI_uncompress.h create mode 100644 arm9/lib/include/OS_cache.h create mode 100644 arm9/lib/src/FS_overlay.c (limited to 'arm9/lib') diff --git a/arm9/lib/include/CARD_rom.h b/arm9/lib/include/CARD_rom.h index 327bc995..c43a2f06 100644 --- a/arm9/lib/include/CARD_rom.h +++ b/arm9/lib/include/CARD_rom.h @@ -1,6 +1,8 @@ #ifndef NITRO_CARD_ROM_H_ #define NITRO_CARD_ROM_H_ +#include "MI_exMemory.h" + typedef struct { u32 offset; @@ -8,4 +10,11 @@ typedef struct } CARDRomRegion; +static inline const CARDRomRegion * CARD_GetRomRegionOVT(MIProcessor target) +{ + return (target == MI_PROCESSOR_ARM9) + ? (const CARDRomRegion *)((const u8 *)HW_ROM_HEADER_BUF + 0x50) + : (const CARDRomRegion *)((const u8 *)HW_ROM_HEADER_BUF + 0x58); +} + #endif //NITRO_CARD_ROM_H_ diff --git a/arm9/lib/include/DGT_common.h b/arm9/lib/include/DGT_common.h new file mode 100644 index 00000000..c74ae7cd --- /dev/null +++ b/arm9/lib/include/DGT_common.h @@ -0,0 +1,6 @@ +#ifndef NITRO_DGT_COMMON_H_ +#define NITRO_DGT_COMMON_H_ + +#define DGT_HASH2_DIGEST_SIZE (160/8) + +#endif //NITRO_DGT_COMMON_H_ diff --git a/arm9/lib/include/DGT_dgt.h b/arm9/lib/include/DGT_dgt.h new file mode 100644 index 00000000..1c48531c --- /dev/null +++ b/arm9/lib/include/DGT_dgt.h @@ -0,0 +1,6 @@ +#ifndef NITRO_DGT_DGT_H_ +#define NITRO_DGT_DGT_H_ + +void DGT_Hash2CalcHmac(void* digest, void* bin_ptr, int bin_len, void* key_ptr, int keylen); + +#endif //NITRO_DGT_DGT_H_ diff --git a/arm9/lib/include/FS_file.h b/arm9/lib/include/FS_file.h index 4871b660..89f69d86 100644 --- a/arm9/lib/include/FS_file.h +++ b/arm9/lib/include/FS_file.h @@ -175,5 +175,18 @@ FSFile; u32 FS_SetDefaultDMA(u32 dma_no); // returns the previous selection void FS_InitFile(FSFile * p_file); BOOL FS_WaitAsync(FSFile * p_file); +BOOL FS_OpenFileDirect(FSFile * p_file, FSArchive * p_arc, u32 image_top, u32 image_bottom, u32 file_index); +int FS_ReadFile(FSFile * p_file, void * dst, s32 len); +int FS_ReadFileAsync(FSFile * p_file, void * dst, s32 len); +BOOL FS_OpenFileFast(FSFile * p_file, FSFileID file_id); + +static inline u32 const FS_GetFileImageTop(volatile const FSFile * p_file) { + return p_file->prop.file.top; +} + +static inline u32 const FS_GetLength(volatile const FSFile * p_file) +{ + return p_file->prop.file.bottom - p_file->prop.file.top; +} #endif //NITRO_FS_FILE_H_ diff --git a/arm9/lib/include/FS_mw_dtor.h b/arm9/lib/include/FS_mw_dtor.h new file mode 100644 index 00000000..a746ed19 --- /dev/null +++ b/arm9/lib/include/FS_mw_dtor.h @@ -0,0 +1,16 @@ +#ifndef NITRO_FS_MW_DTOR_H_ +#define NITRO_FS_MW_DTOR_H_ + +typedef void (*MWI_DESTRUCTOR_FUNC) (void *); + +typedef struct MWiDestructorChain +{ + struct MWiDestructorChain *next; + MWI_DESTRUCTOR_FUNC dtor; + void *obj; +} +MWiDestructorChain; + +extern MWiDestructorChain *__global_destructor_chain; + +#endif //NITRO_FS_MW_DTOR_H_ diff --git a/arm9/lib/include/FS_overlay.h b/arm9/lib/include/FS_overlay.h index c2634509..1ef6469c 100644 --- a/arm9/lib/include/FS_overlay.h +++ b/arm9/lib/include/FS_overlay.h @@ -30,6 +30,21 @@ typedef struct FSOverlayInfo CARDRomRegion file_pos; } FSOverlayInfo; +static inline u8 *const FS_GetOverlayAddress(FSOverlayInfo * p_ovi) +{ + return p_ovi->header.ram_address; +} + +static inline u32 const FS_GetOverlayImageSize(FSOverlayInfo * p_ovi) +{ + return p_ovi->header.ram_size; +} + +static inline u32 const FS_GetOverlayTotalSize(FSOverlayInfo * p_ovi) +{ + return p_ovi->header.ram_size + p_ovi->header.bss_size; +} + BOOL FS_LoadOverlayInfo(FSOverlayInfo *p_ovi, MIProcessor target, FSOverlayID id); BOOL FS_LoadOverlay(MIProcessor target, FSOverlayID id); BOOL FS_UnloadOverlay(MIProcessor target, FSOverlayID id); diff --git a/arm9/lib/include/FS_rom.h b/arm9/lib/include/FS_rom.h index fc62b579..0bba46bf 100644 --- a/arm9/lib/include/FS_rom.h +++ b/arm9/lib/include/FS_rom.h @@ -1,6 +1,13 @@ #ifndef NITRO_FS_ROM_H_ #define NITRO_FS_ROM_H_ +#include "FS_archive.h" +#include "CARD_rom.h" + +extern FSArchive fsi_arc_rom; +extern CARDRomRegion fsi_ovt7; +extern CARDRomRegion fsi_ovt9; + void FSi_InitRom(u32 default_dma_no); #endif //NITRO_FS_ROM_H_ diff --git a/arm9/lib/include/MI_memory.h b/arm9/lib/include/MI_memory.h new file mode 100644 index 00000000..d9935a5f --- /dev/null +++ b/arm9/lib/include/MI_memory.h @@ -0,0 +1,10 @@ +#ifndef NITRO_MI_MEMORY_H_ +#define NITRO_MI_MEMORY_H_ + +void MI_CpuFill8(void *dest, u8 data, u32 size); +void MI_CpuCopy8(void const *src, void *dest, u32 size); +static inline void MI_CpuClear8(void *dest, u32 size) { + MI_CpuFill8(dest, 0, size); +} + +#endif //NITRO_MI_MEMORY_H_ diff --git a/arm9/lib/include/MI_uncompress.h b/arm9/lib/include/MI_uncompress.h new file mode 100644 index 00000000..55f28e27 --- /dev/null +++ b/arm9/lib/include/MI_uncompress.h @@ -0,0 +1,6 @@ +#ifndef NITRO_MI_UNCOMPRESS_H_ +#define NITRO_MI_UNCOMPRESS_H_ + +void MIi_UncompressBackward(void * bottom); + +#endif //NITRO_MI_UNCOMPRESS_H_ diff --git a/arm9/lib/include/OS_cache.h b/arm9/lib/include/OS_cache.h new file mode 100644 index 00000000..bee42d45 --- /dev/null +++ b/arm9/lib/include/OS_cache.h @@ -0,0 +1,9 @@ +#ifndef NITRO_OS_CACHE_H_ +#define NITRO_OS_CACHE_H_ + +void IC_InvalidateRange(void *startAddr, u32 nBytes); +void IC_FlushRange(void *startAddr, u32 nBytes); +void DC_InvalidateRange(void *startAddr, u32 nBytes); +void DC_FlushRange(void *startAddr, u32 nBytes); + +#endif //NITRO_OS_CACHE_H_ diff --git a/arm9/lib/include/OS_system.h b/arm9/lib/include/OS_system.h index 65c58f57..1b263b19 100644 --- a/arm9/lib/include/OS_system.h +++ b/arm9/lib/include/OS_system.h @@ -36,5 +36,10 @@ OSIntrMode OS_GetCpsrIrq(); OSProcMode OS_GetProcMode(); void OS_SpinWait(); void OS_WaitVBlankIntr(); +void OS_Terminate(void); +static inline void OS_TPanic(const char * message) +{ + OS_Terminate(); +} #endif //POKEDIAMOND_OS_SYSTEM_H diff --git a/arm9/lib/src/FS_overlay.c b/arm9/lib/src/FS_overlay.c new file mode 100644 index 00000000..d8d53570 --- /dev/null +++ b/arm9/lib/src/FS_overlay.c @@ -0,0 +1,297 @@ +#include "nitro.h" +#include "DGT_common.h" +#include "DGT_dgt.h" +#include "OS_cache.h" +#include "OS_system.h" +#include "MI_memory.h" +#include "MI_uncompress.h" +#include "FS_rom.h" +#include "FS_overlay.h" +#include "FS_mw_dtor.h" +#include "MB_mb.h" + +#define FS_OVERLAY_FLAG_COMP 0x0001 +#define FS_OVERLAY_FLAG_AUTH 0x0002 +#define FS_OVERLAY_DIGEST_SIZE DGT_HASH2_DIGEST_SIZE + +u32 FSi_GetOverlayBinarySize(FSOverlayInfo * p_ovi) +{ + u32 size = (p_ovi->header.flag & FS_OVERLAY_FLAG_COMP) + ? p_ovi->header.compressed + : p_ovi->header.ram_size; + return size; +} + +void FS_ClearOverlayImage(FSOverlayInfo * p_ovi) +{ + u8 * const im_start = FS_GetOverlayAddress(p_ovi); + u32 const ram_size = FS_GetOverlayImageSize(p_ovi); + u32 const total_size = FS_GetOverlayTotalSize(p_ovi); + + IC_InvalidateRange(im_start, total_size); + DC_InvalidateRange(im_start, total_size); + MI_CpuFill8(im_start + ram_size, 0, total_size - ram_size); +} + +FSFileID FS_GetOverlayFileID(FSOverlayInfo * p_ovi) +{ + FSFileID ret; + ret.arc = &fsi_arc_rom; + ret.file_id = p_ovi->header.file_id; + return ret; +} + +BOOL FSi_LoadOverlayInfoCore(FSOverlayInfo * p_ovi, MIProcessor target, FSOverlayID id, FSArchive * arc, u32 offset_arm9, u32 len_arm9, u32 offset_arm7, u32 len_arm7) +{ + CARDRomRegion pr[1]; + u32 pos; + if (target == MI_PROCESSOR_ARM9) + { + pr->offset = offset_arm9; + pr->length = len_arm9; + } + else + { + pr->offset = offset_arm7; + pr->length = len_arm7; + } + pos = (u32) id * sizeof(FSOverlayInfoHeader); + if (pos >= pr->length) + return FALSE; + + FSFile file[1]; + FS_InitFile(file); + // BOOL FS_OpenFileDirect(FSFile * p_file, FSArchive * p_arc, u32 image_top, u32 image_bottom, u32 file_index) + if (!FS_OpenFileDirect(file, arc, pr->offset + pos, pr->offset + pr->length, (u32)~0)) + return FALSE; + if (FS_ReadFile(file, p_ovi, sizeof(FSOverlayInfoHeader)) != sizeof(FSOverlayInfoHeader)) + { + FS_CloseFile(file); + return FALSE; + } + FS_CloseFile(file); + p_ovi->target = target; + if (!FS_OpenFileFast(file, FS_GetOverlayFileID(p_ovi))) + return FALSE; + p_ovi->file_pos.offset = FS_GetFileImageTop(file); + p_ovi->file_pos.length = FS_GetLength(file); + FS_CloseFile(file); + return TRUE; +} + +BOOL FS_LoadOverlayInfo(FSOverlayInfo * p_ovi, MIProcessor target, FSOverlayID id) +{ + CARDRomRegion * const pr = (target == MI_PROCESSOR_ARM9) ? &fsi_ovt9 : &fsi_ovt7; + if (pr->offset) + { + FSFile file[1]; + const u32 pos = id * sizeof(FSOverlayInfoHeader); + if (pos >= pr->length) + return FALSE; + MI_CpuCopy8((const void *)(pr->offset + pos), p_ovi, sizeof(FSOverlayInfoHeader)); + p_ovi->target = target; + FS_InitFile(file); + if (!FS_OpenFileFast(file, FS_GetOverlayFileID(p_ovi))) + return FALSE; + p_ovi->file_pos.offset = FS_GetFileImageTop(file); + p_ovi->file_pos.length = FS_GetLength(file); + FS_CloseFile(file); + return TRUE; + } + else + { + const CARDRomRegion * const p_ovt9 = CARD_GetRomRegionOVT(MI_PROCESSOR_ARM9); + const CARDRomRegion * const p_ovt7 = CARD_GetRomRegionOVT(MI_PROCESSOR_ARM7); + return FSi_LoadOverlayInfoCore(p_ovi, target, id, &fsi_arc_rom, p_ovt9->offset, p_ovt9->length, p_ovt7->offset, p_ovt7->length); + } +} + +BOOL FS_LoadOverlayImageAsync(FSOverlayInfo * p_ovi, FSFile * p_file) +{ + FS_InitFile(p_file); + if (!FS_OpenFileFast(p_file, FS_GetOverlayFileID(p_ovi))) + return FALSE; + else + { + s32 size = FSi_GetOverlayBinarySize(p_ovi); + FS_ClearOverlayImage(p_ovi); + if (FS_ReadFileAsync(p_file, FS_GetOverlayAddress(p_ovi), size) != size) + { + FS_CloseFile(p_file); + return FALSE; + } + return TRUE; + } +} + +BOOL FS_LoadOverlayImage(FSOverlayInfo * p_ovi) +{ + FSFile file[1]; + FS_InitFile(file); + if (!FS_OpenFileFast(file, FS_GetOverlayFileID(p_ovi))) + return FALSE; + else + { + s32 size = FSi_GetOverlayBinarySize(p_ovi); + FS_ClearOverlayImage(p_ovi); + if (FS_ReadFile(file, FS_GetOverlayAddress(p_ovi), size) != size) + { + FS_CloseFile(file); + return FALSE; + } + FS_CloseFile(file); + return TRUE; + } +} + +const void *fsi_digest_key_ptr; +u32 fsi_digest_key_len; + +BOOL FSi_CompareDigest(const u8 *spec_digest, void *src, int len) +{ + int i; + u8 digest[FS_OVERLAY_DIGEST_SIZE]; + u8 digest_key[64]; + + MI_CpuClear8(digest, sizeof(digest)); + MI_CpuCopy8(fsi_digest_key_ptr, digest_key, fsi_digest_key_len); + DGT_Hash2CalcHmac(digest, src, len, digest_key, fsi_digest_key_len); + for (i = 0; i < sizeof(digest); i += sizeof(u32)) + { + if (*(const u32 *)(digest + i) != *(const u32 *)(spec_digest + i)) + break; + } + return i == sizeof(digest); +} + +extern u8 SDK_OVERLAY_DIGEST[]; +extern u8 SDK_OVERLAY_DIGEST_END[]; + +void FS_StartOverlay(FSOverlayInfo * p_ovi) +{ + u32 rare_size = FSi_GetOverlayBinarySize(p_ovi); + if (MB_IsMultiBootChild()) + { + BOOL ret = FALSE; + + if (p_ovi->header.flag & FS_OVERLAY_FLAG_AUTH) + { + const u32 odt_max = (u32)((SDK_OVERLAY_DIGEST_END - SDK_OVERLAY_DIGEST) / FS_OVERLAY_DIGEST_SIZE); + if (p_ovi->header.id < odt_max) + { + const u8 * spec_digest = SDK_OVERLAY_DIGEST + FS_OVERLAY_DIGEST_SIZE * p_ovi->header.id; + ret = FSi_CompareDigest(spec_digest, p_ovi->header.ram_address, (int)rare_size); + } + } + if (!ret) + { + MI_CpuClear8(p_ovi->header.ram_address, rare_size); + OS_TPanic("FS_StartOverlay() failed! (invalid overlay-segment data)"); + return; + } + } + if (p_ovi->header.flag & FS_OVERLAY_FLAG_COMP) + { + MIi_UncompressBackward(p_ovi->header.ram_address + rare_size); + } + DC_FlushRange(p_ovi->header.ram_address, p_ovi->header.ram_size); + + { + FSOverlayInitFunc *p = p_ovi->header.sinit_init; + FSOverlayInitFunc *q = p_ovi->header.sinit_init_end; + for (; p < q; ++p) + { + if (*p) + (**p)(); + } + } +} + +void FS_EndOverlay(FSOverlayInfo *p_ovi) +{ + for (;;) + { + MWiDestructorChain *head = NULL, *tail = NULL; + const u32 region_top = (u32)FS_GetOverlayAddress(p_ovi); + const u32 region_bottom = region_top + FS_GetOverlayTotalSize(p_ovi); + + { + OSIntrMode bak_psr = OS_DisableInterrupts(); + MWiDestructorChain *prev = NULL; + MWiDestructorChain *base = __global_destructor_chain; + MWiDestructorChain *p = base; + while (p) + { + MWiDestructorChain *next = p->next; + const u32 dtor = (u32)p->dtor; + const u32 obj = (u32)p->obj; + if (((obj == 0) && (dtor >= region_top) && (dtor < region_bottom)) || + ((obj >= region_top) && (obj < region_bottom))) + { + /* If appropriate, extract*/ + if (!tail) + { + head = p; + } + else + { + tail->next = p; + } + if (base == p) + { + base = __global_destructor_chain = next; + } + tail = p, p->next = NULL; + if (prev) + { + prev->next = next; + } + } + else + { + prev = p; + } + p = next; + } + OS_RestoreInterrupts(bak_psr); + } + + if (!head) + { + break; + } + do + { + MWiDestructorChain *next = head->next; + if (head->dtor) + { + (*head->dtor) (head->obj); + } + head = next; + } + while (head); + } +} + +BOOL FS_UnloadOverlayImage(FSOverlayInfo * p_ovi) +{ + FS_EndOverlay(p_ovi); + return TRUE; +} + +BOOL FS_LoadOverlay(MIProcessor target, FSOverlayID id) +{ + FSOverlayInfo ovi; + if (!FS_LoadOverlayInfo(&ovi, target, id) || !FS_LoadOverlayImage(&ovi)) + return FALSE; + FS_StartOverlay(&ovi); + return TRUE; +} + +BOOL FS_UnloadOverlay(MIProcessor target, FSOverlayID id) +{ + FSOverlayInfo ovi; + if (!FS_LoadOverlayInfo(&ovi, target, id) || !FS_UnloadOverlayImage(&ovi)) + return FALSE; + return TRUE; +} -- cgit v1.2.3 From d4575098dbd671e2b6fd27ad65b984502c90465b Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Thu, 7 May 2020 08:52:32 -0400 Subject: FS_archive.c WIP --- arm9/lib/include/FS_archive.h | 56 ++++++++++++++++ arm9/lib/include/FS_command.h | 9 +++ arm9/lib/include/FS_file.h | 20 ++++++ arm9/lib/include/OS_thread.h | 1 + arm9/lib/src/FS_archive.c | 147 ++++++++++++++++++++++++++++++++++++++++++ arm9/lib/src/FS_file.c | 10 --- 6 files changed, 233 insertions(+), 10 deletions(-) create mode 100644 arm9/lib/include/FS_command.h create mode 100644 arm9/lib/src/FS_archive.c (limited to 'arm9/lib') diff --git a/arm9/lib/include/FS_archive.h b/arm9/lib/include/FS_archive.h index 66840b32..b39e7738 100644 --- a/arm9/lib/include/FS_archive.h +++ b/arm9/lib/include/FS_archive.h @@ -47,6 +47,37 @@ typedef enum { FS_COMMAND_INVALID } FSCommandType; +/* Asynchronous commands*/ +#define FS_ARCHIVE_PROC_READFILE (1 << FS_COMMAND_READFILE) +#define FS_ARCHIVE_PROC_WRITEFILE (1 << FS_COMMAND_WRITEFILE) +/* All asynchronous commands*/ +#define FS_ARCHIVE_PROC_ASYNC \ + (FS_ARCHIVE_PROC_READFILE | FS_ARCHIVE_PROC_WRITEFILE) + +/* Synchronous commands*/ +#define FS_ARCHIVE_PROC_SEEKDIR (1 << FS_COMMAND_SEEKDIR) +#define FS_ARCHIVE_PROC_READDIR (1 << FS_COMMAND_READDIR) +#define FS_ARCHIVE_PROC_FINDPATH (1 << FS_COMMAND_FINDPATH) +#define FS_ARCHIVE_PROC_GETPATH (1 << FS_COMMAND_GETPATH) +#define FS_ARCHIVE_PROC_OPENFILEFAST (1 << FS_COMMAND_OPENFILEFAST) +#define FS_ARCHIVE_PROC_OPENFILEDIRECT (1 << FS_COMMAND_OPENFILEDIRECT) +#define FS_ARCHIVE_PROC_CLOSEFILE (1 << FS_COMMAND_CLOSEFILE) +/* All synchronous commands*/ +#define FS_ARCHIVE_PROC_SYNC \ + (FS_ARCHIVE_PROC_SEEKDIR | FS_ARCHIVE_PROC_READDIR | \ + FS_ARCHIVE_PROC_FINDPATH | FS_ARCHIVE_PROC_GETPATH | \ + FS_ARCHIVE_PROC_OPENFILEFAST | FS_ARCHIVE_PROC_OPENFILEDIRECT | FS_ARCHIVE_PROC_CLOSEFILE) + +/* Messages when status changes*/ +#define FS_ARCHIVE_PROC_ACTIVATE (1 << FS_COMMAND_ACTIVATE) +#define FS_ARCHIVE_PROC_IDLE (1 << FS_COMMAND_IDLE) +#define FS_ARCHIVE_PROC_SUSPENDING (1 << FS_COMMAND_SUSPEND) +#define FS_ARCHIVE_PROC_RESUME (1 << FS_COMMAND_RESUME) +/* All messages when status changes*/ +#define FS_ARCHIVE_PROC_STATUS \ + (FS_ARCHIVE_PROC_ACTIVATE | FS_ARCHIVE_PROC_IDLE | \ + FS_ARCHIVE_PROC_SUSPENDING | FS_ARCHIVE_PROC_RESUME) + typedef enum { FS_RESULT_SUCCESS = 0, FS_RESULT_FAILURE, @@ -107,6 +138,31 @@ static inline BOOL FS_IsArchiveLoaded(volatile const FSArchive * p_arc) return (p_arc->flag & FS_ARCHIVE_FLAG_LOADED) ? TRUE : FALSE; } +static inline u32 FS_GetArchiveOffset(const FSArchive * p_arc, u32 pos) +{ + return p_arc->base + pos; +} + +static inline BOOL FSi_IsArchiveCanceling(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_CANCELING) != 0; +} + +static inline BOOL FS_IsArchiveSuspended(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_SUSPEND) ? TRUE : FALSE; +} + +static inline BOOL FSi_IsArchiveSuspending(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_SUSPENDING) != 0; +} + +static inline BOOL FSi_IsArchiveRunning(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_RUNNING) != 0; +} + BOOL FSi_SendCommand(struct FSFile * file, FSCommandType command); BOOL FSi_ExecuteSyncCommand(struct FSFile * file); diff --git a/arm9/lib/include/FS_command.h b/arm9/lib/include/FS_command.h new file mode 100644 index 00000000..db878f3f --- /dev/null +++ b/arm9/lib/include/FS_command.h @@ -0,0 +1,9 @@ +#ifndef NITRO_FS_COMMAND_H_ +#define NITRO_FS_COMMAND_H_ + +#include "FS_file.h" + +void FSi_ReleaseCommand(FSFile * file, FSResult signal); +FSResult FSi_TranslateCommand(FSFile * file, FSCommandType command); + +#endif //NITRO_FS_COMMAND_H_ diff --git a/arm9/lib/include/FS_file.h b/arm9/lib/include/FS_file.h index 89f69d86..92e2149e 100644 --- a/arm9/lib/include/FS_file.h +++ b/arm9/lib/include/FS_file.h @@ -189,4 +189,24 @@ static inline u32 const FS_GetLength(volatile const FSFile * p_file) return p_file->prop.file.bottom - p_file->prop.file.top; } +static inline BOOL FS_IsCanceling(volatile const FSFile * p_file) +{ + return (p_file->stat & FS_FILE_STATUS_CANCEL) ? TRUE : FALSE; +} + +static inline BOOL FS_IsFileSyncMode(volatile const FSFile * p_file) +{ + return (p_file->stat & FS_FILE_STATUS_SYNC) ? TRUE : FALSE; +} + +static inline BOOL FS_IsBusy(volatile const FSFile * p_file) +{ + return p_file->stat & FS_FILE_STATUS_BUSY ? TRUE : FALSE; +} + +static inline BOOL FS_IsSucceeded(volatile const FSFile * p_file) +{ + return (p_file->error == FS_RESULT_SUCCESS) ? TRUE : FALSE; +} + #endif //NITRO_FS_FILE_H_ diff --git a/arm9/lib/include/OS_thread.h b/arm9/lib/include/OS_thread.h index 8820a7a0..c5602559 100644 --- a/arm9/lib/include/OS_thread.h +++ b/arm9/lib/include/OS_thread.h @@ -29,6 +29,7 @@ struct _OSThread }; void OS_SleepThread(OSThreadQueue * queue); +void OS_WakeupThread(OSThreadQueue * queue); static inline void OS_InitThreadQueue(OSThreadQueue * queue) { queue->head = queue->tail = NULL; diff --git a/arm9/lib/src/FS_archive.c b/arm9/lib/src/FS_archive.c new file mode 100644 index 00000000..39daa324 --- /dev/null +++ b/arm9/lib/src/FS_archive.c @@ -0,0 +1,147 @@ +#include "FS_archive.h" +#include "FS_file.h" +#include "FS_command.h" +#include "MI_memory.h" +#include "MI_byteAccess.h" + +FSArchive * arc_list = NULL; +FSDirPos current_dir_pos; + +u32 FSi_GetPackedName(const char * name, int name_len) +{ + u32 ret = 0; + if (name_len <= FS_ARCHIVE_NAME_LEN_MAX) + { + int i = 0; + for (; i < name_len; i++) + { + u32 c = MI_ReadByte(name + i); + if (!c) + break; + c = (u32)(c - 'A'); + if (c <= (u32)('Z' - 'A')) + c = (u32)(c + 'a'); + else + c = (u32)(c + 'A'); + ret |= (u32)(c << (i * 8)); + } + } + return ret; +} + +FSResult FSi_ReadMemCallback(FSArchive * p_arc, u8 * dest, u32 offset, u32 size) +{ + MI_CpuCopy8((const void *)FS_GetArchiveOffset(p_arc, offset), dest, size); + return FS_RESULT_SUCCESS; +} + +FSResult FSi_WriteMemCallback(FSArchive * p_arc, const u8 * src, u32 offset, u32 size) +{ + MI_CpuCopy8(src, (void *)FS_GetArchiveOffset(p_arc, offset), size); + return FS_RESULT_SUCCESS; +} + +FSResult FSi_ReadMemoryCore(FSArchive * p_arc, u8 * dest, u32 offset, u32 size) +{ + MI_CpuCopy8((const void *)offset, dest, size); + return FS_RESULT_SUCCESS; +} + +FSFile * FSi_NextCommand(FSArchive * p_arc) +{ + OSIntrMode bak_psr = OS_DisableInterrupts(); + if (FSi_IsArchiveCanceling(p_arc)) + { + FSFile *p, *q; + p_arc->flag &= ~FS_ARCHIVE_FLAG_CANCELING; + for (p = p_arc->list.next; p; p = q) + { + q = p->link.next; + if (FS_IsCanceling(p)) + { + if (p_arc->list.next == p) + p_arc->list.next = q; + FSi_ReleaseCommand(p, FS_RESULT_CANCELED); + if (!q) + q = p_arc->list.next; + } + } + } + if (!FSi_IsArchiveSuspending(p_arc) && !FS_IsArchiveSuspended(p_arc)) + { + FSFile * p_file = p_arc->list.next; + if (p_file != NULL) + { + const BOOL is_start = !FSi_IsArchiveRunning(p_arc); + if (is_start) + p_arc->flag |= FS_ARCHIVE_FLAG_RUNNING; + OS_RestoreInterrupts(bak_psr); + if (is_start) + { + if ((p_arc->proc_flag & FS_ARCHIVE_PROC_ACTIVATE) != 0) + (*p_arc->proc) (p_file, FS_COMMAND_ACTIVATE); + } + bak_psr = OS_DisableInterrupts(); + p_file->stat |= FS_FILE_STATUS_OPERATING; + if (FS_IsFileSyncMode(p_file)) + { + OS_WakeupThread(p_file->queue); + OS_RestoreInterrupts(bak_psr); + return NULL; + } + OS_RestoreInterrupts(bak_psr); + return p_file; + } + } + if (FSi_IsArchiveRunning(p_arc)) + { + p_arc->flag &= ~FS_ARCHIVE_FLAG_RUNNING; + if (p_arc->proc_flag & FS_ARCHIVE_PROC_IDLE) + { + FSFile tmp; + FS_InitFile(&tmp); + tmp.arc = p_arc; + (*p_arc->proc)(&tmp, FS_COMMAND_IDLE); + } + } + if (FSi_IsArchiveSuspending(p_arc)) + { + p_arc->flag &= ~FS_ARCHIVE_FLAG_SUSPENDING; + p_arc->flag |= FS_ARCHIVE_FLAG_SUSPEND; + OS_WakeupThread(&p_arc->stat_q); + } + OS_RestoreInterrupts(bak_psr); + return NULL; +} + +void FSi_ExecuteAsyncCommand(FSFile * p_file) +{ + FSArchive *const p_arc = p_file->arc; + while (p_file) + { + OSIntrMode bak_psr = OS_DisableInterrupts(); + p_file->stat |= FS_FILE_STATUS_OPERATING; + if (FS_IsFileSyncMode(p_file)) + { + OS_WakeupThread(p_file->queue); + OS_RestoreInterrupts(bak_psr); + break; + } + p_file->stat |= FS_FILE_STATUS_ASYNC; + OS_RestoreInterrupts(bak_psr); + if (FSi_TranslateCommand(p_file, p_file->command) == FS_RESULT_PROC_ASYNC) + break; + p_file = FSi_NextCommand(p_arc); + } +} + +BOOL FSi_ExecuteSyncCommand(FSFile * p_file) +{ + FSFile * p_target; + FSResult ret = FSi_TranslateCommand(p_file, p_file->command); + FSi_ReleaseCommand(p_file, ret); + p_target = FSi_NextCommand(p_file->arc); + if (p_target) + FSi_ExecuteAsyncCommand(p_target); + return FS_IsSucceeded(p_file); +} diff --git a/arm9/lib/src/FS_file.c b/arm9/lib/src/FS_file.c index 8ca89af8..479a5085 100644 --- a/arm9/lib/src/FS_file.c +++ b/arm9/lib/src/FS_file.c @@ -11,16 +11,6 @@ static inline BOOL FSi_IsSlash(u32 c) return (c == '/') || (c == '\\'); } -static inline BOOL FS_IsBusy(volatile const FSFile * p_file) -{ - return p_file->stat & FS_FILE_STATUS_BUSY ? TRUE : FALSE; -} - -static inline BOOL FS_IsSucceeded(volatile const FSFile * p_file) -{ - return p_file->error == FS_RESULT_SUCCESS ? TRUE : FALSE; -} - void FS_Init(u32 default_dma_no) { if (!is_init) -- cgit v1.2.3 From 13ecb2f5cb0bbfee814508f6d05d05074d426807 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Thu, 7 May 2020 16:42:49 -0400 Subject: FS_archive through FS_LoadArchive --- arm9/lib/include/FS_archive.h | 7 +- arm9/lib/include/FSi_util.h | 33 ++++++++++ arm9/lib/src/FS_archive.c | 146 ++++++++++++++++++++++++++++++++++++++++-- arm9/lib/src/FS_file.c | 6 +- 4 files changed, 182 insertions(+), 10 deletions(-) create mode 100644 arm9/lib/include/FSi_util.h (limited to 'arm9/lib') diff --git a/arm9/lib/include/FS_archive.h b/arm9/lib/include/FS_archive.h index b39e7738..baf11add 100644 --- a/arm9/lib/include/FS_archive.h +++ b/arm9/lib/include/FS_archive.h @@ -110,8 +110,8 @@ typedef struct FSArchive char ptr[4]; u32 pack; } name; - struct FSArchive * prev; struct FSArchive * next; + struct FSArchive * prev; OSThreadQueue sync_q; OSThreadQueue stat_q; u32 flag; @@ -163,6 +163,11 @@ static inline BOOL FSi_IsArchiveRunning(volatile const FSArchive * p_arc) return (p_arc->flag & FS_ARCHIVE_FLAG_RUNNING) != 0; } +static inline BOOL FSi_IsArchiveUnloading(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_UNLOADING) != 0; +} + BOOL FSi_SendCommand(struct FSFile * file, FSCommandType command); BOOL FSi_ExecuteSyncCommand(struct FSFile * file); diff --git a/arm9/lib/include/FSi_util.h b/arm9/lib/include/FSi_util.h new file mode 100644 index 00000000..babb6d75 --- /dev/null +++ b/arm9/lib/include/FSi_util.h @@ -0,0 +1,33 @@ +#ifndef NITRO_FSI_UTIL_H_ +#define NITRO_FSI_UTIL_H_ + +static inline BOOL FSi_IsSlash(u32 c) +{ + return (c == '/') || (c == '\\'); +} + +static inline void FSi_CutFromListCore(FSFileLink *trg) +{ + FSFile *const pr = trg->prev; + FSFile *const nx = trg->next; + if (pr) + pr->link.next = nx; + if (nx) + nx->link.prev = pr; +} + +static inline void FSi_AppendToList(FSFile *elem, FSFile *list) +{ + FSFileLink *const trg = &elem->link; + FSi_CutFromListCore(trg); + { + while (list->link.next) + list = list->link.next; + list->link.next = elem; + trg->prev = list; + trg->next = NULL; + } +} + + +#endif //NITRO_FSI_UTIL_H_ diff --git a/arm9/lib/src/FS_archive.c b/arm9/lib/src/FS_archive.c index 39daa324..c8404144 100644 --- a/arm9/lib/src/FS_archive.c +++ b/arm9/lib/src/FS_archive.c @@ -1,6 +1,7 @@ #include "FS_archive.h" #include "FS_file.h" #include "FS_command.h" +#include "FSi_util.h" #include "MI_memory.h" #include "MI_byteAccess.h" @@ -29,15 +30,15 @@ u32 FSi_GetPackedName(const char * name, int name_len) return ret; } -FSResult FSi_ReadMemCallback(FSArchive * p_arc, u8 * dest, u32 offset, u32 size) +FSResult FSi_ReadMemCallback(struct FSArchive * p_arc, void * dest, u32 pos, u32 size) { - MI_CpuCopy8((const void *)FS_GetArchiveOffset(p_arc, offset), dest, size); + MI_CpuCopy8((const void *)FS_GetArchiveOffset(p_arc, pos), dest, size); return FS_RESULT_SUCCESS; } -FSResult FSi_WriteMemCallback(FSArchive * p_arc, const u8 * src, u32 offset, u32 size) +FSResult FSi_WriteMemCallback(struct FSArchive * p_arc, const void * src, u32 pos, u32 size) { - MI_CpuCopy8(src, (void *)FS_GetArchiveOffset(p_arc, offset), size); + MI_CpuCopy8(src, (void *)FS_GetArchiveOffset(p_arc, pos), size); return FS_RESULT_SUCCESS; } @@ -145,3 +146,140 @@ BOOL FSi_ExecuteSyncCommand(FSFile * p_file) FSi_ExecuteAsyncCommand(p_target); return FS_IsSucceeded(p_file); } + +BOOL FSi_SendCommand(FSFile * p_file, FSCommandType command) +{ + FSArchive * p_arc = p_file->arc; + const int bit = 1 << command; + p_file->command = command; + p_file->error = FS_RESULT_BUSY; + p_file->stat |= FS_FILE_STATUS_BUSY; + { + OSIntrMode bak_psr = OS_DisableInterrupts(); + if (FSi_IsArchiveUnloading(p_arc)) + { + FSi_ReleaseCommand(p_file, FS_RESULT_CANCELLED); + OS_RestoreInterrupts(bak_psr); + return FALSE; + } + if ((bit & FS_ARCHIVE_PROC_SYNC) != 0) + p_file->stat |= FS_FILE_STATUS_SYNC; + FSi_AppendToList(p_file, (FSFile *)&p_arc->list); + if (!FS_IsArchiveSuspended(p_arc) && !FSi_IsArchiveRunning(p_arc)) + { + p_arc->flag |= FS_ARCHIVE_FLAG_RUNNING; + OS_RestoreInterrupts(bak_psr); + if ((p_arc->proc_flag & FS_ARCHIVE_PROC_ACTIVATE)) + (*p_arc->proc)(p_file, FS_COMMAND_ACTIVATE); + bak_psr = OS_DisableInterrupts(); + p_file->stat |= FS_FILE_STATUS_OPERATING; + if (!FS_IsFileSyncMode(p_file)) + { + OS_RestoreInterrupts(bak_psr); + FSi_ExecuteAsyncCommand(p_file); + return TRUE; + } + OS_RestoreInterrupts(bak_psr); + } + else if (!FS_IsFileSyncMode(p_file)) + { + OS_RestoreInterrupts(bak_psr); + return TRUE; + } + else + { + do + { + OS_SleepThread(p_file->queue); + } while (!(p_file->stat & FS_FILE_STATUS_OPERATING)); + OS_RestoreInterrupts(bak_psr); + } + } + return FSi_ExecuteSyncCommand(p_file); +} + +void FS_InitArchive(FSArchive * p_arc) +{ + MI_CpuClear8(p_arc, sizeof(FSArchive)); + p_arc->sync_q.head = p_arc->sync_q.tail = NULL; + p_arc->stat_q.head = p_arc->stat_q.tail = NULL; +} + +FSArchive * const FS_FindArchive(const char * name, int name_len) +{ + u32 pack = FSi_GetPackedName(name, name_len); + OSIntrMode bak_psr = OS_DisableInterrupts(); + FSArchive * p_arc = arc_list; + while (p_arc && (p_arc->name.pack != pack)) + p_arc = p_arc->next; + OS_RestoreInterrupts(bak_psr); + return p_arc; +} + +BOOL FS_RegisterArchiveName(FSArchive * p_arc, const char * name, int name_len) +{ + BOOL ret = FALSE; + OSIntrMode bak_psr = OS_DisableInterrupts(); + if (!FS_FindArchive(name, name_len)) + { + FSArchive * p_tail = arc_list; + if (!p_tail) + { + arc_list = p_arc; + current_dir_pos.arc = p_arc; + current_dir_pos.pos = 0; + current_dir_pos.index = 0; + current_dir_pos.own_id = 0; + } + else + { + while (p_tail->next) + p_tail = p_tail->next; + p_tail->next = p_arc; + p_arc->prev = p_tail; + } + p_arc->name.pack = FSi_GetPackedName(name, name_len); + p_arc->flag |= FS_ARCHIVE_FLAG_REGISTER; + ret = TRUE; + } + OS_RestoreInterrupts(bak_psr); + return ret; +} + +void FS_ReleaseArchiveName(FSArchive * p_arc) +{ + if (p_arc->name.pack) + { + OSIntrMode bak_psr = OS_DisableInterrupts(); + if (p_arc->next) + p_arc->next->prev = p_arc->prev; + if (p_arc->prev) + p_arc->prev->next = p_arc->next; + p_arc->name.pack = 0; + p_arc->next = p_arc->prev = NULL; + p_arc->flag &= ~FS_ARCHIVE_FLAG_REGISTER; + if (current_dir_pos.arc == p_arc) + { + current_dir_pos.arc = arc_list; + current_dir_pos.pos = 0; + current_dir_pos.index = 0; + current_dir_pos.own_id = 0; + } + OS_RestoreInterrupts(bak_psr); + } +} + +BOOL FS_LoadArchive(FSArchive * p_arc, u32 base, u32 fat, u32 fat_size, u32 fnt, u32 fnt_size, FS_ARCHIVE_READ_FUNC read_func, FS_ARCHIVE_WRITE_FUNC write_func) +{ + p_arc->base = base; + p_arc->fat_size = fat_size; + p_arc->fat = p_arc->fat_bak = fat; + p_arc->fnt_size = fnt_size; + p_arc->fnt = p_arc->fnt_bak = fnt; + p_arc->read_func = (read_func != NULL) ? read_func : FSi_ReadMemCallback; + p_arc->write_func = (write_func != NULL) ? write_func : FSi_WriteMemCallback; + p_arc->table_func = p_arc->read_func; + p_arc->load_mem = NULL; + p_arc->flag |= FS_ARCHIVE_FLAG_LOADED; + return TRUE; +} diff --git a/arm9/lib/src/FS_file.c b/arm9/lib/src/FS_file.c index 479a5085..32c07187 100644 --- a/arm9/lib/src/FS_file.c +++ b/arm9/lib/src/FS_file.c @@ -2,15 +2,11 @@ #include "MI_byteAccess.h" #include "FS_rom.h" #include "FS_file.h" +#include "FSi_util.h" extern FSDirPos current_dir_pos; BOOL is_init = FALSE; -static inline BOOL FSi_IsSlash(u32 c) -{ - return (c == '/') || (c == '\\'); -} - void FS_Init(u32 default_dma_no) { if (!is_init) -- cgit v1.2.3 From 34ec05f983cec0517765640d084f58e86aa20d79 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Thu, 7 May 2020 17:53:16 -0400 Subject: Finish FS_archive.c --- arm9/lib/include/FS_archive.h | 12 ++++ arm9/lib/include/FS_file.h | 1 + arm9/lib/include/FS_overlay.h | 13 ++-- arm9/lib/include/FSi_util.h | 4 ++ arm9/lib/include/OS_system.h | 6 +- arm9/lib/src/FS_archive.c | 163 +++++++++++++++++++++++++++++++++++++++++- 6 files changed, 186 insertions(+), 13 deletions(-) (limited to 'arm9/lib') diff --git a/arm9/lib/include/FS_archive.h b/arm9/lib/include/FS_archive.h index baf11add..a86478e8 100644 --- a/arm9/lib/include/FS_archive.h +++ b/arm9/lib/include/FS_archive.h @@ -168,7 +168,19 @@ static inline BOOL FSi_IsArchiveUnloading(volatile const FSArchive * p_arc) return (p_arc->flag & FS_ARCHIVE_FLAG_UNLOADING) != 0; } +static inline BOOL FSi_IsArchiveAsync(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_IS_ASYNC) != 0; +} + +static inline BOOL FS_IsArchiveTableLoaded(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_TABLE_LOAD) ? TRUE : FALSE; +} + BOOL FSi_SendCommand(struct FSFile * file, FSCommandType command); BOOL FSi_ExecuteSyncCommand(struct FSFile * file); +BOOL FS_SuspendArchive(FSArchive * p_arc); +BOOL FS_ResumeArchive(FSArchive * p_arc); #endif //NITRO_FS_ARCHIVE_H_ diff --git a/arm9/lib/include/FS_file.h b/arm9/lib/include/FS_file.h index 92e2149e..fdf6c4e2 100644 --- a/arm9/lib/include/FS_file.h +++ b/arm9/lib/include/FS_file.h @@ -179,6 +179,7 @@ BOOL FS_OpenFileDirect(FSFile * p_file, FSArchive * p_arc, u32 image_top, u32 im int FS_ReadFile(FSFile * p_file, void * dst, s32 len); int FS_ReadFileAsync(FSFile * p_file, void * dst, s32 len); BOOL FS_OpenFileFast(FSFile * p_file, FSFileID file_id); +BOOL FS_CloseFile(FSFile * p_file); static inline u32 const FS_GetFileImageTop(volatile const FSFile * p_file) { return p_file->prop.file.top; diff --git a/arm9/lib/include/FS_overlay.h b/arm9/lib/include/FS_overlay.h index 1ef6469c..6025d04a 100644 --- a/arm9/lib/include/FS_overlay.h +++ b/arm9/lib/include/FS_overlay.h @@ -45,12 +45,11 @@ static inline u32 const FS_GetOverlayTotalSize(FSOverlayInfo * p_ovi) return p_ovi->header.ram_size + p_ovi->header.bss_size; } -BOOL FS_LoadOverlayInfo(FSOverlayInfo *p_ovi, MIProcessor target, FSOverlayID id); -BOOL FS_LoadOverlay(MIProcessor target, FSOverlayID id); -BOOL FS_UnloadOverlay(MIProcessor target, FSOverlayID id); -BOOL FS_LoadOverlayImage(FSOverlayInfo *p_ovi); -void FS_StartOverlay(FSOverlayInfo *p_ovi); -BOOL FS_LoadOverlayImageAsync(FSOverlayInfo *p_ovi, FSFile *p_file); -void FS_CloseFile(FSFile *p_file); +BOOL FS_LoadOverlayInfo(FSOverlayInfo *p_ovi, MIProcessor target, FSOverlayID id); +BOOL FS_LoadOverlay(MIProcessor target, FSOverlayID id); +BOOL FS_UnloadOverlay(MIProcessor target, FSOverlayID id); +BOOL FS_LoadOverlayImage(FSOverlayInfo *p_ovi); +void FS_StartOverlay(FSOverlayInfo *p_ovi); +BOOL FS_LoadOverlayImageAsync(FSOverlayInfo *p_ovi, FSFile *p_file); #endif //NITRO_FS_OVERLAY_H_ diff --git a/arm9/lib/include/FSi_util.h b/arm9/lib/include/FSi_util.h index babb6d75..1012df13 100644 --- a/arm9/lib/include/FSi_util.h +++ b/arm9/lib/include/FSi_util.h @@ -1,6 +1,10 @@ #ifndef NITRO_FSI_UTIL_H_ #define NITRO_FSI_UTIL_H_ +#define ALIGN_MASK(a) ((u32)((a) - 1)) + +#define ALIGN_BYTE(n, a) (((u32)(n) + ALIGN_MASK(a)) & ~ALIGN_MASK(a)) + static inline BOOL FSi_IsSlash(u32 c) { return (c == '/') || (c == '\\'); diff --git a/arm9/lib/include/OS_system.h b/arm9/lib/include/OS_system.h index 1b263b19..88137c3b 100644 --- a/arm9/lib/include/OS_system.h +++ b/arm9/lib/include/OS_system.h @@ -37,9 +37,7 @@ OSProcMode OS_GetProcMode(); void OS_SpinWait(); void OS_WaitVBlankIntr(); void OS_Terminate(void); -static inline void OS_TPanic(const char * message) -{ - OS_Terminate(); -} +#define OS_TPanic(...) OS_Terminate() +#define OS_TWarning(...) ((void)0) #endif //POKEDIAMOND_OS_SYSTEM_H diff --git a/arm9/lib/src/FS_archive.c b/arm9/lib/src/FS_archive.c index c8404144..44a4e451 100644 --- a/arm9/lib/src/FS_archive.c +++ b/arm9/lib/src/FS_archive.c @@ -42,9 +42,9 @@ FSResult FSi_WriteMemCallback(struct FSArchive * p_arc, const void * src, u32 po return FS_RESULT_SUCCESS; } -FSResult FSi_ReadMemoryCore(FSArchive * p_arc, u8 * dest, u32 offset, u32 size) +FSResult FSi_ReadMemoryCore(FSArchive * p_arc, void * dest, u32 pos, u32 size) { - MI_CpuCopy8((const void *)offset, dest, size); + MI_CpuCopy8((const void *)pos, dest, size); return FS_RESULT_SUCCESS; } @@ -283,3 +283,162 @@ BOOL FS_LoadArchive(FSArchive * p_arc, u32 base, u32 fat, u32 fat_size, u32 fnt, p_arc->flag |= FS_ARCHIVE_FLAG_LOADED; return TRUE; } + +BOOL FS_UnloadArchive(FSArchive * p_arc) +{ + OSIntrMode bak_psr = OS_DisableInterrupts(); + if (FS_IsArchiveLoaded(p_arc)) + { + if (FS_IsArchiveTableLoaded(p_arc)) + { + OS_TWarning("memory may leak. preloaded-table of archive \"%s\" (0x%08X)", p_arc->name.ptr, p_arc->load_mem); + } + { + FSFile *p, *q; + BOOL bak_state = FS_SuspendArchive(p_arc); + p_arc->flag |= FS_ARCHIVE_FLAG_UNLOADING; + for (p = p_arc->list.next; p; p = q) + { + q = p->link.next; + FSi_ReleaseCommand(p, FS_RESULT_CANCELED); + } + p_arc->list.next = NULL; + if (bak_state) + FS_ResumeArchive(p_arc); + } + p_arc->base = 0; + p_arc->fat = 0; + p_arc->fat_size = 0; + p_arc->fnt = 0; + p_arc->fnt_size = 0; + p_arc->fat_bak = p_arc->fnt_bak = 0; + p_arc->flag &= ~(FS_ARCHIVE_FLAG_CANCELING | FS_ARCHIVE_FLAG_LOADED | FS_ARCHIVE_FLAG_UNLOADING); + } + OS_RestoreInterrupts(bak_psr); + return TRUE; +} + +u32 FS_LoadArchiveTables(FSArchive *p_arc, void *p_mem, u32 max_size) +{ + u32 total_size = ALIGN_BYTE(p_arc->fat_size + p_arc->fnt_size + 32, 32); + if (total_size <= max_size) + { + u8 *p_cache = (u8 *)ALIGN_BYTE((u32)p_mem, 32); + FSFile tmp; + FS_InitFile(&tmp); + if (FS_OpenFileDirect(&tmp, p_arc, p_arc->fat, p_arc->fat + p_arc->fat_size, (u32)~0)) + { + if (FS_ReadFile(&tmp, p_cache, (s32)p_arc->fat_size) < 0) + { + MI_CpuFill8(p_cache, 0x00, p_arc->fat_size); + } + FS_CloseFile(&tmp); + } + p_arc->fat = (u32)p_cache; + p_cache += p_arc->fat_size; + if (FS_OpenFileDirect(&tmp, p_arc, p_arc->fnt, p_arc->fnt + p_arc->fnt_size, (u32)~0)) + { + if (FS_ReadFile(&tmp, p_cache, (s32)p_arc->fnt_size) < 0) + { + MI_CpuFill8(p_cache, 0x00, p_arc->fnt_size); + } + FS_CloseFile(&tmp); + } + p_arc->fnt = (u32)p_cache; + p_arc->load_mem = p_mem; + p_arc->table_func = FSi_ReadMemoryCore; + p_arc->flag |= FS_ARCHIVE_FLAG_TABLE_LOAD; + } + return total_size; +} + +void * FS_UnloadArchiveTables(FSArchive * p_arc) +{ + void *ret = NULL; + if (FS_IsArchiveLoaded(p_arc)) + { + BOOL bak_stat = FS_SuspendArchive(p_arc); + if (FS_IsArchiveTableLoaded(p_arc)) + { + p_arc->flag &= ~FS_ARCHIVE_FLAG_TABLE_LOAD; + ret = p_arc->load_mem; + p_arc->load_mem = NULL; + p_arc->fat = p_arc->fat_bak; + p_arc->fnt = p_arc->fnt_bak; + p_arc->table_func = p_arc->read_func; + } + if (bak_stat) + FS_ResumeArchive(p_arc); + } + return ret; +} + +BOOL FS_SuspendArchive(FSArchive * p_arc) +{ + OSIntrMode bak_psr = OS_DisableInterrupts(); + const BOOL bak_stat = !FS_IsArchiveSuspended(p_arc); + if (bak_stat) + { + if (FSi_IsArchiveRunning(p_arc)) + { + p_arc->flag |= FS_ARCHIVE_FLAG_SUSPENDING; + do { + OS_SleepThread(&p_arc->stat_q); + } while (FSi_IsArchiveSuspending(p_arc)); + } + else + { + p_arc->flag |= FS_ARCHIVE_FLAG_SUSPEND; + } + } + OS_RestoreInterrupts(bak_psr); + return bak_stat; +} + +BOOL FS_ResumeArchive(FSArchive * p_arc) +{ + FSFile * p_target = NULL; + OSIntrMode bak_psr = OS_DisableInterrupts(); + const BOOL bak_stat = !FS_IsArchiveSuspended(p_arc); + if (!bak_stat) + { + p_arc->flag &= ~FS_ARCHIVE_FLAG_SUSPEND; + p_target = FSi_NextCommand(p_arc); + } + OS_RestoreInterrupts(bak_psr); + if (p_target) + FSi_ExecuteAsyncCommand(p_target); + return bak_stat; +} + +void FS_SetArchiveProc(struct FSArchive * p_arc, FS_ARCHIVE_PROC_FUNC proc, u32 flags) +{ + if (!flags) + proc = NULL; + else if (!proc) + flags = 0; + p_arc->proc = proc; + p_arc->proc_flag = flags; +} + +void FS_NotifyArchiveAsyncEnd(FSArchive *p_arc, FSResult ret) +{ + if (FSi_IsArchiveAsync(p_arc)) + { + FSFile *p_file = p_arc->list.next; + p_arc->flag &= ~FS_ARCHIVE_FLAG_IS_ASYNC; + FSi_ReleaseCommand(p_file, ret); + p_file = FSi_NextCommand(p_arc); + if (p_file) + FSi_ExecuteAsyncCommand(p_file); + } + else + { + FSFile *p_file = p_arc->list.next; + OSIntrMode bak_psr = OS_DisableInterrupts(); + p_file->error = ret; + p_arc->flag &= ~FS_ARCHIVE_FLAG_IS_SYNC; + OS_WakeupThread(&p_arc->sync_q); + (void)OS_RestoreInterrupts(bak_psr); + } +} -- cgit v1.2.3 From 994cfcbc9a1e42043b25ae3ab6471b8ecbd55ff1 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Thu, 7 May 2020 19:39:53 -0400 Subject: FS_rom.c --- arm9/lib/include/CARD_common.h | 6 ++ arm9/lib/include/CARD_pullOut.h | 6 ++ arm9/lib/include/CARD_rom.h | 19 +++++++ arm9/lib/include/FS_archive.h | 8 +++ arm9/lib/include/FS_rom.h | 1 + arm9/lib/include/MI_dma.h | 6 ++ arm9/lib/include/OS_printf.h | 6 ++ arm9/lib/include/OS_spinLock.h | 2 + arm9/lib/src/FS_rom.c | 118 ++++++++++++++++++++++++++++++++++++++++ arm9/lib/src/OS_reset.c | 1 - 10 files changed, 172 insertions(+), 1 deletion(-) create mode 100644 arm9/lib/include/CARD_common.h create mode 100644 arm9/lib/include/CARD_pullOut.h create mode 100644 arm9/lib/include/MI_dma.h create mode 100644 arm9/lib/include/OS_printf.h create mode 100644 arm9/lib/src/FS_rom.c (limited to 'arm9/lib') diff --git a/arm9/lib/include/CARD_common.h b/arm9/lib/include/CARD_common.h new file mode 100644 index 00000000..1396de12 --- /dev/null +++ b/arm9/lib/include/CARD_common.h @@ -0,0 +1,6 @@ +#ifndef NITRO_CARD_COMMON_H_ +#define NITRO_CARD_COMMON_H_ + +void CARD_Init(void); + +#endif //NITRO_CARD_COMMON_H_ diff --git a/arm9/lib/include/CARD_pullOut.h b/arm9/lib/include/CARD_pullOut.h new file mode 100644 index 00000000..4a64f5ae --- /dev/null +++ b/arm9/lib/include/CARD_pullOut.h @@ -0,0 +1,6 @@ +#ifndef NITRO_CARD_PULLOUT_H_ +#define NITRO_CARD_PULLOUT_H_ + +BOOL CARD_IsPulledOut(void); + +#endif //NITRO_CARD_PULLOUT_H_ diff --git a/arm9/lib/include/CARD_rom.h b/arm9/lib/include/CARD_rom.h index c43a2f06..4c2e9dd5 100644 --- a/arm9/lib/include/CARD_rom.h +++ b/arm9/lib/include/CARD_rom.h @@ -2,6 +2,7 @@ #define NITRO_CARD_ROM_H_ #include "MI_exMemory.h" +#include "MI_dma.h" typedef struct { @@ -17,4 +18,22 @@ static inline const CARDRomRegion * CARD_GetRomRegionOVT(MIProcessor target) : (const CARDRomRegion *)((const u8 *)HW_ROM_HEADER_BUF + 0x58); } +void CARDi_ReadRom(u32 dma, const void * src, void * dst, u32 len, MIDmaCallback done_cb, void * arg, BOOL is_async); + +static inline void CARD_ReadRomAsync(u32 dma, const void * src, void * dst, u32 len, MIDmaCallback callback, void * arg) +{ + CARDi_ReadRom(dma, src, dst, len, callback, arg, TRUE); +} + +void CARD_LockRom(u16 lock_id); +void CARD_UnlockRom(u16 lock_id); + +static inline const CARDRomRegion * CARD_GetRomRegionFNT() { + return (const CARDRomRegion *)((const u8 *)HW_ROM_HEADER_BUF + 0x40); +} + +static inline const CARDRomRegion * CARD_GetRomRegionFAT() { + return (const CARDRomRegion *)((const u8 *)HW_ROM_HEADER_BUF + 0x48); +} + #endif //NITRO_CARD_ROM_H_ diff --git a/arm9/lib/include/FS_archive.h b/arm9/lib/include/FS_archive.h index a86478e8..d7c2a785 100644 --- a/arm9/lib/include/FS_archive.h +++ b/arm9/lib/include/FS_archive.h @@ -78,6 +78,8 @@ typedef enum { (FS_ARCHIVE_PROC_ACTIVATE | FS_ARCHIVE_PROC_IDLE | \ FS_ARCHIVE_PROC_SUSPENDING | FS_ARCHIVE_PROC_RESUME) +#define FS_ARCHIVE_PROC_ALL (~0) + typedef enum { FS_RESULT_SUCCESS = 0, FS_RESULT_FAILURE, @@ -182,5 +184,11 @@ BOOL FSi_SendCommand(struct FSFile * file, FSCommandType command); BOOL FSi_ExecuteSyncCommand(struct FSFile * file); BOOL FS_SuspendArchive(FSArchive * p_arc); BOOL FS_ResumeArchive(FSArchive * p_arc); +void FS_NotifyArchiveAsyncEnd(FSArchive *p_arc, FSResult ret); +BOOL FS_RegisterArchiveName(FSArchive * p_arc, const char * name, int name_len); +void FS_InitArchive(FSArchive * p_arc); +void FS_SetArchiveProc(struct FSArchive * p_arc, FS_ARCHIVE_PROC_FUNC proc, u32 flags); +BOOL FS_LoadArchive(FSArchive * p_arc, u32 base, u32 fat, u32 fat_size, u32 fnt, u32 fnt_size, FS_ARCHIVE_READ_FUNC read_func, FS_ARCHIVE_WRITE_FUNC write_func); +u32 FS_LoadArchiveTables(FSArchive *p_arc, void *p_mem, u32 max_size); #endif //NITRO_FS_ARCHIVE_H_ diff --git a/arm9/lib/include/FS_rom.h b/arm9/lib/include/FS_rom.h index 0bba46bf..ac8ad8fb 100644 --- a/arm9/lib/include/FS_rom.h +++ b/arm9/lib/include/FS_rom.h @@ -5,6 +5,7 @@ #include "CARD_rom.h" extern FSArchive fsi_arc_rom; +extern s32 fsi_card_lock_id; extern CARDRomRegion fsi_ovt7; extern CARDRomRegion fsi_ovt9; diff --git a/arm9/lib/include/MI_dma.h b/arm9/lib/include/MI_dma.h new file mode 100644 index 00000000..eddcedbb --- /dev/null +++ b/arm9/lib/include/MI_dma.h @@ -0,0 +1,6 @@ +#ifndef NITRO_MI_DMA_H_ +#define NITRO_MI_DMA_H_ + +typedef void (*MIDmaCallback)(void *); + +#endif //NITRO_MI_DMA_H_ diff --git a/arm9/lib/include/OS_printf.h b/arm9/lib/include/OS_printf.h new file mode 100644 index 00000000..0fda0f51 --- /dev/null +++ b/arm9/lib/include/OS_printf.h @@ -0,0 +1,6 @@ +#ifndef NITRO_OS_PRINTF_H_ +#define NITRO_OS_PRINTF_H_ + +#define OS_Warning( ... ) ((void)0) + +#endif //NITRO_OS_PRINTF_H_ diff --git a/arm9/lib/include/OS_spinLock.h b/arm9/lib/include/OS_spinLock.h index b7f0a571..3bb8a1c2 100644 --- a/arm9/lib/include/OS_spinLock.h +++ b/arm9/lib/include/OS_spinLock.h @@ -11,4 +11,6 @@ typedef volatile struct OSLockWord { u16 extension; } OSLockWord; +s32 OS_GetLockID(void); + #endif //POKEDIAMOND_OS_SPINLOCK_H diff --git a/arm9/lib/src/FS_rom.c b/arm9/lib/src/FS_rom.c new file mode 100644 index 00000000..44d31a4a --- /dev/null +++ b/arm9/lib/src/FS_rom.c @@ -0,0 +1,118 @@ +#include "FS_rom.h" +#include "FS_archive.h" +#include "FS_file.h" +#include "CARD_pullOut.h" +#include "CARD_rom.h" +#include "CARD_common.h" +#include "MB_mb.h" +#include "OS_printf.h" + +u32 fsi_default_dma_no; + +void FSi_OnRomReadDone(void * p_arc) +{ + FS_NotifyArchiveAsyncEnd(p_arc, CARD_IsPulledOut() ? FS_RESULT_ERROR : FS_RESULT_SUCCESS); +} + +FSResult FSi_ReadRomCallback(FSArchive * p_arc, void * dst, u32 src, u32 len) +{ + CARD_ReadRomAsync(fsi_default_dma_no, (const void *)src, dst, len, FSi_OnRomReadDone, p_arc); + return FS_RESULT_PROC_ASYNC; +} + +FSResult FSi_WriteDummyCallback(FSArchive * p_arc, const void *src, u32 dst, u32 len) +{ + return FS_RESULT_FAILURE; +} + +FSResult FSi_RomArchiveProc(FSFile * p_arc, FSCommandType cmd) +{ + switch (cmd) + { + case FS_COMMAND_ACTIVATE: + CARD_LockRom(fsi_card_lock_id); + return FS_RESULT_SUCCESS; + case FS_COMMAND_IDLE: + CARD_UnlockRom(fsi_card_lock_id); + return FS_RESULT_SUCCESS; + case FS_COMMAND_WRITEFILE: + return FS_RESULT_UNSUPPORTED; + default: + return FS_RESULT_PROC_UNKNOWN; + } +} + +FSResult FSi_ReadDummyCallback(FSArchive *p_arc, void *dst, u32 src, u32 len) +{ + return FS_RESULT_FAILURE; +} + +FSResult FSi_EmptyArchiveProc(FSFile *p_file, FSCommandType cmd) +{ + return FS_RESULT_UNSUPPORTED; +} + +void FSi_InitRom(u32 default_dma_no) +{ + fsi_default_dma_no = default_dma_no; + fsi_card_lock_id = OS_GetLockID(); + fsi_ovt9.offset = 0; + fsi_ovt9.length = 0; + fsi_ovt7.offset = 0; + fsi_ovt7.length = 0; + + CARD_Init(); + + FS_InitArchive(&fsi_arc_rom); + FS_RegisterArchiveName(&fsi_arc_rom, "rom", 3); + + if (MB_IsMultiBootChild()) + { + fsi_ovt9.offset = (u32)~0; + fsi_ovt9.length = 0; + fsi_ovt7.offset = (u32)~0; + fsi_ovt7.length = 0; + FS_SetArchiveProc(&fsi_arc_rom, FSi_EmptyArchiveProc, (u32)FS_ARCHIVE_PROC_ALL); + FS_LoadArchive(&fsi_arc_rom, 0x00000000, 0, 0, 0, 0, FSi_ReadDummyCallback, FSi_WriteDummyCallback); + } + else + { + const CARDRomRegion *const fnt = CARD_GetRomRegionFNT(); + const CARDRomRegion *const fat = CARD_GetRomRegionFAT(); + + FS_SetArchiveProc(&fsi_arc_rom, FSi_RomArchiveProc, + FS_ARCHIVE_PROC_WRITEFILE | + FS_ARCHIVE_PROC_ACTIVATE | FS_ARCHIVE_PROC_IDLE); + + if ((fnt->offset == 0xFFFFFFFF) || (fnt->offset == 0x00000000) || + (fat->offset == 0xFFFFFFFF) || (fat->offset == 0x00000000)) + { + OS_Warning("file-system : no MAKEROM-information in rom header."); + } + else + { + FS_LoadArchive(&fsi_arc_rom, 0x00000000, + fat->offset, fat->length, + fnt->offset, fnt->length, + FSi_ReadRomCallback, FSi_WriteDummyCallback); + } + } +} + +u32 FS_SetDefaultDMA(u32 dma_no) +{ + OSIntrMode bak_psr = OS_DisableInterrupts(); + u32 bak_dma_no = fsi_default_dma_no; + BOOL bak_stat = FS_SuspendArchive(&fsi_arc_rom); + fsi_default_dma_no = dma_no; + if (bak_stat) + FS_ResumeArchive(&fsi_arc_rom); + OS_RestoreInterrupts(bak_psr); + return bak_dma_no; +} + +u32 FS_TryLoadTable(void * p_mem, u32 size) +{ + return FS_LoadArchiveTables(&fsi_arc_rom, p_mem, size); +} + diff --git a/arm9/lib/src/OS_reset.c b/arm9/lib/src/OS_reset.c index b12703da..774b392b 100644 --- a/arm9/lib/src/OS_reset.c +++ b/arm9/lib/src/OS_reset.c @@ -14,7 +14,6 @@ extern void PXI_SetFifoRecvCallback(u32 param1, void* callback); extern void OS_Terminate(); extern u32 PXI_SendWordByFifo(u32 param1, u32 data, u32 param2); extern void CARD_LockRom(u16 lockId); -extern u32 OS_GetLockID(); extern void MI_StopDma(u32 dma); extern void OS_SetIrqMask(u32 mask); extern void OS_ResetRequestIrqMask(u32 mask); -- cgit v1.2.3 From ab5676fcf0a728374d5495c1980f1e2459d0ba4e Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Thu, 7 May 2020 19:55:15 -0400 Subject: FS_command.c --- arm9/lib/include/FS_archive.h | 5 +++ arm9/lib/include/FS_command.h | 2 ++ arm9/lib/include/FSi_util.h | 7 ++++ arm9/lib/src/FS_command.c | 75 +++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 89 insertions(+) create mode 100644 arm9/lib/src/FS_command.c (limited to 'arm9/lib') diff --git a/arm9/lib/include/FS_archive.h b/arm9/lib/include/FS_archive.h index d7c2a785..3bbbbff7 100644 --- a/arm9/lib/include/FS_archive.h +++ b/arm9/lib/include/FS_archive.h @@ -175,6 +175,11 @@ static inline BOOL FSi_IsArchiveAsync(volatile const FSArchive * p_arc) return (p_arc->flag & FS_ARCHIVE_FLAG_IS_ASYNC) != 0; } +static inline BOOL FSi_IsArchiveSync(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_IS_SYNC) != 0; +} + static inline BOOL FS_IsArchiveTableLoaded(volatile const FSArchive * p_arc) { return (p_arc->flag & FS_ARCHIVE_FLAG_TABLE_LOAD) ? TRUE : FALSE; diff --git a/arm9/lib/include/FS_command.h b/arm9/lib/include/FS_command.h index db878f3f..b5e73bcf 100644 --- a/arm9/lib/include/FS_command.h +++ b/arm9/lib/include/FS_command.h @@ -3,6 +3,8 @@ #include "FS_file.h" +extern FSResult (*const fsi_default_command[])(FSFile *); + void FSi_ReleaseCommand(FSFile * file, FSResult signal); FSResult FSi_TranslateCommand(FSFile * file, FSCommandType command); diff --git a/arm9/lib/include/FSi_util.h b/arm9/lib/include/FSi_util.h index 1012df13..1f6faf6f 100644 --- a/arm9/lib/include/FSi_util.h +++ b/arm9/lib/include/FSi_util.h @@ -20,6 +20,13 @@ static inline void FSi_CutFromListCore(FSFileLink *trg) nx->link.prev = pr; } +static inline void FSi_CutFromList(FSFile *elem) +{ + FSFileLink *const trg = &elem->link; + FSi_CutFromListCore(trg); + trg->next = trg->prev = NULL; +} + static inline void FSi_AppendToList(FSFile *elem, FSFile *list) { FSFileLink *const trg = &elem->link; diff --git a/arm9/lib/src/FS_command.c b/arm9/lib/src/FS_command.c new file mode 100644 index 00000000..bc7839d8 --- /dev/null +++ b/arm9/lib/src/FS_command.c @@ -0,0 +1,75 @@ +#include "FS_file.h" +#include "FS_archive.h" +#include "FSi_util.h" +#include "FS_command.h" + +void FSi_ReleaseCommand(FSFile * p_file, FSResult ret) +{ + OSIntrMode bak_psr = OS_DisableInterrupts(); + FSi_CutFromList(p_file); + p_file->stat &= ~(FS_FILE_STATUS_CANCEL | FS_FILE_STATUS_BUSY | FS_FILE_STATUS_SYNC | FS_FILE_STATUS_ASYNC | FS_FILE_STATUS_OPERATING); + p_file->error = ret; + OS_WakeupThread(p_file->queue); + OS_RestoreInterrupts(bak_psr); +} + +FSResult FSi_TranslateCommand(FSFile *p_file, FSCommandType command) +{ + FSResult ret; + + FSArchive *const p_arc = p_file->arc; + const int bit = (1 << command); + + if (FS_IsFileSyncMode(p_file)) + p_arc->flag |= FS_ARCHIVE_FLAG_IS_SYNC; + else + p_arc->flag |= FS_ARCHIVE_FLAG_IS_ASYNC; + + if ((p_arc->proc_flag & bit) != 0) + { + switch (ret = (*p_arc->proc) (p_file, command)) + { + case FS_RESULT_SUCCESS: + case FS_RESULT_FAILURE: + case FS_RESULT_UNSUPPORTED: + p_file->error = ret; + break; + case FS_RESULT_PROC_ASYNC: + break; + case FS_RESULT_PROC_UNKNOWN: + ret = FS_RESULT_PROC_DEFAULT; + p_arc->proc_flag &= ~bit; + break; + } + } + else + { + ret = FS_RESULT_PROC_DEFAULT; + } + if (ret == FS_RESULT_PROC_DEFAULT) + { + ret = (*fsi_default_command[command]) (p_file); + } + if (ret == FS_RESULT_PROC_ASYNC) + { + if (FS_IsFileSyncMode(p_file)) + { + OSIntrMode bak_psr = OS_DisableInterrupts(); + while (FSi_IsArchiveSync(p_arc)) + OS_SleepThread(&p_arc->sync_q); + ret = p_file->error; + OS_RestoreInterrupts(bak_psr); + } + } + else if (!FS_IsFileSyncMode(p_file)) + { + p_arc->flag &= ~FS_ARCHIVE_FLAG_IS_ASYNC; + FSi_ReleaseCommand(p_file, ret); + } + else + { + p_arc->flag &= ~FS_ARCHIVE_FLAG_IS_SYNC; + p_file->error = ret; + } + return ret; +} -- cgit v1.2.3 From eb410178e4e33ccd19bee4dcbaee730769f1fb86 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Thu, 7 May 2020 21:02:08 -0400 Subject: FS_command_default through FSi_WriteFileCommand --- arm9/lib/src/FS_command_default.c | 108 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 108 insertions(+) create mode 100644 arm9/lib/src/FS_command_default.c (limited to 'arm9/lib') diff --git a/arm9/lib/src/FS_command_default.c b/arm9/lib/src/FS_command_default.c new file mode 100644 index 00000000..bd04f740 --- /dev/null +++ b/arm9/lib/src/FS_command_default.c @@ -0,0 +1,108 @@ +#include "nitro.h" +#include "FS_file.h" +#include "FS_command.h" +#include "FS_archive.h" +#include "MI_byteAccess.h" + +typedef struct +{ + FSArchive *arc; + u32 pos; +} +FSiSyncReadParam; + +FSResult FSi_ReadFileCommand(FSFile * p_file); +FSResult FSi_WriteFileCommand(FSFile * p_file); +FSResult FSi_SeekDirCommand(FSFile * p_file); +FSResult FSi_ReadDirCommand(FSFile * p_file); +FSResult FSi_FindPathCommand(FSFile * p_file); +FSResult FSi_GetPathCommand(FSFile * p_file); +FSResult FSi_OpenFileFastCommand(FSFile * p_file); +FSResult FSi_OpenFileDirectCommand(FSFile * p_file); +FSResult FSi_CloseFileCommand(FSFile * p_file); + +FSResult (*const fsi_default_command[])(FSFile *) = { + [FS_COMMAND_READFILE] = FSi_ReadFileCommand, + [FS_COMMAND_WRITEFILE] = FSi_WriteFileCommand, + [FS_COMMAND_SEEKDIR] = FSi_SeekDirCommand, + [FS_COMMAND_READDIR] = FSi_ReadDirCommand, + [FS_COMMAND_FINDPATH] = FSi_FindPathCommand, + [FS_COMMAND_GETPATH] = FSi_GetPathCommand, + [FS_COMMAND_OPENFILEFAST] = FSi_OpenFileFastCommand, + [FS_COMMAND_OPENFILEDIRECT] = FSi_OpenFileDirectCommand, + [FS_COMMAND_CLOSEFILE] = FSi_CloseFileCommand, +}; + +// Case-insensitive string comparison +u32 FSi_StrNICmp(const char * str1, const char * str2, u32 len) +{ + int i; + for (i = 0; i < len; i++) + { + u32 c = MI_ReadByte(str1 + i) - 'A'; + u32 d = MI_ReadByte(str2 + i) - 'A'; + if (c <= 'Z' - 'A') + c += 'a' - 'A'; + if (d <= 'Z' - 'A') + d += 'a' - 'A'; + if (c != d) + return c - d; + } + return 0; +} + +FSResult FSi_ReadTable(FSiSyncReadParam * p, void * dst, u32 len) +{ + FSResult ret; + FSArchive * const p_arc = p->arc; + p_arc->flag |= FS_ARCHIVE_FLAG_IS_SYNC; + switch (ret = (*p_arc->table_func)(p_arc, dst, p->pos, len)) + { + case FS_RESULT_SUCCESS: + case FS_RESULT_FAILURE: + p_arc->flag &= ~FS_ARCHIVE_FLAG_IS_SYNC; + break; + case FS_RESULT_PROC_ASYNC: + { + OSIntrMode bak_psr = OS_DisableInterrupts(); + while (FSi_IsArchiveSync(p_arc)) + OS_SleepThread(&p_arc->sync_q); + OS_RestoreInterrupts(bak_psr); + ret = p_arc->list.next->error; + } + break; + } + p->pos += len; + return ret; +} + +FSResult FSi_SeekDirDirect(FSFile * p_dir, u32 id) +{ + p_dir->stat |= FS_FILE_STATUS_SYNC; + p_dir->arg.seekdir.pos.arc = p_dir->arc; + p_dir->arg.seekdir.pos.pos = 0; + p_dir->arg.seekdir.pos.index = 0; + p_dir->arg.seekdir.pos.own_id = (u16)id; + return FSi_TranslateCommand(p_dir, FS_COMMAND_SEEKDIR); +} + +// The actual commands +FSResult FSi_ReadFileCommand(FSFile * p_file) +{ + FSArchive *const p_arc = p_file->arc; + const u32 pos = p_file->prop.file.pos; + const u32 len = p_file->arg.readfile.len; + void *const dst = p_file->arg.readfile.dst; + p_file->prop.file.pos += len; + return (*p_arc->read_func)(p_arc, dst, pos, len); +} + +FSResult FSi_WriteFileCommand(FSFile * p_file) +{ + FSArchive *const p_arc = p_file->arc; + const u32 pos = p_file->prop.file.pos; + const u32 len = p_file->arg.writefile.len; + const void *const src = p_file->arg.writefile.src; + p_file->prop.file.pos += len; + return (*p_arc->write_func)(p_arc, src, pos, len); +} -- cgit v1.2.3 From 1966623ed0516e84d8129e8f22dba502b018bcc3 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 8 May 2020 08:35:17 -0400 Subject: Finish FS_command_default.c --- arm9/lib/include/FS_archive.h | 13 ++ arm9/lib/include/FS_file.h | 7 + arm9/lib/include/FSi_util.h | 2 + arm9/lib/include/MI_byteAccess.h | 5 + arm9/lib/src/FS_command_default.c | 360 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 387 insertions(+) (limited to 'arm9/lib') diff --git a/arm9/lib/include/FS_archive.h b/arm9/lib/include/FS_archive.h index 3bbbbff7..d30081d7 100644 --- a/arm9/lib/include/FS_archive.h +++ b/arm9/lib/include/FS_archive.h @@ -105,6 +105,19 @@ typedef struct } FSFileLink; +typedef struct +{ + u32 start; + u16 index; + u16 parent; +} FSArchiveFNT; + +typedef struct +{ + u32 top; + u32 bottom; +} FSArchiveFAT; + typedef struct FSArchive { union diff --git a/arm9/lib/include/FS_file.h b/arm9/lib/include/FS_file.h index fdf6c4e2..55825c61 100644 --- a/arm9/lib/include/FS_file.h +++ b/arm9/lib/include/FS_file.h @@ -13,6 +13,8 @@ #define FS_FILE_STATUS_IS_DIR 0x00000020 #define FS_FILE_STATUS_OPERATING 0x00000040 +#define FS_FILE_NAME_MAX 127 + typedef enum FSSeekFileMode { FS_SEEK_SET = 0, @@ -210,4 +212,9 @@ static inline BOOL FS_IsSucceeded(volatile const FSFile * p_file) return (p_file->error == FS_RESULT_SUCCESS) ? TRUE : FALSE; } +static inline BOOL FS_IsDir(volatile const FSFile * p_file) +{ + return (p_file->stat & FS_FILE_STATUS_IS_DIR) ? TRUE : FALSE; +} + #endif //NITRO_FS_FILE_H_ diff --git a/arm9/lib/include/FSi_util.h b/arm9/lib/include/FSi_util.h index 1f6faf6f..6e96681e 100644 --- a/arm9/lib/include/FSi_util.h +++ b/arm9/lib/include/FSi_util.h @@ -5,6 +5,8 @@ #define ALIGN_BYTE(n, a) (((u32)(n) + ALIGN_MASK(a)) & ~ALIGN_MASK(a)) +#define BIT_MASK(a) ((u32)((1 << (a)) - 1)) + static inline BOOL FSi_IsSlash(u32 c) { return (c == '/') || (c == '\\'); diff --git a/arm9/lib/include/MI_byteAccess.h b/arm9/lib/include/MI_byteAccess.h index 10dae4c9..cad4d518 100644 --- a/arm9/lib/include/MI_byteAccess.h +++ b/arm9/lib/include/MI_byteAccess.h @@ -6,4 +6,9 @@ static inline u8 MI_ReadByte(const void *address) return *(u8 *)address; } +static inline void MI_WriteByte(void *address, u8 value) +{ + *(u8 *)address = value; +} + #endif //NITRO_MI_BYTEACCESS_H_ diff --git a/arm9/lib/src/FS_command_default.c b/arm9/lib/src/FS_command_default.c index bd04f740..85287fa9 100644 --- a/arm9/lib/src/FS_command_default.c +++ b/arm9/lib/src/FS_command_default.c @@ -3,6 +3,8 @@ #include "FS_command.h" #include "FS_archive.h" #include "MI_byteAccess.h" +#include "MI_memory.h" +#include "FSi_util.h" typedef struct { @@ -106,3 +108,361 @@ FSResult FSi_WriteFileCommand(FSFile * p_file) p_file->prop.file.pos += len; return (*p_arc->write_func)(p_arc, src, pos, len); } + +FSResult FSi_SeekDirCommand(FSFile * p_dir) +{ + FSResult ret; + FSArchive *const p_arc = p_dir->arc; + const FSDirPos *const arg = &p_dir->arg.seekdir.pos; + + FSArchiveFNT fnt_entry; + FSiSyncReadParam param; + param.arc = p_arc; + param.pos = p_arc->fnt + arg->own_id * sizeof(fnt_entry); + ret = FSi_ReadTable(¶m, &fnt_entry, sizeof(fnt_entry)); + if (ret == FS_RESULT_SUCCESS) + { + p_dir->prop.dir.pos = *arg; + if ((arg->index == 0) && (arg->pos == 0)) + { + p_dir->prop.dir.pos.index = fnt_entry.index; + p_dir->prop.dir.pos.pos = p_arc->fnt + fnt_entry.start; + } + p_dir->prop.dir.parent = (u32) (fnt_entry.parent & BIT_MASK(12)); + } + return ret; +} + +FSResult FSi_ReadDirCommand(FSFile *p_dir) +{ + FSDirEntry *p_entry = p_dir->arg.readdir.p_entry; + FSResult ret; + + FSiSyncReadParam param; + param.arc = p_dir->arc; + param.pos = p_dir->prop.dir.pos.pos; + + { + u8 len; + ret = FSi_ReadTable(¶m, &len, sizeof(len)); + if (ret != FS_RESULT_SUCCESS) + return ret; + p_entry->name_len = (u32)(len & BIT_MASK(7)); + p_entry->is_directory = (u32)((len >> 7) & 1); + } + if (p_entry->name_len == 0) + return FS_RESULT_FAILURE; + + if (!p_dir->arg.readdir.skip_string) + { + ret = FSi_ReadTable(¶m, p_entry->name, p_entry->name_len); + if (ret != FS_RESULT_SUCCESS) + return ret; + MI_WriteByte((u8 *)p_entry->name + p_entry->name_len, (u8)'\0'); + } + else + { + param.pos += p_entry->name_len; + } + + if (p_entry->is_directory) + { + u16 id; + ret = FSi_ReadTable(¶m, &id, sizeof(id)); + if (ret != FS_RESULT_SUCCESS) + return ret; + p_entry->dir_id.arc = p_dir->arc; + p_entry->dir_id.own_id = (u16)(id & BIT_MASK(12)); + p_entry->dir_id.index = 0; + p_entry->dir_id.pos = 0; + } + else + { + p_entry->file_id.arc = p_dir->arc; + p_entry->file_id.file_id = p_dir->prop.dir.pos.index; + ++p_dir->prop.dir.pos.index; + } + p_dir->prop.dir.pos.pos = param.pos; + + return ret; +} + +FSResult FSi_FindPathCommand(FSFile *p_dir) +{ + const char *path = p_dir->arg.findpath.path; + const BOOL is_dir = p_dir->arg.findpath.find_directory; + p_dir->arg.seekdir.pos = p_dir->arg.findpath.pos; + (void)FSi_TranslateCommand(p_dir, FS_COMMAND_SEEKDIR); + for (; MI_ReadByte(path); path += (MI_ReadByte(path) ? 1 : 0)) + { + u32 is_directory; + int name_len = 0; + while ((is_directory = MI_ReadByte(path + name_len)), + (is_directory && !FSi_IsSlash(is_directory))) + ++name_len; + if (is_directory || is_dir) + is_directory = 1; + if (name_len == 0) + { + return FS_RESULT_FAILURE; + } + else if (MI_ReadByte(path) == '.') + { + if (name_len == 1) + { + path += 1; + continue; + } + else if ((name_len == 2) & (MI_ReadByte(path + 1) == '.')) + { + if (p_dir->prop.dir.pos.own_id != 0) + FSi_SeekDirDirect(p_dir, p_dir->prop.dir.parent); + path += 2; + continue; + } + } + if (name_len > FS_FILE_NAME_MAX) + { + return FS_RESULT_FAILURE; + } + else + { + FSDirEntry etr; + p_dir->arg.readdir.p_entry = &etr; + p_dir->arg.readdir.skip_string = FALSE; + for (;;) + { + if (FSi_TranslateCommand(p_dir, FS_COMMAND_READDIR) != FS_RESULT_SUCCESS) + return FS_RESULT_FAILURE; + if ((is_directory != etr.is_directory) || + (name_len != etr.name_len) || FSi_StrNICmp(path, etr.name, (u32)name_len)) + continue; + if (is_directory) + { + path += name_len; + p_dir->arg.seekdir.pos = etr.dir_id; + (void)FSi_TranslateCommand(p_dir, FS_COMMAND_SEEKDIR); + break; + } + else if (is_dir) + { + return FS_RESULT_FAILURE; + } + else + { + *p_dir->arg.findpath.result.file = etr.file_id; + return FS_RESULT_SUCCESS; + } + } + } + } + if (!is_dir) + return FS_RESULT_FAILURE; + *p_dir->arg.findpath.result.dir = p_dir->prop.dir.pos; + return FS_RESULT_SUCCESS; +} + +FSResult FSi_GetPathCommand(FSFile *p_file) +{ + FSArchive *const p_arc = p_file->arc; + + FSGetPathInfo *p_info = &p_file->arg.getpath; + + FSDirEntry entry; + FSFile tmp; + u32 dir_id; + u32 file_id; + u32 id; + u32 len; + + enum + { INVALID_ID = 0x10000 }; + + FS_InitFile(&tmp); + tmp.arc = p_file->arc; + + if (FS_IsDir(p_file)) + { + dir_id = p_file->prop.dir.pos.own_id; + file_id = INVALID_ID; + } + else + { + file_id = p_file->prop.file.own_id; + if (p_info->total_len != 0) + { + dir_id = p_info->dir_id; + } + else + { + u32 pos = 0; + u32 num_dir = 0; + dir_id = INVALID_ID; + do + { + FSi_SeekDirDirect(&tmp, pos); + if (!pos) + num_dir = tmp.prop.dir.parent; + tmp.arg.readdir.p_entry = &entry; + tmp.arg.readdir.skip_string = TRUE; + while (FSi_TranslateCommand(&tmp, FS_COMMAND_READDIR) == FS_RESULT_SUCCESS) + { + if (!entry.is_directory && (entry.file_id.file_id == file_id)) + { + dir_id = tmp.prop.dir.pos.own_id; + break; + } + } + } + while ((dir_id == INVALID_ID) && (++pos < num_dir)); + } + } + if (dir_id == INVALID_ID) + { + p_info->total_len = 0; + return FS_RESULT_FAILURE; + } + if (p_info->total_len == 0) + { + len = 0; + if (p_arc->name.pack <= 0x000000FF) + len += 1; + else if (p_arc->name.pack <= 0x0000FF00) + len += 2; + else + len += 3; + len += 1 + 1; + if (file_id != INVALID_ID) + len += entry.name_len; + id = dir_id; + if (id != 0) + { + FSi_SeekDirDirect(&tmp, id); + do + { + FSi_SeekDirDirect(&tmp, tmp.prop.dir.parent); + tmp.arg.readdir.p_entry = &entry; + tmp.arg.readdir.skip_string = TRUE; + while (FSi_TranslateCommand(&tmp, FS_COMMAND_READDIR) == FS_RESULT_SUCCESS) + { + if (entry.is_directory && (entry.dir_id.own_id == id)) + { + len += entry.name_len + 1; + break; + } + } + id = tmp.prop.dir.pos.own_id; + } + while (id != 0); + } + p_info->total_len = (u16)(len + 1); + p_info->dir_id = (u16)dir_id; + } + if (!p_info->buf) + return FS_RESULT_SUCCESS; + if (p_info->buf_len < p_info->total_len) + return FS_RESULT_FAILURE; + else + { + u8 *dst = p_info->buf; + u32 total = p_info->total_len; + u32 pos = 0; + if (p_arc->name.pack <= 0x000000FF) + len = 1; + else if (p_arc->name.pack <= 0x0000FF00) + len = 2; + else + len = 3; + MI_CpuCopy8(p_arc->name.ptr, dst + pos, len); + pos += len; + MI_CpuCopy8(":/", dst + pos, 2); + pos += 2; + id = dir_id; + FSi_SeekDirDirect(&tmp, id); + if (file_id != INVALID_ID) + { + tmp.arg.readdir.p_entry = &entry; + tmp.arg.readdir.skip_string = FALSE; + while (FSi_TranslateCommand(&tmp, FS_COMMAND_READDIR) == FS_RESULT_SUCCESS) + { + if (!entry.is_directory && (entry.file_id.file_id == file_id)) + break; + } + len = entry.name_len + 1; + MI_CpuCopy8(entry.name, dst + total - len, len); + total -= len; + } + else + { + MI_WriteByte(dst + total - 1, '\0'); + total -= 1; + } + if (id != 0) + { + do + { + FSi_SeekDirDirect(&tmp, tmp.prop.dir.parent); + tmp.arg.readdir.p_entry = &entry; + tmp.arg.readdir.skip_string = FALSE; + MI_WriteByte(dst + total - 1, '/'); + total -= 1; + while (FSi_TranslateCommand(&tmp, FS_COMMAND_READDIR) == FS_RESULT_SUCCESS) + { + if (entry.is_directory && (entry.dir_id.own_id == id)) + { + len = entry.name_len; + MI_CpuCopy8(entry.name, dst + total - len, len); + total -= len; + break; + } + } + id = tmp.prop.dir.pos.own_id; + } + while (id != 0); + } + } + + return FS_RESULT_SUCCESS; +} + +FSResult FSi_OpenFileFastCommand(FSFile * p_file) +{ + FSArchive *const p_arc = p_file->arc; + const FSFileID *p_id = &p_file->arg.openfilefast.id; + const u32 index = p_id->file_id; + FSResult ret; + + { + u32 pos = (u32)(index * sizeof(FSArchiveFAT)); + if (pos >= p_arc->fat_size) + return FS_RESULT_FAILURE; + else + { + FSArchiveFAT fat; + FSiSyncReadParam param; + param.arc = p_arc; + param.pos = p_arc->fat + pos; + ret = FSi_ReadTable(¶m, &fat, sizeof(fat)); + if (ret != FS_RESULT_SUCCESS) + return ret; + p_file->arg.openfiledirect.top = fat.top; + p_file->arg.openfiledirect.bottom = fat.bottom; + p_file->arg.openfiledirect.index = index; + return FSi_TranslateCommand(p_file, FS_COMMAND_OPENFILEDIRECT); + } + } +} + +FSResult FSi_OpenFileDirectCommand(FSFile * p_file) +{ + p_file->prop.file.top = p_file->arg.openfiledirect.top; + p_file->prop.file.pos = p_file->arg.openfiledirect.top; + p_file->prop.file.bottom = p_file->arg.openfiledirect.bottom; + p_file->prop.file.own_id = p_file->arg.openfiledirect.index; + return FS_RESULT_SUCCESS; +} + +FSResult FSi_CloseFileCommand(FSFile * p_file) +{ + return FS_RESULT_SUCCESS; +} -- cgit v1.2.3 From 26fe22ac52dd917361afb8ce58baf336bbb414f9 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 8 May 2020 09:38:50 -0400 Subject: libfs data/rodata --- arm9/lib/src/FS_overlay.c | 26 ++++++++++++++++++++++++-- 1 file changed, 24 insertions(+), 2 deletions(-) (limited to 'arm9/lib') diff --git a/arm9/lib/src/FS_overlay.c b/arm9/lib/src/FS_overlay.c index d8d53570..d2a4677d 100644 --- a/arm9/lib/src/FS_overlay.c +++ b/arm9/lib/src/FS_overlay.c @@ -144,8 +144,30 @@ BOOL FS_LoadOverlayImage(FSOverlayInfo * p_ovi) } } -const void *fsi_digest_key_ptr; -u32 fsi_digest_key_len; +static const u8 fsi_def_digest_key[64] = { + 0x21, 0x06, 0xc0, 0xde, + 0xba, 0x98, 0xce, 0x3f, + 0xa6, 0x92, 0xe3, 0x9d, + 0x46, 0xf2, 0xed, 0x01, + + 0x76, 0xe3, 0xcc, 0x08, + 0x56, 0x23, 0x63, 0xfa, + 0xca, 0xd4, 0xec, 0xdf, + 0x9a, 0x62, 0x78, 0x34, + + 0x8f, 0x6d, 0x63, 0x3c, + 0xfe, 0x22, 0xca, 0x92, + 0x20, 0x88, 0x97, 0x23, + 0xd2, 0xcf, 0xae, 0xc2, + + 0x32, 0x67, 0x8d, 0xfe, + 0xca, 0x83, 0x64, 0x98, + 0xac, 0xfd, 0x3e, 0x37, + 0x87, 0x46, 0x58, 0x24, +}; + +static const void *fsi_digest_key_ptr = fsi_def_digest_key; +static int fsi_digest_key_len = sizeof(fsi_def_digest_key); BOOL FSi_CompareDigest(const u8 *spec_digest, void *src, int len) { -- cgit v1.2.3 From d3bd9a77bb8ca065d295911aca7fbd2da4a846f5 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 8 May 2020 11:52:42 -0400 Subject: Some prototypes in FS_file.h --- arm9/lib/include/FS_file.h | 2 ++ 1 file changed, 2 insertions(+) (limited to 'arm9/lib') diff --git a/arm9/lib/include/FS_file.h b/arm9/lib/include/FS_file.h index 55825c61..9857a40c 100644 --- a/arm9/lib/include/FS_file.h +++ b/arm9/lib/include/FS_file.h @@ -180,8 +180,10 @@ BOOL FS_WaitAsync(FSFile * p_file); BOOL FS_OpenFileDirect(FSFile * p_file, FSArchive * p_arc, u32 image_top, u32 image_bottom, u32 file_index); int FS_ReadFile(FSFile * p_file, void * dst, s32 len); int FS_ReadFileAsync(FSFile * p_file, void * dst, s32 len); +BOOL FS_OpenFile(FSFile * p_file, const char * path); BOOL FS_OpenFileFast(FSFile * p_file, FSFileID file_id); BOOL FS_CloseFile(FSFile * p_file); +BOOL FS_SeekFile(FSFile * p_file, int offset, FSSeekFileMode origin); static inline u32 const FS_GetFileImageTop(volatile const FSFile * p_file) { return p_file->prop.file.top; -- cgit v1.2.3 From b398a161f324f88a4d4c8682eb15c63a62753a43 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 8 May 2020 19:39:43 -0400 Subject: Fix style inconsistencies --- arm9/lib/include/FS_file.h | 16 ++++----- arm9/lib/include/OS_printf.h | 2 ++ arm9/lib/include/OS_system.h | 4 --- arm9/lib/include/mmap_global.h | 4 --- arm9/lib/src/FS_archive.c | 35 ++++++++++---------- arm9/lib/src/FS_command.c | 4 +-- arm9/lib/src/FS_command_default.c | 42 ++++++++++++------------ arm9/lib/src/FS_file.c | 68 +++++++++++++++++++-------------------- arm9/lib/src/FS_overlay.c | 27 ++++++++-------- arm9/lib/src/FS_rom.c | 18 +++++------ 10 files changed, 107 insertions(+), 113 deletions(-) delete mode 100644 arm9/lib/include/mmap_global.h (limited to 'arm9/lib') diff --git a/arm9/lib/include/FS_file.h b/arm9/lib/include/FS_file.h index 9857a40c..3a7d8730 100644 --- a/arm9/lib/include/FS_file.h +++ b/arm9/lib/include/FS_file.h @@ -5,13 +5,13 @@ #include "FS_archive.h" -#define FS_FILE_STATUS_BUSY 0x00000001 -#define FS_FILE_STATUS_CANCEL 0x00000002 -#define FS_FILE_STATUS_SYNC 0x00000004 -#define FS_FILE_STATUS_ASYNC 0x00000008 -#define FS_FILE_STATUS_IS_FILE 0x00000010 -#define FS_FILE_STATUS_IS_DIR 0x00000020 -#define FS_FILE_STATUS_OPERATING 0x00000040 +#define FS_FILE_STATUS_BUSY 0x00000001 +#define FS_FILE_STATUS_CANCEL 0x00000002 +#define FS_FILE_STATUS_SYNC 0x00000004 +#define FS_FILE_STATUS_ASYNC 0x00000008 +#define FS_FILE_STATUS_IS_FILE 0x00000010 +#define FS_FILE_STATUS_IS_DIR 0x00000020 +#define FS_FILE_STATUS_OPERATING 0x00000040 #define FS_FILE_NAME_MAX 127 @@ -81,7 +81,7 @@ typedef struct FSFileID *file; FSDirPos *dir; } - result; + result; } FSFindPathInfo; diff --git a/arm9/lib/include/OS_printf.h b/arm9/lib/include/OS_printf.h index 0fda0f51..7c02252b 100644 --- a/arm9/lib/include/OS_printf.h +++ b/arm9/lib/include/OS_printf.h @@ -2,5 +2,7 @@ #define NITRO_OS_PRINTF_H_ #define OS_Warning( ... ) ((void)0) +#define OS_TPanic(...) OS_Terminate() +#define OS_TWarning(...) ((void)0) #endif //NITRO_OS_PRINTF_H_ diff --git a/arm9/lib/include/OS_system.h b/arm9/lib/include/OS_system.h index 88137c3b..794e16d2 100644 --- a/arm9/lib/include/OS_system.h +++ b/arm9/lib/include/OS_system.h @@ -7,7 +7,6 @@ #include "function_target.h" #include "consts.h" -#include "function_target.h" typedef enum { OS_PROCMODE_USER=16, @@ -36,8 +35,5 @@ OSIntrMode OS_GetCpsrIrq(); OSProcMode OS_GetProcMode(); void OS_SpinWait(); void OS_WaitVBlankIntr(); -void OS_Terminate(void); -#define OS_TPanic(...) OS_Terminate() -#define OS_TWarning(...) ((void)0) #endif //POKEDIAMOND_OS_SYSTEM_H diff --git a/arm9/lib/include/mmap_global.h b/arm9/lib/include/mmap_global.h deleted file mode 100644 index e657e46f..00000000 --- a/arm9/lib/include/mmap_global.h +++ /dev/null @@ -1,4 +0,0 @@ -#ifndef NITRO_MMAP_GLOBAL_H_ -#define NITRO_MMAP_GLOBAL_H_ - -#endif //NITRO_MMAP_GLOBAL_H_ diff --git a/arm9/lib/src/FS_archive.c b/arm9/lib/src/FS_archive.c index 44a4e451..5928c90b 100644 --- a/arm9/lib/src/FS_archive.c +++ b/arm9/lib/src/FS_archive.c @@ -4,11 +4,12 @@ #include "FSi_util.h" #include "MI_memory.h" #include "MI_byteAccess.h" +#include "OS_printf.h" FSArchive * arc_list = NULL; FSDirPos current_dir_pos; -u32 FSi_GetPackedName(const char * name, int name_len) +ARM_FUNC u32 FSi_GetPackedName(const char * name, int name_len) { u32 ret = 0; if (name_len <= FS_ARCHIVE_NAME_LEN_MAX) @@ -30,19 +31,19 @@ u32 FSi_GetPackedName(const char * name, int name_len) return ret; } -FSResult FSi_ReadMemCallback(struct FSArchive * p_arc, void * dest, u32 pos, u32 size) +ARM_FUNC FSResult FSi_ReadMemCallback(struct FSArchive * p_arc, void * dest, u32 pos, u32 size) { MI_CpuCopy8((const void *)FS_GetArchiveOffset(p_arc, pos), dest, size); return FS_RESULT_SUCCESS; } -FSResult FSi_WriteMemCallback(struct FSArchive * p_arc, const void * src, u32 pos, u32 size) +ARM_FUNC FSResult FSi_WriteMemCallback(struct FSArchive * p_arc, const void * src, u32 pos, u32 size) { MI_CpuCopy8(src, (void *)FS_GetArchiveOffset(p_arc, pos), size); return FS_RESULT_SUCCESS; } -FSResult FSi_ReadMemoryCore(FSArchive * p_arc, void * dest, u32 pos, u32 size) +ARM_FUNC FSResult FSi_ReadMemoryCore(FSArchive * p_arc, void * dest, u32 pos, u32 size) { MI_CpuCopy8((const void *)pos, dest, size); return FS_RESULT_SUCCESS; @@ -115,7 +116,7 @@ FSFile * FSi_NextCommand(FSArchive * p_arc) return NULL; } -void FSi_ExecuteAsyncCommand(FSFile * p_file) +ARM_FUNC void FSi_ExecuteAsyncCommand(FSFile * p_file) { FSArchive *const p_arc = p_file->arc; while (p_file) @@ -136,7 +137,7 @@ void FSi_ExecuteAsyncCommand(FSFile * p_file) } } -BOOL FSi_ExecuteSyncCommand(FSFile * p_file) +ARM_FUNC BOOL FSi_ExecuteSyncCommand(FSFile * p_file) { FSFile * p_target; FSResult ret = FSi_TranslateCommand(p_file, p_file->command); @@ -147,7 +148,7 @@ BOOL FSi_ExecuteSyncCommand(FSFile * p_file) return FS_IsSucceeded(p_file); } -BOOL FSi_SendCommand(FSFile * p_file, FSCommandType command) +ARM_FUNC BOOL FSi_SendCommand(FSFile * p_file, FSCommandType command) { FSArchive * p_arc = p_file->arc; const int bit = 1 << command; @@ -198,7 +199,7 @@ BOOL FSi_SendCommand(FSFile * p_file, FSCommandType command) return FSi_ExecuteSyncCommand(p_file); } -void FS_InitArchive(FSArchive * p_arc) +ARM_FUNC void FS_InitArchive(FSArchive * p_arc) { MI_CpuClear8(p_arc, sizeof(FSArchive)); p_arc->sync_q.head = p_arc->sync_q.tail = NULL; @@ -216,7 +217,7 @@ FSArchive * const FS_FindArchive(const char * name, int name_len) return p_arc; } -BOOL FS_RegisterArchiveName(FSArchive * p_arc, const char * name, int name_len) +ARM_FUNC BOOL FS_RegisterArchiveName(FSArchive * p_arc, const char * name, int name_len) { BOOL ret = FALSE; OSIntrMode bak_psr = OS_DisableInterrupts(); @@ -246,7 +247,7 @@ BOOL FS_RegisterArchiveName(FSArchive * p_arc, const char * name, int name_len) return ret; } -void FS_ReleaseArchiveName(FSArchive * p_arc) +ARM_FUNC void FS_ReleaseArchiveName(FSArchive * p_arc) { if (p_arc->name.pack) { @@ -269,7 +270,7 @@ void FS_ReleaseArchiveName(FSArchive * p_arc) } } -BOOL FS_LoadArchive(FSArchive * p_arc, u32 base, u32 fat, u32 fat_size, u32 fnt, u32 fnt_size, FS_ARCHIVE_READ_FUNC read_func, FS_ARCHIVE_WRITE_FUNC write_func) +ARM_FUNC BOOL FS_LoadArchive(FSArchive * p_arc, u32 base, u32 fat, u32 fat_size, u32 fnt, u32 fnt_size, FS_ARCHIVE_READ_FUNC read_func, FS_ARCHIVE_WRITE_FUNC write_func) { p_arc->base = base; p_arc->fat_size = fat_size; @@ -284,7 +285,7 @@ BOOL FS_LoadArchive(FSArchive * p_arc, u32 base, u32 fat, u32 fat_size, u32 fnt, return TRUE; } -BOOL FS_UnloadArchive(FSArchive * p_arc) +ARM_FUNC BOOL FS_UnloadArchive(FSArchive * p_arc) { OSIntrMode bak_psr = OS_DisableInterrupts(); if (FS_IsArchiveLoaded(p_arc)) @@ -318,7 +319,7 @@ BOOL FS_UnloadArchive(FSArchive * p_arc) return TRUE; } -u32 FS_LoadArchiveTables(FSArchive *p_arc, void *p_mem, u32 max_size) +ARM_FUNC u32 FS_LoadArchiveTables(FSArchive *p_arc, void *p_mem, u32 max_size) { u32 total_size = ALIGN_BYTE(p_arc->fat_size + p_arc->fnt_size + 32, 32); if (total_size <= max_size) @@ -373,7 +374,7 @@ void * FS_UnloadArchiveTables(FSArchive * p_arc) return ret; } -BOOL FS_SuspendArchive(FSArchive * p_arc) +ARM_FUNC BOOL FS_SuspendArchive(FSArchive * p_arc) { OSIntrMode bak_psr = OS_DisableInterrupts(); const BOOL bak_stat = !FS_IsArchiveSuspended(p_arc); @@ -395,7 +396,7 @@ BOOL FS_SuspendArchive(FSArchive * p_arc) return bak_stat; } -BOOL FS_ResumeArchive(FSArchive * p_arc) +ARM_FUNC BOOL FS_ResumeArchive(FSArchive * p_arc) { FSFile * p_target = NULL; OSIntrMode bak_psr = OS_DisableInterrupts(); @@ -411,7 +412,7 @@ BOOL FS_ResumeArchive(FSArchive * p_arc) return bak_stat; } -void FS_SetArchiveProc(struct FSArchive * p_arc, FS_ARCHIVE_PROC_FUNC proc, u32 flags) +ARM_FUNC void FS_SetArchiveProc(struct FSArchive * p_arc, FS_ARCHIVE_PROC_FUNC proc, u32 flags) { if (!flags) proc = NULL; @@ -421,7 +422,7 @@ void FS_SetArchiveProc(struct FSArchive * p_arc, FS_ARCHIVE_PROC_FUNC proc, u32 p_arc->proc_flag = flags; } -void FS_NotifyArchiveAsyncEnd(FSArchive *p_arc, FSResult ret) +ARM_FUNC void FS_NotifyArchiveAsyncEnd(FSArchive *p_arc, FSResult ret) { if (FSi_IsArchiveAsync(p_arc)) { diff --git a/arm9/lib/src/FS_command.c b/arm9/lib/src/FS_command.c index bc7839d8..818a65ea 100644 --- a/arm9/lib/src/FS_command.c +++ b/arm9/lib/src/FS_command.c @@ -3,7 +3,7 @@ #include "FSi_util.h" #include "FS_command.h" -void FSi_ReleaseCommand(FSFile * p_file, FSResult ret) +ARM_FUNC void FSi_ReleaseCommand(FSFile * p_file, FSResult ret) { OSIntrMode bak_psr = OS_DisableInterrupts(); FSi_CutFromList(p_file); @@ -13,7 +13,7 @@ void FSi_ReleaseCommand(FSFile * p_file, FSResult ret) OS_RestoreInterrupts(bak_psr); } -FSResult FSi_TranslateCommand(FSFile *p_file, FSCommandType command) +ARM_FUNC FSResult FSi_TranslateCommand(FSFile *p_file, FSCommandType command) { FSResult ret; diff --git a/arm9/lib/src/FS_command_default.c b/arm9/lib/src/FS_command_default.c index 85287fa9..002e1d53 100644 --- a/arm9/lib/src/FS_command_default.c +++ b/arm9/lib/src/FS_command_default.c @@ -13,15 +13,15 @@ typedef struct } FSiSyncReadParam; -FSResult FSi_ReadFileCommand(FSFile * p_file); -FSResult FSi_WriteFileCommand(FSFile * p_file); -FSResult FSi_SeekDirCommand(FSFile * p_file); -FSResult FSi_ReadDirCommand(FSFile * p_file); -FSResult FSi_FindPathCommand(FSFile * p_file); -FSResult FSi_GetPathCommand(FSFile * p_file); -FSResult FSi_OpenFileFastCommand(FSFile * p_file); -FSResult FSi_OpenFileDirectCommand(FSFile * p_file); -FSResult FSi_CloseFileCommand(FSFile * p_file); +ARM_FUNC FSResult FSi_ReadFileCommand(FSFile * p_file); +ARM_FUNC FSResult FSi_WriteFileCommand(FSFile * p_file); +ARM_FUNC FSResult FSi_SeekDirCommand(FSFile * p_file); +ARM_FUNC FSResult FSi_ReadDirCommand(FSFile * p_file); +ARM_FUNC FSResult FSi_FindPathCommand(FSFile * p_file); +ARM_FUNC FSResult FSi_GetPathCommand(FSFile * p_file); +ARM_FUNC FSResult FSi_OpenFileFastCommand(FSFile * p_file); +ARM_FUNC FSResult FSi_OpenFileDirectCommand(FSFile * p_file); +ARM_FUNC FSResult FSi_CloseFileCommand(FSFile * p_file); FSResult (*const fsi_default_command[])(FSFile *) = { [FS_COMMAND_READFILE] = FSi_ReadFileCommand, @@ -36,7 +36,7 @@ FSResult (*const fsi_default_command[])(FSFile *) = { }; // Case-insensitive string comparison -u32 FSi_StrNICmp(const char * str1, const char * str2, u32 len) +ARM_FUNC u32 FSi_StrNICmp(const char * str1, const char * str2, u32 len) { int i; for (i = 0; i < len; i++) @@ -53,7 +53,7 @@ u32 FSi_StrNICmp(const char * str1, const char * str2, u32 len) return 0; } -FSResult FSi_ReadTable(FSiSyncReadParam * p, void * dst, u32 len) +ARM_FUNC FSResult FSi_ReadTable(FSiSyncReadParam * p, void * dst, u32 len) { FSResult ret; FSArchive * const p_arc = p->arc; @@ -78,7 +78,7 @@ FSResult FSi_ReadTable(FSiSyncReadParam * p, void * dst, u32 len) return ret; } -FSResult FSi_SeekDirDirect(FSFile * p_dir, u32 id) +ARM_FUNC FSResult FSi_SeekDirDirect(FSFile * p_dir, u32 id) { p_dir->stat |= FS_FILE_STATUS_SYNC; p_dir->arg.seekdir.pos.arc = p_dir->arc; @@ -89,7 +89,7 @@ FSResult FSi_SeekDirDirect(FSFile * p_dir, u32 id) } // The actual commands -FSResult FSi_ReadFileCommand(FSFile * p_file) +ARM_FUNC FSResult FSi_ReadFileCommand(FSFile * p_file) { FSArchive *const p_arc = p_file->arc; const u32 pos = p_file->prop.file.pos; @@ -99,7 +99,7 @@ FSResult FSi_ReadFileCommand(FSFile * p_file) return (*p_arc->read_func)(p_arc, dst, pos, len); } -FSResult FSi_WriteFileCommand(FSFile * p_file) +ARM_FUNC FSResult FSi_WriteFileCommand(FSFile * p_file) { FSArchive *const p_arc = p_file->arc; const u32 pos = p_file->prop.file.pos; @@ -109,7 +109,7 @@ FSResult FSi_WriteFileCommand(FSFile * p_file) return (*p_arc->write_func)(p_arc, src, pos, len); } -FSResult FSi_SeekDirCommand(FSFile * p_dir) +ARM_FUNC FSResult FSi_SeekDirCommand(FSFile * p_dir) { FSResult ret; FSArchive *const p_arc = p_dir->arc; @@ -133,7 +133,7 @@ FSResult FSi_SeekDirCommand(FSFile * p_dir) return ret; } -FSResult FSi_ReadDirCommand(FSFile *p_dir) +ARM_FUNC FSResult FSi_ReadDirCommand(FSFile *p_dir) { FSDirEntry *p_entry = p_dir->arg.readdir.p_entry; FSResult ret; @@ -187,7 +187,7 @@ FSResult FSi_ReadDirCommand(FSFile *p_dir) return ret; } -FSResult FSi_FindPathCommand(FSFile *p_dir) +ARM_FUNC FSResult FSi_FindPathCommand(FSFile *p_dir) { const char *path = p_dir->arg.findpath.path; const BOOL is_dir = p_dir->arg.findpath.find_directory; @@ -262,7 +262,7 @@ FSResult FSi_FindPathCommand(FSFile *p_dir) return FS_RESULT_SUCCESS; } -FSResult FSi_GetPathCommand(FSFile *p_file) +ARM_FUNC FSResult FSi_GetPathCommand(FSFile *p_file) { FSArchive *const p_arc = p_file->arc; @@ -425,7 +425,7 @@ FSResult FSi_GetPathCommand(FSFile *p_file) return FS_RESULT_SUCCESS; } -FSResult FSi_OpenFileFastCommand(FSFile * p_file) +ARM_FUNC FSResult FSi_OpenFileFastCommand(FSFile * p_file) { FSArchive *const p_arc = p_file->arc; const FSFileID *p_id = &p_file->arg.openfilefast.id; @@ -453,7 +453,7 @@ FSResult FSi_OpenFileFastCommand(FSFile * p_file) } } -FSResult FSi_OpenFileDirectCommand(FSFile * p_file) +ARM_FUNC FSResult FSi_OpenFileDirectCommand(FSFile * p_file) { p_file->prop.file.top = p_file->arg.openfiledirect.top; p_file->prop.file.pos = p_file->arg.openfiledirect.top; @@ -462,7 +462,7 @@ FSResult FSi_OpenFileDirectCommand(FSFile * p_file) return FS_RESULT_SUCCESS; } -FSResult FSi_CloseFileCommand(FSFile * p_file) +ARM_FUNC FSResult FSi_CloseFileCommand(FSFile * p_file) { return FS_RESULT_SUCCESS; } diff --git a/arm9/lib/src/FS_file.c b/arm9/lib/src/FS_file.c index 32c07187..5a540885 100644 --- a/arm9/lib/src/FS_file.c +++ b/arm9/lib/src/FS_file.c @@ -4,10 +4,10 @@ #include "FS_file.h" #include "FSi_util.h" -extern FSDirPos current_dir_pos; +ARM_FUNC extern FSDirPos current_dir_pos; BOOL is_init = FALSE; -void FS_Init(u32 default_dma_no) +ARM_FUNC void FS_Init(u32 default_dma_no) { if (!is_init) { @@ -16,12 +16,12 @@ void FS_Init(u32 default_dma_no) } } -BOOL FS_IsAvailable(void) +ARM_FUNC BOOL FS_IsAvailable(void) { return is_init; } -void FS_InitFile(FSFile * p_file) +ARM_FUNC void FS_InitFile(FSFile * p_file) { p_file->link.next = p_file->link.prev = NULL; OS_InitThreadQueue(p_file->queue); @@ -88,34 +88,32 @@ static BOOL FSi_FindPath(FSFile * p_dir, const char * path, FSFileID * p_file_id return FSi_SendCommand(p_dir, FS_COMMAND_FINDPATH); } -int FSi_ReadFileCore(FSFile * p_file, void * dst, s32 len, BOOL async) +ARM_FUNC int FSi_ReadFileCore(FSFile * p_file, void * dst, s32 len, BOOL async) { + const s32 pos = p_file->prop.file.pos; + const s32 rest = p_file->prop.file.bottom - pos; + const u32 org = len; + if (len > rest) + len = rest; + if (len < 0) + len = 0; + p_file->arg.readfile.dst = dst; + p_file->arg.readfile.len_org = org; + p_file->arg.readfile.len = len; + if (!async) + p_file->stat |= FS_FILE_STATUS_SYNC; + FSi_SendCommand(p_file, FS_COMMAND_READFILE); + if (!async) { - const s32 pos = (s32)p_file->prop.file.pos; - const s32 rest = (s32)p_file->prop.file.bottom - pos; - const u32 org = (u32)len; - if (len > rest) - len = rest; - if (len < 0) - len = 0; - p_file->arg.readfile.dst = dst; - p_file->arg.readfile.len_org = org; - p_file->arg.readfile.len = (u32)(len); - if (!async) - p_file->stat |= FS_FILE_STATUS_SYNC; - (void)FSi_SendCommand(p_file, FS_COMMAND_READFILE); - if (!async) - { - if (FS_WaitAsync(p_file)) - len = (s32)p_file->prop.file.pos - pos; - else - len = -1; - } + if (FS_WaitAsync(p_file)) + len = p_file->prop.file.pos - pos; + else + len = -1; } return len; } -BOOL FS_ConvertPathToFileID(FSFileID * p_file_id, const char * path) +ARM_FUNC BOOL FS_ConvertPathToFileID(FSFileID * p_file_id, const char * path) { FSFile dir; FS_InitFile(&dir); @@ -124,7 +122,7 @@ BOOL FS_ConvertPathToFileID(FSFileID * p_file_id, const char * path) return TRUE; } -BOOL FS_OpenFileDirect(FSFile * p_file, FSArchive * p_arc, u32 image_top, u32 image_bottom, u32 file_index) +ARM_FUNC BOOL FS_OpenFileDirect(FSFile * p_file, FSArchive * p_arc, u32 image_top, u32 image_bottom, u32 file_index) { p_file->arc = p_arc; p_file->arg.openfiledirect.index = file_index; @@ -137,7 +135,7 @@ BOOL FS_OpenFileDirect(FSFile * p_file, FSArchive * p_arc, u32 image_top, u32 im return TRUE; } -BOOL FS_OpenFileFast(FSFile * p_file, FSFileID file_id) +ARM_FUNC BOOL FS_OpenFileFast(FSFile * p_file, FSFileID file_id) { if (!file_id.arc) return FALSE; @@ -150,13 +148,13 @@ BOOL FS_OpenFileFast(FSFile * p_file, FSFileID file_id) return TRUE; } -BOOL FS_OpenFile(FSFile * p_file, const char * path) +ARM_FUNC BOOL FS_OpenFile(FSFile * p_file, const char * path) { FSFileID file_id; return FS_ConvertPathToFileID(&file_id, path) && FS_OpenFileFast(p_file, file_id); } -BOOL FS_CloseFile(FSFile * p_file) +ARM_FUNC BOOL FS_CloseFile(FSFile * p_file) { if (!FSi_SendCommand(p_file, FS_COMMAND_CLOSEFILE)) return FALSE; @@ -166,7 +164,7 @@ BOOL FS_CloseFile(FSFile * p_file) return TRUE; } -BOOL FS_WaitAsync(FSFile * p_file) +ARM_FUNC BOOL FS_WaitAsync(FSFile * p_file) { BOOL is_owner = FALSE; OSIntrMode bak_par = OS_DisableInterrupts(); @@ -198,17 +196,17 @@ BOOL FS_WaitAsync(FSFile * p_file) return FS_IsSucceeded(p_file); } -int FS_ReadFileAsync(FSFile * p_file, void * dst, s32 len) +ARM_FUNC int FS_ReadFileAsync(FSFile * p_file, void * dst, s32 len) { return FSi_ReadFileCore(p_file, dst, len, TRUE); } -int FS_ReadFile(FSFile * p_file, void * dst, s32 len) +ARM_FUNC int FS_ReadFile(FSFile * p_file, void * dst, s32 len) { return FSi_ReadFileCore(p_file, dst, len, FALSE); } -BOOL FS_SeekFile(FSFile * p_file, int offset, FSSeekFileMode origin) +ARM_FUNC BOOL FS_SeekFile(FSFile * p_file, int offset, FSSeekFileMode origin) { switch (origin) { @@ -232,7 +230,7 @@ BOOL FS_SeekFile(FSFile * p_file, int offset, FSSeekFileMode origin) return TRUE; } -BOOL FS_ChangeDir(const char * path) +ARM_FUNC BOOL FS_ChangeDir(const char * path) { FSDirPos pos; FSFile dir; diff --git a/arm9/lib/src/FS_overlay.c b/arm9/lib/src/FS_overlay.c index d2a4677d..79a3b43e 100644 --- a/arm9/lib/src/FS_overlay.c +++ b/arm9/lib/src/FS_overlay.c @@ -3,6 +3,7 @@ #include "DGT_dgt.h" #include "OS_cache.h" #include "OS_system.h" +#include "OS_printf.h" #include "MI_memory.h" #include "MI_uncompress.h" #include "FS_rom.h" @@ -14,7 +15,7 @@ #define FS_OVERLAY_FLAG_AUTH 0x0002 #define FS_OVERLAY_DIGEST_SIZE DGT_HASH2_DIGEST_SIZE -u32 FSi_GetOverlayBinarySize(FSOverlayInfo * p_ovi) +ARM_FUNC u32 FSi_GetOverlayBinarySize(FSOverlayInfo * p_ovi) { u32 size = (p_ovi->header.flag & FS_OVERLAY_FLAG_COMP) ? p_ovi->header.compressed @@ -22,7 +23,7 @@ u32 FSi_GetOverlayBinarySize(FSOverlayInfo * p_ovi) return size; } -void FS_ClearOverlayImage(FSOverlayInfo * p_ovi) +ARM_FUNC void FS_ClearOverlayImage(FSOverlayInfo * p_ovi) { u8 * const im_start = FS_GetOverlayAddress(p_ovi); u32 const ram_size = FS_GetOverlayImageSize(p_ovi); @@ -33,7 +34,7 @@ void FS_ClearOverlayImage(FSOverlayInfo * p_ovi) MI_CpuFill8(im_start + ram_size, 0, total_size - ram_size); } -FSFileID FS_GetOverlayFileID(FSOverlayInfo * p_ovi) +ARM_FUNC FSFileID FS_GetOverlayFileID(FSOverlayInfo * p_ovi) { FSFileID ret; ret.arc = &fsi_arc_rom; @@ -41,7 +42,7 @@ FSFileID FS_GetOverlayFileID(FSOverlayInfo * p_ovi) return ret; } -BOOL FSi_LoadOverlayInfoCore(FSOverlayInfo * p_ovi, MIProcessor target, FSOverlayID id, FSArchive * arc, u32 offset_arm9, u32 len_arm9, u32 offset_arm7, u32 len_arm7) +ARM_FUNC BOOL FSi_LoadOverlayInfoCore(FSOverlayInfo * p_ovi, MIProcessor target, FSOverlayID id, FSArchive * arc, u32 offset_arm9, u32 len_arm9, u32 offset_arm7, u32 len_arm7) { CARDRomRegion pr[1]; u32 pos; @@ -79,7 +80,7 @@ BOOL FSi_LoadOverlayInfoCore(FSOverlayInfo * p_ovi, MIProcessor target, FSOverla return TRUE; } -BOOL FS_LoadOverlayInfo(FSOverlayInfo * p_ovi, MIProcessor target, FSOverlayID id) +ARM_FUNC BOOL FS_LoadOverlayInfo(FSOverlayInfo * p_ovi, MIProcessor target, FSOverlayID id) { CARDRomRegion * const pr = (target == MI_PROCESSOR_ARM9) ? &fsi_ovt9 : &fsi_ovt7; if (pr->offset) @@ -106,7 +107,7 @@ BOOL FS_LoadOverlayInfo(FSOverlayInfo * p_ovi, MIProcessor target, FSOverlayID i } } -BOOL FS_LoadOverlayImageAsync(FSOverlayInfo * p_ovi, FSFile * p_file) +ARM_FUNC BOOL FS_LoadOverlayImageAsync(FSOverlayInfo * p_ovi, FSFile * p_file) { FS_InitFile(p_file); if (!FS_OpenFileFast(p_file, FS_GetOverlayFileID(p_ovi))) @@ -124,7 +125,7 @@ BOOL FS_LoadOverlayImageAsync(FSOverlayInfo * p_ovi, FSFile * p_file) } } -BOOL FS_LoadOverlayImage(FSOverlayInfo * p_ovi) +ARM_FUNC BOOL FS_LoadOverlayImage(FSOverlayInfo * p_ovi) { FSFile file[1]; FS_InitFile(file); @@ -169,7 +170,7 @@ static const u8 fsi_def_digest_key[64] = { static const void *fsi_digest_key_ptr = fsi_def_digest_key; static int fsi_digest_key_len = sizeof(fsi_def_digest_key); -BOOL FSi_CompareDigest(const u8 *spec_digest, void *src, int len) +ARM_FUNC BOOL FSi_CompareDigest(const u8 *spec_digest, void *src, int len) { int i; u8 digest[FS_OVERLAY_DIGEST_SIZE]; @@ -189,7 +190,7 @@ BOOL FSi_CompareDigest(const u8 *spec_digest, void *src, int len) extern u8 SDK_OVERLAY_DIGEST[]; extern u8 SDK_OVERLAY_DIGEST_END[]; -void FS_StartOverlay(FSOverlayInfo * p_ovi) +ARM_FUNC void FS_StartOverlay(FSOverlayInfo * p_ovi) { u32 rare_size = FSi_GetOverlayBinarySize(p_ovi); if (MB_IsMultiBootChild()) @@ -229,7 +230,7 @@ void FS_StartOverlay(FSOverlayInfo * p_ovi) } } -void FS_EndOverlay(FSOverlayInfo *p_ovi) +ARM_FUNC void FS_EndOverlay(FSOverlayInfo *p_ovi) { for (;;) { @@ -295,13 +296,13 @@ void FS_EndOverlay(FSOverlayInfo *p_ovi) } } -BOOL FS_UnloadOverlayImage(FSOverlayInfo * p_ovi) +ARM_FUNC BOOL FS_UnloadOverlayImage(FSOverlayInfo * p_ovi) { FS_EndOverlay(p_ovi); return TRUE; } -BOOL FS_LoadOverlay(MIProcessor target, FSOverlayID id) +ARM_FUNC BOOL FS_LoadOverlay(MIProcessor target, FSOverlayID id) { FSOverlayInfo ovi; if (!FS_LoadOverlayInfo(&ovi, target, id) || !FS_LoadOverlayImage(&ovi)) @@ -310,7 +311,7 @@ BOOL FS_LoadOverlay(MIProcessor target, FSOverlayID id) return TRUE; } -BOOL FS_UnloadOverlay(MIProcessor target, FSOverlayID id) +ARM_FUNC BOOL FS_UnloadOverlay(MIProcessor target, FSOverlayID id) { FSOverlayInfo ovi; if (!FS_LoadOverlayInfo(&ovi, target, id) || !FS_UnloadOverlayImage(&ovi)) diff --git a/arm9/lib/src/FS_rom.c b/arm9/lib/src/FS_rom.c index 44d31a4a..32f66c10 100644 --- a/arm9/lib/src/FS_rom.c +++ b/arm9/lib/src/FS_rom.c @@ -9,23 +9,23 @@ u32 fsi_default_dma_no; -void FSi_OnRomReadDone(void * p_arc) +ARM_FUNC void FSi_OnRomReadDone(void * p_arc) { FS_NotifyArchiveAsyncEnd(p_arc, CARD_IsPulledOut() ? FS_RESULT_ERROR : FS_RESULT_SUCCESS); } -FSResult FSi_ReadRomCallback(FSArchive * p_arc, void * dst, u32 src, u32 len) +ARM_FUNC FSResult FSi_ReadRomCallback(FSArchive * p_arc, void * dst, u32 src, u32 len) { CARD_ReadRomAsync(fsi_default_dma_no, (const void *)src, dst, len, FSi_OnRomReadDone, p_arc); return FS_RESULT_PROC_ASYNC; } -FSResult FSi_WriteDummyCallback(FSArchive * p_arc, const void *src, u32 dst, u32 len) +ARM_FUNC FSResult FSi_WriteDummyCallback(FSArchive * p_arc, const void *src, u32 dst, u32 len) { return FS_RESULT_FAILURE; } -FSResult FSi_RomArchiveProc(FSFile * p_arc, FSCommandType cmd) +ARM_FUNC FSResult FSi_RomArchiveProc(FSFile * p_arc, FSCommandType cmd) { switch (cmd) { @@ -42,17 +42,17 @@ FSResult FSi_RomArchiveProc(FSFile * p_arc, FSCommandType cmd) } } -FSResult FSi_ReadDummyCallback(FSArchive *p_arc, void *dst, u32 src, u32 len) +ARM_FUNC FSResult FSi_ReadDummyCallback(FSArchive *p_arc, void *dst, u32 src, u32 len) { return FS_RESULT_FAILURE; } -FSResult FSi_EmptyArchiveProc(FSFile *p_file, FSCommandType cmd) +ARM_FUNC FSResult FSi_EmptyArchiveProc(FSFile *p_file, FSCommandType cmd) { return FS_RESULT_UNSUPPORTED; } -void FSi_InitRom(u32 default_dma_no) +ARM_FUNC void FSi_InitRom(u32 default_dma_no) { fsi_default_dma_no = default_dma_no; fsi_card_lock_id = OS_GetLockID(); @@ -99,7 +99,7 @@ void FSi_InitRom(u32 default_dma_no) } } -u32 FS_SetDefaultDMA(u32 dma_no) +ARM_FUNC u32 FS_SetDefaultDMA(u32 dma_no) { OSIntrMode bak_psr = OS_DisableInterrupts(); u32 bak_dma_no = fsi_default_dma_no; @@ -111,7 +111,7 @@ u32 FS_SetDefaultDMA(u32 dma_no) return bak_dma_no; } -u32 FS_TryLoadTable(void * p_mem, u32 size) +ARM_FUNC u32 FS_TryLoadTable(void * p_mem, u32 size) { return FS_LoadArchiveTables(&fsi_arc_rom, p_mem, size); } -- cgit v1.2.3 From 96d1131eead640f4716e4864699ded6ef64701e3 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 8 May 2020 19:45:39 -0400 Subject: Fix errant ARM_FUNC --- arm9/lib/src/FS_file.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'arm9/lib') diff --git a/arm9/lib/src/FS_file.c b/arm9/lib/src/FS_file.c index 5a540885..8bca5c8e 100644 --- a/arm9/lib/src/FS_file.c +++ b/arm9/lib/src/FS_file.c @@ -4,7 +4,7 @@ #include "FS_file.h" #include "FSi_util.h" -ARM_FUNC extern FSDirPos current_dir_pos; +extern FSDirPos current_dir_pos; BOOL is_init = FALSE; ARM_FUNC void FS_Init(u32 default_dma_no) -- cgit v1.2.3 From e660f7a7f749242dc73851d47e806b96783bc47d Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Sat, 9 May 2020 10:20:42 -0400 Subject: Remaining ARM_FUNCs --- arm9/lib/src/FS_archive.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'arm9/lib') diff --git a/arm9/lib/src/FS_archive.c b/arm9/lib/src/FS_archive.c index 5928c90b..6c0f01f1 100644 --- a/arm9/lib/src/FS_archive.c +++ b/arm9/lib/src/FS_archive.c @@ -49,7 +49,7 @@ ARM_FUNC FSResult FSi_ReadMemoryCore(FSArchive * p_arc, void * dest, u32 pos, u3 return FS_RESULT_SUCCESS; } -FSFile * FSi_NextCommand(FSArchive * p_arc) +ARM_FUNC FSFile * FSi_NextCommand(FSArchive * p_arc) { OSIntrMode bak_psr = OS_DisableInterrupts(); if (FSi_IsArchiveCanceling(p_arc)) @@ -206,7 +206,7 @@ ARM_FUNC void FS_InitArchive(FSArchive * p_arc) p_arc->stat_q.head = p_arc->stat_q.tail = NULL; } -FSArchive * const FS_FindArchive(const char * name, int name_len) +ARM_FUNC FSArchive * const FS_FindArchive(const char * name, int name_len) { u32 pack = FSi_GetPackedName(name, name_len); OSIntrMode bak_psr = OS_DisableInterrupts(); @@ -353,7 +353,7 @@ ARM_FUNC u32 FS_LoadArchiveTables(FSArchive *p_arc, void *p_mem, u32 max_size) return total_size; } -void * FS_UnloadArchiveTables(FSArchive * p_arc) +ARM_FUNC void * FS_UnloadArchiveTables(FSArchive * p_arc) { void *ret = NULL; if (FS_IsArchiveLoaded(p_arc)) -- cgit v1.2.3