info.mediaType = MEDIATYPE_NAND;
res = svcGetProcessId(&pid, 0xFFFF8001);
if (R_SUCCEEDED(res)) {
- res = FSREG_Register(pid, 0xFFFF000000000000LL, &info, (u8*)storage);
+ res = FSREG_Register(pid, 0xFFFF000000000000LL, &info, (u8 *)storage);
}
return res;
}
Result
FSLDR_InitializeWithSdkVersion(Handle session, u32 version)
{
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x861, 1, 2); // 0x8610042
cmdbuf[1] = version;
Result
FSLDR_SetPriority(u32 priority)
{
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x862, 1, 0); // 0x8620040
cmdbuf[1] = priority;
}
Result
-FSLDR_OpenFileDirectly(Handle* out, FS_ArchiveID archiveId, FS_Path archivePath,
- FS_Path filePath, u32 openFlags, u32 attributes)
+FSLDR_OpenFileDirectly(Handle *out, FS_ArchiveID archiveId, FS_Path archivePath, FS_Path filePath, u32 openFlags, u32 attributes)
{
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x803, 8, 4); // 0x8030204
cmdbuf[1] = 0;
void fsldrExit(void);
Result FSLDR_InitializeWithSdkVersion(Handle session, u32 version);
Result FSLDR_SetPriority(u32 priority);
-Result FSLDR_OpenFileDirectly(Handle* out, FS_ArchiveID archiveId,
- FS_Path archivePath, FS_Path filePath,
- u32 openFlags, u32 attributes);
+Result FSLDR_OpenFileDirectly(Handle *out, FS_ArchiveID archiveId, FS_Path archivePath, FS_Path filePath, u32 openFlags, u32 attributes);
#endif
Result
FSREG_CheckHostLoadId(u64 prog_handle)
{
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x406, 2, 0); // 0x4060080
cmdbuf[1] = (u32)(prog_handle);
}
Result
-FSREG_LoadProgram(u64* prog_handle, FS_ProgramInfo* title)
+FSREG_LoadProgram(u64 *prog_handle, FS_ProgramInfo *title)
{
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x404, 4, 0); // 0x4040100
memcpy(&cmdbuf[1], &title->programId, sizeof(u64));
- *(u8*)&cmdbuf[3] = title->mediaType;
- memcpy(((u8*)&cmdbuf[3]) + 1, &title->padding, 7);
+ *(u8 *)&cmdbuf[3] = title->mediaType;
+ memcpy(((u8 *)&cmdbuf[3]) + 1, &title->padding, 7);
Result ret = 0;
if (R_FAILED(ret = svcSendSyncRequest(fsregHandle)))
return ret;
- *prog_handle = *(u64*)&cmdbuf[2];
+ *prog_handle = *(u64 *)&cmdbuf[2];
return cmdbuf[1];
}
Result
-FSREG_GetProgramInfo(exheader_header* exheader, u32 entry_count,
- u64 prog_handle)
+FSREG_GetProgramInfo(exheader_header *exheader, u32 entry_count, u64 prog_handle)
{
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x403, 3, 0); // 0x40300C0
cmdbuf[1] = entry_count;
- *(u64*)&cmdbuf[2] = prog_handle;
+ *(u64 *)&cmdbuf[2] = prog_handle;
cmdbuf[64] = ((entry_count << 10) << 14) | 2;
cmdbuf[65] = (u32)exheader;
Result
FSREG_UnloadProgram(u64 prog_handle)
{
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x405, 2, 0); // 0x4050080
cmdbuf[1] = (u32)(prog_handle);
Result
FSREG_Unregister(u32 pid)
{
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x402, 1, 0); // 0x4020040
cmdbuf[1] = pid;
}
Result
-FSREG_Register(u32 pid, u64 prog_handle, FS_ProgramInfo* info,
- void* storageinfo)
+FSREG_Register(u32 pid, u64 prog_handle, FS_ProgramInfo *info, void *storageinfo)
{
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x401, 0xf, 0); // 0x40103C0
cmdbuf[1] = pid;
- *(u64*)&cmdbuf[2] = prog_handle;
+ *(u64 *)&cmdbuf[2] = prog_handle;
memcpy(&cmdbuf[4], &info->programId, sizeof(u64));
- *(u8*)&cmdbuf[6] = info->mediaType;
- memcpy(((u8*)&cmdbuf[6]) + 1, &info->padding, 7);
- memcpy((u8*)&cmdbuf[8], storageinfo, 32);
+ *(u8 *)&cmdbuf[6] = info->mediaType;
+ memcpy(((u8 *)&cmdbuf[6]) + 1, &info->padding, 7);
+ memcpy((u8 *)&cmdbuf[8], storageinfo, 32);
Result ret = 0;
if (R_FAILED(ret = svcSendSyncRequest(fsregHandle)))
Result fsregInit(void);
void fsregExit(void);
Result FSREG_CheckHostLoadId(u64 prog_handle);
-Result FSREG_LoadProgram(u64* prog_handle, FS_ProgramInfo* title);
-Result FSREG_GetProgramInfo(exheader_header* exheader, u32 entry_count,
- u64 prog_handle);
+Result FSREG_LoadProgram(u64 *prog_handle, FS_ProgramInfo *title);
+Result FSREG_GetProgramInfo(exheader_header *exheader, u32 entry_count, u64 prog_handle);
Result FSREG_UnloadProgram(u64 prog_handle);
Result FSREG_Unregister(u32 pid);
-Result FSREG_Register(u32 pid, u64 prog_handle, FS_ProgramInfo* info,
- void* storageinfo);
+Result FSREG_Register(u32 pid, u64 prog_handle, FS_ProgramInfo *info, void *storageinfo);
#endif
#define __INTERNAL_H
// These are libc builtins, so there's no need to carry an implementation here.
-void* memcpy(void* dest, const void* src, size_t len);
-size_t strlen(const char* string);
+void *memcpy(void *dest, const void *src, size_t len);
+size_t strlen(const char *string);
#endif
#ifndef __INTERP_H
#define __INTERP_H
-int execb(uint64_t tid, uint8_t* search_mem, uint32_t search_len);
+int execb(uint64_t tid, uint8_t *search_mem, uint32_t search_len);
#endif
#define MAX_SESSIONS 1
-const char CODE_PATH[] = { 0x01, 0x00, 0x00, 0x00, 0x2E, 0x63,
- 0x6F, 0x64, 0x65, 0x00, 0x00, 0x00 };
+const char CODE_PATH[] = { 0x01, 0x00, 0x00, 0x00, 0x2E, 0x63, 0x6F, 0x64, 0x65, 0x00, 0x00, 0x00 };
typedef struct
{
static char g_ret_buf[1024];
static Result
-allocate_shared_mem(prog_addrs_t* shared, prog_addrs_t* vaddr, int flags)
+allocate_shared_mem(prog_addrs_t *shared, prog_addrs_t *vaddr, int flags)
{
// Somehow, we need to allow reallocating.
// address to kill ASLR (I believe.)
shared->ro_addr = shared->text_addr + (shared->text_size << 12);
shared->data_addr = shared->ro_addr + (shared->ro_size << 12);
- return svcControlMemory(
- &dummy, shared->text_addr, 0, shared->total_size << 12,
- (flags & 0xF00) | MEMOP_ALLOC, MEMPERM_READ | MEMPERM_WRITE);
+ return svcControlMemory(&dummy, shared->text_addr, 0, shared->total_size << 12, (flags & 0xF00) | MEMOP_ALLOC, MEMPERM_READ | MEMPERM_WRITE);
}
static Result
-load_code(u64 progid, prog_addrs_t* shared, prog_addrs_t* original,
- u64 prog_handle, int is_compressed)
+load_code(u64 progid, prog_addrs_t *shared, prog_addrs_t *original, u64 prog_handle, int is_compressed)
{
- Handle handle;
+ Handle handle;
FS_Path archivePath;
FS_Path path;
Result res;
path.data = CODE_PATH;
path.size = sizeof(CODE_PATH);
- if (R_FAILED(FSLDR_OpenFileDirectly(&handle, ARCHIVE_SAVEDATA_AND_CONTENT2, archivePath,
- path, FS_OPEN_READ, 0))) {
+ if (R_FAILED(FSLDR_OpenFileDirectly(&handle, ARCHIVE_SAVEDATA_AND_CONTENT2, archivePath, path, FS_OPEN_READ, 0))) {
svcBreak(USERBREAK_ASSERT);
}
}
// read code
- res = FSFILE_Read(handle, &total, 0, (void*)shared->text_addr, size);
+ res = FSFILE_Read(handle, &total, 0, (void *)shared->text_addr, size);
FSFILE_Close(handle); // done reading
if (R_FAILED(res)) {
svcBreak(USERBREAK_ASSERT);
// decompress in place
if (is_compressed) {
- lzss_decompress((u8*)shared->text_addr + size);
+ lzss_decompress((u8 *)shared->text_addr + size);
}
// Patch segments
- patch_text(progid, (u8*)shared->text_addr, shared->text_size << 12,
- original->text_size << 12);
- patch_data(progid, (u8*)shared->data_addr, shared->data_size << 12,
- original->data_size << 12);
- patch_ro(progid, (u8*)shared->ro_addr, shared->ro_size << 12,
- original->ro_size << 12);
+ patch_text(progid, (u8 *)shared->text_addr, shared->text_size << 12, original->text_size << 12);
+ patch_data(progid, (u8 *)shared->data_addr, shared->data_size << 12, original->data_size << 12);
+ patch_ro(progid, (u8 *)shared->ro_addr, shared->ro_size << 12, original->ro_size << 12);
return 0;
}
static Result
-loader_GetProgramInfo(exheader_header* exheader, u64 prog_handle)
+loader_GetProgramInfo(exheader_header *exheader, u64 prog_handle)
{
Result res;
}
}
-extern void KernelSetState(unsigned int, unsigned int, unsigned int,
- unsigned int);
+extern void KernelSetState(unsigned int, unsigned int, unsigned int, unsigned int);
static void
ConfigureNew3DSCPU(u8 mode)
}
static Result
-loader_LoadProcess(Handle* process, u64 prog_handle)
+loader_LoadProcess(Handle *process, u64 prog_handle)
{
Result res;
int count;
u64 progid;
u32 text_grow, data_grow, ro_grow;
- openLogger();
+ openLogger();
// make sure the cached info corrosponds to the current prog_handle
if (g_cached_prog_handle != prog_handle) {
// load code
progid = g_exheader.arm11systemlocalcaps.programid;
- logu64(progid);
- logstr(" validated params\n");
+ logu64(progid);
+ logstr(" validated params\n");
load_config(); // First order of business - we need the config file.
// sysmodule. It doesn't make sense.
}
- // TODO - clean up this shit below. Not only is it unoptimized but it reads like garbage.
+ // TODO - clean up this shit below. Not only is it unoptimized but it reads like garbage.
// What the addressing info would be if not for expansion. This is passed to
// patchCode.
- original_vaddr.text_size = (g_exheader.codesetinfo.text.codesize + 4095) >>
- 12; // (Text size + one page) >> page size
+ original_vaddr.text_size = (g_exheader.codesetinfo.text.codesize + 4095) >> 12; // (Text size + one page) >> page size
original_vaddr.ro_size = (g_exheader.codesetinfo.ro.codesize + 4095) >> 12;
- original_vaddr.data_size =
- (g_exheader.codesetinfo.data.codesize + 4095) >> 12;
- original_vaddr.total_size = original_vaddr.text_size +
- original_vaddr.ro_size +
- original_vaddr.data_size;
+ original_vaddr.data_size = (g_exheader.codesetinfo.data.codesize + 4095) >> 12;
+ original_vaddr.total_size = original_vaddr.text_size + original_vaddr.ro_size + original_vaddr.data_size;
// Allow changing code, ro, data sizes to allow adding code
text_grow = get_text_extend(progid, g_exheader.codesetinfo.text.codesize);
// Allocate process memory, growing as needed for extra patches
vaddr.text_addr = g_exheader.codesetinfo.text.address;
- vaddr.text_size =
- (g_exheader.codesetinfo.text.codesize + text_grow + 4095) >>
- 12; // (Text size + one page) >> page size
+ vaddr.text_size = (g_exheader.codesetinfo.text.codesize + text_grow + 4095) >> 12; // (Text size + one page) >> page size
vaddr.ro_addr = g_exheader.codesetinfo.ro.address;
vaddr.ro_size = (g_exheader.codesetinfo.ro.codesize + ro_grow + 4095) >> 12;
vaddr.data_addr = g_exheader.codesetinfo.data.address;
- vaddr.data_size =
- (g_exheader.codesetinfo.data.codesize + data_grow + 4095) >> 12;
- data_mem_size = (g_exheader.codesetinfo.data.codesize + text_grow +
- g_exheader.codesetinfo.bsssize + 4095) >>
- 12;
- vaddr.total_size = vaddr.text_size + vaddr.ro_size + vaddr.data_size +
- text_grow + ro_grow + data_grow;
+ vaddr.data_size = (g_exheader.codesetinfo.data.codesize + data_grow + 4095) >> 12;
+ data_mem_size = (g_exheader.codesetinfo.data.codesize + text_grow + g_exheader.codesetinfo.bsssize + 4095) >> 12;
+ vaddr.total_size = vaddr.text_size + vaddr.ro_size + vaddr.data_size + text_grow + ro_grow + data_grow;
if ((res = allocate_shared_mem(&shared_addr, &vaddr, flags)) < 0) {
return res;
}
- if ((res = load_code(progid, &shared_addr, &original_vaddr, prog_handle,
- g_exheader.codesetinfo.flags.flag & 1)) >= 0) {
+ if ((res = load_code(progid, &shared_addr, &original_vaddr, prog_handle, g_exheader.codesetinfo.flags.flag & 1)) >= 0) {
memcpy(&codesetinfo.name, g_exheader.codesetinfo.name, 8);
codesetinfo.program_id = progid;
codesetinfo.text_addr = vaddr.text_addr;
codesetinfo.rw_addr = vaddr.data_addr;
codesetinfo.rw_size = vaddr.data_size;
codesetinfo.rw_size_total = data_mem_size;
- res = svcCreateCodeSet(
- &codeset, &codesetinfo, (void*)shared_addr.text_addr,
- (void*)shared_addr.ro_addr, (void*)shared_addr.data_addr);
+ res = svcCreateCodeSet(&codeset, &codesetinfo, (void *)shared_addr.text_addr, (void *)shared_addr.ro_addr, (void *)shared_addr.data_addr);
if (res >= 0) {
- closeLogger();
+ closeLogger();
- res =
- svcCreateProcess(process, codeset,
- g_exheader.arm11kernelcaps.descriptors, count);
+ res = svcCreateProcess(process, codeset, g_exheader.arm11kernelcaps.descriptors, count);
svcCloseHandle(codeset);
if (res >= 0) {
return 0;
}
}
- svcControlMemory(&dummy, shared_addr.text_addr, 0,
- shared_addr.total_size << 12, MEMOP_FREE, 0);
+ svcControlMemory(&dummy, shared_addr.text_addr, 0, shared_addr.total_size << 12, MEMOP_FREE, 0);
return res;
}
static Result
-loader_RegisterProgram(u64* prog_handle, FS_ProgramInfo* title,
- FS_ProgramInfo* update)
+loader_RegisterProgram(u64 *prog_handle, FS_ProgramInfo *title, FS_ProgramInfo *update)
{
Result res;
u64 prog_id;
res = FSREG_CheckHostLoadId(*prog_handle);
// if ((res >= 0 && (unsigned)res >> 27) || (res < 0 &&
// ((unsigned)res >> 27)-32))
- if (R_FAILED(res) ||
- (R_SUCCEEDED(res) && R_LEVEL(res) != RL_SUCCESS)) {
+ if (R_FAILED(res) || (R_SUCCEEDED(res) && R_LEVEL(res) != RL_SUCCESS)) {
return 0;
}
}
}
}
- if ((title->mediaType != update->mediaType) ||
- (prog_id != update->programId)) {
+ if ((title->mediaType != update->mediaType) || (prog_id != update->programId)) {
svcBreak(USERBREAK_ASSERT);
}
res = FSREG_LoadProgram(prog_handle, title);
{
FS_ProgramInfo title;
FS_ProgramInfo update;
- u32* cmdbuf;
+ u32 *cmdbuf;
u16 cmdid;
int res;
Handle handle;
switch (cmdid) {
case 1: // LoadProcess
{
- res = loader_LoadProcess(&handle, *(u64*)&cmdbuf[1]);
+ res = loader_LoadProcess(&handle, *(u64 *)&cmdbuf[1]);
cmdbuf[0] = 0x10042;
cmdbuf[1] = res;
cmdbuf[2] = 16;
res = loader_RegisterProgram(&prog_handle, &title, &update);
cmdbuf[0] = 0x200C0;
cmdbuf[1] = res;
- *(u64*)&cmdbuf[2] = prog_handle;
+ *(u64 *)&cmdbuf[2] = prog_handle;
break;
}
case 3: // UnregisterProgram
g_cached_prog_handle = 0;
}
cmdbuf[0] = 0x30040;
- cmdbuf[1] = loader_UnregisterProgram(*(u64*)&cmdbuf[1]);
+ cmdbuf[1] = loader_UnregisterProgram(*(u64 *)&cmdbuf[1]);
break;
}
case 4: // GetProgramInfo
{
- prog_handle = *(u64*)&cmdbuf[1];
+ prog_handle = *(u64 *)&cmdbuf[1];
if (prog_handle != g_cached_prog_handle) {
res = loader_GetProgramInfo(&g_exheader, prog_handle);
if (res >= 0) {
}
static Result
-should_terminate(int* term_request)
+should_terminate(int *term_request)
{
u32 notid;
Result ret;
Result ret;
Handle handle;
Handle reply_target;
- Handle* srv_handle;
- Handle* notification_handle;
+ Handle *srv_handle;
+ Handle *notification_handle;
s32 index;
int i;
int term_request;
- u32* cmdbuf;
+ u32 *cmdbuf;
ret = 0;
cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = 0xFFFF0000;
}
- ret = svcReplyAndReceive(&index, g_handles, g_active_handles,
- reply_target);
+ ret = svcReplyAndReceive(&index, g_handles, g_active_handles, reply_target);
if (R_FAILED(ret)) {
// check if any handle has been closed
Handle log_file_hdl;
int logger_is_initd = 0;
-void openLogger() {
+void
+openLogger()
+{
Result r;
if (logger_is_initd)
return;
- r = fileOpen(&log_file_hdl, ARCHIVE_SDMC, "/corbenik/loader.log", FS_OPEN_WRITE|FS_OPEN_READ|FS_OPEN_CREATE);
+ r = fileOpen(&log_file_hdl, ARCHIVE_SDMC, "/corbenik/loader.log", FS_OPEN_WRITE | FS_OPEN_READ | FS_OPEN_CREATE);
if (R_FAILED(r)) {
logger_is_initd = -1;
}
- logger_is_initd = 1;
+ logger_is_initd = 1;
}
-void logstr(const char* str) {
- if (logger_is_initd == -1)
- return; // Errored during init. Don't bother.
+void
+logstr(const char *str)
+{
+ if (logger_is_initd == -1)
+ return; // Errored during init. Don't bother.
- u32 len = strlen(str);
- u64 size;
- u32 wrote;
- Result r;
+ u32 len = strlen(str);
+ u64 size;
+ u32 wrote;
+ Result r;
- // Get current size.
- r = FSFILE_GetSize(log_file_hdl, &size);
+ // Get current size.
+ r = FSFILE_GetSize(log_file_hdl, &size);
if (R_FAILED(r))
- return;
+ return;
- // Expand file size.
- r = FSFILE_SetSize(log_file_hdl, size+len);
+ // Expand file size.
+ r = FSFILE_SetSize(log_file_hdl, size + len);
if (R_FAILED(r))
- return;
+ return;
- // Write data.
- FSFILE_Write(log_file_hdl, &wrote, size, str, len, FS_WRITE_FLUSH);
+ // Write data.
+ FSFILE_Write(log_file_hdl, &wrote, size, str, len, FS_WRITE_FLUSH);
}
-void logu64(u64 progId) {
- char str[] = "Title: 0000000000000000\n";
- u32 i = 22;
- while(progId) {
- static const char hexDigits[] = "0123456789ABCDEF";
- str[i--] = hexDigits[(u32)(progId & 0xF)];
- progId >>= 4;
- }
+void
+logu64(u64 progId)
+{
+ char str[] = "Title: 0000000000000000\n";
+ u32 i = 22;
+ while (progId) {
+ static const char hexDigits[] = "0123456789ABCDEF";
+ str[i--] = hexDigits[(u32)(progId & 0xF)];
+ progId >>= 4;
+ }
- logstr(str);
+ logstr(str);
}
-void closeLogger() {
- FSFILE_Close(log_file_hdl);
- logger_is_initd = 0;
+void
+closeLogger()
+{
+ FSFILE_Close(log_file_hdl);
+ logger_is_initd = 0;
}
#define __LOGGER_H
void openLogger();
-void logstr(const char* str);
+void logstr(const char *str);
void logu64(u64 progId);
void closeLogger();
// TODO - In the future, why not ADD code compression modes? Like, zlib, for example. Or lzss+zlib.
int
-lzss_decompress(u8* buffer)
+lzss_decompress(u8 *buffer)
{
// This WAS originally a decompilation in @yifan_lu's repo; it was rewritten
// for readability following ctrtool's namings.
return 0;
// v1=decompressedSize, v2=compressedSize, v3=index, v4=stopIndex
- decompSize = *((u32*)buffer - 2);
- compressEndOff = &buffer[*((u32*)buffer - 1)];
+ decompSize = *((u32 *)buffer - 2);
+ compressEndOff = &buffer[*((u32 *)buffer - 1)];
index = &buffer[-(decompSize >> 24)]; // FIXME - The integer negation is due
// to a compiler optimization. It's
// probably okay, but...
#ifndef __LZSS_H
#define __LZSS_H
-int lzss_decompress(u8* buffer);
+int lzss_decompress(u8 *buffer);
#endif
#include "../../../source/patch_format.h"
int
-memcmp(const void* buf1, const void* buf2, u32 size)
+memcmp(const void *buf1, const void *buf2, u32 size)
{
- const u8* buf1c = (const u8*)buf1;
- const u8* buf2c = (const u8*)buf2;
+ const u8 *buf1c = (const u8 *)buf1;
+ const u8 *buf2c = (const u8 *)buf2;
for (u32 i = 0; i < size; i++) {
int cmp = buf1c[i] - buf2c[i];
// Quick Search algorithm, adapted from
// http://igm.univ-mlv.fr/~lecroq/string/node19.html#SECTION00190
-u8*
-memfind(u8* startPos, u32 size, const void* pattern, u32 patternSize)
+u8 *
+memfind(u8 *startPos, u32 size, const void *pattern, u32 patternSize)
{
- const u8* patternc = (const u8*)pattern;
+ const u8 *patternc = (const u8 *)pattern;
// Preprocessing
u32 table[256];
}
u32
-patchMemory(u8* start, u32 size, const void* pattern, u32 patSize, int offset,
- const void* replace, u32 repSize, u32 count)
+patchMemory(u8 *start, u32 size, const void *pattern, u32 patSize, int offset, const void *replace, u32 repSize, u32 count)
{
u32 i;
for (i = 0; i < count; i++) {
- u8* found = memfind(start, size, pattern, patSize);
+ u8 *found = memfind(start, size, pattern, patSize);
if (found == NULL)
break;
}
size_t
-strnlen(const char* string, size_t maxlen)
+strnlen(const char *string, size_t maxlen)
{
size_t size;
- for (size = 0; *string && size < maxlen; string++, size++);
+ for (size = 0; *string && size < maxlen; string++, size++)
+ ;
return size;
}
#ifndef __MEMORY_H
#define __MEMORY_H
-int memcmp(const void* buf1, const void* buf2, u32 size);
-u8* memfind(u8* startPos, u32 size, const void* pattern, u32 patternSize);
-u32 patchMemory(u8* start, u32 size, const void* pattern, u32 patSize, int offset,
- const void* replace, u32 repSize, u32 count);
-size_t strnlen(const char* string, size_t maxlen);
+int memcmp(const void *buf1, const void *buf2, u32 size);
+u8 *memfind(u8 *startPos, u32 size, const void *pattern, u32 patternSize);
+u32 patchMemory(u8 *start, u32 size, const void *pattern, u32 patSize, int offset, const void *replace, u32 repSize, u32 count);
+size_t strnlen(const char *string, size_t maxlen);
#endif
#include "config.h"
int
-fileOpen(Handle* file, FS_ArchiveID id, const char* path, int flags)
+fileOpen(Handle *file, FS_ArchiveID id, const char *path, int flags)
{
FS_Path apath;
FS_Path ppath;
apath.type = PATH_EMPTY;
apath.size = 1;
- apath.data = (u8*)"";
+ apath.data = (u8 *)"";
ppath.type = PATH_ASCII;
ppath.data = path;
}
// Read file.
- if (!R_SUCCEEDED(
- FSFILE_Read(file, &total, 0, &config, sizeof(struct config_file)))) {
+ if (!R_SUCCEEDED(FSFILE_Read(file, &total, 0, &config, sizeof(struct config_file)))) {
FSFILE_Close(file); // Read to memory.
// Failed to read.
failed_load_config = 0;
- logstr(" loaded config file\n");
+ logstr(" loaded config file\n");
return;
}
-static int loadTitleLocaleConfig(u64 progId, u8 *regionId, u8 *languageId)
+static int
+loadTitleLocaleConfig(u64 progId, u8 *regionId, u8 *languageId)
{
// FIXME - Rewrite this function to use a single line-based config of
- // the grammar:
+ // the grammar:
- // lang := "ja" | "en" | "fr" | "de" | "it" | "es" | "zh" | "ko" | "nl" | "pt" | "ru" | "tw"
- // region := "JP" | "US" | "EU" | "AU" | "CN" | "KO" | "TW"
- // title := (0123456789abcdef)16
- // langcode := lang . "_" . country
- // line := title langcode
+ // lang := "ja" | "en" | "fr" | "de" | "it" | "es" | "zh" | "ko" | "nl" | "pt" | "ru" | "tw"
+ // region := "JP" | "US" | "EU" | "AU" | "CN" | "KO" | "TW"
+ // title := (0123456789abcdef)16
+ // langcode := lang . "_" . country
+ // line := title langcode
- // So this would be valid as an example file:
- // 0040000000012300 en_US
- // 0040000000032100 ja_JP
+ // So this would be valid as an example file:
+ // 0040000000012300 en_US
+ // 0040000000032100 ja_JP
// Directory seeks have severe issues on FAT and
// dumping configs based on 3dsdb (more than 1000) causes things
// to kinda choke. FAT is not meant for large numbers of files per
// directory due to linear seeks rather than tree or hash-based indexes.
- // This really does need a rewrite.
-
- char path[] = "/corbenik/etc/locale/0000000000000000";
- u32 i = 36;
- while(progId) {
- static const char hexDigits[] = "0123456789ABCDEF";
- path[i--] = hexDigits[(u32)(progId & 0xF)];
- progId >>= 4;
- }
-
- static const char* regions[] = { "JPN", "USA", "EUR", "AUS",
- "CHN", "KOR", "TWN" };
- static const char* languages[] = { "JA", "EN", "FR", "DE", "IT", "ES",
- "ZH", "KO", "NL", "PT", "RU", "TW" };
- Handle file;
- Result ret = fileOpen(&file, ARCHIVE_SDMC, path, FS_OPEN_READ);
- if(R_SUCCEEDED(ret)) {
- char buf[6];
- u32 total;
- ret = FSFILE_Read(file, &total, 0, buf, 6);
- FSFILE_Close(file);
-
- if(!R_SUCCEEDED(ret) || total < 6)
- return -1;
-
- for(u32 i = 0; i < 7; i++) {
- if(memcmp(buf, regions[i], 3) == 0) {
- *regionId = (u8)i;
- break;
- }
- }
-
- for(u32 i = 0; i < 12; i++) {
- if(memcmp(buf + 4, languages[i], 2) == 0) {
- *languageId = (u8)i;
- break;
- }
- }
-
- logstr(" langemu cfg applied\n ");
- logstr(path);
- logstr("\n");
- }
- return ret;
+ // This really does need a rewrite.
+
+ char path[] = "/corbenik/etc/locale/0000000000000000";
+ u32 i = 36;
+ while (progId) {
+ static const char hexDigits[] = "0123456789ABCDEF";
+ path[i--] = hexDigits[(u32)(progId & 0xF)];
+ progId >>= 4;
+ }
+
+ static const char *regions[] = { "JPN", "USA", "EUR", "AUS", "CHN", "KOR", "TWN" };
+ static const char *languages[] = { "JA", "EN", "FR", "DE", "IT", "ES", "ZH", "KO", "NL", "PT", "RU", "TW" };
+ Handle file;
+ Result ret = fileOpen(&file, ARCHIVE_SDMC, path, FS_OPEN_READ);
+ if (R_SUCCEEDED(ret)) {
+ char buf[6];
+ u32 total;
+ ret = FSFILE_Read(file, &total, 0, buf, 6);
+ FSFILE_Close(file);
+
+ if (!R_SUCCEEDED(ret) || total < 6)
+ return -1;
+
+ for (u32 i = 0; i < 7; i++) {
+ if (memcmp(buf, regions[i], 3) == 0) {
+ *regionId = (u8)i;
+ break;
+ }
+ }
+
+ for (u32 i = 0; i < 12; i++) {
+ if (memcmp(buf + 4, languages[i], 2) == 0) {
+ *languageId = (u8)i;
+ break;
+ }
+ }
+
+ logstr(" langemu cfg applied\n ");
+ logstr(path);
+ logstr("\n");
+ }
+ return ret;
}
-static u8*
-getCfgOffsets(u8* code, u32 size, u32* CFGUHandleOffset)
+static u8 *
+getCfgOffsets(u8 *code, u32 size, u32 *CFGUHandleOffset)
{
// HANS:
// Look for error code which is known to be stored near cfg:u handle
u32 n = 0, possible[24];
- for (u8* pos = code + 4; n < 24 && pos < code + size - 4; pos += 4) {
- if (*(u32*)pos == 0xD8A103F9) {
- for (u32* l = (u32*)pos - 4; n < 24 && l < (u32*)pos + 4; l++)
+ for (u8 *pos = code + 4; n < 24 && pos < code + size - 4; pos += 4) {
+ if (*(u32 *)pos == 0xD8A103F9) {
+ for (u32 *l = (u32 *)pos - 4; n < 24 && l < (u32 *)pos + 4; l++)
if (*l <= 0x10000000)
possible[n++] = *l;
}
}
- for (u8* CFGU_GetConfigInfoBlk2_endPos = code;
- CFGU_GetConfigInfoBlk2_endPos < code + size - 8;
- CFGU_GetConfigInfoBlk2_endPos += 4) {
- static const u32 CFGU_GetConfigInfoBlk2_endPattern[] = { 0xE8BD8010,
- 0x00010082 };
+ for (u8 *CFGU_GetConfigInfoBlk2_endPos = code; CFGU_GetConfigInfoBlk2_endPos < code + size - 8; CFGU_GetConfigInfoBlk2_endPos += 4) {
+ static const u32 CFGU_GetConfigInfoBlk2_endPattern[] = { 0xE8BD8010, 0x00010082 };
// There might be multiple implementations of GetConfigInfoBlk2 but
// let's search for the one we want
- u32* cmp = (u32*)CFGU_GetConfigInfoBlk2_endPos;
+ u32 *cmp = (u32 *)CFGU_GetConfigInfoBlk2_endPos;
- if (cmp[0] == CFGU_GetConfigInfoBlk2_endPattern[0] &&
- cmp[1] == CFGU_GetConfigInfoBlk2_endPattern[1]) {
- *CFGUHandleOffset = *((u32*)CFGU_GetConfigInfoBlk2_endPos + 2);
+ if (cmp[0] == CFGU_GetConfigInfoBlk2_endPattern[0] && cmp[1] == CFGU_GetConfigInfoBlk2_endPattern[1]) {
+ *CFGUHandleOffset = *((u32 *)CFGU_GetConfigInfoBlk2_endPos + 2);
for (u32 i = 0; i < n; i++)
if (possible[i] == *CFGUHandleOffset)
}
static void
-patchCfgGetLanguage(u8* code, u32 size, u8 languageId,
- u8* CFGU_GetConfigInfoBlk2_endPos)
+patchCfgGetLanguage(u8 *code, u32 size, u8 languageId, u8 *CFGU_GetConfigInfoBlk2_endPos)
{
- u8* CFGU_GetConfigInfoBlk2_startPos; // Let's find STMFD SP (there might be
+ u8 *CFGU_GetConfigInfoBlk2_startPos; // Let's find STMFD SP (there might be
// a NOP before, but nevermind)
for (CFGU_GetConfigInfoBlk2_startPos = CFGU_GetConfigInfoBlk2_endPos - 4;
- CFGU_GetConfigInfoBlk2_startPos >= code &&
- *((u16*)CFGU_GetConfigInfoBlk2_startPos + 1) != 0xE92D;
- CFGU_GetConfigInfoBlk2_startPos -= 2)
+ CFGU_GetConfigInfoBlk2_startPos >= code && *((u16 *)CFGU_GetConfigInfoBlk2_startPos + 1) != 0xE92D; CFGU_GetConfigInfoBlk2_startPos -= 2)
;
- for (u8* languageBlkIdPos = code; languageBlkIdPos < code + size;
- languageBlkIdPos += 4) {
- if (*(u32*)languageBlkIdPos == 0xA0002) {
- for (u8* instr = languageBlkIdPos - 8;
- instr >= languageBlkIdPos - 0x1008 && instr >= code + 4;
- instr -= 4) // Should be enough
+ for (u8 *languageBlkIdPos = code; languageBlkIdPos < code + size; languageBlkIdPos += 4) {
+ if (*(u32 *)languageBlkIdPos == 0xA0002) {
+ for (u8 *instr = languageBlkIdPos - 8; instr >= languageBlkIdPos - 0x1008 && instr >= code + 4; instr -= 4) // Should be enough
{
if (instr[3] == 0xEB) // We're looking for BL
{
- u8* calledFunction = instr;
+ u8 *calledFunction = instr;
u32 i = 0, found;
do {
- u32 low24 = (*(u32*)calledFunction & 0x00FFFFFF) << 2;
- u32 signMask = (u32)(-(low24 >> 25)) &
- 0xFC000000; // Sign extension
- s32 offset = (s32)(low24 | signMask) +
- 8; // Branch offset + 8 for prefetch
+ u32 low24 = (*(u32 *)calledFunction & 0x00FFFFFF) << 2;
+ u32 signMask = (u32)(-(low24 >> 25)) & 0xFC000000; // Sign extension
+ s32 offset = (s32)(low24 | signMask) + 8; // Branch offset + 8 for prefetch
calledFunction += offset;
- found = calledFunction >=
- CFGU_GetConfigInfoBlk2_startPos - 4 &&
- calledFunction <= CFGU_GetConfigInfoBlk2_endPos;
+ found = calledFunction >= CFGU_GetConfigInfoBlk2_startPos - 4 && calledFunction <= CFGU_GetConfigInfoBlk2_endPos;
i++;
} while (i < 2 && !found && calledFunction[3] == 0xEA);
if (found) {
- *((u32*)instr - 1) =
- 0xE3A00000 | languageId; // mov r0, sp
- // => mov r0, =languageId
- *(u32*)instr = 0xE5CD0000; // bl
+ *((u32 *)instr - 1) = 0xE3A00000 | languageId; // mov r0, sp
+ // => mov r0, =languageId
+ *(u32 *)instr = 0xE5CD0000; // bl
// CFGU_GetConfigInfoBlk2 =>
// strb r0, [sp]
- *((u32*)instr + 1) =
- 0xE3B00000; // (1 or 2 instructions) => movs
- // r0, 0 (result code)
+ *((u32 *)instr + 1) = 0xE3B00000; // (1 or 2 instructions) => movs
+ // r0, 0 (result code)
- logstr(" patched language\n");
+ logstr(" patched language\n");
// We're done
return;
}
static void
-patchCfgGetRegion(u8* code, u32 size, u8 regionId, u32 CFGUHandleOffset)
+patchCfgGetRegion(u8 *code, u32 size, u8 regionId, u32 CFGUHandleOffset)
{
- for (u8* cmdPos = code; cmdPos < code + size - 28; cmdPos += 4) {
- static const u32 cfgSecureInfoGetRegionCmdPattern[] = { 0xEE1D4F70,
- 0xE3A00802,
- 0xE5A40080 };
-
- u32* cmp = (u32*)cmdPos;
-
- if (cmp[0] == cfgSecureInfoGetRegionCmdPattern[0] &&
- cmp[1] == cfgSecureInfoGetRegionCmdPattern[1] &&
- cmp[2] == cfgSecureInfoGetRegionCmdPattern[2] &&
- *((u16*)cmdPos + 7) == 0xE59F &&
- *(u32*)(cmdPos + 20 + *((u16*)cmdPos + 6)) == CFGUHandleOffset) {
- *((u32*)cmdPos + 4) = 0xE3A00000 | regionId; // mov r0, =regionId
- *((u32*)cmdPos + 5) = 0xE5C40008; // strb r0, [r4, 8]
- *((u32*)cmdPos + 6) = 0xE3B00000; // movs r0, 0 (result
- // code) ('s' not needed but nvm)
- *((u32*)cmdPos + 7) = 0xE5840004; // str r0, [r4, 4]
+ for (u8 *cmdPos = code; cmdPos < code + size - 28; cmdPos += 4) {
+ static const u32 cfgSecureInfoGetRegionCmdPattern[] = { 0xEE1D4F70, 0xE3A00802, 0xE5A40080 };
+
+ u32 *cmp = (u32 *)cmdPos;
+
+ if (cmp[0] == cfgSecureInfoGetRegionCmdPattern[0] && cmp[1] == cfgSecureInfoGetRegionCmdPattern[1] && cmp[2] == cfgSecureInfoGetRegionCmdPattern[2] &&
+ *((u16 *)cmdPos + 7) == 0xE59F && *(u32 *)(cmdPos + 20 + *((u16 *)cmdPos + 6)) == CFGUHandleOffset) {
+ *((u32 *)cmdPos + 4) = 0xE3A00000 | regionId; // mov r0, =regionId
+ *((u32 *)cmdPos + 5) = 0xE5C40008; // strb r0, [r4, 8]
+ *((u32 *)cmdPos + 6) = 0xE3B00000; // movs r0, 0 (result
+ // code) ('s' not needed but nvm)
+ *((u32 *)cmdPos + 7) = 0xE5840004; // str r0, [r4, 4]
// The remaining, not patched, function code will do the rest for us
break;
}
}
- logstr(" patched region\n");
+ logstr(" patched region\n");
}
static void
-adjust_cpu_settings(u64 progId, u8* code, u32 size)
+adjust_cpu_settings(u64 progId, u8 *code, u32 size)
{
if (!failed_load_config) {
u32 cpuSetting = 0;
cpuSetting |= config.options[OPTION_LOADER_CPU_800MHZ] << 1;
if (cpuSetting) {
- static const u8 cfgN3dsCpuPattern[] = { 0x00, 0x40, 0xA0,
- 0xE1, 0x07, 0x00 };
+ static const u8 cfgN3dsCpuPattern[] = { 0x00, 0x40, 0xA0, 0xE1, 0x07, 0x00 };
- u32* cfgN3dsCpuLoc = (u32*)memfind(code, size, cfgN3dsCpuPattern,
- sizeof(cfgN3dsCpuPattern));
+ u32 *cfgN3dsCpuLoc = (u32 *)memfind(code, size, cfgN3dsCpuPattern, sizeof(cfgN3dsCpuPattern));
// Patch N3DS CPU Clock and L2 cache setting
if (cfgN3dsCpuLoc != NULL) {
}
}
-
void
-language_emu(u64 progId, u8* code, u32 size)
+language_emu(u64 progId, u8 *code, u32 size)
{
if (!failed_load_config && config.options[OPTION_LOADER_LANGEMU]) {
u32 tidHigh = (progId & 0xFFFFFFF000000000LL) >> 0x24;
// Language emulation
u8 regionId = 0xFF, languageId = 0xFF;
- if (R_SUCCEEDED(
- loadTitleLocaleConfig(progId, ®ionId, &languageId))) {
+ if (R_SUCCEEDED(loadTitleLocaleConfig(progId, ®ionId, &languageId))) {
u32 CFGUHandleOffset;
- u8* CFGU_GetConfigInfoBlk2_endPos =
- getCfgOffsets(code, size, &CFGUHandleOffset);
+ u8 *CFGU_GetConfigInfoBlk2_endPos = getCfgOffsets(code, size, &CFGUHandleOffset);
if (CFGU_GetConfigInfoBlk2_endPos != NULL) {
if (languageId != 0xFF)
- patchCfgGetLanguage(code, size, languageId,
- CFGU_GetConfigInfoBlk2_endPos);
+ patchCfgGetLanguage(code, size, languageId, CFGU_GetConfigInfoBlk2_endPos);
if (regionId != 0xFF)
- patchCfgGetRegion(code, size, regionId,
- CFGUHandleOffset);
+ patchCfgGetRegion(code, size, regionId, CFGUHandleOffset);
}
}
}
}
void
-overlay_patch(u64 progId, u8* code, u32 size)
+overlay_patch(u64 progId, u8 *code, u32 size)
{
// TODO - Implement. Needs some thought. This should allow usage of files off SD rather than RomFS.
}
// This is only for the .data segment.
void
-patch_data(u64 progId, u8* data, u32 size, u32 orig_size)
+patch_data(u64 progId, u8 *data, u32 size, u32 orig_size)
{
}
// This is only for the .ro segment.
void
-patch_ro(u64 progId, u8* ro, u32 size, u32 orig_size)
+patch_ro(u64 progId, u8 *ro, u32 size, u32 orig_size)
{
}
// This is only for the .code segment.
void
-patch_text(u64 progId, u8* text, u32 size, u32 orig_size)
+patch_text(u64 progId, u8 *text, u32 size, u32 orig_size)
{
- if (progId == 0x0004013000008002LL)
+ if (progId == 0x0004013000008002LL)
adjust_cpu_settings(progId, text, orig_size);
- execb(progId, text, orig_size);
+ execb(progId, text, orig_size);
language_emu(progId, text, orig_size);
}
#include <3ds/types.h>
-void patch_text(u64 progId, u8* text, u32 size, u32 orig_size);
-void patch_data(u64 progId, u8* data, u32 size, u32 orig_size);
-void patch_ro(u64 progId, u8* ro, u32 size, u32 orig_size);
+void patch_text(u64 progId, u8 *text, u32 size, u32 orig_size);
+void patch_data(u64 progId, u8 *data, u32 size, u32 orig_size);
+void patch_ro(u64 progId, u8 *ro, u32 size, u32 orig_size);
u32 get_text_extend(u64 progId, u32 size_orig);
u32 get_ro_extend(u64 progId, u32 size_orig);
void load_config();
-int fileOpen(Handle* file, FS_ArchiveID id, const char* path, int flags);
+int fileOpen(Handle *file, FS_ArchiveID id, const char *path, int flags);
u8 get_cpumode(u64 progId);
}
Result
-PXIPM_RegisterProgram(u64* prog_handle, FS_ProgramInfo* title,
- FS_ProgramInfo* update)
+PXIPM_RegisterProgram(u64 *prog_handle, FS_ProgramInfo *title, FS_ProgramInfo *update)
{
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x2, 8, 0); // 0x20200
memcpy(&cmdbuf[1], &title->programId, sizeof(u64));
- *(u8*)&cmdbuf[3] = title->mediaType;
- memcpy(((u8*)&cmdbuf[3]) + 1, &title->padding, 7);
+ *(u8 *)&cmdbuf[3] = title->mediaType;
+ memcpy(((u8 *)&cmdbuf[3]) + 1, &title->padding, 7);
memcpy(&cmdbuf[5], &update->programId, sizeof(u64));
- *(u8*)&cmdbuf[7] = update->mediaType;
- memcpy(((u8*)&cmdbuf[7]) + 1, &update->padding, 7);
+ *(u8 *)&cmdbuf[7] = update->mediaType;
+ memcpy(((u8 *)&cmdbuf[7]) + 1, &update->padding, 7);
Result ret = 0;
if (R_FAILED(ret = svcSendSyncRequest(pxipmHandle)))
return ret;
- *prog_handle = *(u64*)&cmdbuf[2];
+ *prog_handle = *(u64 *)&cmdbuf[2];
return cmdbuf[1];
}
Result
-PXIPM_GetProgramInfo(exheader_header* exheader, u64 prog_handle)
+PXIPM_GetProgramInfo(exheader_header *exheader, u64 prog_handle)
{
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x1, 2, 2); // 0x10082
cmdbuf[1] = (u32)(prog_handle);
Result
PXIPM_UnregisterProgram(u64 prog_handle)
{
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x3, 2, 0); // 0x30080
cmdbuf[1] = (u32)(prog_handle);
Result pxipmInit(void);
void pxipmExit(void);
-Result PXIPM_RegisterProgram(u64* prog_handle, FS_ProgramInfo* title,
- FS_ProgramInfo* update);
-Result PXIPM_GetProgramInfo(exheader_header* exheader, u64 prog_handle);
+Result PXIPM_RegisterProgram(u64 *prog_handle, FS_ProgramInfo *title, FS_ProgramInfo *update);
+Result PXIPM_GetProgramInfo(exheader_header *exheader, u64 prog_handle);
Result PXIPM_UnregisterProgram(u64 prog_handle);
#endif
while (1) {
rc = svcConnectToPort(&srvHandle, "srv:");
- if (R_LEVEL(rc) != RL_PERMANENT || R_SUMMARY(rc) != RS_NOTFOUND ||
- R_DESCRIPTION(rc) != RD_NOT_FOUND)
+ if (R_LEVEL(rc) != RL_PERMANENT || R_SUMMARY(rc) != RS_NOTFOUND || R_DESCRIPTION(rc) != RD_NOT_FOUND)
break;
svcSleepThread(500000);
}
srvSysRegisterClient(void)
{
Result rc = 0;
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x1, 0, 2); // 0x10002
cmdbuf[1] = IPC_Desc_CurProcessHandle();
}
Result
-srvSysGetServiceHandle(Handle* out, const char* name)
+srvSysGetServiceHandle(Handle *out, const char *name)
{
Result rc = 0;
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x5, 4, 0); // 0x50100
- strncpy((char*)&cmdbuf[1], name, 8);
+ strncpy((char *)&cmdbuf[1], name, 8);
cmdbuf[3] = strlen(name);
cmdbuf[4] = 0x0;
}
Result
-srvSysEnableNotification(Handle* semaphoreOut)
+srvSysEnableNotification(Handle *semaphoreOut)
{
Result rc = 0;
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x2, 0, 0);
}
Result
-srvSysReceiveNotification(u32* notificationIdOut)
+srvSysReceiveNotification(u32 *notificationIdOut)
{
Result rc = 0;
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0xB, 0, 0); // 0xB0000
}
Result
-srvSysRegisterService(Handle* out, const char* name, int maxSessions)
+srvSysRegisterService(Handle *out, const char *name, int maxSessions)
{
Result rc = 0;
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x3, 4, 0); // 0x30100
- strncpy((char*)&cmdbuf[1], name, 8);
+ strncpy((char *)&cmdbuf[1], name, 8);
cmdbuf[3] = strlen(name);
cmdbuf[4] = maxSessions;
}
Result
-srvSysUnregisterService(const char* name)
+srvSysUnregisterService(const char *name)
{
Result rc = 0;
- u32* cmdbuf = getThreadCommandBuffer();
+ u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = IPC_MakeHeader(0x4, 3, 0); // 0x400C0
- strncpy((char*)&cmdbuf[1], name, 8);
+ strncpy((char *)&cmdbuf[1], name, 8);
cmdbuf[3] = strlen(name);
if (R_FAILED(rc = svcSendSyncRequest(srvHandle)))
* @param out Pointer to write the handle to.
* @param name Name of the service.
*/
-Result srvSysGetServiceHandle(Handle* out, const char* name);
+Result srvSysGetServiceHandle(Handle *out, const char *name);
/// Registers the current process as a client to the service API.
Result srvSysRegisterClient(void);
* @brief Enables service notificatios, returning a notification semaphore.
* @param semaphoreOut Pointer to output the notification semaphore to.
*/
-Result srvSysEnableNotification(Handle* semaphoreOut);
+Result srvSysEnableNotification(Handle *semaphoreOut);
/**
* @brief Receives a notification.
* @param notificationIdOut Pointer to output the ID of the received
* notification to.
*/
-Result srvSysReceiveNotification(u32* notificationIdOut);
+Result srvSysReceiveNotification(u32 *notificationIdOut);
/**
* @brief Registers the current process as a service.
* @param name Name of the service.
* @param maxSessions Maximum number of sessions the service can handle.
*/
-Result srvSysRegisterService(Handle* out, const char* name, int maxSessions);
+Result srvSysRegisterService(Handle *out, const char *name, int maxSessions);
/**
* @brief Unregisters the current process as a service.
* @param name Name of the service.
*/
-Result srvSysUnregisterService(const char* name);
+Result srvSysUnregisterService(const char *name);
#endif
#include "common.h"
-FILE* conf_handle;
+FILE *conf_handle;
struct config_file config;
"has incorrect magic:\n"
" '%c%c%c%c'\n"
"Regenerating with defaults.\n",
- PATH_CONFIG, config.magic[0], config.magic[1],
- config.magic[2], config.magic[3]);
+ PATH_CONFIG, config.magic[0], config.magic[1], config.magic[2], config.magic[3]);
f_unlink(PATH_CONFIG);
regenerate_config();
}
enum type
{
- boolean_val, // Toggle
- ranged_val, // N1 - N2, left and right to pick.
- mask_val, // Bitmask allowed values.
- not_option // Skip over this.
+ boolean_val, // Toggle
+ ranged_val, // N1 - N2, left and right to pick.
+ mask_val, // Bitmask allowed values.
+ not_option // Skip over this.
};
struct range_str
#define OPTION_TRANSP_BG 8 // Background color is not drawn under text.
#define OPTION_NO_CLEAR_BG 9
- // Framebuffer is preserved from whatever ran before us.
+// Framebuffer is preserved from whatever ran before us.
#define OPTION_READ_ME 10 // Remove Help/Readme from menu.
#define OPTION_LOADER_CPU_L2 11 // Enable L2 cache.
#define OPTION_LOADER_LANGEMU 13 // Enable 800Mhz mode.
#define OPTION_REPLACE_ALLOCATED_SVC 14
- // Replace allocated services. Normally you don't want this.
+// Replace allocated services. Normally you don't want this.
#define IGNORE_PATCH_DEPS 14 // Ignore patch UUID dependencies. Not recommended.
#define IGNORE_BROKEN_SHIT 15
- // Allow enabling patches which are marked as 'incompatible'. Chances are
- // there's a reason.
+// Allow enabling patches which are marked as 'incompatible'. Chances are
+// there's a reason.
#define OPTION_AADOWNGRADE 16 // Anti-anti-downgrade.
-#define OPTION_MEMEXEC 17 // Prevent MPU from disabling execute permissions.
-#define OPTION_UNITINFO 18 // Dev UNITINFO. Note that this is overkill.
+#define OPTION_MEMEXEC 17 // Prevent MPU from disabling execute permissions.
+#define OPTION_UNITINFO 18 // Dev UNITINFO. Note that this is overkill.
//#define HEADER_COLOR 12 // Color of header text.
//#define BG_COLOR 13 // Color of background.
/*-----------------------------------------------------------------------*/
DSTATUS
-disk_status(__attribute__((unused))
- BYTE pdrv /* Physical drive nmuber to identify the drive */
+disk_status(__attribute__((unused)) BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{
return RES_OK;
/*-----------------------------------------------------------------------*/
DSTATUS
-disk_initialize(__attribute__((unused))
- BYTE pdrv /* Physical drive nmuber to identify the drive */
+disk_initialize(__attribute__((unused)) BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{
if (!sdmmc_sdcard_init())
/*-----------------------------------------------------------------------*/
DRESULT
-disk_read(__attribute__((unused))
- BYTE pdrv, /* Physical drive nmuber to identify the drive */
- BYTE* buff, /* Data buffer to store read data */
- DWORD sector, /* Sector address in LBA */
- UINT count /* Number of sectors to read */
+disk_read(__attribute__((unused)) BYTE pdrv, /* Physical drive nmuber to identify the drive */
+ BYTE *buff, /* Data buffer to store read data */
+ DWORD sector, /* Sector address in LBA */
+ UINT count /* Number of sectors to read */
)
{
if (sdmmc_sdcard_readsectors(sector, count, buff)) {
#if _USE_WRITE
DRESULT
-disk_write(__attribute__((unused))
- BYTE pdrv, /* Physical drive nmuber to identify the drive */
- const BYTE* buff, /* Data to be written */
- DWORD sector, /* Sector address in LBA */
- UINT count /* Number of sectors to write */
+disk_write(__attribute__((unused)) BYTE pdrv, /* Physical drive nmuber to identify the drive */
+ const BYTE *buff, /* Data to be written */
+ DWORD sector, /* Sector address in LBA */
+ UINT count /* Number of sectors to write */
)
{
- if (sdmmc_sdcard_writesectors(sector, count, (BYTE*)buff)) {
+ if (sdmmc_sdcard_writesectors(sector, count, (BYTE *)buff)) {
return RES_PARERR;
}
#if _USE_IOCTL
DRESULT
-disk_ioctl(
- __attribute__((unused)) BYTE pdrv, /* Physical drive nmuber (0..) */
- __attribute__((unused)) BYTE cmd, /* Control code */
- __attribute__((unused)) void* buff /* Buffer to send/receive control data */
- )
+disk_ioctl(__attribute__((unused)) BYTE pdrv, /* Physical drive nmuber (0..) */
+ __attribute__((unused)) BYTE cmd, /* Control code */
+ __attribute__((unused)) void *buff /* Buffer to send/receive control data */
+ )
{
switch (cmd) {
case GET_SECTOR_SIZE:
- *((DWORD*)buff) = 0x200;
+ *((DWORD *)buff) = 0x200;
return RES_OK;
case GET_SECTOR_COUNT:
- *((DWORD*)buff) = getMMCDevice(1)->total_size;
+ *((DWORD *)buff) = getMMCDevice(1)->total_size;
return RES_OK;
case GET_BLOCK_SIZE:
- *((DWORD*)buff) = 0x2000;
+ *((DWORD *)buff) = 0x2000;
return RES_OK;
case CTRL_SYNC:
// nothing to do here - the disk_write function handles that
DSTATUS disk_initialize(BYTE pdrv);
DSTATUS disk_status(BYTE pdrv);
-DRESULT disk_read(BYTE pdrv, BYTE* buff, DWORD sector, UINT count);
-DRESULT disk_write(BYTE pdrv, const BYTE* buff, DWORD sector, UINT count);
-DRESULT disk_ioctl(BYTE pdrv, BYTE cmd, void* buff);
+DRESULT disk_read(BYTE pdrv, BYTE *buff, DWORD sector, UINT count);
+DRESULT disk_write(BYTE pdrv, const BYTE *buff, DWORD sector, UINT count);
+DRESULT disk_ioctl(BYTE pdrv, BYTE cmd, void *buff);
/* Disk Status Bits (DSTATUS) */
/* Command code for disk_ioctrl fucntion */
/* Generic command (Used by FatFs) */
-#define CTRL_SYNC \
- 0 /* Complete pending write process (needed at _FS_READONLY == 0) */
+#define CTRL_SYNC 0 /* Complete pending write process (needed at _FS_READONLY == 0) */
#define GET_SECTOR_COUNT 1 /* Get media size (needed at _USE_MKFS == 1) */
#define GET_SECTOR_SIZE 2 /* Get sector size (needed at _MAX_SS != _MIN_SS) */
#define GET_BLOCK_SIZE 3 /* Get erase block size (needed at _USE_MKFS == 1) */
-#define CTRL_TRIM \
- 4 /* Inform device that the data on the block of sectors is no longer used \
+#define CTRL_TRIM \
+ 4 /* Inform device that the data on the block of sectors is no longer used \
(needed at _USE_TRIM == 1) */
/* Generic command (Not used by FatFs) */
#if _USE_LFN == 1
#error Static LFN work area cannot be used at thread-safe configuration
#endif
-#define ENTER_FF(fs) \
- { \
- if (!lock_fs(fs)) \
- return FR_TIMEOUT; \
+#define ENTER_FF(fs) \
+ { \
+ if (!lock_fs(fs)) \
+ return FR_TIMEOUT; \
}
-#define LEAVE_FF(fs, res) \
- { \
- unlock_fs(fs, res); \
- return res; \
+#define LEAVE_FF(fs, res) \
+ { \
+ unlock_fs(fs, res); \
+ return res; \
}
#else
#define ENTER_FF(fs)
#define LEAVE_FF(fs, res) return res
#endif
-#define ABORT(fs, res) \
- { \
- fp->err = (BYTE)(res); \
- LEAVE_FF(fs, res); \
+#define ABORT(fs, res) \
+ { \
+ fp->err = (BYTE)(res); \
+ LEAVE_FF(fs, res); \
}
/* Definitions of sector size */
-#if (_MAX_SS < _MIN_SS) || (_MAX_SS != 512 && _MAX_SS != 1024 && \
- _MAX_SS != 2048 && _MAX_SS != 4096) || \
+#if (_MAX_SS < _MIN_SS) || (_MAX_SS != 512 && _MAX_SS != 1024 && _MAX_SS != 2048 && _MAX_SS != 4096) || \
(_MIN_SS != 512 && _MIN_SS != 1024 && _MIN_SS != 2048 && _MIN_SS != 4096)
#error Wrong sector size configuration
#endif
/* Timestamp feature */
#if _FS_NORTC == 1
-#if _NORTC_YEAR < 1980 || _NORTC_YEAR > 2107 || _NORTC_MON < 1 || \
- _NORTC_MON > 12 || _NORTC_MDAY < 1 || _NORTC_MDAY > 31
+#if _NORTC_YEAR < 1980 || _NORTC_YEAR > 2107 || _NORTC_MON < 1 || _NORTC_MON > 12 || _NORTC_MDAY < 1 || _NORTC_MDAY > 31
#error Invalid _FS_NORTC settings
#endif
-#define GET_FATTIME() \
- ((DWORD)(_NORTC_YEAR - 1980) << 25 | (DWORD)_NORTC_MON << 21 | \
- (DWORD)_NORTC_MDAY << 16)
+#define GET_FATTIME() ((DWORD)(_NORTC_YEAR - 1980) << 25 | (DWORD)_NORTC_MON << 21 | (DWORD)_NORTC_MDAY << 16)
#else
#define GET_FATTIME() get_fattime()
#endif
#endif
typedef struct
{
- FATFS* fs; /* Object ID 1, volume (NULL:blank entry) */
+ FATFS *fs; /* Object ID 1, volume (NULL:blank entry) */
DWORD clu; /* Object ID 2, directory (0:root) */
WORD idx; /* Object ID 3, directory index */
WORD ctr; /* Object open counter, 0:none, 0x01..0xFF:read mode open count,
\
0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}*/
-static const unsigned short Tbl[] =
- { /* CP437(0x80-0xFF) to Unicode conversion table */
- 0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7, 0x00EA,
- 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5, 0x00C9, 0x00E6,
- 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9, 0x00FF, 0x00D6, 0x00DC,
- 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192, 0x00E1, 0x00ED, 0x00F3, 0x00FA,
- 0x00F1, 0x00D1, 0x00AA, 0x00BA, 0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC,
- 0x00A1, 0x00AB, 0x00BB, 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561,
- 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B,
- 0x2510, 0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
- 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567, 0x2568,
- 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, 0x256A, 0x2518,
- 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580, 0x03B1, 0x00DF, 0x0393,
- 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4, 0x03A6, 0x0398, 0x03A9, 0x03B4,
- 0x221E, 0x03C6, 0x03B5, 0x2229, 0x2261, 0x00B1, 0x2265, 0x2264, 0x2320,
- 0x2321, 0x00F7, 0x2248, 0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2,
- 0x25A0, 0x00A0
- };
+static const unsigned short Tbl[] = { /* CP437(0x80-0xFF) to Unicode conversion table */
+ 0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7, 0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4,
+ 0x00C5, 0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9, 0x00FF, 0x00D6, 0x00DC, 0x00A2, 0x00A3, 0x00A5,
+ 0x20A7, 0x0192, 0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA, 0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC,
+ 0x00A1, 0x00AB, 0x00BB, 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557,
+ 0x255D, 0x255C, 0x255B, 0x2510, 0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F, 0x255A, 0x2554, 0x2569,
+ 0x2566, 0x2560, 0x2550, 0x256C, 0x2567, 0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, 0x256A, 0x2518,
+ 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580, 0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4, 0x03A6,
+ 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229, 0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
+ 0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
+};
WCHAR
ff_convert( /* Converted character, Returns zero on error */
#elif _CODE_PAGE == 720 /* Arabic (OEM) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x81, 0x45, 0x41, 0x84, 0x41, 0x86, 0x43, 0x45, 0x45, 0x45, \
- 0x49, 0x49, 0x8D, 0x8E, 0x8F, 0x90, 0x92, 0x92, 0x93, 0x94, 0x95, \
- 0x49, 0x49, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, \
- 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, \
- 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, \
- 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
- 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x81, 0x45, 0x41, 0x84, 0x41, 0x86, 0x43, 0x45, 0x45, 0x45, 0x49, 0x49, 0x8D, 0x8E, 0x8F, 0x90, 0x92, 0x92, 0x93, 0x94, 0x95, 0x49, 0x49, 0x98, \
+ 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, \
+ 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
+ 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
}
#elif _CODE_PAGE == 737 /* Greek (OEM) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, \
- 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x92, 0x92, 0x93, 0x94, 0x95, \
- 0x96, 0x97, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, \
- 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0xAA, 0x92, \
- 0x93, 0x94, 0x95, 0x96, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0x97, 0xEA, 0xEB, \
- 0xEC, 0xE4, 0xED, 0xEE, 0xE7, 0xE8, 0xF1, 0xEA, 0xEB, 0xEC, 0xED, \
- 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
- 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x92, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x80, \
+ 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0xAA, 0x92, 0x93, 0x94, 0x95, 0x96, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0x97, \
+ 0xEA, 0xEB, 0xEC, 0xE4, 0xED, 0xEE, 0xE7, 0xE8, 0xF1, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
+ 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
}
#elif _CODE_PAGE == 775 /* Baltic (OEM) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x9A, 0x91, 0xA0, 0x8E, 0x95, 0x8F, 0x80, 0xAD, 0xED, 0x8A, \
- 0x8A, 0xA1, 0x8D, 0x8E, 0x8F, 0x90, 0x92, 0x92, 0xE2, 0x99, 0x95, \
- 0x96, 0x97, 0x97, 0x99, 0x9A, 0x9D, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, \
- 0xA1, 0xE0, 0xA3, 0xA3, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xB5, 0xB6, 0xB7, 0xB8, 0xBD, 0xBE, 0xC6, 0xC7, \
- 0xA5, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, \
- 0xE3, 0xE5, 0xE5, 0xE6, 0xE3, 0xE8, 0xE8, 0xEA, 0xEA, 0xEE, 0xED, \
- 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
- 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x9A, 0x91, 0xA0, 0x8E, 0x95, 0x8F, 0x80, 0xAD, 0xED, 0x8A, 0x8A, 0xA1, 0x8D, 0x8E, 0x8F, 0x90, 0x92, 0x92, 0xE2, 0x99, 0x95, 0x96, 0x97, 0x97, \
+ 0x99, 0x9A, 0x9D, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xE0, 0xA3, 0xA3, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xB5, 0xB6, 0xB7, 0xB8, 0xBD, 0xBE, 0xC6, 0xC7, 0xA5, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, \
+ 0xE1, 0xE2, 0xE3, 0xE5, 0xE5, 0xE6, 0xE3, 0xE8, 0xE8, 0xEA, 0xEA, 0xEE, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
+ 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
}
#elif _CODE_PAGE == 850 /* Multilingual Latin 1 (OEM) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x9A, 0x90, 0xB6, 0x8E, 0xB7, 0x8F, 0x80, 0xD2, 0xD3, 0xD4, \
- 0xD8, 0xD7, 0xDE, 0x8E, 0x8F, 0x90, 0x92, 0x92, 0xE2, 0x99, 0xE3, \
- 0xEA, 0xEB, 0x59, 0x99, 0x9A, 0x9D, 0x9C, 0x9D, 0x9E, 0x9F, 0xB5, \
- 0xD6, 0xE0, 0xE9, 0xA5, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0x21, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC7, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, \
- 0xE3, 0xE5, 0xE5, 0xE6, 0xE7, 0xE7, 0xE9, 0xEA, 0xEB, 0xED, 0xED, \
- 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
- 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x9A, 0x90, 0xB6, 0x8E, 0xB7, 0x8F, 0x80, 0xD2, 0xD3, 0xD4, 0xD8, 0xD7, 0xDE, 0x8E, 0x8F, 0x90, 0x92, 0x92, 0xE2, 0x99, 0xE3, 0xEA, 0xEB, 0x59, \
+ 0x99, 0x9A, 0x9D, 0x9C, 0x9D, 0x9E, 0x9F, 0xB5, 0xD6, 0xE0, 0xE9, 0xA5, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0x21, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC7, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, \
+ 0xE1, 0xE2, 0xE3, 0xE5, 0xE5, 0xE6, 0xE7, 0xE7, 0xE9, 0xEA, 0xEB, 0xED, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
+ 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
}
#elif _CODE_PAGE == 852 /* Latin 2 (OEM) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x9A, 0x90, 0xB6, 0x8E, 0xDE, 0x8F, 0x80, 0x9D, 0xD3, 0x8A, \
- 0x8A, 0xD7, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x91, 0xE2, 0x99, 0x95, \
- 0x95, 0x97, 0x97, 0x99, 0x9A, 0x9B, 0x9B, 0x9D, 0x9E, 0x9F, 0xB5, \
- 0xD6, 0xE0, 0xE9, 0xA4, 0xA4, 0xA6, 0xA6, 0xA8, 0xA8, 0xAA, 0x8D, \
- 0xAC, 0xB8, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBD, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC6, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD1, 0xD1, 0xD2, 0xD3, 0xD2, 0xD5, 0xD6, 0xD7, \
- 0xB7, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, \
- 0xE3, 0xE3, 0xD5, 0xE6, 0xE6, 0xE8, 0xE9, 0xE8, 0xEB, 0xED, 0xED, \
- 0xDD, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
- 0xF9, 0xFA, 0xEB, 0xFC, 0xFC, 0xFE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x9A, 0x90, 0xB6, 0x8E, 0xDE, 0x8F, 0x80, 0x9D, 0xD3, 0x8A, 0x8A, 0xD7, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x91, 0xE2, 0x99, 0x95, 0x95, 0x97, 0x97, \
+ 0x99, 0x9A, 0x9B, 0x9B, 0x9D, 0x9E, 0x9F, 0xB5, 0xD6, 0xE0, 0xE9, 0xA4, 0xA4, 0xA6, 0xA6, 0xA8, 0xA8, 0xAA, 0x8D, 0xAC, 0xB8, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBD, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC6, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD1, 0xD1, 0xD2, 0xD3, 0xD2, 0xD5, 0xD6, 0xD7, 0xB7, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, \
+ 0xE1, 0xE2, 0xE3, 0xE3, 0xD5, 0xE6, 0xE6, 0xE8, 0xE9, 0xE8, 0xEB, 0xED, 0xED, 0xDD, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
+ 0xF9, 0xFA, 0xEB, 0xFC, 0xFC, 0xFE, 0xFF \
}
#elif _CODE_PAGE == 855 /* Cyrillic (OEM) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x81, 0x81, 0x83, 0x83, 0x85, 0x85, 0x87, 0x87, 0x89, 0x89, 0x8B, \
- 0x8B, 0x8D, 0x8D, 0x8F, 0x8F, 0x91, 0x91, 0x93, 0x93, 0x95, 0x95, \
- 0x97, 0x97, 0x99, 0x99, 0x9B, 0x9B, 0x9D, 0x9D, 0x9F, 0x9F, 0xA1, \
- 0xA1, 0xA3, 0xA3, 0xA5, 0xA5, 0xA7, 0xA7, 0xA9, 0xA9, 0xAB, 0xAB, \
- 0xAD, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB6, 0xB6, \
- 0xB8, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBE, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC7, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD1, 0xD1, 0xD3, 0xD3, 0xD5, 0xD5, 0xD7, 0xD7, \
- 0xDD, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xE0, 0xDF, 0xE0, 0xE2, 0xE2, \
- 0xE4, 0xE4, 0xE6, 0xE6, 0xE8, 0xE8, 0xEA, 0xEA, 0xEC, 0xEC, 0xEE, \
- 0xEE, 0xEF, 0xF0, 0xF2, 0xF2, 0xF4, 0xF4, 0xF6, 0xF6, 0xF8, 0xF8, \
- 0xFA, 0xFA, 0xFC, 0xFC, 0xFD, 0xFE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x81, 0x81, 0x83, 0x83, 0x85, 0x85, 0x87, 0x87, 0x89, 0x89, 0x8B, 0x8B, 0x8D, 0x8D, 0x8F, 0x8F, 0x91, 0x91, 0x93, 0x93, 0x95, 0x95, 0x97, 0x97, 0x99, \
+ 0x99, 0x9B, 0x9B, 0x9D, 0x9D, 0x9F, 0x9F, 0xA1, 0xA1, 0xA3, 0xA3, 0xA5, 0xA5, 0xA7, 0xA7, 0xA9, 0xA9, 0xAB, 0xAB, 0xAD, 0xAD, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB6, 0xB6, 0xB8, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBE, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC7, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD1, 0xD1, 0xD3, 0xD3, 0xD5, 0xD5, 0xD7, 0xD7, 0xDD, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xE0, 0xDF, 0xE0, \
+ 0xE2, 0xE2, 0xE4, 0xE4, 0xE6, 0xE6, 0xE8, 0xE8, 0xEA, 0xEA, 0xEC, 0xEC, 0xEE, 0xEE, 0xEF, 0xF0, 0xF2, 0xF2, 0xF4, 0xF4, 0xF6, 0xF6, 0xF8, 0xF8, \
+ 0xFA, 0xFA, 0xFC, 0xFC, 0xFD, 0xFE, 0xFF \
}
#elif _CODE_PAGE == 857 /* Turkish (OEM) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x9A, 0x90, 0xB6, 0x8E, 0xB7, 0x8F, 0x80, 0xD2, 0xD3, 0xD4, \
- 0xD8, 0xD7, 0x98, 0x8E, 0x8F, 0x90, 0x92, 0x92, 0xE2, 0x99, 0xE3, \
- 0xEA, 0xEB, 0x98, 0x99, 0x9A, 0x9D, 0x9C, 0x9D, 0x9E, 0x9E, 0xB5, \
- 0xD6, 0xE0, 0xE9, 0xA5, 0xA5, 0xA6, 0xA6, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0x21, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC7, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, \
- 0xE3, 0xE5, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xDE, 0x59, \
- 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
- 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x9A, 0x90, 0xB6, 0x8E, 0xB7, 0x8F, 0x80, 0xD2, 0xD3, 0xD4, 0xD8, 0xD7, 0x98, 0x8E, 0x8F, 0x90, 0x92, 0x92, 0xE2, 0x99, 0xE3, 0xEA, 0xEB, 0x98, \
+ 0x99, 0x9A, 0x9D, 0x9C, 0x9D, 0x9E, 0x9E, 0xB5, 0xD6, 0xE0, 0xE9, 0xA5, 0xA5, 0xA6, 0xA6, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0x21, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC7, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, \
+ 0xE1, 0xE2, 0xE3, 0xE5, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xDE, 0x59, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
+ 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
}
#elif _CODE_PAGE == 858 /* Multilingual Latin 1 + Euro (OEM) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x9A, 0x90, 0xB6, 0x8E, 0xB7, 0x8F, 0x80, 0xD2, 0xD3, 0xD4, \
- 0xD8, 0xD7, 0xDE, 0x8E, 0x8F, 0x90, 0x92, 0x92, 0xE2, 0x99, 0xE3, \
- 0xEA, 0xEB, 0x59, 0x99, 0x9A, 0x9D, 0x9C, 0x9D, 0x9E, 0x9F, 0xB5, \
- 0xD6, 0xE0, 0xE9, 0xA5, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0x21, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC7, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD1, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, \
- 0xE3, 0xE5, 0xE5, 0xE6, 0xE7, 0xE7, 0xE9, 0xEA, 0xEB, 0xED, 0xED, \
- 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
- 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x9A, 0x90, 0xB6, 0x8E, 0xB7, 0x8F, 0x80, 0xD2, 0xD3, 0xD4, 0xD8, 0xD7, 0xDE, 0x8E, 0x8F, 0x90, 0x92, 0x92, 0xE2, 0x99, 0xE3, 0xEA, 0xEB, 0x59, \
+ 0x99, 0x9A, 0x9D, 0x9C, 0x9D, 0x9E, 0x9F, 0xB5, 0xD6, 0xE0, 0xE9, 0xA5, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0x21, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC7, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD1, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, \
+ 0xE1, 0xE2, 0xE3, 0xE5, 0xE5, 0xE6, 0xE7, 0xE7, 0xE9, 0xEA, 0xEB, 0xED, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
+ 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
}
#elif _CODE_PAGE == 862 /* Hebrew (OEM) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, \
- 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, \
- 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0x41, \
- 0x49, 0x4F, 0x55, 0xA5, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0x21, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, \
- 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, \
- 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
- 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, \
+ 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0x41, 0x49, 0x4F, 0x55, 0xA5, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0x21, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, \
+ 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
+ 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
}
#elif _CODE_PAGE == 866 /* Russian (OEM) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, \
- 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, \
- 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0x80, \
- 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, \
- 0x8C, 0x8D, 0x8E, 0x8F, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0x90, 0x91, 0x92, \
- 0x93, 0x9d, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, \
- 0x9E, 0x9F, 0xF0, 0xF0, 0xF2, 0xF2, 0xF4, 0xF4, 0xF6, 0xF6, 0xF8, \
- 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, \
+ 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0x90, \
+ 0x91, 0x92, 0x93, 0x9d, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xF0, 0xF0, 0xF2, 0xF2, 0xF4, 0xF4, 0xF6, 0xF6, 0xF8, \
+ 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
}
#elif _CODE_PAGE == 874 /* Thai (OEM, Windows) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, \
- 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, \
- 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, \
- 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, \
- 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, \
- 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
- 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, \
+ 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, \
+ 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
+ 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
}
#elif _CODE_PAGE == 1250 /* Central Europe (Windows) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, \
- 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, \
- 0x96, 0x97, 0x98, 0x99, 0x8A, 0x9B, 0x8C, 0x8D, 0x8E, 0x8F, 0xA0, \
- 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xA3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xA5, 0xAA, 0xBB, 0xBC, 0xBD, 0xBC, 0xAF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xC0, 0xC1, 0xC2, \
- 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, \
- 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xF7, 0xD8, \
- 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, \
+ 0x99, 0x8A, 0x9B, 0x8C, 0x8D, 0x8E, 0x8F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xA3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xA5, 0xAA, 0xBB, 0xBC, 0xBD, 0xBC, 0xAF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xC0, \
+ 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xF7, 0xD8, \
+ 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xFF \
}
#elif _CODE_PAGE == 1251 /* Cyrillic (Windows) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x81, 0x82, 0x82, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, \
- 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x80, 0x91, 0x92, 0x93, 0x94, 0x95, \
- 0x96, 0x97, 0x98, 0x99, 0x8A, 0x9B, 0x8C, 0x8D, 0x8E, 0x8F, 0xA0, \
- 0xA2, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB2, 0xA5, 0xB5, 0xB6, \
- 0xB7, 0xA8, 0xB9, 0xAA, 0xBB, 0xA3, 0xBD, 0xBD, 0xAF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xC0, 0xC1, 0xC2, \
- 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, \
- 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, \
- 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF \
+#define _EXCVT \
+ { \
+ 0x80, 0x81, 0x82, 0x82, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x80, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, \
+ 0x99, 0x8A, 0x9B, 0x8C, 0x8D, 0x8E, 0x8F, 0xA0, 0xA2, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB2, 0xA5, 0xB5, 0xB6, 0xB7, 0xA8, 0xB9, 0xAA, 0xBB, 0xA3, 0xBD, 0xBD, 0xAF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xC0, \
+ 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, \
+ 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF \
}
#elif _CODE_PAGE == 1252 /* Latin 1 (Windows) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, \
- 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, \
- 0x96, 0x97, 0x98, 0x99, 0xAd, 0x9B, 0x8C, 0x9D, 0xAE, 0x9F, 0xA0, \
- 0x21, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xC0, 0xC1, 0xC2, \
- 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, \
- 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xF7, 0xD8, \
- 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0x9F \
+#define _EXCVT \
+ { \
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, \
+ 0x99, 0xAd, 0x9B, 0x8C, 0x9D, 0xAE, 0x9F, 0xA0, 0x21, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xC0, \
+ 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xF7, 0xD8, \
+ 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0x9F \
}
#elif _CODE_PAGE == 1253 /* Greek (Windows) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, \
- 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, \
- 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, \
- 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xA2, 0xB8, 0xB9, 0xBA, 0xE0, 0xC1, 0xC2, \
- 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, \
- 0xCE, 0xCF, 0xD0, 0xD1, 0xF2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, \
- 0xD9, 0xDA, 0xFB, 0xBC, 0xFD, 0xBF, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, \
+ 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xA2, 0xB8, 0xB9, 0xBA, 0xE0, \
+ 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xF2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, \
+ 0xD9, 0xDA, 0xFB, 0xBC, 0xFD, 0xBF, 0xFF \
}
#elif _CODE_PAGE == 1254 /* Turkish (Windows) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, \
- 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, \
- 0x96, 0x97, 0x98, 0x99, 0x8A, 0x9B, 0x8C, 0x9D, 0x9E, 0x9F, 0xA0, \
- 0x21, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xC0, 0xC1, 0xC2, \
- 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, \
- 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xF7, 0xD8, \
- 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0x9F \
+#define _EXCVT \
+ { \
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, \
+ 0x99, 0x8A, 0x9B, 0x8C, 0x9D, 0x9E, 0x9F, 0xA0, 0x21, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xC0, \
+ 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xF7, 0xD8, \
+ 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0x9F \
}
#elif _CODE_PAGE == 1255 /* Hebrew (Windows) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, \
- 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, \
- 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, \
- 0x21, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, \
- 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, \
- 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
- 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, \
+ 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0x21, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, \
+ 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, \
+ 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF \
}
#elif _CODE_PAGE == 1256 /* Arabic (Windows) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, \
- 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, \
- 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x8C, 0x9D, 0x9E, 0x9F, 0xA0, \
- 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0x41, 0xE1, 0x41, \
- 0xE3, 0xE4, 0xE5, 0xE6, 0x43, 0x45, 0x45, 0x45, 0x45, 0xEC, 0xED, \
- 0x49, 0x49, 0xF0, 0xF1, 0xF2, 0xF3, 0x4F, 0xF5, 0xF6, 0xF7, 0xF8, \
- 0x55, 0xFA, 0x55, 0x55, 0xFD, 0xFE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, \
+ 0x99, 0x9A, 0x9B, 0x8C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0x41, \
+ 0xE1, 0x41, 0xE3, 0xE4, 0xE5, 0xE6, 0x43, 0x45, 0x45, 0x45, 0x45, 0xEC, 0xED, 0x49, 0x49, 0xF0, 0xF1, 0xF2, 0xF3, 0x4F, 0xF5, 0xF6, 0xF7, 0xF8, \
+ 0x55, 0xFA, 0x55, 0x55, 0xFD, 0xFE, 0xFF \
}
#elif _CODE_PAGE == 1257 /* Baltic (Windows) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, \
- 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, \
- 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, \
- 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xA8, 0xB9, 0xAA, 0xBB, 0xBC, 0xBD, 0xBE, 0xAF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xC0, 0xC1, 0xC2, \
- 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, \
- 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xF7, 0xD8, \
- 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xFF \
+#define _EXCVT \
+ { \
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, \
+ 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xA8, 0xB9, 0xAA, 0xBB, 0xBC, 0xBD, 0xBE, 0xAF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xC0, \
+ 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xF7, 0xD8, \
+ 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xFF \
}
#elif _CODE_PAGE == 1258 /* Vietnam (OEM, Windows) */
#define _DF1S 0
-#define _EXCVT \
- { \
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, \
- 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, \
- 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0xAC, 0x9D, 0x9E, 0x9F, 0xA0, \
- 0x21, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, \
- 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, \
- 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, \
- 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, \
- 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, \
- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xC0, 0xC1, 0xC2, \
- 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xEC, 0xCD, \
- 0xCE, 0xCF, 0xD0, 0xD1, 0xF2, 0xD3, 0xD4, 0xD5, 0xD6, 0xF7, 0xD8, \
- 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xFE, 0x9F \
+#define _EXCVT \
+ { \
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, \
+ 0x99, 0x9A, 0x9B, 0xAC, 0x9D, 0x9E, 0x9F, 0xA0, 0x21, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, \
+ 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, \
+ 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xC0, \
+ 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xEC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xF2, 0xD3, 0xD4, 0xD5, 0xD6, 0xF7, 0xD8, \
+ 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xFE, 0x9F \
}
#elif _CODE_PAGE == 1 /* ASCII (for only non-LFN cfg) */
#if _DF1S /* Code page is DBCS */
#ifdef _DF2S /* Two 1st byte areas */
-#define IsDBCS1(c) \
- (((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E) || \
- ((BYTE)(c) >= _DF2S && (BYTE)(c) <= _DF2E))
+#define IsDBCS1(c) (((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E) || ((BYTE)(c) >= _DF2S && (BYTE)(c) <= _DF2E))
#else /* One 1st byte area */
#define IsDBCS1(c) ((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E)
#endif
#ifdef _DS3S /* Three 2nd byte areas */
-#define IsDBCS2(c) \
- (((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || \
- ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E) || \
- ((BYTE)(c) >= _DS3S && (BYTE)(c) <= _DS3E))
+#define IsDBCS2(c) (((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E) || ((BYTE)(c) >= _DS3S && (BYTE)(c) <= _DS3E))
#else /* Two 2nd byte areas */
-#define IsDBCS2(c) \
- (((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || \
- ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E))
+#define IsDBCS2(c) (((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E))
#endif
#else /* Code page is SBCS */
/ structure member because the structure is not binary compatible between
/ different platforms */
-#define BS_jmpBoot 0 /* x86 jump instruction (3) */
-#define BS_OEMName 3 /* OEM name (8) */
-#define BPB_BytsPerSec 11 /* Sector size [byte] (2) */
-#define BPB_SecPerClus 13 /* Cluster size [sector] (1) */
-#define BPB_RsvdSecCnt 14 /* Size of reserved area [sector] (2) */
-#define BPB_NumFATs 16 /* Number of FAT copies (1) */
-#define BPB_RootEntCnt \
- 17 /* Number of root directory entries for FAT12/16 (2) */
-#define BPB_TotSec16 19 /* Volume size [sector] (2) */
-#define BPB_Media 21 /* Media descriptor (1) */
-#define BPB_FATSz16 22 /* FAT size [sector] (2) */
-#define BPB_SecPerTrk 24 /* Track size [sector] (2) */
-#define BPB_NumHeads 26 /* Number of heads (2) */
-#define BPB_HiddSec 28 /* Number of special hidden sectors (4) */
-#define BPB_TotSec32 32 /* Volume size [sector] (4) */
-#define BS_DrvNum 36 /* Physical drive number (2) */
-#define BS_BootSig 38 /* Extended boot signature (1) */
-#define BS_VolID 39 /* Volume serial number (4) */
-#define BS_VolLab 43 /* Volume label (8) */
-#define BS_FilSysType 54 /* File system type (1) */
-#define BPB_FATSz32 36 /* FAT size [sector] (4) */
-#define BPB_ExtFlags 40 /* Extended flags (2) */
-#define BPB_FSVer 42 /* File system version (2) */
-#define BPB_RootClus 44 /* Root directory first cluster (4) */
-#define BPB_FSInfo 48 /* Offset of FSINFO sector (2) */
-#define BPB_BkBootSec 50 /* Offset of backup boot sector (2) */
-#define BS_DrvNum32 64 /* Physical drive number (2) */
-#define BS_BootSig32 66 /* Extended boot signature (1) */
-#define BS_VolID32 67 /* Volume serial number (4) */
-#define BS_VolLab32 71 /* Volume label (8) */
+#define BS_jmpBoot 0 /* x86 jump instruction (3) */
+#define BS_OEMName 3 /* OEM name (8) */
+#define BPB_BytsPerSec 11 /* Sector size [byte] (2) */
+#define BPB_SecPerClus 13 /* Cluster size [sector] (1) */
+#define BPB_RsvdSecCnt 14 /* Size of reserved area [sector] (2) */
+#define BPB_NumFATs 16 /* Number of FAT copies (1) */
+#define BPB_RootEntCnt 17 /* Number of root directory entries for FAT12/16 (2) */
+#define BPB_TotSec16 19 /* Volume size [sector] (2) */
+#define BPB_Media 21 /* Media descriptor (1) */
+#define BPB_FATSz16 22 /* FAT size [sector] (2) */
+#define BPB_SecPerTrk 24 /* Track size [sector] (2) */
+#define BPB_NumHeads 26 /* Number of heads (2) */
+#define BPB_HiddSec 28 /* Number of special hidden sectors (4) */
+#define BPB_TotSec32 32 /* Volume size [sector] (4) */
+#define BS_DrvNum 36 /* Physical drive number (2) */
+#define BS_BootSig 38 /* Extended boot signature (1) */
+#define BS_VolID 39 /* Volume serial number (4) */
+#define BS_VolLab 43 /* Volume label (8) */
+#define BS_FilSysType 54 /* File system type (1) */
+#define BPB_FATSz32 36 /* FAT size [sector] (4) */
+#define BPB_ExtFlags 40 /* Extended flags (2) */
+#define BPB_FSVer 42 /* File system version (2) */
+#define BPB_RootClus 44 /* Root directory first cluster (4) */
+#define BPB_FSInfo 48 /* Offset of FSINFO sector (2) */
+#define BPB_BkBootSec 50 /* Offset of backup boot sector (2) */
+#define BS_DrvNum32 64 /* Physical drive number (2) */
+#define BS_BootSig32 66 /* Extended boot signature (1) */
+#define BS_VolID32 67 /* Volume serial number (4) */
+#define BS_VolLab32 71 /* Volume label (8) */
#define BS_FilSysType32 82 /* File system type (1) */
#define FSI_LeadSig 0 /* FSI: Leading signature (4) */
#define FSI_StrucSig 484 /* FSI: Structure signature (4) */
#define SZ_DIRE 32 /* Size of a directory entry */
#define LLEF 0x40 /* Last long entry flag in LDIR_Ord */
#define DDEM 0xE5 /* Deleted directory entry mark at DIR_Name[0] */
-#define RDDEM 0x05 /* Replacement of the character collides with DDEM */
+#define RDDEM 0x05 /* Replacement of the character collides with DDEM */
/*------------------------------------------------------------*/
/* Module private work area */
#if _VOLUMES < 1 || _VOLUMES > 9
#error Wrong _VOLUMES setting
#endif
-static FATFS*
- FatFs[_VOLUMES]; /* Pointer to the file system objects (logical drives) */
-static WORD Fsid; /* File system mount ID */
+static FATFS *FatFs[_VOLUMES]; /* Pointer to the file system objects (logical drives) */
+static WORD Fsid; /* File system mount ID */
#if _FS_RPATH && _VOLUMES >= 2
static BYTE CurrVol; /* Current drive */
#if _USE_LFN == 1 /* LFN feature with static working buffer */
static WCHAR LfnBuf[_MAX_LFN + 1];
#define DEFINE_NAMEBUF BYTE sfn[12]
-#define INIT_BUF(dobj) \
- { \
- (dobj).fn = sfn; \
- (dobj).lfn = LfnBuf; \
+#define INIT_BUF(dobj) \
+ { \
+ (dobj).fn = sfn; \
+ (dobj).lfn = LfnBuf; \
}
#define FREE_BUF()
#elif _USE_LFN == 2 /* LFN feature with dynamic working buffer on the stack */
-#define DEFINE_NAMEBUF \
- BYTE sfn[12]; \
+#define DEFINE_NAMEBUF \
+ BYTE sfn[12]; \
WCHAR lbuf[_MAX_LFN + 1]
-#define INIT_BUF(dobj) \
- { \
- (dobj).fn = sfn; \
- (dobj).lfn = lbuf; \
+#define INIT_BUF(dobj) \
+ { \
+ (dobj).fn = sfn; \
+ (dobj).lfn = lbuf; \
}
#define FREE_BUF()
#elif _USE_LFN == 3 /* LFN feature with dynamic working buffer on the heap */
-#define DEFINE_NAMEBUF \
- BYTE sfn[12]; \
- WCHAR* lfn
-#define INIT_BUF(dobj) \
- { \
- lfn = ff_memalloc((_MAX_LFN + 1) * 2); \
- if (!lfn) \
- LEAVE_FF((dobj).fs, FR_NOT_ENOUGH_CORE); \
- (dobj).lfn = lfn; \
- (dobj).fn = sfn; \
+#define DEFINE_NAMEBUF \
+ BYTE sfn[12]; \
+ WCHAR *lfn
+#define INIT_BUF(dobj) \
+ { \
+ lfn = ff_memalloc((_MAX_LFN + 1) * 2); \
+ if (!lfn) \
+ LEAVE_FF((dobj).fs, FR_NOT_ENOUGH_CORE); \
+ (dobj).lfn = lfn; \
+ (dobj).fn = sfn; \
}
#define FREE_BUF() ff_memfree(lfn)
#else
#endif
#ifdef _EXCVT
-static const BYTE ExCvt[] =
- _EXCVT; /* Upper conversion table for extended characters */
+static const BYTE ExCvt[] = _EXCVT; /* Upper conversion table for extended characters */
#endif
/*--------------------------------------------------------------------------
/* Copy memory to memory */
static void
-mem_cpy(void* dst, const void* src, UINT cnt)
+mem_cpy(void *dst, const void *src, UINT cnt)
{
- BYTE* d = (BYTE*)dst;
- const BYTE* s = (const BYTE*)src;
+ BYTE *d = (BYTE *)dst;
+ const BYTE *s = (const BYTE *)src;
#if _WORD_ACCESS == 1
while (cnt >= sizeof(int)) {
- *(int*)d = *(int*)s;
+ *(int *)d = *(int *)s;
d += sizeof(int);
s += sizeof(int);
cnt -= sizeof(int);
/* Fill memory */
static void
-mem_set(void* dst, int val, UINT cnt)
+mem_set(void *dst, int val, UINT cnt)
{
- BYTE* d = (BYTE*)dst;
+ BYTE *d = (BYTE *)dst;
while (cnt--)
*d++ = (BYTE)val;
/* Compare memory to memory */
static int
-mem_cmp(const void* dst, const void* src, UINT cnt)
+mem_cmp(const void *dst, const void *src, UINT cnt)
{
const BYTE *d = (const BYTE *)dst, *s = (const BYTE *)src;
int r = 0;
/* Check if chr is contained in the string */
static int
-chk_chr(const char* str, int chr)
+chk_chr(const char *str, int chr)
{
while (*str && *str != chr)
str++;
/*-----------------------------------------------------------------------*/
#if _FS_REENTRANT
static int
-lock_fs(FATFS* fs /* File system object */
+lock_fs(FATFS *fs /* File system object */
)
{
return ff_req_grant(fs->sobj);
}
static void
-unlock_fs(FATFS* fs, /* File system object */
+unlock_fs(FATFS *fs, /* File system object */
FRESULT res /* Result code to be returned */
)
{
- if (fs && res != FR_NOT_ENABLED && res != FR_INVALID_DRIVE &&
- res != FR_INVALID_OBJECT && res != FR_TIMEOUT) {
+ if (fs && res != FR_NOT_ENABLED && res != FR_INVALID_DRIVE && res != FR_INVALID_OBJECT && res != FR_TIMEOUT) {
ff_rel_grant(fs->sobj);
}
}
static FRESULT
chk_lock( /* Check if the file can be accessed */
- DIR* dp, /* Directory object pointing the file to be checked */
+ DIR *dp, /* Directory object pointing the file to be checked */
int acc /* Desired access type (0:Read, 1:Write, 2:Delete/Rename) */
)
{
/* Search file semaphore table */
for (i = be = 0; i < _FS_LOCK; i++) {
- if (Files[i].fs) { /* Existing entry */
- if (Files[i].fs ==
- dp->fs && /* Check if the object matched with an open
- object */
- Files[i].clu == dp->sclust &&
- Files[i].idx == dp->index)
+ if (Files[i].fs) { /* Existing entry */
+ if (Files[i].fs == dp->fs && /* Check if the object matched with an open
+ object */
+ Files[i].clu == dp->sclust && Files[i].idx == dp->index)
break;
} else { /* Blank entry */
be = 1;
}
}
- if (i == _FS_LOCK) /* The object is not opened */
- return (be || acc == 2) ? FR_OK
- : FR_TOO_MANY_OPEN_FILES; /* Is there a blank
- entry for new
- object? */
+ if (i == _FS_LOCK) /* The object is not opened */
+ return (be || acc == 2) ? FR_OK : FR_TOO_MANY_OPEN_FILES; /* Is there a blank
+ entry for new
+ object? */
/* The object has been opened. Reject any open against writing file and all
* write mode open */
}
static UINT
-inc_lock(/* Increment object open counter and returns its index (0:Internal
- error) */
- DIR* dp, /* Directory object pointing the file to register or increment
+inc_lock( /* Increment object open counter and returns its index (0:Internal
+ error) */
+ DIR *dp, /* Directory object pointing the file to register or increment
*/
int acc /* Desired access (0:Read, 1:Write, 2:Delete/Rename) */
)
UINT i;
for (i = 0; i < _FS_LOCK; i++) { /* Find the object */
- if (Files[i].fs == dp->fs && Files[i].clu == dp->sclust &&
- Files[i].idx == dp->index)
+ if (Files[i].fs == dp->fs && Files[i].clu == dp->sclust && Files[i].idx == dp->index)
break;
}
static void
clear_lock(/* Clear lock entries of the volume */
- FATFS* fs)
+ FATFS *fs)
{
UINT i;
/*-----------------------------------------------------------------------*/
#if !_FS_READONLY
static FRESULT
-sync_window(FATFS* fs /* File system object */
+sync_window(FATFS *fs /* File system object */
)
{
DWORD wsect;
res = FR_DISK_ERR;
} else {
fs->wflag = 0;
- if (wsect - fs->fatbase < fs->fsize) { /* Is it in the FAT area? */
- for (nf = fs->n_fats; nf >= 2;
- nf--) { /* Reflect the change to all FAT copies */
+ if (wsect - fs->fatbase < fs->fsize) { /* Is it in the FAT area? */
+ for (nf = fs->n_fats; nf >= 2; nf--) { /* Reflect the change to all FAT copies */
wsect += fs->fsize;
disk_write(fs->drv, fs->win, wsect, 1);
}
#endif
static FRESULT
-move_window(FATFS* fs, /* File system object */
+move_window(FATFS *fs, /* File system object */
DWORD sector /* Sector number to make appearance in the fs->win[] */
)
{
#endif
if (res == FR_OK) { /* Fill sector window with new data */
if (disk_read(fs->drv, fs->win, sector, 1) != RES_OK) {
- sector =
- 0xFFFFFFFF; /* Invalidate window if data is not reliable */
+ sector = 0xFFFFFFFF; /* Invalidate window if data is not reliable */
res = FR_DISK_ERR;
}
fs->winsect = sector;
#if !_FS_READONLY
static FRESULT
sync_fs( /* FR_OK: successful, FR_DISK_ERR: failed */
- FATFS* fs /* File system object */
+ FATFS *fs /* File system object */
)
{
FRESULT res;
DWORD
clust2sect( /* !=0: Sector number, 0: Failed - invalid cluster# */
- FATFS* fs, /* File system object */
+ FATFS *fs, /* File system object */
DWORD clst /* Cluster# to be converted */
)
{
/* Hidden API for hacks and disk tools */
DWORD
-get_fat(/* 0xFFFFFFFF:Disk error, 1:Internal error, 2..0x0FFFFFFF:Cluster status
- */
- FATFS* fs, /* File system object */
+get_fat( /* 0xFFFFFFFF:Disk error, 1:Internal error, 2..0x0FFFFFFF:Cluster status
+ */
+ FATFS *fs, /* File system object */
DWORD clst /* FAT index number (cluster number) to get the value */
)
{
UINT wc, bc;
- BYTE* p;
+ BYTE *p;
DWORD val;
if (clst < 2 || clst >= fs->n_fatent) { /* Check range */
break;
case FS_FAT16:
- if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 2))) !=
- FR_OK)
+ if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 2))) != FR_OK)
break;
p = &fs->win[clst * 2 % SS(fs)];
val = LD_WORD(p);
break;
case FS_FAT32:
- if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 4))) !=
- FR_OK)
+ if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 4))) != FR_OK)
break;
p = &fs->win[clst * 4 % SS(fs)];
val = LD_DWORD(p) & 0x0FFFFFFF;
#if !_FS_READONLY
FRESULT
-put_fat(FATFS* fs, /* File system object */
+put_fat(FATFS *fs, /* File system object */
DWORD clst, /* FAT index number (cluster number) to be changed */
DWORD val /* New value to be set to the entry */
)
{
UINT bc;
- BYTE* p;
+ BYTE *p;
FRESULT res;
if (clst < 2 || clst >= fs->n_fatent) { /* Check range */
if (res != FR_OK)
break;
p = &fs->win[bc % SS(fs)];
- *p = (clst & 1) ? (BYTE)(val >> 4)
- : ((*p & 0xF0) | ((BYTE)(val >> 8) & 0x0F));
+ *p = (clst & 1) ? (BYTE)(val >> 4) : ((*p & 0xF0) | ((BYTE)(val >> 8) & 0x0F));
fs->wflag = 1;
break;
/*-----------------------------------------------------------------------*/
#if !_FS_READONLY
static FRESULT
-remove_chain(FATFS* fs, /* File system object */
+remove_chain(FATFS *fs, /* File system object */
DWORD clst /* Cluster# to remove a chain from */
)
{
#if _USE_TRIM
if (ecl + 1 == nxt) { /* Is next cluster contiguous? */
ecl = nxt;
- } else { /* End of contiguous clusters */
- rt[0] = clust2sect(fs, scl); /* Start sector */
+ } else { /* End of contiguous clusters */
+ rt[0] = clust2sect(fs, scl); /* Start sector */
rt[1] = clust2sect(fs, ecl) + fs->csize - 1; /* End sector */
- disk_ioctl(fs->drv, CTRL_TRIM, rt); /* Erase the block */
+ disk_ioctl(fs->drv, CTRL_TRIM, rt); /* Erase the block */
scl = ecl = nxt;
}
#endif
/*-----------------------------------------------------------------------*/
#if !_FS_READONLY
static DWORD
-create_chain(/* 0:No free cluster, 1:Internal error, 0xFFFFFFFF:Disk error,
- >=2:New cluster# */
- FATFS* fs, /* File system object */
+create_chain( /* 0:No free cluster, 1:Internal error, 0xFFFFFFFF:Disk error,
+ >=2:New cluster# */
+ FATFS *fs, /* File system object */
DWORD clst /* Cluster# to stretch. 0 means create a new chain. */
)
{
res = put_fat(fs, ncl, 0x0FFFFFFF); /* Mark the new cluster "last link" */
if (res == FR_OK && clst != 0) {
- res =
- put_fat(fs, clst, ncl); /* Link it to the previous one if needed */
+ res = put_fat(fs, clst, ncl); /* Link it to the previous one if needed */
}
if (res == FR_OK) {
fs->last_clust = ncl; /* Update FSINFO */
#if _USE_FASTSEEK
static DWORD
clmt_clust( /* <2:Error, >=2:Cluster number */
- FIL* fp, /* Pointer to the file object */
+ FIL *fp, /* Pointer to the file object */
DWORD ofs /* File offset to be converted to cluster# */
)
{
DWORD cl, ncl, *tbl;
- tbl = fp->cltbl + 1; /* Top of CLMT */
- cl = ofs / SS(fp->fs) /
- fp->fs->csize; /* Cluster order from top of the file */
+ tbl = fp->cltbl + 1; /* Top of CLMT */
+ cl = ofs / SS(fp->fs) / fp->fs->csize; /* Cluster order from top of the file */
for (;;) {
ncl = *tbl++; /* Number of cluters in the fragment */
if (!ncl)
/*-----------------------------------------------------------------------*/
static FRESULT
-dir_sdi(DIR* dp, /* Pointer to directory object */
+dir_sdi(DIR *dp, /* Pointer to directory object */
UINT idx /* Index of directory table */
)
{
DWORD clst, sect;
UINT ic;
- dp->index = (WORD)idx; /* Current index */
- clst = dp->sclust; /* Table start cluster (0:root) */
+ dp->index = (WORD)idx; /* Current index */
+ clst = dp->sclust; /* Table start cluster (0:root) */
if (clst == 1 || clst >= dp->fs->n_fatent) /* Check start cluster range */
return FR_INT_ERR;
- if (!clst &&
- dp->fs->fs_type ==
- FS_FAT32) /* Replace cluster# 0 with root cluster# if in FAT32 */
+ if (!clst && dp->fs->fs_type == FS_FAT32) /* Replace cluster# 0 with root cluster# if in FAT32 */
clst = dp->fs->dirbase;
- if (clst == 0) { /* Static table (root-directory in FAT12/16) */
+ if (clst == 0) { /* Static table (root-directory in FAT12/16) */
if (idx >= dp->fs->n_rootdir) /* Is index out of range? */
return FR_INT_ERR;
sect = dp->fs->dirbase;
- } else { /* Dynamic table (root-directory in FAT32 or sub-directory) */
+ } else { /* Dynamic table (root-directory in FAT32 or sub-directory) */
ic = SS(dp->fs) / SZ_DIRE * dp->fs->csize; /* Entries per cluster */
while (idx >= ic) { /* Follow cluster chain */
clst = get_fat(dp->fs, clst); /* Get next cluster */
if (clst == 0xFFFFFFFF)
- return FR_DISK_ERR; /* Disk error */
- if (clst < 2 ||
- clst >= dp->fs->n_fatent) /* Reached to end of table or internal
- error */
+ return FR_DISK_ERR; /* Disk error */
+ if (clst < 2 || clst >= dp->fs->n_fatent) /* Reached to end of table or internal
+ error */
return FR_INT_ERR;
idx -= ic;
}
dp->clust = clst; /* Current cluster# */
if (!sect)
return FR_INT_ERR;
- dp->sect =
- sect +
- idx / (SS(dp->fs) / SZ_DIRE); /* Sector# of the directory entry */
- dp->dir = dp->fs->win +
- (idx % (SS(dp->fs) / SZ_DIRE)) *
- SZ_DIRE; /* Ptr to the entry in the sector */
+ dp->sect = sect + idx / (SS(dp->fs) / SZ_DIRE); /* Sector# of the directory entry */
+ dp->dir = dp->fs->win + (idx % (SS(dp->fs) / SZ_DIRE)) * SZ_DIRE; /* Ptr to the entry in the sector */
return FR_OK;
}
/*-----------------------------------------------------------------------*/
static FRESULT
-dir_next(/* FR_OK:Succeeded, FR_NO_FILE:End of table, FR_DENIED:Could not
- stretch */
- DIR* dp, /* Pointer to the directory object */
+dir_next( /* FR_OK:Succeeded, FR_NO_FILE:End of table, FR_DENIED:Could not
+ stretch */
+ DIR *dp, /* Pointer to the directory object */
int stretch /* 0: Do not stretch table, 1: Stretch table if needed */
)
{
#endif
i = dp->index + 1;
- if (!(i & 0xFFFF) ||
- !dp->sect) /* Report EOT when index has reached 65535 */
+ if (!(i & 0xFFFF) || !dp->sect) /* Report EOT when index has reached 65535 */
return FR_NO_FILE;
if (!(i % (SS(dp->fs) / SZ_DIRE))) { /* Sector changed? */
if (i >= dp->fs->n_rootdir) /* Report EOT if it reached end of
static table */
return FR_NO_FILE;
- } else { /* Dynamic table */
- if (((i / (SS(dp->fs) / SZ_DIRE)) & (dp->fs->csize - 1)) ==
- 0) { /* Cluster changed? */
- clst = get_fat(dp->fs, dp->clust); /* Get next cluster */
+ } else { /* Dynamic table */
+ if (((i / (SS(dp->fs) / SZ_DIRE)) & (dp->fs->csize - 1)) == 0) { /* Cluster changed? */
+ clst = get_fat(dp->fs, dp->clust); /* Get next cluster */
if (clst <= 1)
return FR_INT_ERR;
if (clst == 0xFFFFFFFF)
return FR_DISK_ERR;
- if (clst >=
- dp->fs
- ->n_fatent) { /* If it reached end of dynamic table, */
+ if (clst >= dp->fs->n_fatent) { /* If it reached end of dynamic table, */
#if !_FS_READONLY
if (!stretch)
- return FR_NO_FILE; /* If do not stretch, report EOT */
- clst = create_chain(dp->fs,
- dp->clust); /* Stretch cluster chain */
+ return FR_NO_FILE; /* If do not stretch, report EOT */
+ clst = create_chain(dp->fs, dp->clust); /* Stretch cluster chain */
if (clst == 0)
return FR_DENIED; /* No free cluster */
if (clst == 1)
return FR_DISK_ERR;
/* Clean-up stretched table */
if (sync_window(dp->fs))
- return FR_DISK_ERR; /* Flush disk access window */
- mem_set(dp->fs->win, 0,
- SS(dp->fs)); /* Clear window buffer */
- dp->fs->winsect =
- clust2sect(dp->fs, clst); /* Cluster start sector */
- for (c = 0; c < dp->fs->csize;
- c++) { /* Fill the new cluster with 0 */
+ return FR_DISK_ERR; /* Flush disk access window */
+ mem_set(dp->fs->win, 0, SS(dp->fs)); /* Clear window buffer */
+ dp->fs->winsect = clust2sect(dp->fs, clst); /* Cluster start sector */
+ for (c = 0; c < dp->fs->csize; c++) { /* Fill the new cluster with 0 */
dp->fs->wflag = 1;
if (sync_window(dp->fs))
return FR_DISK_ERR;
dp->fs->winsect -= c; /* Rewind window offset */
#else
if (!stretch)
- return FR_NO_FILE; /* If do not stretch, report EOT
- (this is to suppress warning) */
- return FR_NO_FILE; /* Report EOT */
+ return FR_NO_FILE; /* If do not stretch, report EOT
+ (this is to suppress warning) */
+ return FR_NO_FILE; /* Report EOT */
#endif
}
dp->clust = clst; /* Initialize data for new cluster */
}
}
- dp->index = (WORD)i; /* Current index */
- dp->dir = dp->fs->win +
- (i % (SS(dp->fs) / SZ_DIRE)) *
- SZ_DIRE; /* Current entry in the window */
+ dp->index = (WORD)i; /* Current index */
+ dp->dir = dp->fs->win + (i % (SS(dp->fs) / SZ_DIRE)) * SZ_DIRE; /* Current entry in the window */
return FR_OK;
}
#if !_FS_READONLY
static FRESULT
-dir_alloc(DIR* dp, /* Pointer to the directory object */
+dir_alloc(DIR *dp, /* Pointer to the directory object */
UINT nent /* Number of contiguous entries to allocate (1-21) */
)
{
res = move_window(dp->fs, dp->sect);
if (res != FR_OK)
break;
- if (dp->dir[0] == DDEM ||
- dp->dir[0] == 0) { /* Is it a free entry? */
+ if (dp->dir[0] == DDEM || dp->dir[0] == 0) { /* Is it a free entry? */
if (++n == nent)
break; /* A block of contiguous free entries is found */
} else {
/*-----------------------------------------------------------------------*/
static DWORD
-ld_clust(FATFS* fs, /* Pointer to the fs object */
- BYTE* dir /* Pointer to the directory entry */
+ld_clust(FATFS *fs, /* Pointer to the fs object */
+ BYTE *dir /* Pointer to the directory entry */
)
{
DWORD cl;
#if !_FS_READONLY
static void
-st_clust(BYTE* dir, /* Pointer to the directory entry */
+st_clust(BYTE *dir, /* Pointer to the directory entry */
DWORD cl /* Value to be set */
)
{
/* LFN handling - Test/Pick/Fit an LFN segment from/to directory entry */
/*-----------------------------------------------------------------------*/
#if _USE_LFN
-static const BYTE LfnOfs[] = {
- 1, 3, 5, 7, 9, 14, 16, 18, 20, 22, 24, 28, 30
-}; /* Offset of LFN characters in the directory entry */
+static const BYTE LfnOfs[] = { 1, 3, 5, 7, 9, 14, 16, 18, 20, 22, 24, 28, 30 }; /* Offset of LFN characters in the directory entry */
static int
cmp_lfn( /* 1:Matched, 0:Not matched */
- WCHAR* lfnbuf, /* Pointer to the LFN to be compared */
- BYTE* dir /* Pointer to the directory entry containing a part of LFN */
+ WCHAR *lfnbuf, /* Pointer to the LFN to be compared */
+ BYTE *dir /* Pointer to the directory entry containing a part of LFN */
)
{
UINT i, s;
s = 0;
wc = 1;
do {
- uc =
- LD_WORD(dir + LfnOfs[s]); /* Pick an LFN character from the entry */
- if (wc) { /* Last character has not been processed */
- wc = ff_wtoupper(uc); /* Convert it to upper case */
- if (i >= _MAX_LFN ||
- wc != ff_wtoupper(lfnbuf[i++])) /* Compare it */
- return 0; /* Not matched */
+ uc = LD_WORD(dir + LfnOfs[s]); /* Pick an LFN character from the entry */
+ if (wc) { /* Last character has not been processed */
+ wc = ff_wtoupper(uc); /* Convert it to upper case */
+ if (i >= _MAX_LFN || wc != ff_wtoupper(lfnbuf[i++])) /* Compare it */
+ return 0; /* Not matched */
} else {
if (uc != 0xFFFF)
return 0; /* Check filler */
}
- } while (++s <
- 13); /* Repeat until all characters in the entry are checked */
+ } while (++s < 13); /* Repeat until all characters in the entry are checked */
- if ((dir[LDIR_Ord] & LLEF) && wc &&
- lfnbuf[i]) /* Last segment matched but different length */
+ if ((dir[LDIR_Ord] & LLEF) && wc && lfnbuf[i]) /* Last segment matched but different length */
return 0;
return 1; /* The part of LFN matched */
static int
pick_lfn( /* 1:Succeeded, 0:Buffer overflow */
- WCHAR* lfnbuf, /* Pointer to the Unicode-LFN buffer */
- BYTE* dir /* Pointer to the directory entry */
+ WCHAR *lfnbuf, /* Pointer to the Unicode-LFN buffer */
+ BYTE *dir /* Pointer to the directory entry */
)
{
UINT i, s;
s = 0;
wc = 1;
do {
- uc =
- LD_WORD(dir + LfnOfs[s]); /* Pick an LFN character from the entry */
- if (wc) { /* Last character has not been processed */
+ uc = LD_WORD(dir + LfnOfs[s]); /* Pick an LFN character from the entry */
+ if (wc) { /* Last character has not been processed */
if (i >= _MAX_LFN)
return 0; /* Buffer overflow? */
lfnbuf[i++] = wc = uc; /* Store it */
#if !_FS_READONLY
static void
-fit_lfn(const WCHAR* lfnbuf, /* Pointer to the LFN buffer */
- BYTE* dir, /* Pointer to the directory entry */
+fit_lfn(const WCHAR *lfnbuf, /* Pointer to the LFN buffer */
+ BYTE *dir, /* Pointer to the directory entry */
BYTE ord, /* LFN order (1-20) */
BYTE sum /* SFN sum */
)
/*-----------------------------------------------------------------------*/
#if _USE_LFN
static void
-gen_numname(BYTE* dst, /* Pointer to the buffer to store numbered SFN */
- const BYTE* src, /* Pointer to SFN */
- const WCHAR* lfn, /* Pointer to LFN */
+gen_numname(BYTE *dst, /* Pointer to the buffer to store numbered SFN */
+ const BYTE *src, /* Pointer to SFN */
+ const WCHAR *lfn, /* Pointer to LFN */
UINT seq /* Sequence number */
)
{
/*-----------------------------------------------------------------------*/
#if _USE_LFN
static BYTE
-sum_sfn(const BYTE* dir /* Pointer to the SFN entry */
+sum_sfn(const BYTE *dir /* Pointer to the SFN entry */
)
{
BYTE sum = 0;
/*-----------------------------------------------------------------------*/
static FRESULT
-dir_find(DIR* dp /* Pointer to the directory object linked to the file name */
+dir_find(DIR *dp /* Pointer to the directory object linked to the file name */
)
{
FRESULT res;
} /* Reached to end of table */
#if _USE_LFN /* LFN configuration */
a = dir[DIR_Attr] & AM_MASK;
- if (c == DDEM ||
- ((a & AM_VOL) && a != AM_LFN)) { /* An entry without valid data */
+ if (c == DDEM || ((a & AM_VOL) && a != AM_LFN)) { /* An entry without valid data */
ord = 0xFF;
dp->lfn_idx = 0xFFFF; /* Reset LFN sequence */
} else {
}
/* Check validity of the LFN entry and compare it with given
* name */
- ord = (c == ord && sum == dir[LDIR_Chksum] &&
- cmp_lfn(dp->lfn, dir))
- ? ord - 1
- : 0xFF;
+ ord = (c == ord && sum == dir[LDIR_Chksum] && cmp_lfn(dp->lfn, dir)) ? ord - 1 : 0xFF;
}
} else { /* An SFN entry is found */
if (!ord && sum == sum_sfn(dir))
}
}
#else /* Non LFN configuration */
- if (!(dir[DIR_Attr] & AM_VOL) &&
- !mem_cmp(dir, dp->fn, 11)) /* Is it a valid entry? */
+ if (!(dir[DIR_Attr] & AM_VOL) && !mem_cmp(dir, dp->fn, 11)) /* Is it a valid entry? */
break;
#endif
res = dir_next(dp, 0); /* Next entry */
/*-----------------------------------------------------------------------*/
#if _FS_MINIMIZE <= 1 || _USE_LABEL || _FS_RPATH >= 2
static FRESULT
-dir_read(DIR* dp, /* Pointer to the directory object */
+dir_read(DIR *dp, /* Pointer to the directory object */
int vol /* Filtered by 0:file/directory or 1:volume label */
)
{
break;
} /* Reached to end of table */
a = dir[DIR_Attr] & AM_MASK;
-#if _USE_LFN /* LFN configuration */
- if (c == DDEM || (!_FS_RPATH && c == '.') ||
- (int)((a & ~AM_ARC) == AM_VOL) !=
- vol) { /* An entry without valid data */
+#if _USE_LFN /* LFN configuration */
+ if (c == DDEM || (!_FS_RPATH && c == '.') || (int)((a & ~AM_ARC) == AM_VOL) != vol) { /* An entry without valid data */
ord = 0xFF;
} else {
if (a == AM_LFN) { /* An LFN entry is found */
dp->lfn_idx = dp->index;
}
/* Check LFN validity and capture it */
- ord = (c == ord && sum == dir[LDIR_Chksum] &&
- pick_lfn(dp->lfn, dir))
- ? ord - 1
- : 0xFF;
+ ord = (c == ord && sum == dir[LDIR_Chksum] && pick_lfn(dp->lfn, dir)) ? ord - 1 : 0xFF;
} else { /* An SFN entry is found */
if (ord || sum != sum_sfn(dir)) /* Is there a valid LFN? */
dp->lfn_idx = 0xFFFF; /* It has no LFN. */
}
}
#else /* Non LFN configuration */
- if (c != DDEM && (_FS_RPATH || c != '.') && a != AM_LFN &&
- (int)((a & ~AM_ARC) == AM_VOL) == vol) /* Is it a valid entry? */
+ if (c != DDEM && (_FS_RPATH || c != '.') && a != AM_LFN && (int)((a & ~AM_ARC) == AM_VOL) == vol) /* Is it a valid entry? */
break;
#endif
res = dir_next(dp, 0); /* Next entry */
/*-----------------------------------------------------------------------*/
#if !_FS_READONLY
static FRESULT
-dir_register(/* FR_OK:Successful, FR_DENIED:No free entry or too many SFN
- collision, FR_DISK_ERR:Disk error */
- DIR* dp /* Target directory with object name to be created */
+dir_register( /* FR_OK:Successful, FR_DENIED:No free entry or too many SFN
+ collision, FR_DISK_ERR:Disk error */
+ DIR *dp /* Target directory with object name to be created */
)
{
FRESULT res;
#if _USE_LFN /* LFN configuration */
UINT n, nent;
BYTE sn[12], *fn, sum;
- WCHAR* lfn;
+ WCHAR *lfn;
fn = dp->fn;
lfn = dp->lfn;
if (_FS_RPATH && (sn[NSFLAG] & NS_DOT)) /* Cannot create dot entry */
return FR_INVALID_NAME;
- if (sn[NSFLAG] &
- NS_LOSS) { /* When LFN is out of 8.3 format, generate a numbered name */
+ if (sn[NSFLAG] & NS_LOSS) { /* When LFN is out of 8.3 format, generate a numbered name */
fn[NSFLAG] = 0;
dp->lfn = 0; /* Find only SFN */
for (n = 1; n < 100; n++) {
gen_numname(fn, sn, lfn, n); /* Generate a numbered name */
- res =
- dir_find(dp); /* Check if the name collides with existing SFN */
+ res = dir_find(dp); /* Check if the name collides with existing SFN */
if (res != FR_OK)
break;
}
mem_set(dp->dir, 0, SZ_DIRE); /* Clean the entry */
mem_cpy(dp->dir, dp->fn, 11); /* Put SFN */
#if _USE_LFN
- dp->dir[DIR_NTres] =
- dp->fn[NSFLAG] & (NS_BODY | NS_EXT); /* Put NT flag */
+ dp->dir[DIR_NTres] = dp->fn[NSFLAG] & (NS_BODY | NS_EXT); /* Put NT flag */
#endif
dp->fs->wflag = 1;
}
#if !_FS_READONLY && !_FS_MINIMIZE
static FRESULT
dir_remove( /* FR_OK: Successful, FR_DISK_ERR: A disk error */
- DIR* dp /* Directory object pointing the entry to be removed */
+ DIR *dp /* Directory object pointing the entry to be removed */
)
{
FRESULT res;
#if _USE_LFN /* LFN configuration */
UINT i;
- i = dp->index; /* SFN index */
- res = dir_sdi(
- dp, (dp->lfn_idx == 0xFFFF)
- ? i
- : dp->lfn_idx); /* Goto the SFN or top of the LFN entries */
+ i = dp->index; /* SFN index */
+ res = dir_sdi(dp, (dp->lfn_idx == 0xFFFF) ? i : dp->lfn_idx); /* Goto the SFN or top of the LFN entries */
if (res == FR_OK) {
do {
res = move_window(dp->fs, dp->sect);
if (res != FR_OK)
break;
- mem_set(dp->dir, 0,
- SZ_DIRE); /* Clear and mark the entry "deleted" */
+ mem_set(dp->dir, 0, SZ_DIRE); /* Clear and mark the entry "deleted" */
*dp->dir = DDEM;
dp->fs->wflag = 1;
if (dp->index >= i)
- break; /* When reached SFN, all entries of the object has been
- deleted. */
+ break; /* When reached SFN, all entries of the object has been
+ deleted. */
res = dir_next(dp, 0); /* Next entry */
} while (res == FR_OK);
if (res == FR_NO_FILE)
if (res == FR_OK) {
res = move_window(dp->fs, dp->sect);
if (res == FR_OK) {
- mem_set(dp->dir, 0,
- SZ_DIRE); /* Clear and mark the entry "deleted" */
+ mem_set(dp->dir, 0, SZ_DIRE); /* Clear and mark the entry "deleted" */
*dp->dir = DDEM;
dp->fs->wflag = 1;
}
#if _FS_MINIMIZE <= 1 || _FS_RPATH >= 2
static void
get_fileinfo( /* No return code */
- DIR* dp, /* Pointer to the directory object */
- FILINFO* fno /* Pointer to the file information to be filled */
+ DIR *dp, /* Pointer to the directory object */
+ FILINFO *fno /* Pointer to the file information to be filled */
)
{
UINT i;
TCHAR *p, c;
- BYTE* dir;
+ BYTE *dir;
#if _USE_LFN
WCHAR w, *lfn;
#endif
if (fno->lfname) {
i = 0;
p = fno->lfname;
- if (dp->sect && fno->lfsize &&
- dp->lfn_idx != 0xFFFF) { /* Get LFN if available */
+ if (dp->sect && fno->lfsize && dp->lfn_idx != 0xFFFF) { /* Get LFN if available */
lfn = dp->lfn;
while ((w = *lfn++) != 0) { /* Get an LFN character */
#if !_LFN_UNICODE
if (!w) {
i = 0;
break;
- } /* No LFN if it could not be converted */
- if (_DF1S &&
- w >= 0x100) /* Put 1st byte if it is a DBC (always false on
- SBCS cfg) */
+ } /* No LFN if it could not be converted */
+ if (_DF1S && w >= 0x100) /* Put 1st byte if it is a DBC (always false on
+ SBCS cfg) */
p[i++] = (TCHAR)(w >> 8);
#endif
if (i >= fno->lfsize - 1) {
/*-----------------------------------------------------------------------*/
#if _USE_FIND && _FS_MINIMIZE <= 1
static WCHAR
-get_achar(/* Get a character and advances ptr 1 or 2 */
- const TCHAR**
- ptr /* Pointer to pointer to the SBCS/DBCS/Unicode string */
+get_achar( /* Get a character and advances ptr 1 or 2 */
+ const TCHAR **ptr /* Pointer to pointer to the SBCS/DBCS/Unicode string */
)
{
WCHAR chr;
chr = ExCvt[chr - 0x80]; /* To upper SBCS extended char */
#endif
#else
- chr = ff_wtoupper(*(*ptr)++); /* Get a word and to upper */
+ chr = ff_wtoupper(*(*ptr)++); /* Get a word and to upper */
#endif
return chr;
}
static int
pattern_matching( /* Return value: 0:mismatched, 1:matched */
- const TCHAR* pat, /* Matching pattern */
- const TCHAR* nam, /* String to be tested */
+ const TCHAR *pat, /* Matching pattern */
+ const TCHAR *nam, /* String to be tested */
int skip, /* Number of pre-skip chars (number of ?s) */
int inf /* Infinite search (* specified) */
)
return 1; /* Branch matched? (matched at end of both strings) */
}
get_achar(&nam); /* nam++ */
- } while (inf &&
- nc); /* Retry until end of name if infinite search is specified */
+ } while (inf && nc); /* Retry until end of name if infinite search is specified */
return 0;
}
/*-----------------------------------------------------------------------*/
static FRESULT
-create_name(DIR* dp, /* Pointer to the directory object */
- const TCHAR**
- path /* Pointer to pointer to the segment in the path string */
+create_name(DIR *dp, /* Pointer to the directory object */
+ const TCHAR **path /* Pointer to pointer to the segment in the path string */
)
{
#if _USE_LFN /* LFN configuration */
BYTE b, cf;
WCHAR w, *lfn;
UINT i, ni, si, di;
- const TCHAR* p;
+ const TCHAR *p;
/* Create LFN in Unicode */
for (p = *path; *p == '/' || *p == '\\'; p++)
return FR_INVALID_NAME;
#if !_LFN_UNICODE
w &= 0xFF;
- if (IsDBCS1(w)) { /* Check if it is a DBC 1st byte (always false on SBCS
- cfg) */
+ if (IsDBCS1(w)) { /* Check if it is a DBC 1st byte (always false on SBCS
+ cfg) */
b = (BYTE)p[si++]; /* Get 2nd byte */
w = (w << 8) + b; /* Create a DBC */
if (!IsDBCS2(b))
if (!w)
return FR_INVALID_NAME; /* Reject invalid code */
#endif
- if (w < 0x80 &&
- chk_chr("\"*:<>\?|\x7F", w)) /* Reject illegal characters for LFN */
+ if (w < 0x80 && chk_chr("\"*:<>\?|\x7F", w)) /* Reject illegal characters for LFN */
return FR_INVALID_NAME;
lfn[di++] = w; /* Store the Unicode character */
}
w = ExCvt[w - 0x80]; /* Convert extended character to upper
(SBCS) */
#else
- w = ff_convert(ff_wtoupper(w),
- 0); /* Upper converted Unicode -> OEM code */
+ w = ff_convert(ff_wtoupper(w), 0); /* Upper converted Unicode -> OEM code */
#endif
cf |= NS_LFN; /* Force create LFN entry */
}
continue;
}
dp->fn[i++] = (BYTE)(w >> 8);
- } else { /* SBC */
- if (!w ||
- chk_chr("+,;=[]", w)) { /* Replace illegal characters for SFN */
+ } else { /* SBC */
+ if (!w || chk_chr("+,;=[]", w)) { /* Replace illegal characters for SFN */
w = '_';
cf |= NS_LOSS | NS_LFN; /* Lossy conversion */
} else {
if (ni == 8)
b <<= 2;
- if ((b & 0x0C) == 0x0C ||
- (b & 0x03) ==
- 0x03) /* Create LFN entry when there are composite capitals */
+ if ((b & 0x0C) == 0x0C || (b & 0x03) == 0x03) /* Create LFN entry when there are composite capitals */
cf |= NS_LFN;
if (!(cf & NS_LFN)) { /* When LFN is in 8.3 format without extended
character, NT flags are created */
#else /* Non-LFN configuration */
BYTE b, c, d, *sfn;
UINT ni, si, i;
- const char* p;
+ const char *p;
/* Create file name in directory form */
for (p = *path; *p == '/' || *p == '\\'; p++)
}
if (c != '/' && c != '\\' && c > ' ')
return FR_INVALID_NAME;
- *path = &p[si]; /* Return pointer to the next segment */
- sfn[NSFLAG] = (c <= ' ')
- ? NS_LAST | NS_DOT
- : NS_DOT; /* Set last segment flag if end of path */
+ *path = &p[si]; /* Return pointer to the next segment */
+ sfn[NSFLAG] = (c <= ' ') ? NS_LAST | NS_DOT : NS_DOT; /* Set last segment flag if end of path */
return FR_OK;
}
#endif
b <<= 2;
continue;
}
- if (c >= 0x80) { /* Extended character? */
- b |= 3; /* Eliminate NT flag */
+ if (c >= 0x80) { /* Extended character? */
+ b |= 3; /* Eliminate NT flag */
#ifdef _EXCVT
c = ExCvt[c - 0x80]; /* To upper extended characters (SBCS cfg) */
#else
#endif
#endif
}
- if (IsDBCS1(c)) { /* Check if it is a DBC 1st byte (always false on SBCS
- cfg) */
+ if (IsDBCS1(c)) { /* Check if it is a DBC 1st byte (always false on SBCS
+ cfg) */
d = (BYTE)p[si++]; /* Get 2nd byte */
if (!IsDBCS2(d) || i >= ni - 1) /* Reject invalid DBC */
return FR_INVALID_NAME;
sfn[i++] = c;
sfn[i++] = d;
- } else { /* SBC */
- if (chk_chr("\"*+,:;<=>\?[]|\x7F",
- c)) /* Reject illegal chrs for SFN */
+ } else { /* SBC */
+ if (chk_chr("\"*+,:;<=>\?[]|\x7F", c)) /* Reject illegal chrs for SFN */
return FR_INVALID_NAME;
if (IsUpper(c)) { /* ASCII large capital? */
b |= 2;
/*-----------------------------------------------------------------------*/
static FRESULT
-follow_path( /* FR_OK(0): successful, !=0: error code */
- DIR* dp, /* Directory object to return last directory and found
- object */
- const TCHAR* path /* Full-path string to find a file or directory */
+follow_path( /* FR_OK(0): successful, !=0: error code */
+ DIR *dp, /* Directory object to return last directory and found
+ object */
+ const TCHAR *path /* Full-path string to find a file or directory */
)
{
FRESULT res;
#if _FS_RPATH
if (*path == '/' || *path == '\\') { /* There is a heading separator */
path++;
- dp->sclust = 0; /* Strip it and start from the root directory */
- } else { /* No heading separator */
+ dp->sclust = 0; /* Strip it and start from the root directory */
+ } else { /* No heading separator */
dp->sclust = dp->fs->cdir; /* Start from the current directory */
}
#else
break;
res = dir_find(dp); /* Find an object with the sagment name */
ns = dp->fn[NSFLAG];
- if (res != FR_OK) { /* Failed to find the object */
- if (res == FR_NO_FILE) { /* Object is not found */
- if (_FS_RPATH &&
- (ns & NS_DOT)) { /* If dot entry is not exist, */
+ if (res != FR_OK) { /* Failed to find the object */
+ if (res == FR_NO_FILE) { /* Object is not found */
+ if (_FS_RPATH && (ns & NS_DOT)) { /* If dot entry is not exist, */
dp->sclust = 0;
- dp->dir =
- 0; /* it is the root directory and stay there */
+ dp->dir = 0; /* it is the root directory and stay there */
if (!(ns & NS_LAST))
continue; /* Continue to follow if not last segment
*/
break;
}
if (ns & NS_LAST)
- break; /* Last segment matched. Function completed. */
- dir = dp->dir; /* Follow the sub-directory */
- if (!(dir[DIR_Attr] &
- AM_DIR)) { /* It is not a sub-directory and cannot follow */
+ break; /* Last segment matched. Function completed. */
+ dir = dp->dir; /* Follow the sub-directory */
+ if (!(dir[DIR_Attr] & AM_DIR)) { /* It is not a sub-directory and cannot follow */
res = FR_NO_PATH;
break;
}
/*-----------------------------------------------------------------------*/
static int
-get_ldnumber(/* Returns logical drive number (-1:invalid drive) */
- const TCHAR** path /* Pointer to pointer to the path name */
+get_ldnumber( /* Returns logical drive number (-1:invalid drive) */
+ const TCHAR **path /* Pointer to pointer to the path name */
)
{
const TCHAR *tp, *tt;
UINT i;
int vol = -1;
#if _STR_VOLUME_ID /* Find string drive id */
- static const char* const str[] = { _VOLUME_STRS };
- const char* sp;
+ static const char *const str[] = { _VOLUME_STRS };
+ const char *sp;
char c;
TCHAR tc;
#endif
if (*path) { /* If the pointer is not a null */
- for (tt = *path; (UINT)*tt >= (_USE_LFN ? ' ' : '!') && *tt != ':';
- tt++)
+ for (tt = *path; (UINT)*tt >= (_USE_LFN ? ' ' : '!') && *tt != ':'; tt++)
; /* Find ':' in the path */
if (*tt == ':') { /* If a ':' is exist in the path name */
tp = *path;
i = *tp++ - '0';
if (i < 10 && tp == tt) { /* Is there a numeric drive id? */
- if (i < _VOLUMES) { /* If a drive id is found, get the value and
- strip it */
+ if (i < _VOLUMES) { /* If a drive id is found, get the value and
+ strip it */
vol = (int)i;
*path = ++tt;
}
if (IsLower(tc))
tc -= 0x20;
} while (c && (TCHAR)c == tc);
- } while (
- (c || tp != tt) &&
- ++i <
- _VOLUMES); /* Repeat for each id until pattern match */
- if (i < _VOLUMES) { /* If a drive id is found, get the value and
- strip it */
+ } while ((c || tp != tt) && ++i < _VOLUMES); /* Repeat for each id until pattern match */
+ if (i < _VOLUMES) { /* If a drive id is found, get the value and
+ strip it */
vol = (int)i;
*path = tt;
}
/*-----------------------------------------------------------------------*/
static BYTE
-check_fs(/* 0:FAT boor sector, 1:Valid boor sector but not FAT, 2:Not a boot
- sector, 3:Disk error */
- FATFS* fs, /* File system object */
+check_fs( /* 0:FAT boor sector, 1:Valid boor sector but not FAT, 2:Not a boot
+ sector, 3:Disk error */
+ FATFS *fs, /* File system object */
DWORD sect /* Sector# (lba) to check if it is an FAT boot record or not
*/
)
>512) */
return 2;
- if ((LD_DWORD(&fs->win[BS_FilSysType]) & 0xFFFFFF) ==
- 0x544146) /* Check "FAT" string */
+ if ((LD_DWORD(&fs->win[BS_FilSysType]) & 0xFFFFFF) == 0x544146) /* Check "FAT" string */
return 0;
- if ((LD_DWORD(&fs->win[BS_FilSysType32]) & 0xFFFFFF) ==
- 0x544146) /* Check "FAT" string */
+ if ((LD_DWORD(&fs->win[BS_FilSysType32]) & 0xFFFFFF) == 0x544146) /* Check "FAT" string */
return 0;
return 1;
/*-----------------------------------------------------------------------*/
static FRESULT
-find_volume(/* FR_OK(0): successful, !=0: any error occurred */
- FATFS**
- rfs, /* Pointer to pointer to the found file system object */
- const TCHAR**
- path, /* Pointer to pointer to the path name (drive number) */
- BYTE wmode /* !=0: Check write protection for write access */
+find_volume( /* FR_OK(0): successful, !=0: any error occurred */
+ FATFS **rfs, /* Pointer to pointer to the found file system object */
+ const TCHAR **path, /* Pointer to pointer to the path name (drive number) */
+ BYTE wmode /* !=0: Check write protection for write access */
)
{
BYTE fmt, *pt;
DSTATUS stat;
DWORD bsect, fasize, tsect, sysect, nclst, szbfat, br[4];
WORD nrsv;
- FATFS* fs;
+ FATFS *fs;
UINT i;
/* Get logical drive number from the path name */
if (fs->fs_type) { /* If the volume has been mounted */
stat = disk_status(fs->drv);
- if (!(stat &
- STA_NOINIT)) { /* and the physical drive is kept initialized */
- if (!_FS_READONLY && wmode &&
- (stat & STA_PROTECT)) /* Check write protection if needed */
+ if (!(stat & STA_NOINIT)) { /* and the physical drive is kept initialized */
+ if (!_FS_READONLY && wmode && (stat & STA_PROTECT)) /* Check write protection if needed */
return FR_WRITE_PROTECTED;
return FR_OK; /* The file system object is valid */
}
/* Following code attempts to mount the volume. (analyze BPB and initialize
* the fs object) */
- fs->fs_type = 0; /* Clear the file system object */
- fs->drv = LD2PD(vol); /* Bind the logical drive and a physical drive */
- stat = disk_initialize(fs->drv); /* Initialize the physical drive */
- if (stat & STA_NOINIT) /* Check if the initialization succeeded */
- return FR_NOT_READY; /* Failed to initialize due to no medium or hard
- error */
- if (!_FS_READONLY && wmode &&
- (stat & STA_PROTECT)) /* Check disk write protection if needed */
+ fs->fs_type = 0; /* Clear the file system object */
+ fs->drv = LD2PD(vol); /* Bind the logical drive and a physical drive */
+ stat = disk_initialize(fs->drv); /* Initialize the physical drive */
+ if (stat & STA_NOINIT) /* Check if the initialization succeeded */
+ return FR_NOT_READY; /* Failed to initialize due to no medium or hard
+ error */
+ if (!_FS_READONLY && wmode && (stat & STA_PROTECT)) /* Check disk write protection if needed */
return FR_WRITE_PROTECTED;
#if _MAX_SS != _MIN_SS /* Get sector size (multiple sector size cfg only) */
- if (disk_ioctl(fs->drv, GET_SECTOR_SIZE, &SS(fs)) != RES_OK ||
- SS(fs) < _MIN_SS || SS(fs) > _MAX_SS)
+ if (disk_ioctl(fs->drv, GET_SECTOR_SIZE, &SS(fs)) != RES_OK || SS(fs) < _MIN_SS || SS(fs) > _MAX_SS)
return FR_DISK_ERR;
#endif
/* Find an FAT partition on the drive. Supports only generic partitioning,
* FDISK and SFD. */
bsect = 0;
- fmt = check_fs(
- fs,
- bsect); /* Load sector 0 and check if it is an FAT boot sector as SFD */
- if (fmt == 1 ||
- (!fmt &&
- (LD2PT(
- vol)))) { /* Not an FAT boot sector or forced partition number */
- for (i = 0; i < 4; i++) { /* Get partition offset */
+ fmt = check_fs(fs, bsect); /* Load sector 0 and check if it is an FAT boot sector as SFD */
+ if (fmt == 1 || (!fmt && (LD2PT(vol)))) { /* Not an FAT boot sector or forced partition number */
+ for (i = 0; i < 4; i++) { /* Get partition offset */
pt = fs->win + MBR_Table + i * SZ_PTE;
br[i] = pt[4] ? LD_DWORD(&pt[8]) : 0;
}
/* An FAT volume is found. Following code initializes the file system object
*/
- if (LD_WORD(fs->win + BPB_BytsPerSec) !=
- SS(fs)) /* (BPB_BytsPerSec must be equal to the physical sector size) */
+ if (LD_WORD(fs->win + BPB_BytsPerSec) != SS(fs)) /* (BPB_BytsPerSec must be equal to the physical sector size) */
return FR_NO_FILESYSTEM;
fasize = LD_WORD(fs->win + BPB_FATSz16); /* Number of sectors per FAT */
return FR_NO_FILESYSTEM;
fasize *= fs->n_fats; /* Number of sectors for FAT area */
- fs->csize = fs->win[BPB_SecPerClus]; /* Number of sectors per cluster */
+ fs->csize = fs->win[BPB_SecPerClus]; /* Number of sectors per cluster */
if (!fs->csize || (fs->csize & (fs->csize - 1))) /* (Must be power of 2) */
return FR_NO_FILESYSTEM;
- fs->n_rootdir = LD_WORD(
- fs->win + BPB_RootEntCnt); /* Number of root directory entries */
- if (fs->n_rootdir % (SS(fs) / SZ_DIRE)) /* (Must be sector aligned) */
+ fs->n_rootdir = LD_WORD(fs->win + BPB_RootEntCnt); /* Number of root directory entries */
+ if (fs->n_rootdir % (SS(fs) / SZ_DIRE)) /* (Must be sector aligned) */
return FR_NO_FILESYSTEM;
- tsect =
- LD_WORD(fs->win + BPB_TotSec16); /* Number of sectors on the volume */
+ tsect = LD_WORD(fs->win + BPB_TotSec16); /* Number of sectors on the volume */
if (!tsect)
tsect = LD_DWORD(fs->win + BPB_TotSec32);
return FR_NO_FILESYSTEM; /* (Must not be 0) */
/* Determine the FAT sub type */
- sysect = nrsv + fasize +
- fs->n_rootdir / (SS(fs) / SZ_DIRE); /* RSV + FAT + DIR */
+ sysect = nrsv + fasize + fs->n_rootdir / (SS(fs) / SZ_DIRE); /* RSV + FAT + DIR */
if (tsect < sysect)
return FR_NO_FILESYSTEM; /* (Invalid volume size) */
nclst = (tsect - sysect) / fs->csize; /* Number of clusters */
fs->database = bsect + sysect; /* Data start sector */
if (fmt == FS_FAT32) {
if (fs->n_rootdir)
- return FR_NO_FILESYSTEM; /* (BPB_RootEntCnt must be 0) */
- fs->dirbase =
- LD_DWORD(fs->win + BPB_RootClus); /* Root directory start cluster */
- szbfat = fs->n_fatent * 4; /* (Needed FAT size) */
+ return FR_NO_FILESYSTEM; /* (BPB_RootEntCnt must be 0) */
+ fs->dirbase = LD_DWORD(fs->win + BPB_RootClus); /* Root directory start cluster */
+ szbfat = fs->n_fatent * 4; /* (Needed FAT size) */
} else {
if (!fs->n_rootdir)
return FR_NO_FILESYSTEM; /* (BPB_RootEntCnt must not be 0) */
fs->n_fatent * 2
: fs->n_fatent * 3 / 2 + (fs->n_fatent & 1);
}
- if (fs->fsize <
- (szbfat + (SS(fs) - 1)) /
- SS(fs)) /* (BPB_FATSz must not be less than the size needed) */
+ if (fs->fsize < (szbfat + (SS(fs) - 1)) / SS(fs)) /* (BPB_FATSz must not be less than the size needed) */
return FR_NO_FILESYSTEM;
#if !_FS_READONLY
fs->fsi_flag = 0x80;
#if (_FS_NOFSINFO & 3) != 3
if (fmt == FS_FAT32 /* Enable FSINFO only if FAT32 and BPB_FSInfo is 1 */
- && LD_WORD(fs->win + BPB_FSInfo) == 1 &&
- move_window(fs, bsect + 1) == FR_OK) {
+ && LD_WORD(fs->win + BPB_FSInfo) == 1 && move_window(fs, bsect + 1) == FR_OK) {
fs->fsi_flag = 0;
- if (LD_WORD(fs->win + BS_55AA) ==
- 0xAA55 /* Load FSINFO data if available */
- && LD_DWORD(fs->win + FSI_LeadSig) == 0x41615252 &&
- LD_DWORD(fs->win + FSI_StrucSig) == 0x61417272) {
+ if (LD_WORD(fs->win + BS_55AA) == 0xAA55 /* Load FSINFO data if available */
+ && LD_DWORD(fs->win + FSI_LeadSig) == 0x41615252 && LD_DWORD(fs->win + FSI_StrucSig) == 0x61417272) {
#if (_FS_NOFSINFO & 1) == 0
fs->free_clust = LD_DWORD(fs->win + FSI_Free_Count);
#endif
static FRESULT
validate( /* FR_OK(0): The object is valid, !=0: Invalid */
- void* obj /* Pointer to the object FIL/DIR to check validity */
+ void *obj /* Pointer to the object FIL/DIR to check validity */
)
{
- FIL* fil = (FIL*)obj; /* Assuming offset of .fs and .id in the FIL/DIR
- structure is identical */
+ FIL *fil = (FIL *)obj; /* Assuming offset of .fs and .id in the FIL/DIR
+ structure is identical */
if (!fil || !fil->fs || !fil->fs->fs_type || fil->fs->id != fil->id)
return FR_INVALID_OBJECT;
/*-----------------------------------------------------------------------*/
FRESULT
-f_mount(FATFS* fs, /* Pointer to the file system object (NULL:unmount)*/
- const TCHAR* path, /* Logical drive number to be mounted/unmounted */
- BYTE opt /* 0:Do not mount (delayed mount), 1:Mount immediately */
+f_mount(FATFS *fs, /* Pointer to the file system object (NULL:unmount)*/
+ const TCHAR *path, /* Logical drive number to be mounted/unmounted */
+ BYTE opt /* 0:Do not mount (delayed mount), 1:Mount immediately */
)
{
- FATFS* cfs;
+ FATFS *cfs;
int vol;
FRESULT res;
- const TCHAR* rp = path;
+ const TCHAR *rp = path;
vol = get_ldnumber(&rp);
if (vol < 0)
/*-----------------------------------------------------------------------*/
FRESULT
-f_open(FIL* fp, /* Pointer to the blank file object */
- const TCHAR* path, /* Pointer to the file name */
+f_open(FIL *fp, /* Pointer to the blank file object */
+ const TCHAR *path, /* Pointer to the file name */
BYTE mode /* Access mode and file open mode flags */
)
{
FRESULT res;
DIR dj;
- BYTE* dir;
+ BYTE *dir;
DEFINE_NAMEBUF;
#if !_FS_READONLY
DWORD dw, cl;
/* Get logical drive number */
#if !_FS_READONLY
- mode &=
- FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW;
+ mode &= FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW;
res = find_volume(&dj.fs, &path, (BYTE)(mode & ~FA_READ));
#else
mode &= FA_READ;
}
/* Create or Open a file */
if (mode & (FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW)) {
- if (res != FR_OK) { /* No file, create new */
- if (res ==
- FR_NO_FILE) /* There is no file to open, create a new entry
- */
+ if (res != FR_OK) { /* No file, create new */
+ if (res == FR_NO_FILE) /* There is no file to open, create a new entry
+ */
#if _FS_LOCK
- res =
- enq_lock() ? dir_register(&dj) : FR_TOO_MANY_OPEN_FILES;
+ res = enq_lock() ? dir_register(&dj) : FR_TOO_MANY_OPEN_FILES;
#else
res = dir_register(&dj);
#endif
- mode |= FA_CREATE_ALWAYS; /* File is created */
- dir = dj.dir; /* New entry */
- } else { /* Any object is already existing */
- if (dir[DIR_Attr] &
- (AM_RDO | AM_DIR)) { /* Cannot overwrite it (R/O or DIR) */
+ mode |= FA_CREATE_ALWAYS; /* File is created */
+ dir = dj.dir; /* New entry */
+ } else { /* Any object is already existing */
+ if (dir[DIR_Attr] & (AM_RDO | AM_DIR)) { /* Cannot overwrite it (R/O or DIR) */
res = FR_DENIED;
} else {
if (mode & FA_CREATE_NEW) /* Cannot create as new file */
res = FR_EXIST;
}
}
- if (res == FR_OK &&
- (mode & FA_CREATE_ALWAYS)) { /* Truncate it if overwrite mode */
- dw = GET_FATTIME(); /* Created time */
+ if (res == FR_OK && (mode & FA_CREATE_ALWAYS)) { /* Truncate it if overwrite mode */
+ dw = GET_FATTIME(); /* Created time */
ST_DWORD(dir + DIR_CrtTime, dw);
dir[DIR_Attr] = 0; /* Reset attribute */
ST_DWORD(dir + DIR_FileSize, 0); /* size = 0 */
if (dir[DIR_Attr] & AM_DIR) { /* It is a directory */
res = FR_NO_FILE;
} else {
- if ((mode & FA_WRITE) &&
- (dir[DIR_Attr] & AM_RDO)) /* R/O violation */
+ if ((mode & FA_WRITE) && (dir[DIR_Attr] & AM_RDO)) /* R/O violation */
res = FR_DENIED;
}
}
/*-----------------------------------------------------------------------*/
FRESULT
-f_read(FIL* fp, /* Pointer to the file object */
- void* buff, /* Pointer to data buffer */
+f_read(FIL *fp, /* Pointer to the file object */
+ void *buff, /* Pointer to data buffer */
UINT btr, /* Number of bytes to read */
- UINT* br /* Pointer to number of bytes read */
+ UINT *br /* Pointer to number of bytes read */
)
{
FRESULT res;
btr = (UINT)remain; /* Truncate btr by remaining bytes */
for (; btr; /* Repeat until all data read */
- rbuff += rcnt, fp->fptr += rcnt, * br += rcnt, btr -= rcnt) {
- if ((fp->fptr % SS(fp->fs)) == 0) { /* On the sector boundary? */
- csect =
- (BYTE)(fp->fptr / SS(fp->fs) &
- (fp->fs->csize - 1)); /* Sector offset in the cluster */
- if (!csect) { /* On the cluster boundary? */
- if (fp->fptr == 0) { /* On the top of the file? */
- clst = fp->sclust; /* Follow from the origin */
- } else { /* Middle or end of the file */
+ rbuff += rcnt, fp->fptr += rcnt, *br += rcnt, btr -= rcnt) {
+ if ((fp->fptr % SS(fp->fs)) == 0) { /* On the sector boundary? */
+ csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1)); /* Sector offset in the cluster */
+ if (!csect) { /* On the cluster boundary? */
+ if (fp->fptr == 0) { /* On the top of the file? */
+ clst = fp->sclust; /* Follow from the origin */
+ } else { /* Middle or end of the file */
#if _USE_FASTSEEK
if (fp->cltbl)
- clst = clmt_clust(
- fp, fp->fptr); /* Get cluster# from the CLMT */
+ clst = clmt_clust(fp, fp->fptr); /* Get cluster# from the CLMT */
else
#endif
- clst = get_fat(
- fp->fs,
- fp->clust); /* Follow cluster chain on the FAT */
+ clst = get_fat(fp->fs, fp->clust); /* Follow cluster chain on the FAT */
}
if (clst < 2)
ABORT(fp->fs, FR_INT_ERR);
if (!sect)
ABORT(fp->fs, FR_INT_ERR);
sect += csect;
- cc = btr / SS(fp->fs); /* When remaining bytes >= sector size, */
- if (cc) { /* Read maximum contiguous sectors directly */
+ cc = btr / SS(fp->fs); /* When remaining bytes >= sector size, */
+ if (cc) { /* Read maximum contiguous sectors directly */
if (csect + cc > fp->fs->csize) /* Clip at cluster boundary */
cc = fp->fs->csize - csect;
if (disk_read(fp->fs->drv, rbuff, sect, cc) != RES_OK)
ABORT(fp->fs, FR_DISK_ERR);
-#if !_FS_READONLY && \
- _FS_MINIMIZE <= 2 /* Replace one of the read sectors with cached data if \
- it contains a dirty sector */
+#if !_FS_READONLY && _FS_MINIMIZE <= 2 /* Replace one of the read sectors with cached data if \
+ it contains a dirty sector */
#if _FS_TINY
if (fp->fs->wflag && fp->fs->winsect - sect < cc)
- mem_cpy(rbuff + ((fp->fs->winsect - sect) * SS(fp->fs)),
- fp->fs->win, SS(fp->fs));
+ mem_cpy(rbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), fp->fs->win, SS(fp->fs));
#else
if ((fp->flag & FA__DIRTY) && fp->dsect - sect < cc)
- mem_cpy(rbuff + ((fp->dsect - sect) * SS(fp->fs)), fp->buf,
- SS(fp->fs));
+ mem_cpy(rbuff + ((fp->dsect - sect) * SS(fp->fs)), fp->buf, SS(fp->fs));
#endif
#endif
rcnt = SS(fp->fs) * cc; /* Number of bytes transferred */
if (fp->dsect != sect) { /* Load data sector if not in cache */
#if !_FS_READONLY
if (fp->flag & FA__DIRTY) { /* Write-back dirty sector cache */
- if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) !=
- RES_OK)
+ if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
ABORT(fp->fs, FR_DISK_ERR);
fp->flag &= ~FA__DIRTY;
}
#endif
- if (disk_read(fp->fs->drv, fp->buf, sect, 1) !=
- RES_OK) /* Fill sector cache */
+ if (disk_read(fp->fs->drv, fp->buf, sect, 1) != RES_OK) /* Fill sector cache */
ABORT(fp->fs, FR_DISK_ERR);
}
#endif
fp->dsect = sect;
}
- rcnt = SS(fp->fs) -
- ((UINT)fp->fptr %
- SS(fp->fs)); /* Get partial sector data from sector buffer */
+ rcnt = SS(fp->fs) - ((UINT)fp->fptr % SS(fp->fs)); /* Get partial sector data from sector buffer */
if (rcnt > btr)
rcnt = btr;
#if _FS_TINY
if (move_window(fp->fs, fp->dsect) != FR_OK) /* Move sector window */
ABORT(fp->fs, FR_DISK_ERR);
- mem_cpy(rbuff, &fp->fs->win[fp->fptr % SS(fp->fs)],
- rcnt); /* Pick partial sector */
+ mem_cpy(rbuff, &fp->fs->win[fp->fptr % SS(fp->fs)], rcnt); /* Pick partial sector */
#else
- mem_cpy(rbuff, &fp->buf[fp->fptr % SS(fp->fs)],
- rcnt); /* Pick partial sector */
+ mem_cpy(rbuff, &fp->buf[fp->fptr % SS(fp->fs)], rcnt); /* Pick partial sector */
#endif
}
/*-----------------------------------------------------------------------*/
FRESULT
-f_write(FIL* fp, /* Pointer to the file object */
- const void* buff, /* Pointer to the data to be written */
+f_write(FIL *fp, /* Pointer to the file object */
+ const void *buff, /* Pointer to the data to be written */
UINT btw, /* Number of bytes to write */
- UINT* bw /* Pointer to number of bytes written */
+ UINT *bw /* Pointer to number of bytes written */
)
{
FRESULT res;
DWORD clst, sect;
UINT wcnt, cc;
- const BYTE* wbuff = (const BYTE*)buff;
+ const BYTE *wbuff = (const BYTE *)buff;
BYTE csect;
*bw = 0; /* Clear write byte counter */
btw = 0; /* File size cannot reach 4GB */
for (; btw; /* Repeat until all data written */
- wbuff += wcnt, fp->fptr += wcnt, * bw += wcnt, btw -= wcnt) {
- if ((fp->fptr % SS(fp->fs)) == 0) { /* On the sector boundary? */
- csect =
- (BYTE)(fp->fptr / SS(fp->fs) &
- (fp->fs->csize - 1)); /* Sector offset in the cluster */
- if (!csect) { /* On the cluster boundary? */
- if (fp->fptr == 0) { /* On the top of the file? */
- clst = fp->sclust; /* Follow from the origin */
- if (clst == 0) /* When no cluster is allocated, */
- clst = create_chain(fp->fs,
- 0); /* Create a new cluster chain */
- } else { /* Middle or end of the file */
+ wbuff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt) {
+ if ((fp->fptr % SS(fp->fs)) == 0) { /* On the sector boundary? */
+ csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1)); /* Sector offset in the cluster */
+ if (!csect) { /* On the cluster boundary? */
+ if (fp->fptr == 0) { /* On the top of the file? */
+ clst = fp->sclust; /* Follow from the origin */
+ if (clst == 0) /* When no cluster is allocated, */
+ clst = create_chain(fp->fs, 0); /* Create a new cluster chain */
+ } else { /* Middle or end of the file */
#if _USE_FASTSEEK
if (fp->cltbl)
- clst = clmt_clust(
- fp, fp->fptr); /* Get cluster# from the CLMT */
+ clst = clmt_clust(fp, fp->fptr); /* Get cluster# from the CLMT */
else
#endif
- clst = create_chain(
- fp->fs, fp->clust); /* Follow or stretch cluster
- chain on the FAT */
+ clst = create_chain(fp->fs, fp->clust); /* Follow or stretch cluster
+ chain on the FAT */
}
if (clst == 0)
break; /* Could not allocate a new cluster (disk full) */
ABORT(fp->fs, FR_DISK_ERR);
fp->clust = clst; /* Update current cluster */
if (fp->sclust == 0)
- fp->sclust =
- clst; /* Set start cluster if the first write */
+ fp->sclust = clst; /* Set start cluster if the first write */
}
#if _FS_TINY
- if (fp->fs->winsect == fp->dsect &&
- sync_window(fp->fs)) /* Write-back sector cache */
+ if (fp->fs->winsect == fp->dsect && sync_window(fp->fs)) /* Write-back sector cache */
ABORT(fp->fs, FR_DISK_ERR);
#else
if (fp->flag & FA__DIRTY) { /* Write-back sector cache */
if (!sect)
ABORT(fp->fs, FR_INT_ERR);
sect += csect;
- cc = btw / SS(fp->fs); /* When remaining bytes >= sector size, */
- if (cc) { /* Write maximum contiguous sectors directly */
+ cc = btw / SS(fp->fs); /* When remaining bytes >= sector size, */
+ if (cc) { /* Write maximum contiguous sectors directly */
if (csect + cc > fp->fs->csize) /* Clip at cluster boundary */
cc = fp->fs->csize - csect;
if (disk_write(fp->fs->drv, wbuff, sect, cc) != RES_OK)
ABORT(fp->fs, FR_DISK_ERR);
#if _FS_MINIMIZE <= 2
#if _FS_TINY
- if (fp->fs->winsect - sect <
- cc) { /* Refill sector cache if it gets invalidated by the
- direct write */
- mem_cpy(fp->fs->win,
- wbuff + ((fp->fs->winsect - sect) * SS(fp->fs)),
- SS(fp->fs));
+ if (fp->fs->winsect - sect < cc) { /* Refill sector cache if it gets invalidated by the
+ direct write */
+ mem_cpy(fp->fs->win, wbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), SS(fp->fs));
fp->fs->wflag = 0;
}
#else
- if (fp->dsect - sect <
- cc) { /* Refill sector cache if it gets invalidated by the
- direct write */
- mem_cpy(fp->buf, wbuff + ((fp->dsect - sect) * SS(fp->fs)),
- SS(fp->fs));
+ if (fp->dsect - sect < cc) { /* Refill sector cache if it gets invalidated by the
+ direct write */
+ mem_cpy(fp->buf, wbuff + ((fp->dsect - sect) * SS(fp->fs)), SS(fp->fs));
fp->flag &= ~FA__DIRTY;
}
#endif
continue;
}
#if _FS_TINY
- if (fp->fptr >=
- fp->fsize) { /* Avoid silly cache filling at growing edge */
+ if (fp->fptr >= fp->fsize) { /* Avoid silly cache filling at growing edge */
if (sync_window(fp->fs))
ABORT(fp->fs, FR_DISK_ERR);
fp->fs->winsect = sect;
}
#else
if (fp->dsect != sect) { /* Fill sector cache with file data */
- if (fp->fptr < fp->fsize &&
- disk_read(fp->fs->drv, fp->buf, sect, 1) != RES_OK)
+ if (fp->fptr < fp->fsize && disk_read(fp->fs->drv, fp->buf, sect, 1) != RES_OK)
ABORT(fp->fs, FR_DISK_ERR);
}
#endif
fp->dsect = sect;
}
- wcnt = SS(fp->fs) -
- ((UINT)fp->fptr %
- SS(fp->fs)); /* Put partial sector into file I/O buffer */
+ wcnt = SS(fp->fs) - ((UINT)fp->fptr % SS(fp->fs)); /* Put partial sector into file I/O buffer */
if (wcnt > btw)
wcnt = btw;
#if _FS_TINY
if (move_window(fp->fs, fp->dsect) != FR_OK) /* Move sector window */
ABORT(fp->fs, FR_DISK_ERR);
- mem_cpy(&fp->fs->win[fp->fptr % SS(fp->fs)], wbuff,
- wcnt); /* Fit partial sector */
+ mem_cpy(&fp->fs->win[fp->fptr % SS(fp->fs)], wbuff, wcnt); /* Fit partial sector */
fp->fs->wflag = 1;
#else
- mem_cpy(&fp->buf[fp->fptr % SS(fp->fs)], wbuff,
- wcnt); /* Fit partial sector */
+ mem_cpy(&fp->buf[fp->fptr % SS(fp->fs)], wbuff, wcnt); /* Fit partial sector */
fp->flag |= FA__DIRTY;
#endif
}
/*-----------------------------------------------------------------------*/
FRESULT
-f_sync(FIL* fp /* Pointer to the file object */
+f_sync(FIL *fp /* Pointer to the file object */
)
{
FRESULT res;
DWORD tm;
- BYTE* dir;
+ BYTE *dir;
res = validate(fp); /* Check validity of the object */
if (res == FR_OK) {
dir = fp->dir_ptr;
dir[DIR_Attr] |= AM_ARC; /* Set archive bit */
ST_DWORD(dir + DIR_FileSize, fp->fsize); /* Update file size */
- st_clust(dir, fp->sclust); /* Update start cluster */
- tm = GET_FATTIME(); /* Update updated time */
+ st_clust(dir, fp->sclust); /* Update start cluster */
+ tm = GET_FATTIME(); /* Update updated time */
ST_DWORD(dir + DIR_WrtTime, tm);
ST_WORD(dir + DIR_LstAccDate, 0);
fp->flag &= ~FA__WRITTEN;
/*-----------------------------------------------------------------------*/
FRESULT
-f_close(FIL* fp /* Pointer to the file object to be closed */
+f_close(FIL *fp /* Pointer to the file object to be closed */
)
{
FRESULT res;
res = validate(fp); /* Lock volume */
if (res == FR_OK) {
#if _FS_REENTRANT
- FATFS* fs = fp->fs;
+ FATFS *fs = fp->fs;
#endif
#if _FS_LOCK
res = dec_lock(fp->lockid); /* Decrement file open counter */
#if _FS_RPATH >= 1
#if _VOLUMES >= 2
FRESULT
-f_chdrive(const TCHAR* path /* Drive number */
+f_chdrive(const TCHAR *path /* Drive number */
)
{
int vol;
#endif
FRESULT
-f_chdir(const TCHAR* path /* Pointer to the directory path */
+f_chdir(const TCHAR *path /* Pointer to the directory path */
)
{
FRESULT res;
#if _FS_RPATH >= 2
FRESULT
-f_getcwd(TCHAR* buff, /* Pointer to the directory path */
+f_getcwd(TCHAR *buff, /* Pointer to the directory path */
UINT len /* Size of path */
)
{
DIR dj;
UINT i, n;
DWORD ccl;
- TCHAR* tp;
+ TCHAR *tp;
FILINFO fno;
DEFINE_NAMEBUF;
*buff = 0;
/* Get logical drive number */
- res = find_volume(&dj.fs, (const TCHAR**)&buff, 0); /* Get current volume */
+ res = find_volume(&dj.fs, (const TCHAR **)&buff, 0); /* Get current volume */
if (res == FR_OK) {
INIT_BUF(dj);
- i = len; /* Bottom of buffer (directory stack base) */
- dj.sclust = dj.fs->cdir; /* Start to follow upper directory from current
- directory */
- while ((ccl = dj.sclust) !=
- 0) { /* Repeat while current directory is a sub-directory */
- res = dir_sdi(&dj, 1); /* Get parent directory */
+ i = len; /* Bottom of buffer (directory stack base) */
+ dj.sclust = dj.fs->cdir; /* Start to follow upper directory from current
+ directory */
+ while ((ccl = dj.sclust) != 0) { /* Repeat while current directory is a sub-directory */
+ res = dir_sdi(&dj, 1); /* Get parent directory */
if (res != FR_OK)
break;
res = dir_read(&dj, 0);
fno.lfname = buff;
fno.lfsize = i;
#endif
- get_fileinfo(
- &dj,
- &fno); /* Get the directory name and push it to the buffer */
+ get_fileinfo(&dj, &fno); /* Get the directory name and push it to the buffer */
tp = fno.fname;
#if _USE_LFN
if (*buff)
/*-----------------------------------------------------------------------*/
FRESULT
-f_lseek(FIL* fp, /* Pointer to the file object */
+f_lseek(FIL *fp, /* Pointer to the file object */
DWORD ofs /* File pointer from top of file */
)
{
if (cl == 0xFFFFFFFF)
ABORT(fp->fs, FR_DISK_ERR);
} while (cl == pcl + 1);
- if (ulen <=
- tlen) { /* Store the length and top of the fragment */
+ if (ulen <= tlen) { /* Store the length and top of the fragment */
*tbl++ = ncl;
*tbl++ = tcl;
}
if (!dsc)
ABORT(fp->fs, FR_INT_ERR);
dsc += (ofs - 1) / SS(fp->fs) & (fp->fs->csize - 1);
- if (fp->fptr % SS(fp->fs) &&
- dsc != fp->dsect) { /* Refill sector cache if needed */
+ if (fp->fptr % SS(fp->fs) && dsc != fp->dsect) { /* Refill sector cache if needed */
#if !_FS_TINY
#if !_FS_READONLY
- if (fp->flag &
- FA__DIRTY) { /* Write-back dirty sector cache */
- if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) !=
- RES_OK)
+ if (fp->flag & FA__DIRTY) { /* Write-back dirty sector cache */
+ if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
ABORT(fp->fs, FR_DISK_ERR);
fp->flag &= ~FA__DIRTY;
}
#endif
- if (disk_read(fp->fs->drv, fp->buf, dsc, 1) !=
- RES_OK) /* Load current sector */
+ if (disk_read(fp->fs->drv, fp->buf, dsc, 1) != RES_OK) /* Load current sector */
ABORT(fp->fs, FR_DISK_ERR);
#endif
fp->dsect = dsc;
ifptr = fp->fptr;
fp->fptr = nsect = 0;
if (ofs) {
- bcs = (DWORD)fp->fs->csize * SS(fp->fs); /* Cluster size (byte) */
- if (ifptr > 0 &&
- (ofs - 1) / bcs >=
- (ifptr - 1) /
- bcs) { /* When seek to same or following cluster, */
- fp->fptr = (ifptr - 1) &
- ~(bcs - 1); /* start from the current cluster */
+ bcs = (DWORD)fp->fs->csize * SS(fp->fs); /* Cluster size (byte) */
+ if (ifptr > 0 && (ofs - 1) / bcs >= (ifptr - 1) / bcs) { /* When seek to same or following cluster, */
+ fp->fptr = (ifptr - 1) & ~(bcs - 1); /* start from the current cluster */
ofs -= fp->fptr;
clst = fp->clust;
} else { /* When seek to back cluster, */
if (clst != 0) {
while (ofs > bcs) { /* Cluster following loop */
#if !_FS_READONLY
- if (fp->flag &
- FA_WRITE) { /* Check if in write mode or not */
- clst = create_chain(
- fp->fs, clst); /* Force stretch if in write mode */
- if (clst ==
- 0) { /* When disk gets full, clip file size */
+ if (fp->flag & FA_WRITE) { /* Check if in write mode or not */
+ clst = create_chain(fp->fs, clst); /* Force stretch if in write mode */
+ if (clst == 0) { /* When disk gets full, clip file size */
ofs = bcs;
break;
}
}
}
}
- if (fp->fptr % SS(fp->fs) &&
- nsect != fp->dsect) { /* Fill sector cache if needed */
+ if (fp->fptr % SS(fp->fs) && nsect != fp->dsect) { /* Fill sector cache if needed */
#if !_FS_TINY
#if !_FS_READONLY
if (fp->flag & FA__DIRTY) { /* Write-back dirty sector cache */
fp->flag &= ~FA__DIRTY;
}
#endif
- if (disk_read(fp->fs->drv, fp->buf, nsect, 1) !=
- RES_OK) /* Fill sector cache */
+ if (disk_read(fp->fs->drv, fp->buf, nsect, 1) != RES_OK) /* Fill sector cache */
ABORT(fp->fs, FR_DISK_ERR);
#endif
fp->dsect = nsect;
}
#if !_FS_READONLY
- if (fp->fptr >
- fp->fsize) { /* Set file change flag if the file size is extended */
+ if (fp->fptr > fp->fsize) { /* Set file change flag if the file size is extended */
fp->fsize = fp->fptr;
fp->flag |= FA__WRITTEN;
}
/*-----------------------------------------------------------------------*/
FRESULT
-f_opendir(DIR* dp, /* Pointer to directory object to create */
- const TCHAR* path /* Pointer to the directory path */
+f_opendir(DIR *dp, /* Pointer to directory object to create */
+ const TCHAR *path /* Pointer to the directory path */
)
{
FRESULT res;
- FATFS* fs;
+ FATFS *fs;
DEFINE_NAMEBUF;
if (!dp)
INIT_BUF(*dp);
res = follow_path(dp, path); /* Follow the path to the directory */
FREE_BUF();
- if (res == FR_OK) { /* Follow completed */
- if (dp->dir) { /* It is not the origin directory itself */
- if (dp->dir[DIR_Attr] &
- AM_DIR) /* The object is a sub directory */
+ if (res == FR_OK) { /* Follow completed */
+ if (dp->dir) { /* It is not the origin directory itself */
+ if (dp->dir[DIR_Attr] & AM_DIR) /* The object is a sub directory */
dp->sclust = ld_clust(fs, dp->dir);
else /* The object is a file */
res = FR_NO_PATH;
#if _FS_LOCK
if (res == FR_OK) {
if (dp->sclust) {
- dp->lockid =
- inc_lock(dp, 0); /* Lock the sub directory */
+ dp->lockid = inc_lock(dp, 0); /* Lock the sub directory */
if (!dp->lockid)
res = FR_TOO_MANY_OPEN_FILES;
} else {
- dp->lockid =
- 0; /* Root directory need not to be locked */
+ dp->lockid = 0; /* Root directory need not to be locked */
}
}
#endif
/*-----------------------------------------------------------------------*/
FRESULT
-f_closedir(DIR* dp /* Pointer to the directory object to be closed */
+f_closedir(DIR *dp /* Pointer to the directory object to be closed */
)
{
FRESULT res;
res = validate(dp);
if (res == FR_OK) {
#if _FS_REENTRANT
- FATFS* fs = dp->fs;
+ FATFS *fs = dp->fs;
#endif
#if _FS_LOCK
if (dp->lockid) /* Decrement sub-directory open counter */
/*-----------------------------------------------------------------------*/
FRESULT
-f_readdir(DIR* dp, /* Pointer to the open directory object */
- FILINFO* fno /* Pointer to file information to return */
+f_readdir(DIR *dp, /* Pointer to the open directory object */
+ FILINFO *fno /* Pointer to file information to return */
)
{
FRESULT res;
/*-----------------------------------------------------------------------*/
FRESULT
-f_findnext(DIR* dp, /* Pointer to the open directory object */
- FILINFO* fno /* Pointer to the file information structure */
+f_findnext(DIR *dp, /* Pointer to the open directory object */
+ FILINFO *fno /* Pointer to the file information structure */
)
{
FRESULT res;
/*-----------------------------------------------------------------------*/
FRESULT
-f_findfirst(DIR* dp, /* Pointer to the blank directory object */
- FILINFO* fno, /* Pointer to the file information structure */
- const TCHAR* path, /* Pointer to the directory to open */
- const TCHAR* pattern /* Pointer to the matching pattern */
+f_findfirst(DIR *dp, /* Pointer to the blank directory object */
+ FILINFO *fno, /* Pointer to the file information structure */
+ const TCHAR *path, /* Pointer to the directory to open */
+ const TCHAR *pattern /* Pointer to the matching pattern */
)
{
FRESULT res;
/*-----------------------------------------------------------------------*/
FRESULT
-f_stat(const TCHAR* path, /* Pointer to the file path */
- FILINFO* fno /* Pointer to file information to return */
+f_stat(const TCHAR *path, /* Pointer to the file path */
+ FILINFO *fno /* Pointer to file information to return */
)
{
FRESULT res;
/*-----------------------------------------------------------------------*/
FRESULT
-f_getfree(
- const TCHAR* path, /* Path name of the logical drive number */
- DWORD* nclst, /* Pointer to a variable to return number of free clusters */
- FATFS** fatfs /* Pointer to return pointer to corresponding file system
- object */
- )
+f_getfree(const TCHAR *path, /* Path name of the logical drive number */
+ DWORD *nclst, /* Pointer to a variable to return number of free clusters */
+ FATFS **fatfs /* Pointer to return pointer to corresponding file system
+ object */
+ )
{
FRESULT res;
- FATFS* fs;
+ FATFS *fs;
DWORD n, clst, sect, stat;
UINT i;
BYTE fat, *p;
/*-----------------------------------------------------------------------*/
FRESULT
-f_truncate(FIL* fp /* Pointer to the file object */
+f_truncate(FIL *fp /* Pointer to the file object */
)
{
FRESULT res;
/*-----------------------------------------------------------------------*/
FRESULT
-f_unlink(const TCHAR* path /* Pointer to the file or directory path */
+f_unlink(const TCHAR *path /* Pointer to the file or directory path */
)
{
FRESULT res;
DIR dj, sdj;
- BYTE* dir;
+ BYTE *dir;
DWORD dclst = 0;
DEFINE_NAMEBUF;
}
if (res == FR_OK) {
dclst = ld_clust(dj.fs, dir);
- if (dclst &&
- (dir[DIR_Attr] & AM_DIR)) { /* Is it a sub-directory ? */
+ if (dclst && (dir[DIR_Attr] & AM_DIR)) { /* Is it a sub-directory ? */
#if _FS_RPATH
- if (dclst ==
- dj.fs->cdir) { /* Is it the current directory? */
+ if (dclst == dj.fs->cdir) { /* Is it the current directory? */
res = FR_DENIED;
} else
#endif
{
- mem_cpy(&sdj, &dj,
- sizeof(DIR)); /* Open the sub-directory */
+ mem_cpy(&sdj, &dj, sizeof(DIR)); /* Open the sub-directory */
sdj.sclust = dclst;
res = dir_sdi(&sdj, 2);
if (res == FR_OK) {
- res = dir_read(
- &sdj,
- 0); /* Read an item (excluding dot entries) */
+ res = dir_read(&sdj, 0); /* Read an item (excluding dot entries) */
if (res == FR_OK)
- res =
- FR_DENIED; /* Not empty? (cannot remove) */
+ res = FR_DENIED; /* Not empty? (cannot remove) */
if (res == FR_NO_FILE)
res = FR_OK; /* Empty? (can remove) */
}
}
}
if (res == FR_OK) {
- res = dir_remove(&dj); /* Remove the directory entry */
- if (res == FR_OK &&
- dclst) /* Remove the cluster chain if exist */
+ res = dir_remove(&dj); /* Remove the directory entry */
+ if (res == FR_OK && dclst) /* Remove the cluster chain if exist */
res = remove_chain(dj.fs, dclst);
if (res == FR_OK)
res = sync_fs(dj.fs);
/*-----------------------------------------------------------------------*/
FRESULT
-f_mkdir(const TCHAR* path /* Pointer to the directory path */
+f_mkdir(const TCHAR *path /* Pointer to the directory path */
)
{
FRESULT res;
res = FR_EXIST; /* Any object with same name is already existing */
if (_FS_RPATH && res == FR_NO_FILE && (dj.fn[NSFLAG] & NS_DOT))
res = FR_INVALID_NAME;
- if (res == FR_NO_FILE) { /* Can create a new directory */
- dcl = create_chain(
- dj.fs, 0); /* Allocate a cluster for the new directory table */
+ if (res == FR_NO_FILE) { /* Can create a new directory */
+ dcl = create_chain(dj.fs, 0); /* Allocate a cluster for the new directory table */
res = FR_OK;
if (dcl == 0)
res = FR_DENIED; /* No space to allocate a new cluster */
if (dj.fs->fs_type == FS_FAT32 && pcl == dj.fs->dirbase)
pcl = 0;
st_clust(dir + SZ_DIRE, pcl);
- for (n = dj.fs->csize; n;
- n--) { /* Write dot entries and clear following sectors */
+ for (n = dj.fs->csize; n; n--) { /* Write dot entries and clear following sectors */
dj.fs->winsect = dsc++;
dj.fs->wflag = 1;
res = sync_window(dj.fs);
}
}
if (res == FR_OK)
- res =
- dir_register(&dj); /* Register the object to the directoy */
+ res = dir_register(&dj); /* Register the object to the directoy */
if (res != FR_OK) {
- remove_chain(
- dj.fs, dcl); /* Could not register, remove cluster chain */
+ remove_chain(dj.fs, dcl); /* Could not register, remove cluster chain */
} else {
dir = dj.dir;
dir[DIR_Attr] = AM_DIR; /* Attribute */
/*-----------------------------------------------------------------------*/
FRESULT
-f_chmod(const TCHAR* path, /* Pointer to the file path */
+f_chmod(const TCHAR *path, /* Pointer to the file path */
BYTE attr, /* Attribute bits */
BYTE mask /* Attribute mask to change */
)
{
FRESULT res;
DIR dj;
- BYTE* dir;
+ BYTE *dir;
DEFINE_NAMEBUF;
/* Get logical drive number */
dir = dj.dir;
if (!dir) { /* Is it a root directory? */
res = FR_INVALID_NAME;
- } else { /* File or sub directory */
- mask &= AM_RDO | AM_HID | AM_SYS |
- AM_ARC; /* Valid attribute mask */
- dir[DIR_Attr] =
- (attr & mask) |
- (dir[DIR_Attr] & (BYTE)~mask); /* Apply attribute change */
+ } else { /* File or sub directory */
+ mask &= AM_RDO | AM_HID | AM_SYS | AM_ARC; /* Valid attribute mask */
+ dir[DIR_Attr] = (attr & mask) | (dir[DIR_Attr] & (BYTE)~mask); /* Apply attribute change */
dj.fs->wflag = 1;
res = sync_fs(dj.fs);
}
/*-----------------------------------------------------------------------*/
FRESULT
-f_rename(const TCHAR* path_old, /* Pointer to the object to be renamed */
- const TCHAR* path_new /* Pointer to the new name */
+f_rename(const TCHAR *path_old, /* Pointer to the object to be renamed */
+ const TCHAR *path_new /* Pointer to the new name */
)
{
FRESULT res;
if (!djo.dir) { /* Is root dir? */
res = FR_NO_FILE;
} else {
- mem_cpy(buf, djo.dir + DIR_Attr,
- 21); /* Save information about object except name */
- mem_cpy(&djn, &djo,
- sizeof(DIR)); /* Duplicate the directory object */
- if (get_ldnumber(&path_new) >=
- 0) /* Snip drive number off and ignore it */
+ mem_cpy(buf, djo.dir + DIR_Attr, 21); /* Save information about object except name */
+ mem_cpy(&djn, &djo, sizeof(DIR)); /* Duplicate the directory object */
+ if (get_ldnumber(&path_new) >= 0) /* Snip drive number off and ignore it */
res = follow_path(&djn, path_new); /* and make sure if new
object name is not
conflicting */
else
res = FR_INVALID_DRIVE;
if (res == FR_OK)
- res =
- FR_EXIST; /* The new object name is already existing */
- if (res ==
- FR_NO_FILE) { /* It is a valid path and no name collision */
+ res = FR_EXIST; /* The new object name is already existing */
+ if (res == FR_NO_FILE) { /* It is a valid path and no name collision */
res = dir_register(&djn); /* Register the new entry */
if (res == FR_OK) {
/* Start of critical section where any interruption can
mem_cpy(dir + 13, buf + 2, 19);
dir[DIR_Attr] = buf[0] | AM_ARC;
djo.fs->wflag = 1;
- if ((dir[DIR_Attr] & AM_DIR) &&
- djo.sclust !=
- djn.sclust) { /* Update .. entry in the
- sub-directory if needed */
+ if ((dir[DIR_Attr] & AM_DIR) && djo.sclust != djn.sclust) { /* Update .. entry in the
+ sub-directory if needed */
dw = clust2sect(djo.fs, ld_clust(djo.fs, dir));
if (!dw) {
res = FR_INT_ERR;
} else {
res = move_window(djo.fs, dw);
- dir = djo.fs->win +
- SZ_DIRE * 1; /* Ptr to .. entry */
+ dir = djo.fs->win + SZ_DIRE * 1; /* Ptr to .. entry */
if (res == FR_OK && dir[1] == '.') {
st_clust(dir, djn.sclust);
djo.fs->wflag = 1;
/*-----------------------------------------------------------------------*/
FRESULT
-f_utime(const TCHAR* path, /* Pointer to the file/directory name */
- const FILINFO* fno /* Pointer to the time stamp to be set */
+f_utime(const TCHAR *path, /* Pointer to the file/directory name */
+ const FILINFO *fno /* Pointer to the time stamp to be set */
)
{
FRESULT res;
DIR dj;
- BYTE* dir;
+ BYTE *dir;
DEFINE_NAMEBUF;
/* Get logical drive number */
/*-----------------------------------------------------------------------*/
FRESULT
-f_getlabel(
- const TCHAR* path, /* Path name of the logical drive number */
- TCHAR* label, /* Pointer to a buffer to return the volume label */
- DWORD* vsn /* Pointer to a variable to return the volume serial number */
- )
+f_getlabel(const TCHAR *path, /* Path name of the logical drive number */
+ TCHAR *label, /* Pointer to a buffer to return the volume label */
+ DWORD *vsn /* Pointer to a variable to return the volume serial number */
+ )
{
FRESULT res;
DIR dj;
/*-----------------------------------------------------------------------*/
FRESULT
-f_setlabel(const TCHAR* label /* Pointer to the volume label to set */
+f_setlabel(const TCHAR *label /* Pointer to the volume label to set */
)
{
FRESULT res;
#else
w = (BYTE)label[i++];
if (IsDBCS1(w))
- w = (j < 10 && i < sl && IsDBCS2(label[i]))
- ? w << 8 | (BYTE)label[i++]
- : 0;
+ w = (j < 10 && i < sl && IsDBCS2(label[i])) ? w << 8 | (BYTE)label[i++] : 0;
#if _USE_LFN
w = ff_convert(ff_wtoupper(ff_convert(w, 1)), 0);
#else
w -= 0x20; /* To upper ASCII characters */
#ifdef _EXCVT
if (w >= 0x80)
- w = ExCvt[w -
- 0x80]; /* To upper extended characters (SBCS cfg) */
+ w = ExCvt[w - 0x80]; /* To upper extended characters (SBCS cfg) */
#else
if (!_DF1S && w >= 0x80)
w = 0; /* Reject extended characters (ASCII cfg) */
#endif
#endif
#endif
- if (!w || chk_chr("\"*+,.:;<=>\?[]|\x7F", w) ||
- j >= (UINT)((w >= 0x100) ? 10 : 11)) /* Reject invalid
- characters for volume
- label */
+ if (!w || chk_chr("\"*+,.:;<=>\?[]|\x7F", w) || j >= (UINT)((w >= 0x100) ? 10 : 11)) /* Reject invalid
+ characters for volume
+ label */
LEAVE_FF(dj.fs, FR_INVALID_NAME);
if (w >= 0x100)
vn[j++] = (BYTE)(w >> 8);
while (j < 11)
vn[j++] = ' '; /* Fill remaining name field */
if (vn[0] == DDEM)
- LEAVE_FF(dj.fs,
- FR_INVALID_NAME); /* Reject illegal name (heading DDEM) */
+ LEAVE_FF(dj.fs, FR_INVALID_NAME); /* Reject illegal name (heading DDEM) */
}
/* Set volume label */
} else { /* No volume label is found or error */
if (res == FR_NO_FILE) {
res = FR_OK;
- if (vn[0]) { /* Create volume label as new */
- res = dir_alloc(&dj,
- 1); /* Allocate an entry for volume label */
+ if (vn[0]) { /* Create volume label as new */
+ res = dir_alloc(&dj, 1); /* Allocate an entry for volume label */
if (res == FR_OK) {
mem_set(dj.dir, 0, SZ_DIRE); /* Set volume label */
mem_cpy(dj.dir, vn, 11);
#if _USE_FORWARD && _FS_TINY
FRESULT
-f_forward(FIL* fp, /* Pointer to the file object */
- UINT (*func)(const BYTE*,
- UINT), /* Pointer to the streaming function */
- UINT btf, /* Number of bytes to forward */
- UINT* bf /* Pointer to number of bytes forwarded */
+f_forward(FIL *fp, /* Pointer to the file object */
+ UINT (*func)(const BYTE *, UINT), /* Pointer to the streaming function */
+ UINT btf, /* Number of bytes to forward */
+ UINT *bf /* Pointer to number of bytes forwarded */
)
{
FRESULT res;
if (btf > remain)
btf = (UINT)remain; /* Truncate btf by remaining bytes */
- for (;
- btf &&
- (*func)(
- 0,
- 0); /* Repeat until all data transferred or stream becomes busy */
- fp->fptr += rcnt, * bf += rcnt, btf -= rcnt) {
- csect = (BYTE)(fp->fptr / SS(fp->fs) &
- (fp->fs->csize - 1)); /* Sector offset in the cluster */
- if ((fp->fptr % SS(fp->fs)) == 0) { /* On the sector boundary? */
- if (!csect) { /* On the cluster boundary? */
- clst = (fp->fptr == 0) ? /* On the top of the file? */
+ for (; btf && (*func)(0, 0); /* Repeat until all data transferred or stream becomes busy */
+ fp->fptr += rcnt, *bf += rcnt, btf -= rcnt) {
+ csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1)); /* Sector offset in the cluster */
+ if ((fp->fptr % SS(fp->fs)) == 0) { /* On the sector boundary? */
+ if (!csect) { /* On the cluster boundary? */
+ clst = (fp->fptr == 0) ? /* On the top of the file? */
fp->sclust
: get_fat(fp->fs, fp->clust);
if (clst <= 1)
if (move_window(fp->fs, sect) != FR_OK) /* Move sector window */
ABORT(fp->fs, FR_DISK_ERR);
fp->dsect = sect;
- rcnt =
- SS(fp->fs) -
- (WORD)(fp->fptr % SS(fp->fs)); /* Forward data from sector window */
+ rcnt = SS(fp->fs) - (WORD)(fp->fptr % SS(fp->fs)); /* Forward data from sector window */
if (rcnt > btf)
rcnt = btf;
rcnt = (*func)(&fp->fs->win[(WORD)fp->fptr % SS(fp->fs)], rcnt);
#define N_FATS 1 /* Number of FATs (1 or 2) */
FRESULT
-f_mkfs(const TCHAR* path, /* Logical drive number */
+f_mkfs(const TCHAR *path, /* Logical drive number */
BYTE sfd, /* Partitioning rule 0:FDISK, 1:SFD */
- UINT au /* Size of allocation unit in unit of byte or sector */
+ UINT au /* Size of allocation unit in unit of byte or sector */
)
{
static const WORD vst[] = { 1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 0 };
- static const WORD cst[] = { 32768, 16384, 8192, 4096, 2048, 16384,
- 8192, 4096, 2048, 1024, 512 };
+ static const WORD cst[] = { 32768, 16384, 8192, 4096, 2048, 16384, 8192, 4096, 2048, 1024, 512 };
int vol;
BYTE fmt, md, sys, *tbl, pdrv, part;
DWORD n_clst, vs, n, wsect;
UINT i;
DWORD b_vol, b_fat, b_dir, b_data; /* LBA */
DWORD n_vol, n_rsv, n_fat, n_dir; /* Size */
- FATFS* fs;
+ FATFS *fs;
DSTATUS stat;
#if _USE_TRIM
DWORD eb[2];
return FR_NOT_ENABLED;
fs->fs_type = 0;
pdrv = LD2PD(vol); /* Physical drive */
- part =
- LD2PT(vol); /* Partition (0:auto detect, 1-4:get from partition table)*/
+ part = LD2PT(vol); /* Partition (0:auto detect, 1-4:get from partition table)*/
/* Get disk statics */
stat = disk_initialize(pdrv);
if (stat & STA_PROTECT)
return FR_WRITE_PROTECTED;
#if _MAX_SS != _MIN_SS /* Get disk sector size */
- if (disk_ioctl(pdrv, GET_SECTOR_SIZE, &SS(fs)) != RES_OK ||
- SS(fs) > _MAX_SS || SS(fs) < _MIN_SS)
+ if (disk_ioctl(pdrv, GET_SECTOR_SIZE, &SS(fs)) != RES_OK || SS(fs) > _MAX_SS || SS(fs) < _MIN_SS)
return FR_DISK_ERR;
#endif
if (_MULTI_PARTITION && part) {
*/
if (disk_ioctl(pdrv, GET_BLOCK_SIZE, &n) != RES_OK || !n || n > 32768)
n = 1;
- n = (b_data + n - 1) &
- ~(n - 1); /* Next nearest erase block from current data start */
+ n = (b_data + n - 1) & ~(n - 1); /* Next nearest erase block from current data start */
n = (n - b_data) / N_FATS;
if (fmt == FS_FAT32) { /* FAT32: Move FAT offset */
n_rsv += n;
/* Determine number of clusters and final check of validity of the FAT
* sub-type */
n_clst = (n_vol - n_rsv - n_fat * N_FATS - n_dir) / au;
- if ((fmt == FS_FAT16 && n_clst < MIN_FAT16) ||
- (fmt == FS_FAT32 && n_clst < MIN_FAT32))
+ if ((fmt == FS_FAT16 && n_clst < MIN_FAT16) || (fmt == FS_FAT32 && n_clst < MIN_FAT32))
return FR_MKFS_ABORTED;
/* Determine system ID in the partition table */
if (fmt == FS_FAT12 && n_vol < 0x10000) {
sys = 0x01; /* FAT12(<65536) */
} else {
- sys = (n_vol < 0x10000)
- ? 0x04
- : 0x06; /* FAT16(<65536) : FAT12/16(>=65536) */
+ sys = (n_vol < 0x10000) ? 0x04 : 0x06; /* FAT16(<65536) : FAT12/16(>=65536) */
}
}
tbl[4] = sys; /* System type */
tbl[5] = 254; /* Partition end head */
n = (b_vol + n_vol) / 63 / 255;
- tbl[6] = (BYTE)(n >> 2 | 63); /* Partition end sector */
- tbl[7] = (BYTE)n; /* End cylinder */
- ST_DWORD(tbl + 8, 63); /* Partition start in LBA */
- ST_DWORD(tbl + 12, n_vol); /* Partition size in LBA */
- ST_WORD(fs->win + BS_55AA, 0xAA55); /* MBR signature */
- if (disk_write(pdrv, fs->win, 0, 1) !=
- RES_OK) /* Write it to the MBR */
+ tbl[6] = (BYTE)(n >> 2 | 63); /* Partition end sector */
+ tbl[7] = (BYTE)n; /* End cylinder */
+ ST_DWORD(tbl + 8, 63); /* Partition start in LBA */
+ ST_DWORD(tbl + 12, n_vol); /* Partition size in LBA */
+ ST_WORD(fs->win + BS_55AA, 0xAA55); /* MBR signature */
+ if (disk_write(pdrv, fs->win, 0, 1) != RES_OK) /* Write it to the MBR */
return FR_DISK_ERR;
md = 0xF8;
}
11); /* Boot jump code, OEM name */
i = SS(fs); /* Sector size */
ST_WORD(tbl + BPB_BytsPerSec, i);
- tbl[BPB_SecPerClus] = (BYTE)au; /* Sectors per cluster */
- ST_WORD(tbl + BPB_RsvdSecCnt, n_rsv); /* Reserved sectors */
- tbl[BPB_NumFATs] = N_FATS; /* Number of FATs */
- i = (fmt == FS_FAT32) ? 0
- : N_ROOTDIR; /* Number of root directory entries */
+ tbl[BPB_SecPerClus] = (BYTE)au; /* Sectors per cluster */
+ ST_WORD(tbl + BPB_RsvdSecCnt, n_rsv); /* Reserved sectors */
+ tbl[BPB_NumFATs] = N_FATS; /* Number of FATs */
+ i = (fmt == FS_FAT32) ? 0 : N_ROOTDIR; /* Number of root directory entries */
ST_WORD(tbl + BPB_RootEntCnt, i);
if (n_vol < 0x10000) { /* Number of total sectors */
ST_WORD(tbl + BPB_TotSec16, n_vol);
if (fmt == FS_FAT32) {
ST_DWORD(tbl + BS_VolID32, n); /* VSN */
ST_DWORD(tbl + BPB_FATSz32, n_fat); /* Number of sectors per FAT */
- ST_DWORD(tbl + BPB_RootClus, 2); /* Root directory start cluster (2) */
- ST_WORD(tbl + BPB_FSInfo, 1); /* FSINFO record offset (VBR + 1) */
- ST_WORD(tbl + BPB_BkBootSec,
- 6); /* Backup boot record offset (VBR + 6) */
- tbl[BS_DrvNum32] = 0x80; /* Drive number */
- tbl[BS_BootSig32] = 0x29; /* Extended boot signature */
+ ST_DWORD(tbl + BPB_RootClus, 2); /* Root directory start cluster (2) */
+ ST_WORD(tbl + BPB_FSInfo, 1); /* FSINFO record offset (VBR + 1) */
+ ST_WORD(tbl + BPB_BkBootSec, 6); /* Backup boot record offset (VBR + 6) */
+ tbl[BS_DrvNum32] = 0x80; /* Drive number */
+ tbl[BS_BootSig32] = 0x29; /* Extended boot signature */
mem_cpy(tbl + BS_VolLab32, "NO NAME "
"FAT32 ",
19); /* Volume label, FAT signature */
"FAT ",
19); /* Volume label, FAT signature */
}
- ST_WORD(tbl + BS_55AA, 0xAA55); /* Signature (Offset is fixed here
- regardless of sector size) */
- if (disk_write(pdrv, tbl, b_vol, 1) !=
- RES_OK) /* Write it to the VBR sector */
+ ST_WORD(tbl + BS_55AA, 0xAA55); /* Signature (Offset is fixed here
+ regardless of sector size) */
+ if (disk_write(pdrv, tbl, b_vol, 1) != RES_OK) /* Write it to the VBR sector */
return FR_DISK_ERR;
if (fmt == FS_FAT32) /* Write backup VBR if needed (VBR + 6) */
disk_write(pdrv, tbl, b_vol + 6, 1);
n |= 0xFFFFFF00;
ST_DWORD(tbl + 0, n); /* Reserve cluster #0-1 (FAT32) */
ST_DWORD(tbl + 4, 0xFFFFFFFF);
- ST_DWORD(tbl + 8,
- 0x0FFFFFFF); /* Reserve cluster #2 for root directory */
+ ST_DWORD(tbl + 8, 0x0FFFFFFF); /* Reserve cluster #2 for root directory */
}
if (disk_write(pdrv, tbl, wsect++, 1) != RES_OK)
return FR_DISK_ERR;
- mem_set(tbl, 0, SS(fs)); /* Fill following FAT entries with zero */
- for (n = 1; n < n_fat;
- n++) { /* This loop may take a time on FAT32 volume due to many
- single sector writes */
+ mem_set(tbl, 0, SS(fs)); /* Fill following FAT entries with zero */
+ for (n = 1; n < n_fat; n++) { /* This loop may take a time on FAT32 volume due to many
+ single sector writes */
if (disk_write(pdrv, tbl, wsect++, 1) != RES_OK)
return FR_DISK_ERR;
}
if (fmt == FS_FAT32) {
ST_DWORD(tbl + FSI_LeadSig, 0x41615252);
ST_DWORD(tbl + FSI_StrucSig, 0x61417272);
- ST_DWORD(tbl + FSI_Free_Count,
- n_clst - 1); /* Number of free clusters */
- ST_DWORD(tbl + FSI_Nxt_Free, 2); /* Last allocated cluster# */
+ ST_DWORD(tbl + FSI_Free_Count, n_clst - 1); /* Number of free clusters */
+ ST_DWORD(tbl + FSI_Nxt_Free, 2); /* Last allocated cluster# */
ST_WORD(tbl + BS_55AA, 0xAA55);
disk_write(pdrv, tbl, b_vol + 1, 1); /* Write original (VBR + 1) */
disk_write(pdrv, tbl, b_vol + 7, 1); /* Write backup (VBR + 7) */
FRESULT
f_fdisk(BYTE pdrv, /* Physical drive number */
const DWORD szt[], /* Pointer to the size table for each partitions */
- void* work /* Pointer to the working buffer */
+ void *work /* Pointer to the working buffer */
)
{
UINT i, n, sz_cyl, tot_cyl, b_cyl, e_cyl, p_cyl;
p = buf + MBR_Table;
b_cyl = 0;
for (i = 0; i < 4; i++, p += SZ_PTE) {
- p_cyl =
- (szt[i] <= 100U) ? (DWORD)tot_cyl * szt[i] / 100 : szt[i] / sz_cyl;
+ p_cyl = (szt[i] <= 100U) ? (DWORD)tot_cyl * szt[i] / 100 : szt[i] / sz_cyl;
if (!p_cyl)
continue;
s_part = (DWORD)sz_cyl * b_cyl;
ST_WORD(p, 0xAA55);
/* Write it to the MBR */
- return (disk_write(pdrv, buf, 0, 1) != RES_OK ||
- disk_ioctl(pdrv, CTRL_SYNC, 0) != RES_OK)
- ? FR_DISK_ERR
- : FR_OK;
+ return (disk_write(pdrv, buf, 0, 1) != RES_OK || disk_ioctl(pdrv, CTRL_SYNC, 0) != RES_OK) ? FR_DISK_ERR : FR_OK;
}
#endif /* _MULTI_PARTITION */
/* Get a string from the file */
/*-----------------------------------------------------------------------*/
-TCHAR*
-f_gets(TCHAR* buff, /* Pointer to the string buffer to read */
+TCHAR *
+f_gets(TCHAR *buff, /* Pointer to the string buffer to read */
int len, /* Size of string buffer (characters) */
- FIL* fp /* Pointer to the file object */
+ FIL *fp /* Pointer to the file object */
)
{
int n = 0;
break; /* Break on EOL */
}
*p = 0;
- return n ? buff
- : 0; /* When no data read (eof or error), return with error. */
+ return n ? buff : 0; /* When no data read (eof or error), return with error. */
}
#if !_FS_READONLY
typedef struct
{
- FIL* fp;
+ FIL *fp;
int idx, nchr;
BYTE buf[64];
} putbuff;
static void
-putc_bfd(putbuff* pb, TCHAR c)
+putc_bfd(putbuff *pb, TCHAR c)
{
UINT bw;
int i;
pb->buf[i++] = (BYTE)c;
#endif
- if (i >=
- (int)(sizeof pb->buf) - 3) { /* Write buffered characters to the file */
+ if (i >= (int)(sizeof pb->buf) - 3) { /* Write buffered characters to the file */
f_write(pb->fp, pb->buf, (UINT)i, &bw);
i = (bw == (UINT)i) ? 0 : -1;
}
int
f_putc(TCHAR c, /* A character to be output */
- FIL* fp /* Pointer to the file object */
+ FIL *fp /* Pointer to the file object */
)
{
putbuff pb;
putc_bfd(&pb, c); /* Put a character */
if (pb.idx >= 0 /* Flush buffered characters to the file */
- && f_write(pb.fp, pb.buf, (UINT)pb.idx, &nw) == FR_OK &&
- (UINT)pb.idx == nw)
+ && f_write(pb.fp, pb.buf, (UINT)pb.idx, &nw) == FR_OK && (UINT)pb.idx == nw)
return pb.nchr;
return EOF;
}
/*-----------------------------------------------------------------------*/
int
-f_puts(const TCHAR* str, /* Pointer to the string to be output */
- FIL* fp /* Pointer to the file object */
+f_puts(const TCHAR *str, /* Pointer to the string to be output */
+ FIL *fp /* Pointer to the file object */
)
{
putbuff pb;
putc_bfd(&pb, *str++);
if (pb.idx >= 0 /* Flush buffered characters to the file */
- && f_write(pb.fp, pb.buf, (UINT)pb.idx, &nw) == FR_OK &&
- (UINT)pb.idx == nw)
+ && f_write(pb.fp, pb.buf, (UINT)pb.idx, &nw) == FR_OK && (UINT)pb.idx == nw)
return pb.nchr;
return EOF;
}
/*-----------------------------------------------------------------------*/
int
-f_printf(FIL* fp, /* Pointer to the file object */
- const TCHAR* fmt, /* Pointer to the format string */
+f_printf(FIL *fp, /* Pointer to the file object */
+ const TCHAR *fmt, /* Pointer to the format string */
... /* Optional arguments... */
)
{
d -= 0x20;
switch (d) { /* Type is... */
case 'S': /* String */
- p = va_arg(arp, TCHAR*);
+ p = va_arg(arp, TCHAR *);
for (j = 0; p[j]; j++)
;
if (!(f & 2)) {
}
/* Get an argument and put it in numeral */
- v = (f & 4) ? (DWORD)va_arg(arp, long)
- : ((d == 'D') ? (DWORD)(long)va_arg(arp, int)
- : (DWORD)va_arg(arp, unsigned int));
+ v = (f & 4) ? (DWORD)va_arg(arp, long) : ((d == 'D') ? (DWORD)(long)va_arg(arp, int) : (DWORD)va_arg(arp, unsigned int));
if (d == 'D' && (v & 0x80000000)) {
v = 0 - v;
f |= 8;
va_end(arp);
if (pb.idx >= 0 /* Flush buffered characters to the file */
- && f_write(pb.fp, pb.buf, (UINT)pb.idx, &nw) == FR_OK &&
- (UINT)pb.idx == nw)
+ && f_write(pb.fp, pb.buf, (UINT)pb.idx, &nw) == FR_OK && (UINT)pb.idx == nw)
return pb.nchr;
return EOF;
}
#define LD2PT(vol) (VolToPart[vol].pt) /* Get partition index */
#else /* Single partition configuration */
-#define LD2PD(vol) \
- (BYTE)(vol) /* Each logical drive is bound to the same physical drive \
+#define LD2PD(vol) \
+ (BYTE)(vol) /* Each logical drive is bound to the same physical drive \
number */
#define LD2PT(vol) 0 /* Find first valid partition or in SFD */
typedef struct
{
- FATFS* fs; /* Pointer to the related file system object (**do not change
+ FATFS *fs; /* Pointer to the related file system object (**do not change
order**) */
WORD id; /* Owner file system mount ID (**do not change order**) */
BYTE flag; /* Status flags */
DWORD dsect; /* Sector number appearing in buf[] (0:invalid) */
#if !_FS_READONLY
DWORD dir_sect; /* Sector number containing the directory entry */
- BYTE* dir_ptr; /* Pointer to the directory entry in the win[] */
+ BYTE *dir_ptr; /* Pointer to the directory entry in the win[] */
#endif
#if _USE_FASTSEEK
- DWORD*
- cltbl; /* Pointer to the cluster link map table (Nulled on file open) */
+ DWORD *cltbl; /* Pointer to the cluster link map table (Nulled on file open) */
#endif
#if _FS_LOCK
UINT lockid; /* File lock ID origin from 1 (index of file semaphore table
typedef struct
{
- FATFS* fs; /* Pointer to the owner file system object (**do not change
+ FATFS *fs; /* Pointer to the owner file system object (**do not change
order**) */
WORD id; /* Owner file system mount ID (**do not change order**) */
WORD index; /* Current read/write index number */
DWORD sclust; /* Table start cluster (0:Root dir) */
DWORD clust; /* Current cluster */
DWORD sect; /* Current sector */
- BYTE* dir; /* Pointer to the current SFN entry in the win[] */
- BYTE* fn; /* Pointer to the SFN (in/out) {file[8],ext[3],status[1]} */
+ BYTE *dir; /* Pointer to the current SFN entry in the win[] */
+ BYTE *fn; /* Pointer to the SFN (in/out) {file[8],ext[3],status[1]} */
#if _FS_LOCK
UINT lockid; /* File lock ID (index of file semaphore table Files[]) */
#endif
#if _USE_LFN
- WCHAR* lfn; /* Pointer to the LFN working buffer */
+ WCHAR *lfn; /* Pointer to the LFN working buffer */
WORD lfn_idx; /* Last matched LFN index number (0xFFFF:No LFN) */
#endif
#if _USE_FIND
- const TCHAR* pat; /* Pointer to the name matching pattern */
+ const TCHAR *pat; /* Pointer to the name matching pattern */
#endif
} DIR;
BYTE fattrib; /* Attribute */
TCHAR fname[13]; /* Short file name (8.3 format) */
#if _USE_LFN
- TCHAR* lfname; /* Pointer to the LFN buffer */
+ TCHAR *lfname; /* Pointer to the LFN buffer */
UINT lfsize; /* Size of LFN buffer in TCHAR */
#endif
} FILINFO;
/* File function return code (FRESULT) */
typedef enum {
- FR_OK = 0, /* (0) Succeeded */
- FR_DISK_ERR, /* (1) A hard error occurred in the low level disk I/O layer */
- FR_INT_ERR, /* (2) Assertion failed */
- FR_NOT_READY, /* (3) The physical drive cannot work */
- FR_NO_FILE, /* (4) Could not find the file */
- FR_NO_PATH, /* (5) Could not find the path */
- FR_INVALID_NAME, /* (6) The path name format is invalid */
- FR_DENIED, /* (7) Access denied due to prohibited access or directory full
- */
- FR_EXIST, /* (8) Access denied due to prohibited access */
- FR_INVALID_OBJECT, /* (9) The file/directory object is invalid */
- FR_WRITE_PROTECTED, /* (10) The physical drive is write protected */
- FR_INVALID_DRIVE, /* (11) The logical drive number is invalid */
- FR_NOT_ENABLED, /* (12) The volume has no work area */
- FR_NO_FILESYSTEM, /* (13) There is no valid FAT volume */
- FR_MKFS_ABORTED, /* (14) The f_mkfs() aborted due to any parameter error */
- FR_TIMEOUT, /* (15) Could not get a grant to access the volume within
- defined period */
- FR_LOCKED, /* (16) The operation is rejected according to the file sharing
- policy */
+ FR_OK = 0, /* (0) Succeeded */
+ FR_DISK_ERR, /* (1) A hard error occurred in the low level disk I/O layer */
+ FR_INT_ERR, /* (2) Assertion failed */
+ FR_NOT_READY, /* (3) The physical drive cannot work */
+ FR_NO_FILE, /* (4) Could not find the file */
+ FR_NO_PATH, /* (5) Could not find the path */
+ FR_INVALID_NAME, /* (6) The path name format is invalid */
+ FR_DENIED, /* (7) Access denied due to prohibited access or directory full
+ */
+ FR_EXIST, /* (8) Access denied due to prohibited access */
+ FR_INVALID_OBJECT, /* (9) The file/directory object is invalid */
+ FR_WRITE_PROTECTED, /* (10) The physical drive is write protected */
+ FR_INVALID_DRIVE, /* (11) The logical drive number is invalid */
+ FR_NOT_ENABLED, /* (12) The volume has no work area */
+ FR_NO_FILESYSTEM, /* (13) There is no valid FAT volume */
+ FR_MKFS_ABORTED, /* (14) The f_mkfs() aborted due to any parameter error */
+ FR_TIMEOUT, /* (15) Could not get a grant to access the volume within
+ defined period */
+ FR_LOCKED, /* (16) The operation is rejected according to the file sharing
+ policy */
FR_NOT_ENOUGH_CORE, /* (17) LFN working buffer could not be allocated */
FR_TOO_MANY_OPEN_FILES, /* (18) Number of open files > _FS_SHARE */
FR_INVALID_PARAMETER /* (19) Given parameter is invalid */
/*--------------------------------------------------------------*/
/* FatFs module application interface */
-FRESULT f_open(FIL* fp, const TCHAR* path,
- BYTE mode); /* Open or create a file */
-FRESULT f_close(FIL* fp); /* Close an open file object */
-FRESULT f_read(FIL* fp, void* buff, UINT btr,
- UINT* br); /* Read data from a file */
-FRESULT f_write(FIL* fp, const void* buff, UINT btw,
- UINT* bw); /* Write data to a file */
-FRESULT f_forward(FIL* fp, UINT (*func)(const BYTE*, UINT), UINT btf,
- UINT* bf); /* Forward data to the stream */
-FRESULT f_lseek(FIL* fp, DWORD ofs); /* Move file pointer of a file object */
-FRESULT f_truncate(FIL* fp); /* Truncate file */
-FRESULT f_sync(FIL* fp); /* Flush cached data of a writing file */
-FRESULT f_opendir(DIR* dp, const TCHAR* path); /* Open a directory */
-FRESULT f_closedir(DIR* dp); /* Close an open directory */
-FRESULT f_readdir(DIR* dp, FILINFO* fno); /* Read a directory item */
-FRESULT f_findfirst(DIR* dp, FILINFO* fno, const TCHAR* path,
- const TCHAR* pattern); /* Find first file */
-FRESULT f_findnext(DIR* dp, FILINFO* fno); /* Find next file */
-FRESULT f_mkdir(const TCHAR* path); /* Create a sub directory */
-FRESULT f_unlink(const TCHAR* path); /* Delete an existing file or directory */
-FRESULT f_rename(const TCHAR* path_old,
- const TCHAR* path_new); /* Rename/Move a file or directory */
-FRESULT f_stat(const TCHAR* path, FILINFO* fno); /* Get file status */
-FRESULT f_chmod(const TCHAR* path, BYTE attr,
- BYTE mask); /* Change attribute of the file/dir */
-FRESULT f_utime(const TCHAR* path,
- const FILINFO* fno); /* Change times-tamp of the file/dir */
-FRESULT f_chdir(const TCHAR* path); /* Change current directory */
-FRESULT f_chdrive(const TCHAR* path); /* Change current drive */
-FRESULT f_getcwd(TCHAR* buff, UINT len); /* Get current directory */
-FRESULT f_getfree(const TCHAR* path, DWORD* nclst,
- FATFS** fatfs); /* Get number of free clusters on the drive */
-FRESULT f_getlabel(const TCHAR* path, TCHAR* label,
- DWORD* vsn); /* Get volume label */
-FRESULT f_setlabel(const TCHAR* label); /* Set volume label */
-FRESULT f_mount(FATFS* fs, const TCHAR* path,
- BYTE opt); /* Mount/Unmount a logical drive */
-FRESULT f_mkfs(const TCHAR* path, BYTE sfd,
- UINT au); /* Create a file system on the volume */
-FRESULT f_fdisk(BYTE pdrv, const DWORD szt[],
- void* work); /* Divide a physical drive into some partitions */
-int f_putc(TCHAR c, FIL* fp); /* Put a character to the file */
-int f_puts(const TCHAR* str, FIL* cp); /* Put a string to the file */
-int f_printf(FIL* fp, const TCHAR* str,
- ...); /* Put a formatted string to the file */
-TCHAR* f_gets(TCHAR* buff, int len, FIL* fp); /* Get a string from the file */
+FRESULT f_open(FIL *fp, const TCHAR *path, BYTE mode); /* Open or create a file */
+FRESULT f_close(FIL *fp); /* Close an open file object */
+FRESULT f_read(FIL *fp, void *buff, UINT btr, UINT *br); /* Read data from a file */
+FRESULT f_write(FIL *fp, const void *buff, UINT btw, UINT *bw); /* Write data to a file */
+FRESULT f_forward(FIL *fp, UINT (*func)(const BYTE *, UINT), UINT btf, UINT *bf); /* Forward data to the stream */
+FRESULT f_lseek(FIL *fp, DWORD ofs); /* Move file pointer of a file object */
+FRESULT f_truncate(FIL *fp); /* Truncate file */
+FRESULT f_sync(FIL *fp); /* Flush cached data of a writing file */
+FRESULT f_opendir(DIR *dp, const TCHAR *path); /* Open a directory */
+FRESULT f_closedir(DIR *dp); /* Close an open directory */
+FRESULT f_readdir(DIR *dp, FILINFO *fno); /* Read a directory item */
+FRESULT f_findfirst(DIR *dp, FILINFO *fno, const TCHAR *path, const TCHAR *pattern); /* Find first file */
+FRESULT f_findnext(DIR *dp, FILINFO *fno); /* Find next file */
+FRESULT f_mkdir(const TCHAR *path); /* Create a sub directory */
+FRESULT f_unlink(const TCHAR *path); /* Delete an existing file or directory */
+FRESULT f_rename(const TCHAR *path_old, const TCHAR *path_new); /* Rename/Move a file or directory */
+FRESULT f_stat(const TCHAR *path, FILINFO *fno); /* Get file status */
+FRESULT f_chmod(const TCHAR *path, BYTE attr, BYTE mask); /* Change attribute of the file/dir */
+FRESULT f_utime(const TCHAR *path, const FILINFO *fno); /* Change times-tamp of the file/dir */
+FRESULT f_chdir(const TCHAR *path); /* Change current directory */
+FRESULT f_chdrive(const TCHAR *path); /* Change current drive */
+FRESULT f_getcwd(TCHAR *buff, UINT len); /* Get current directory */
+FRESULT f_getfree(const TCHAR *path, DWORD *nclst, FATFS **fatfs); /* Get number of free clusters on the drive */
+FRESULT f_getlabel(const TCHAR *path, TCHAR *label, DWORD *vsn); /* Get volume label */
+FRESULT f_setlabel(const TCHAR *label); /* Set volume label */
+FRESULT f_mount(FATFS *fs, const TCHAR *path, BYTE opt); /* Mount/Unmount a logical drive */
+FRESULT f_mkfs(const TCHAR *path, BYTE sfd, UINT au); /* Create a file system on the volume */
+FRESULT f_fdisk(BYTE pdrv, const DWORD szt[], void *work); /* Divide a physical drive into some partitions */
+int f_putc(TCHAR c, FIL *fp); /* Put a character to the file */
+int f_puts(const TCHAR *str, FIL *cp); /* Put a string to the file */
+int f_printf(FIL *fp, const TCHAR *str, ...); /* Put a formatted string to the file */
+TCHAR *f_gets(TCHAR *buff, int len, FIL *fp); /* Get a string from the file */
#define f_eof(fp) ((int)((fp)->fptr == (fp)->fsize))
#define f_error(fp) ((fp)->err)
#endif
/* Unicode support functions */
-#if _USE_LFN /* Unicode - OEM code conversion */
-WCHAR ff_convert(WCHAR chr,
- UINT dir); /* OEM-Unicode bidirectional conversion */
-WCHAR ff_wtoupper(WCHAR chr); /* Unicode upper-case conversion */
-#if _USE_LFN == 3 /* Memory functions */
-void* ff_memalloc(UINT msize); /* Allocate memory block */
-void ff_memfree(void* mblock); /* Free memory block */
+#if _USE_LFN /* Unicode - OEM code conversion */
+WCHAR ff_convert(WCHAR chr, UINT dir); /* OEM-Unicode bidirectional conversion */
+WCHAR ff_wtoupper(WCHAR chr); /* Unicode upper-case conversion */
+#if _USE_LFN == 3 /* Memory functions */
+void *ff_memalloc(UINT msize); /* Allocate memory block */
+void ff_memfree(void *mblock); /* Free memory block */
#endif
#endif
/* Sync functions */
#if _FS_REENTRANT
-int ff_cre_syncobj(BYTE vol, _SYNC_t* sobj); /* Create a sync object */
+int ff_cre_syncobj(BYTE vol, _SYNC_t *sobj); /* Create a sync object */
int ff_req_grant(_SYNC_t sobj); /* Lock sync object */
void ff_rel_grant(_SYNC_t sobj); /* Unlock sync object */
int ff_del_syncobj(_SYNC_t sobj); /* Delete a sync object */
/* Multi-byte word access macros */
#if _WORD_ACCESS == 1 /* Enable word access to the FAT structure */
-#define LD_WORD(ptr) (WORD)(*(WORD*)(BYTE*)(ptr))
-#define LD_DWORD(ptr) (DWORD)(*(DWORD*)(BYTE*)(ptr))
-#define ST_WORD(ptr, val) *(WORD*)(BYTE*)(ptr) = (WORD)(val)
-#define ST_DWORD(ptr, val) *(DWORD*)(BYTE*)(ptr) = (DWORD)(val)
+#define LD_WORD(ptr) (WORD)(*(WORD *)(BYTE *)(ptr))
+#define LD_DWORD(ptr) (DWORD)(*(DWORD *)(BYTE *)(ptr))
+#define ST_WORD(ptr, val) *(WORD *)(BYTE *)(ptr) = (WORD)(val)
+#define ST_DWORD(ptr, val) *(DWORD *)(BYTE *)(ptr) = (DWORD)(val)
#else /* Use byte-by-byte access to the FAT structure */
-#define LD_WORD(ptr) \
- (WORD)(((WORD) * ((BYTE*)(ptr) + 1) << 8) | (WORD) * (BYTE*)(ptr))
-#define LD_DWORD(ptr) \
- (DWORD)(((DWORD) * ((BYTE*)(ptr) + 3) << 24) | \
- ((DWORD) * ((BYTE*)(ptr) + 2) << 16) | \
- ((WORD) * ((BYTE*)(ptr) + 1) << 8) | *(BYTE*)(ptr))
-#define ST_WORD(ptr, val) \
- *(BYTE*)(ptr) = (BYTE)(val); \
- *((BYTE*)(ptr) + 1) = (BYTE)((WORD)(val) >> 8)
-#define ST_DWORD(ptr, val) \
- *(BYTE*)(ptr) = (BYTE)(val); \
- *((BYTE*)(ptr) + 1) = (BYTE)((WORD)(val) >> 8); \
- *((BYTE*)(ptr) + 2) = (BYTE)((DWORD)(val) >> 16); \
- *((BYTE*)(ptr) + 3) = (BYTE)((DWORD)(val) >> 24)
+#define LD_WORD(ptr) (WORD)(((WORD) * ((BYTE *)(ptr) + 1) << 8) | (WORD) * (BYTE *)(ptr))
+#define LD_DWORD(ptr) \
+ (DWORD)(((DWORD) * ((BYTE *)(ptr) + 3) << 24) | ((DWORD) * ((BYTE *)(ptr) + 2) << 16) | ((WORD) * ((BYTE *)(ptr) + 1) << 8) | *(BYTE *)(ptr))
+#define ST_WORD(ptr, val) \
+ *(BYTE *)(ptr) = (BYTE)(val); \
+ *((BYTE *)(ptr) + 1) = (BYTE)((WORD)(val) >> 8)
+#define ST_DWORD(ptr, val) \
+ *(BYTE *)(ptr) = (BYTE)(val); \
+ *((BYTE *)(ptr) + 1) = (BYTE)((WORD)(val) >> 8); \
+ *((BYTE *)(ptr) + 2) = (BYTE)((DWORD)(val) >> 16); \
+ *((BYTE *)(ptr) + 3) = (BYTE)((DWORD)(val) >> 24)
#endif
#ifdef __cplusplus
//#define DEBUG_SDMMC
#ifdef DEBUG_SDMMC
-extern uint8_t* topScreen;
-extern void DrawHexWithName(unsigned char* screen, const char* str,
- unsigned int hex, int x, int y, int color,
- int bgcolor);
-#define DEBUGPRINT(scr, str, hex, x, y, color, bg) \
- DrawHexWithName(scr, str, hex, x, y, color, bg)
+extern uint8_t *topScreen;
+extern void DrawHexWithName(unsigned char *screen, const char *str, unsigned int hex, int x, int y, int color, int bgcolor);
+#define DEBUGPRINT(scr, str, hex, x, y, color, bg) DrawHexWithName(scr, str, hex, x, y, color, bg)
#else
#define DEBUGPRINT(...)
#endif
struct mmcdevice handelNAND;
struct mmcdevice handelSD;
-mmcdevice*
+mmcdevice *
getMMCDevice(int drive)
{
if (drive == 0)
}
int
-geterror(struct mmcdevice* ctx)
+geterror(struct mmcdevice *ctx)
{
return (ctx->error << 29) >> 31;
}
void
-inittarget(struct mmcdevice* ctx)
+inittarget(struct mmcdevice *ctx)
{
sdmmc_mask16(REG_SDPORTSEL, 0x3, (uint16_t)ctx->devicenumber);
setckl(ctx->clk);
}
void NO_INLINE
-sdmmc_send_command(struct mmcdevice* ctx, uint32_t cmd, uint32_t args)
+sdmmc_send_command(struct mmcdevice *ctx, uint32_t cmd, uint32_t args)
{
bool getSDRESP = (cmd << 15) >> 31;
uint16_t flags = (cmd << 15) >> 31;
sdmmc_write16(REG_SDCMD, cmd & 0xFFFF);
uint32_t size = ctx->size;
- uint16_t* dataPtr = (uint16_t*)ctx->data;
+ uint16_t *dataPtr = (uint16_t *)ctx->data;
#ifdef DATA32_SUPPORT
- uint32_t* dataPtr32 = (uint32_t*)ctx->data;
+ uint32_t *dataPtr32 = (uint32_t *)ctx->data;
#endif
bool useBuf = (NULL != dataPtr);
sdmmc_write16(REG_SDSTATUS1, 0);
if (getSDRESP != 0) {
- ctx->ret[0] =
- sdmmc_read16(REG_SDRESP0) | (sdmmc_read16(REG_SDRESP1) << 16);
- ctx->ret[1] =
- sdmmc_read16(REG_SDRESP2) | (sdmmc_read16(REG_SDRESP3) << 16);
- ctx->ret[2] =
- sdmmc_read16(REG_SDRESP4) | (sdmmc_read16(REG_SDRESP5) << 16);
- ctx->ret[3] =
- sdmmc_read16(REG_SDRESP6) | (sdmmc_read16(REG_SDRESP7) << 16);
+ ctx->ret[0] = sdmmc_read16(REG_SDRESP0) | (sdmmc_read16(REG_SDRESP1) << 16);
+ ctx->ret[1] = sdmmc_read16(REG_SDRESP2) | (sdmmc_read16(REG_SDRESP3) << 16);
+ ctx->ret[2] = sdmmc_read16(REG_SDRESP4) | (sdmmc_read16(REG_SDRESP5) << 16);
+ ctx->ret[3] = sdmmc_read16(REG_SDRESP6) | (sdmmc_read16(REG_SDRESP7) << 16);
}
}
int NO_INLINE
-sdmmc_sdcard_writesectors(uint32_t sector_no, uint32_t numsectors, uint8_t* in)
+sdmmc_sdcard_writesectors(uint32_t sector_no, uint32_t numsectors, uint8_t *in)
{
if (handelSD.isSDHC == 0)
sector_no <<= 9;
}
int NO_INLINE
-sdmmc_sdcard_readsectors(uint32_t sector_no, uint32_t numsectors, uint8_t* out)
+sdmmc_sdcard_readsectors(uint32_t sector_no, uint32_t numsectors, uint8_t *out)
{
if (handelSD.isSDHC == 0)
sector_no <<= 9;
}
int NO_INLINE
-sdmmc_nand_readsectors(uint32_t sector_no, uint32_t numsectors, uint8_t* out)
+sdmmc_nand_readsectors(uint32_t sector_no, uint32_t numsectors, uint8_t *out)
{
if (handelNAND.isSDHC == 0)
sector_no <<= 9;
return geterror(&handelNAND);
}
-int NO_INLINE sdmmc_nand_writesectors(uint32_t sector_no, uint32_t numsectors,
- uint8_t* in) // experimental
+int NO_INLINE sdmmc_nand_writesectors(uint32_t sector_no, uint32_t numsectors, uint8_t *in) // experimental
{
if (handelNAND.isSDHC == 0)
sector_no <<= 9;
}
static uint32_t
-calcSDSize(uint8_t* csd, int type)
+calcSDSize(uint8_t *csd, int type)
{
uint32_t result = 0;
if (type == -1)
// sdmmc_write16(REG_SDBLKLEN,0x200);
// sdmmc_write16(REG_SDSTOP,0);
- *(volatile uint16_t*)0x10006100 &= 0xF7FFu; // SDDATACTL32
- *(volatile uint16_t*)0x10006100 &= 0xEFFFu; // SDDATACTL32
+ *(volatile uint16_t *)0x10006100 &= 0xF7FFu; // SDDATACTL32
+ *(volatile uint16_t *)0x10006100 &= 0xEFFFu; // SDDATACTL32
#ifdef DATA32_SUPPORT
- *(volatile uint16_t*)0x10006100 |= 0x402u; // SDDATACTL32
+ *(volatile uint16_t *)0x10006100 |= 0x402u; // SDDATACTL32
#else
- *(volatile uint16_t*)0x10006100 |= 0x402u; // SDDATACTL32
+ *(volatile uint16_t *)0x10006100 |= 0x402u; // SDDATACTL32
#endif
- *(volatile uint16_t*)0x100060D8 =
- (*(volatile uint16_t*)0x100060D8 & 0xFFDD) | 2;
+ *(volatile uint16_t *)0x100060D8 = (*(volatile uint16_t *)0x100060D8 & 0xFFDD) | 2;
#ifdef DATA32_SUPPORT
- *(volatile uint16_t*)0x10006100 &= 0xFFFFu; // SDDATACTL32
- *(volatile uint16_t*)0x100060D8 &= 0xFFDFu; // SDDATACTL
- *(volatile uint16_t*)0x10006104 = 512; // SDBLKLEN32
+ *(volatile uint16_t *)0x10006100 &= 0xFFFFu; // SDDATACTL32
+ *(volatile uint16_t *)0x100060D8 &= 0xFFDFu; // SDDATACTL
+ *(volatile uint16_t *)0x10006104 = 512; // SDBLKLEN32
#else
- *(volatile uint16_t*)0x10006100 &= 0xFFFDu; // SDDATACTL32
- *(volatile uint16_t*)0x100060D8 &= 0xFFDDu; // SDDATACTL
- *(volatile uint16_t*)0x10006104 = 0; // SDBLKLEN32
+ *(volatile uint16_t *)0x10006100 &= 0xFFFDu; // SDDATACTL32
+ *(volatile uint16_t *)0x100060D8 &= 0xFFDDu; // SDDATACTL
+ *(volatile uint16_t *)0x10006104 = 0; // SDBLKLEN32
#endif
- *(volatile uint16_t*)0x10006108 = 1; // SDBLKCOUNT32
- *(volatile uint16_t*)0x100060E0 &= 0xFFFEu; // SDRESET
- *(volatile uint16_t*)0x100060E0 |= 1u; // SDRESET
- *(volatile uint16_t*)0x10006020 |= TMIO_MASK_ALL; // SDIR_MASK0
- *(volatile uint16_t*)0x10006022 |= TMIO_MASK_ALL >> 16; // SDIR_MASK1
- *(volatile uint16_t*)0x100060FC |= 0xDBu; // SDCTL_RESERVED7
- *(volatile uint16_t*)0x100060FE |= 0xDBu; // SDCTL_RESERVED8
- *(volatile uint16_t*)0x10006002 &= 0xFFFCu; // SDPORTSEL
+ *(volatile uint16_t *)0x10006108 = 1; // SDBLKCOUNT32
+ *(volatile uint16_t *)0x100060E0 &= 0xFFFEu; // SDRESET
+ *(volatile uint16_t *)0x100060E0 |= 1u; // SDRESET
+ *(volatile uint16_t *)0x10006020 |= TMIO_MASK_ALL; // SDIR_MASK0
+ *(volatile uint16_t *)0x10006022 |= TMIO_MASK_ALL >> 16; // SDIR_MASK1
+ *(volatile uint16_t *)0x100060FC |= 0xDBu; // SDCTL_RESERVED7
+ *(volatile uint16_t *)0x100060FE |= 0xDBu; // SDCTL_RESERVED8
+ *(volatile uint16_t *)0x10006002 &= 0xFFFCu; // SDPORTSEL
#ifdef DATA32_SUPPORT
- *(volatile uint16_t*)0x10006024 = 0x20;
- *(volatile uint16_t*)0x10006028 = 0x40EE;
+ *(volatile uint16_t *)0x10006024 = 0x20;
+ *(volatile uint16_t *)0x10006028 = 0x40EE;
#else
- *(volatile uint16_t*)0x10006024 = 0x40; // Nintendo sets this to 0x20
- *(volatile uint16_t*)0x10006028 = 0x40EB; // Nintendo sets this to 0x40EE
+ *(volatile uint16_t *)0x10006024 = 0x40; // Nintendo sets this to 0x20
+ *(volatile uint16_t *)0x10006028 = 0x40EB; // Nintendo sets this to 0x40EE
#endif
- *(volatile uint16_t*)0x10006002 &= 0xFFFCu; ////SDPORTSEL
- *(volatile uint16_t*)0x10006026 = 512; // SDBLKLEN
- *(volatile uint16_t*)0x10006008 = 0; // SDSTOP
+ *(volatile uint16_t *)0x10006002 &= 0xFFFCu; ////SDPORTSEL
+ *(volatile uint16_t *)0x10006026 = 512; // SDBLKLEN
+ *(volatile uint16_t *)0x10006008 = 0; // SDSTOP
inittarget(&handelSD);
}
inittarget(&handelNAND);
waitcycles(0xF000);
- DEBUGPRINT(topScreen, "0x00000 ", handelNAND.error, 10, 20 + 13 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x00000 ", handelNAND.error, 10, 20 + 13 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelNAND, 0, 0);
- DEBUGPRINT(topScreen, "0x10701 ", handelNAND.error, 10, 20 + 13 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10701 ", handelNAND.error, 10, 20 + 13 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
do {
do {
sdmmc_send_command(&handelNAND, 0x10701, 0x100000);
- DEBUGPRINT(topScreen, "error ", handelNAND.error, 10, 20 + 17 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
- DEBUGPRINT(topScreen, "ret: ", handelNAND.ret[0], 10, 20 + 18 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
- DEBUGPRINT(topScreen, "test ", 3, 10, 20 + 19 * 8, RGB(40, 40, 40),
- RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "error ", handelNAND.error, 10, 20 + 17 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "ret: ", handelNAND.ret[0], 10, 20 + 18 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "test ", 3, 10, 20 + 19 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
} while (!(handelNAND.error & 1));
} while ((handelNAND.ret[0] & 0x80000000) == 0);
- DEBUGPRINT(topScreen, "0x10602 ", handelNAND.error, 10, 20 + 13 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10602 ", handelNAND.error, 10, 20 + 13 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelNAND, 0x10602, 0x0);
if ((handelNAND.error & 0x4))
return -1;
- DEBUGPRINT(topScreen, "0x10403 ", handelNAND.error, 10, 20 + 13 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10403 ", handelNAND.error, 10, 20 + 13 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelNAND, 0x10403, handelNAND.initarg << 0x10);
if ((handelNAND.error & 0x4))
return -1;
- DEBUGPRINT(topScreen, "0x10609 ", handelNAND.error, 10, 20 + 13 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10609 ", handelNAND.error, 10, 20 + 13 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelNAND, 0x10609, handelNAND.initarg << 0x10);
if ((handelNAND.error & 0x4))
return -1;
- DEBUGPRINT(topScreen, "0x10407 ", handelNAND.error, 10, 20 + 13 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10407 ", handelNAND.error, 10, 20 + 13 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
- handelNAND.total_size = calcSDSize((uint8_t*)&handelNAND.ret[0], 0);
+ handelNAND.total_size = calcSDSize((uint8_t *)&handelNAND.ret[0], 0);
handelNAND.clk = 1;
setckl(1);
if ((handelNAND.error & 0x4))
return -1;
- DEBUGPRINT(topScreen, "0x10506 ", handelNAND.error, 10, 20 + 13 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10506 ", handelNAND.error, 10, 20 + 13 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
handelNAND.SDOPT = 1;
if ((handelNAND.error & 0x4))
return -1;
- DEBUGPRINT(topScreen, "0x10506 ", handelNAND.error, 10, 20 + 13 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10506 ", handelNAND.error, 10, 20 + 13 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelNAND, 0x10506, 0x3B90100);
if ((handelNAND.error & 0x4))
return -1;
- DEBUGPRINT(topScreen, "0x1040D ", handelNAND.error, 10, 20 + 13 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x1040D ", handelNAND.error, 10, 20 + 13 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelNAND, 0x1040D, handelNAND.initarg << 0x10);
if ((handelNAND.error & 0x4))
return -1;
- DEBUGPRINT(topScreen, "0x10410 ", handelNAND.error, 10, 20 + 13 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10410 ", handelNAND.error, 10, 20 + 13 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelNAND, 0x10410, 0x200);
if ((handelNAND.error & 0x4))
// waitcycles(0x3E8);
// waitcycles(0xF000);
- waitcycles(
- 1u << 19); // Card needs a little bit of time to be detected, it seems
- if (!(*((volatile uint16_t*)0x1000601c) & TMIO_STAT0_SIGSTATE))
+ waitcycles(1u << 19); // Card needs a little bit of time to be detected, it seems
+ if (!(*((volatile uint16_t *)0x1000601c) & TMIO_STAT0_SIGSTATE))
return -1; // check if card inserted
- DEBUGPRINT(topScreen, "0x00000 ", handelSD.error, 10, 20 + 14 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x00000 ", handelSD.error, 10, 20 + 14 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelSD, 0, 0);
- DEBUGPRINT(topScreen, "0x10408 ", handelSD.error, 10, 20 + 14 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10408 ", handelSD.error, 10, 20 + 14 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelSD, 0x10408, 0x1AA);
// uint32_t temp = (handelSD.ret[0] == 0x1AA) << 0x1E;
uint32_t temp = (handelSD.error & 0x1) << 0x1E;
- DEBUGPRINT(topScreen, "0x10769 ", handelSD.error, 10, 20 + 14 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
- DEBUGPRINT(topScreen, "sd ret: ", handelSD.ret[0], 10, 20 + 15 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
- DEBUGPRINT(topScreen, "temp: ", temp, 10, 20 + 16 * 8, RGB(40, 40, 40),
- RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10769 ", handelSD.error, 10, 20 + 14 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "sd ret: ", handelSD.ret[0], 10, 20 + 15 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "temp: ", temp, 10, 20 + 16 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
// int count = 0;
uint32_t temp2 = 0;
handelSD.isSDHC = temp2;
// handelSD.isSDHC = (handelSD.ret[0] & 0x40000000);
- DEBUGPRINT(topScreen, "0x10602 ", handelSD.error, 10, 20 + 14 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10602 ", handelSD.error, 10, 20 + 14 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelSD, 0x10602, 0);
if ((handelSD.error & 0x4))
return -1;
- DEBUGPRINT(topScreen, "0x10403 ", handelSD.error, 10, 20 + 14 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10403 ", handelSD.error, 10, 20 + 14 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelSD, 0x10403, 0);
if ((handelSD.error & 0x4))
return -1;
handelSD.initarg = handelSD.ret[0] >> 0x10;
- DEBUGPRINT(topScreen, "0x10609 ", handelSD.error, 10, 20 + 14 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10609 ", handelSD.error, 10, 20 + 14 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelSD, 0x10609, handelSD.initarg << 0x10);
if ((handelSD.error & 0x4))
return -1;
- handelSD.total_size = calcSDSize((uint8_t*)&handelSD.ret[0], -1);
+ handelSD.total_size = calcSDSize((uint8_t *)&handelSD.ret[0], -1);
handelSD.clk = 1;
setckl(1);
- DEBUGPRINT(topScreen, "0x10507 ", handelSD.error, 10, 20 + 14 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10507 ", handelSD.error, 10, 20 + 14 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelSD, 0x10507, handelSD.initarg << 0x10);
if ((handelSD.error & 0x4))
return -1;
- DEBUGPRINT(topScreen, "0x10437 ", handelSD.error, 10, 20 + 14 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10437 ", handelSD.error, 10, 20 + 14 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelSD, 0x10437, handelSD.initarg << 0x10);
if ((handelSD.error & 0x4))
return -1;
- DEBUGPRINT(topScreen, "0x10446 ", handelSD.error, 10, 20 + 14 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10446 ", handelSD.error, 10, 20 + 14 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
handelSD.SDOPT = 1;
sdmmc_send_command(&handelSD, 0x10446, 0x2);
if ((handelSD.error & 0x4))
return -1;
- DEBUGPRINT(topScreen, "0x1040D ", handelSD.error, 10, 20 + 14 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x1040D ", handelSD.error, 10, 20 + 14 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelSD, 0x1040D, handelSD.initarg << 0x10);
if ((handelSD.error & 0x4))
return -1;
- DEBUGPRINT(topScreen, "0x10410 ", handelSD.error, 10, 20 + 14 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "0x10410 ", handelSD.error, 10, 20 + 14 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
sdmmc_send_command(&handelSD, 0x10410, 0x200);
if ((handelSD.error & 0x4))
int
sdmmc_sdcard_init()
{
- DEBUGPRINT(topScreen, "sdmmc_sdcard_init ", handelSD.error, 10, 20 + 2 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "sdmmc_sdcard_init ", handelSD.error, 10, 20 + 2 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
InitSD();
// SD_Init2();
// Nand_Init();
Nand_Init();
- DEBUGPRINT(topScreen, "nand_res ", nand_res, 10, 20 + 3 * 8,
- RGB(40, 40, 40), RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "nand_res ", nand_res, 10, 20 + 3 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
if (SD_Init() != 0)
return FALSE;
- DEBUGPRINT(topScreen, "sd_res ", sd_res, 10, 20 + 4 * 8, RGB(40, 40, 40),
- RGB(208, 208, 208));
+ DEBUGPRINT(topScreen, "sd_res ", sd_res, 10, 20 + 4 * 8, RGB(40, 40, 40), RGB(208, 208, 208));
return TRUE;
}
int
-sdmmc_get_cid(int isNand, uint32_t* info)
+sdmmc_get_cid(int isNand, uint32_t *info)
{
- struct mmcdevice* device;
+ struct mmcdevice *device;
if (isNand)
device = &handelNAND;
else
#define TMIO_MASK_ALL 0x837f031d
-#define TMIO_MASK_GW \
- (TMIO_STAT1_ILL_ACCESS | TMIO_STAT1_CMDTIMEOUT | TMIO_STAT1_TXUNDERRUN | \
- TMIO_STAT1_RXOVERFLOW | TMIO_STAT1_DATATIMEOUT | TMIO_STAT1_STOPBIT_ERR | \
+#define TMIO_MASK_GW \
+ (TMIO_STAT1_ILL_ACCESS | TMIO_STAT1_CMDTIMEOUT | TMIO_STAT1_TXUNDERRUN | TMIO_STAT1_RXOVERFLOW | TMIO_STAT1_DATATIMEOUT | TMIO_STAT1_STOPBIT_ERR | \
TMIO_STAT1_CRCFAIL | TMIO_STAT1_CMD_IDX_ERR)
#define TMIO_MASK_READOP (TMIO_STAT1_RXRDY | TMIO_STAT1_DATAEND)
typedef struct mmcdevice
{
- uint8_t* data;
+ uint8_t *data;
uint32_t size;
uint32_t error;
uint16_t stat0;
} mmcdevice;
int sdmmc_sdcard_init();
-int sdmmc_sdcard_readsector(uint32_t sector_no, uint8_t* out);
-int sdmmc_sdcard_readsectors(uint32_t sector_no, uint32_t numsectors,
- uint8_t* out);
-int sdmmc_sdcard_writesector(uint32_t sector_no, uint8_t* in);
-int sdmmc_sdcard_writesectors(uint32_t sector_no, uint32_t numsectors,
- uint8_t* in);
+int sdmmc_sdcard_readsector(uint32_t sector_no, uint8_t *out);
+int sdmmc_sdcard_readsectors(uint32_t sector_no, uint32_t numsectors, uint8_t *out);
+int sdmmc_sdcard_writesector(uint32_t sector_no, uint8_t *in);
+int sdmmc_sdcard_writesectors(uint32_t sector_no, uint32_t numsectors, uint8_t *in);
-int sdmmc_nand_readsectors(uint32_t sector_no, uint32_t numsectors,
- uint8_t* out);
-int sdmmc_nand_writesectors(uint32_t sector_no, uint32_t numsectors,
- uint8_t* in);
+int sdmmc_nand_readsectors(uint32_t sector_no, uint32_t numsectors, uint8_t *out);
+int sdmmc_nand_writesectors(uint32_t sector_no, uint32_t numsectors, uint8_t *in);
-int sdmmc_get_cid(int isNand, uint32_t* info);
+int sdmmc_get_cid(int isNand, uint32_t *info);
-mmcdevice* getMMCDevice(int drive);
+mmcdevice *getMMCDevice(int drive);
void InitSD();
int Nand_Init();
sdmmc_read16(uint16_t reg)
{
//---------------------------------------------------------------------------------
- return *(volatile uint16_t*)(SDMMC_BASE + reg);
+ return *(volatile uint16_t *)(SDMMC_BASE + reg);
}
//---------------------------------------------------------------------------------
sdmmc_write16(uint16_t reg, uint16_t val)
{
//---------------------------------------------------------------------------------
- *(volatile uint16_t*)(SDMMC_BASE + reg) = val;
+ *(volatile uint16_t *)(SDMMC_BASE + reg) = val;
}
//---------------------------------------------------------------------------------
sdmmc_read32(uint16_t reg)
{
//---------------------------------------------------------------------------------
- return *(volatile uint32_t*)(SDMMC_BASE + reg);
+ return *(volatile uint32_t *)(SDMMC_BASE + reg);
}
//---------------------------------------------------------------------------------
sdmmc_write32(uint16_t reg, uint32_t val)
{
//---------------------------------------------------------------------------------
- *(volatile uint32_t*)(SDMMC_BASE + reg) = val;
+ *(volatile uint32_t *)(SDMMC_BASE + reg) = val;
}
//---------------------------------------------------------------------------------
/* original version by megazig */
#ifndef __thumb__
-#define BSWAP32(x) \
- { \
- __asm__("eor r1, %1, %1, ror #16\n\t" \
- "bic r1, r1, #0xFF0000\n\t" \
- "mov %0, %1, ror #8\n\t" \
- "eor %0, %0, r1, lsr #8\n\t" \
- : "=r"(x) \
- : "0"(x) \
- : "r1"); \
+#define BSWAP32(x) \
+ { \
+ __asm__("eor r1, %1, %1, ror #16\n\t" \
+ "bic r1, r1, #0xFF0000\n\t" \
+ "mov %0, %1, ror #8\n\t" \
+ "eor %0, %0, r1, lsr #8\n\t" \
+ : "=r"(x) \
+ : "0"(x) \
+ : "r1"); \
};
-#define ADD_u128_uint32_t(u128_0, u128_1, u128_2, u128_3, uint32_t_0) \
- { \
- __asm__("adds %0, %4\n\t" \
- "addcss %1, %1, #1\n\t" \
- "addcss %2, %2, #1\n\t" \
- "addcs %3, %3, #1\n\t" \
- : "+r"(u128_0), "+r"(u128_1), "+r"(u128_2), "+r"(u128_3) \
- : "r"(uint32_t_0) \
- : "cc"); \
+#define ADD_u128_uint32_t(u128_0, u128_1, u128_2, u128_3, uint32_t_0) \
+ { \
+ __asm__("adds %0, %4\n\t" \
+ "addcss %1, %1, #1\n\t" \
+ "addcss %2, %2, #1\n\t" \
+ "addcs %3, %3, #1\n\t" \
+ : "+r"(u128_0), "+r"(u128_1), "+r"(u128_2), "+r"(u128_3) \
+ : "r"(uint32_t_0) \
+ : "cc"); \
}
#else
-#define BSWAP32(x) \
- { \
- x = __builtin_bswap32(x); \
+#define BSWAP32(x) \
+ { \
+ x = __builtin_bswap32(x); \
}
-#define ADD_u128_uint32_t(u128_0, u128_1, u128_2, u128_3, uint32_t_0) \
- { \
- __asm__("mov r4, #0\n\t" \
- "add %0, %0, %4\n\t" \
- "adc %1, %1, r4\n\t" \
- "adc %2, %2, r4\n\t" \
- "adc %3, %3, r4\n\t" \
- : "+r"(u128_0), "+r"(u128_1), "+r"(u128_2), "+r"(u128_3) \
- : "r"(uint32_t_0) \
- : "cc", "r4"); \
+#define ADD_u128_uint32_t(u128_0, u128_1, u128_2, u128_3, uint32_t_0) \
+ { \
+ __asm__("mov r4, #0\n\t" \
+ "add %0, %0, %4\n\t" \
+ "adc %1, %1, r4\n\t" \
+ "adc %2, %2, r4\n\t" \
+ "adc %3, %3, r4\n\t" \
+ : "+r"(u128_0), "+r"(u128_1), "+r"(u128_2), "+r"(u128_3) \
+ : "r"(uint32_t_0) \
+ : "cc", "r4"); \
}
#endif /*__thumb__*/
void
-aes_setkey(uint8_t keyslot, const void* key, uint32_t keyType, uint32_t mode)
+aes_setkey(uint8_t keyslot, const void *key, uint32_t keyType, uint32_t mode)
{
if (keyslot <= 0x03)
return; // Ignore TWL keys for now
- uint32_t* key32 = (uint32_t*)key;
- *REG_AESCNT =
- (*REG_AESCNT & ~(AES_CNT_INPUT_ENDIAN | AES_CNT_INPUT_ORDER)) | mode;
+ uint32_t *key32 = (uint32_t *)key;
+ *REG_AESCNT = (*REG_AESCNT & ~(AES_CNT_INPUT_ENDIAN | AES_CNT_INPUT_ORDER)) | mode;
*REG_AESKEYCNT = (*REG_AESKEYCNT >> 6 << 6) | keyslot | AES_KEYCNT_WRITE;
REG_AESKEYFIFO[keyType] = key32[0];
}
void
-aes_setiv(const void* iv, uint32_t mode)
+aes_setiv(const void *iv, uint32_t mode)
{
- const uint32_t* iv32 = (const uint32_t*)iv;
- *REG_AESCNT =
- (*REG_AESCNT & ~(AES_CNT_INPUT_ENDIAN | AES_CNT_INPUT_ORDER)) | mode;
+ const uint32_t *iv32 = (const uint32_t *)iv;
+ *REG_AESCNT = (*REG_AESCNT & ~(AES_CNT_INPUT_ENDIAN | AES_CNT_INPUT_ORDER)) | mode;
// Word order for IV can't be changed in REG_AESCNT and always default to
// reversed
}
void
-aes_advctr(void* ctr, uint32_t val, uint32_t mode)
+aes_advctr(void *ctr, uint32_t val, uint32_t mode)
{
- uint32_t* ctr32 = (uint32_t*)ctr;
+ uint32_t *ctr32 = (uint32_t *)ctr;
int i;
if (mode & AES_INPUT_BE) {
}
void
-aes_change_ctrmode(void* ctr, uint32_t fromMode, uint32_t toMode)
+aes_change_ctrmode(void *ctr, uint32_t fromMode, uint32_t toMode)
{
- uint32_t* ctr32 = (uint32_t*)ctr;
+ uint32_t *ctr32 = (uint32_t *)ctr;
int i;
if ((fromMode ^ toMode) & AES_CNT_INPUT_ENDIAN) {
for (i = 0; i < 4; ++i)
}
void
-aes_batch(void* dst, const void* src, uint32_t blockCount)
+aes_batch(void *dst, const void *src, uint32_t blockCount)
{
*REG_AESBLKCNT = blockCount << 16;
*REG_AESCNT |= AES_CNT_START;
- const uint32_t* src32 = (const uint32_t*)src;
- uint32_t* dst32 = (uint32_t*)dst;
+ const uint32_t *src32 = (const uint32_t *)src;
+ uint32_t *dst32 = (uint32_t *)dst;
uint32_t wbc = blockCount;
uint32_t rbc = blockCount;
while (rbc) {
- if (wbc &&
- ((*REG_AESCNT & 0x1F) <= 0xC)) // There's space for at least 4 ints
+ if (wbc && ((*REG_AESCNT & 0x1F) <= 0xC)) // There's space for at least 4 ints
{
*REG_AESWRFIFO = *src32++;
*REG_AESWRFIFO = *src32++;
wbc--;
}
- if (rbc && ((*REG_AESCNT & (0x1F << 0x5)) >=
- (0x4 << 0x5))) // At least 4 ints available for read
+ if (rbc && ((*REG_AESCNT & (0x1F << 0x5)) >= (0x4 << 0x5))) // At least 4 ints available for read
{
*dst32++ = *REG_AESRDFIFO;
*dst32++ = *REG_AESRDFIFO;
inline void
aes_setmode(uint32_t mode)
{
- *REG_AESCNT = mode | AES_CNT_INPUT_ORDER | AES_CNT_OUTPUT_ORDER |
- AES_CNT_INPUT_ENDIAN | AES_CNT_OUTPUT_ENDIAN |
- AES_CNT_FLUSH_READ | AES_CNT_FLUSH_WRITE;
+ *REG_AESCNT = mode | AES_CNT_INPUT_ORDER | AES_CNT_OUTPUT_ORDER | AES_CNT_INPUT_ENDIAN | AES_CNT_OUTPUT_ENDIAN | AES_CNT_FLUSH_READ | AES_CNT_FLUSH_WRITE;
}
void
-aes(void* dst, const void* src, uint32_t blockCount, void* iv, uint32_t mode,
- uint32_t ivMode)
+aes(void *dst, const void *src, uint32_t blockCount, void *iv, uint32_t mode, uint32_t ivMode)
{
aes_setmode(mode);
uint32_t blocks;
while (blockCount != 0) {
- if ((mode & AES_ALL_MODES) != AES_ECB_ENCRYPT_MODE &&
- (mode & AES_ALL_MODES) != AES_ECB_DECRYPT_MODE)
+ if ((mode & AES_ALL_MODES) != AES_ECB_ENCRYPT_MODE && (mode & AES_ALL_MODES) != AES_ECB_DECRYPT_MODE)
aes_setiv(iv, ivMode);
blocks = (blockCount >= 0xFFFF) ? 0xFFFF : blockCount;
}
void
-ncch_getctr(const ncch_h* ncch, uint8_t* ctr, uint8_t type)
+ncch_getctr(const ncch_h *ncch, uint8_t *ctr, uint8_t type)
{
uint32_t version = ncch->version;
- const uint8_t* partitionID = ncch->partitionID;
+ const uint8_t *partitionID = ncch->partitionID;
int i;
for (i = 0; i < 16; i++)
}
void
-sha(void* res, const void* src, uint32_t size, uint32_t mode)
+sha(void *res, const void *src, uint32_t size, uint32_t mode)
{
sha_wait_idle();
*REG_SHA_CNT = mode | SHA_CNT_OUTPUT_ENDIAN | SHA_NORMAL_ROUND;
- const uint32_t* src32 = (const uint32_t*)src;
+ const uint32_t *src32 = (const uint32_t *)src;
int i;
while (size >= 0x40) {
sha_wait_idle();
}
sha_wait_idle();
- memcpy((void*)REG_SHA_INFIFO, src32, size);
+ memcpy((void *)REG_SHA_INFIFO, src32, size);
*REG_SHA_CNT = (*REG_SHA_CNT & ~SHA_NORMAL_ROUND) | SHA_FINAL_ROUND;
else if (mode == SHA_1_MODE)
hashSize = SHA_1_HASH_SIZE;
- memcpy(res, (void*)REG_SHA_HASH, hashSize);
+ memcpy(res, (void *)REG_SHA_HASH, hashSize);
}
void
}
void
-rsa_setkey(uint32_t keyslot, const void* mod, const void* exp, uint32_t mode)
+rsa_setkey(uint32_t keyslot, const void *mod, const void *exp, uint32_t mode)
{
rsa_wait_idle();
- *REG_RSA_CNT = (*REG_RSA_CNT & ~RSA_CNT_KEYSLOTS) | (keyslot << 4) |
- RSA_IO_BE | RSA_IO_NORMAL;
+ *REG_RSA_CNT = (*REG_RSA_CNT & ~RSA_CNT_KEYSLOTS) | (keyslot << 4) | RSA_IO_BE | RSA_IO_NORMAL;
uint32_t size = mode * 4;
- volatile uint32_t* keyslotCnt = REG_RSA_SLOT0 + (keyslot << 4);
+ volatile uint32_t *keyslotCnt = REG_RSA_SLOT0 + (keyslot << 4);
keyslotCnt[0] &= ~(RSA_SLOTCNT_KEY_SET | RSA_SLOTCNT_WPROTECT);
keyslotCnt[1] = mode;
- memcpy((void*)REG_RSA_MOD_END - size, mod, size);
+ memcpy((void *)REG_RSA_MOD_END - size, mod, size);
if (exp == NULL) {
size -= 4;
}
*REG_RSA_EXPFIFO = 0x01000100; // 0x00010001 byteswapped
} else {
- const uint32_t* exp32 = (const uint32_t*)exp;
+ const uint32_t *exp32 = (const uint32_t *)exp;
while (size) {
*REG_RSA_EXPFIFO = *exp32++;
size -= 4;
}
void
-rsa(void* dst, const void* src, uint32_t size)
+rsa(void *dst, const void *src, uint32_t size)
{
uint32_t keyslot = (*REG_RSA_CNT & RSA_CNT_KEYSLOTS) >> 4;
if (rsa_iskeyset(keyslot) == 0)
// Pad the message with zeroes so that it's a multiple of 8
// and write the message with the end aligned with the register
uint32_t padSize = ((size + 7) & ~7) - size;
- memset((void*)REG_RSA_TXT_END - (size + padSize), 0, padSize);
- memcpy((void*)REG_RSA_TXT_END - size, src, size);
+ memset((void *)REG_RSA_TXT_END - (size + padSize), 0, padSize);
+ memcpy((void *)REG_RSA_TXT_END - size, src, size);
// Start
*REG_RSA_CNT |= RSA_CNT_START;
rsa_wait_idle();
- memcpy(dst, (void*)REG_RSA_TXT_END - size, size);
+ memcpy(dst, (void *)REG_RSA_TXT_END - size, size);
}
int
-rsa_verify(const void* data, uint32_t size, const void* sig, uint32_t mode)
+rsa_verify(const void *data, uint32_t size, const void *sig, uint32_t mode)
{
uint8_t dataHash[SHA_256_HASH_SIZE];
sha(dataHash, data, size, SHA_256_MODE);
uint32_t sigSize = mode * 4;
rsa(decSig, sig, sigSize);
- return memcmp(dataHash, decSig + (sigSize - SHA_256_HASH_SIZE),
- SHA_256_HASH_SIZE) == 0;
+ return memcmp(dataHash, decSig + (sigSize - SHA_256_HASH_SIZE), SHA_256_HASH_SIZE) == 0;
}
#include "headers.h"
/**************************AES****************************/
-#define REG_AESCNT ((volatile uint32_t*)0x10009000)
-#define REG_AESBLKCNT ((volatile uint32_t*)0x10009004)
-#define REG_AESWRFIFO ((volatile uint32_t*)0x10009008)
-#define REG_AESRDFIFO ((volatile uint32_t*)0x1000900C)
-#define REG_AESKEYSEL ((volatile uint8_t*)0x10009010)
-#define REG_AESKEYCNT ((volatile uint8_t*)0x10009011)
-#define REG_AESCTR ((volatile uint32_t*)0x10009020)
-
-#define REG_AESKEYFIFO ((volatile uint32_t*)0x10009100)
-#define REG_AESKEYXFIFO ((volatile uint32_t*)0x10009104)
-#define REG_AESKEYYFIFO ((volatile uint32_t*)0x10009108)
+#define REG_AESCNT ((volatile uint32_t *)0x10009000)
+#define REG_AESBLKCNT ((volatile uint32_t *)0x10009004)
+#define REG_AESWRFIFO ((volatile uint32_t *)0x10009008)
+#define REG_AESRDFIFO ((volatile uint32_t *)0x1000900C)
+#define REG_AESKEYSEL ((volatile uint8_t *)0x10009010)
+#define REG_AESKEYCNT ((volatile uint8_t *)0x10009011)
+#define REG_AESCTR ((volatile uint32_t *)0x10009020)
+
+#define REG_AESKEYFIFO ((volatile uint32_t *)0x10009100)
+#define REG_AESKEYXFIFO ((volatile uint32_t *)0x10009104)
+#define REG_AESKEYYFIFO ((volatile uint32_t *)0x10009108)
#define AES_CCM_DECRYPT_MODE (0u << 27)
#define AES_CCM_ENCRYPT_MODE (1u << 27)
#define AES_KEYY 2
/**************************SHA****************************/
-#define REG_SHA_CNT ((volatile uint32_t*)0x1000A000)
-#define REG_SHA_BLKCNT ((volatile uint32_t*)0x1000A004)
-#define REG_SHA_HASH ((volatile uint32_t*)0x1000A040)
-#define REG_SHA_INFIFO ((volatile uint32_t*)0x1000A080)
+#define REG_SHA_CNT ((volatile uint32_t *)0x1000A000)
+#define REG_SHA_BLKCNT ((volatile uint32_t *)0x1000A004)
+#define REG_SHA_HASH ((volatile uint32_t *)0x1000A040)
+#define REG_SHA_INFIFO ((volatile uint32_t *)0x1000A080)
#define SHA_CNT_STATE 0x00000003
#define SHA_CNT_UNK2 0x00000004
#define SHA_1_HASH_SIZE (160 / 8)
/**************************RSA****************************/
-#define REG_RSA_CNT ((volatile uint32_t*)0x1000B000)
-#define REG_RSA_SLOT0 ((volatile uint32_t*)0x1000B100)
-#define REG_RSA_SLOT1 ((volatile uint32_t*)0x1000B110)
-#define REG_RSA_SLOT2 ((volatile uint32_t*)0x1000B120)
-#define REG_RSA_SLOT3 ((volatile uint32_t*)0x1000B130)
-#define REG_RSA_EXPFIFO ((volatile uint32_t*)0x1000B200)
-#define REG_RSA_MOD_END ((volatile uint32_t*)0x1000B500)
-#define REG_RSA_TXT_END ((volatile uint32_t*)0x1000B900)
+#define REG_RSA_CNT ((volatile uint32_t *)0x1000B000)
+#define REG_RSA_SLOT0 ((volatile uint32_t *)0x1000B100)
+#define REG_RSA_SLOT1 ((volatile uint32_t *)0x1000B110)
+#define REG_RSA_SLOT2 ((volatile uint32_t *)0x1000B120)
+#define REG_RSA_SLOT3 ((volatile uint32_t *)0x1000B130)
+#define REG_RSA_EXPFIFO ((volatile uint32_t *)0x1000B200)
+#define REG_RSA_MOD_END ((volatile uint32_t *)0x1000B500)
+#define REG_RSA_TXT_END ((volatile uint32_t *)0x1000B900)
#define RSA_CNT_START 0x00000001
#define RSA_CNT_KEYSLOTS 0x000000F0
#define RSA_1024_MODE 0x20
#define RSA_2048_MODE 0x40
-void aes_setkey(uint8_t keyslot, const void* key, uint32_t keyType,
- uint32_t mode);
+void aes_setkey(uint8_t keyslot, const void *key, uint32_t keyType, uint32_t mode);
void aes_use_keyslot(uint8_t keyslot);
-void aes(void* dst, const void* src, uint32_t blockCount, void* iv,
- uint32_t mode, uint32_t ivMode);
+void aes(void *dst, const void *src, uint32_t blockCount, void *iv, uint32_t mode, uint32_t ivMode);
-void aes_setiv(const void* iv, uint32_t mode);
-void aes_advctr(void* ctr, uint32_t val, uint32_t mode);
-void aes_change_ctrmode(void* ctr, uint32_t fromMode, uint32_t toMode);
+void aes_setiv(const void *iv, uint32_t mode);
+void aes_advctr(void *ctr, uint32_t val, uint32_t mode);
+void aes_change_ctrmode(void *ctr, uint32_t fromMode, uint32_t toMode);
-void aes_batch(void* dst, const void* src, uint32_t blockCount);
+void aes_batch(void *dst, const void *src, uint32_t blockCount);
-void sha(void* res, const void* src, uint32_t size, uint32_t mode);
+void sha(void *res, const void *src, uint32_t size, uint32_t mode);
-void rsa_setkey(uint32_t keyslot, const void* mod, const void* exp,
- uint32_t mode);
+void rsa_setkey(uint32_t keyslot, const void *mod, const void *exp, uint32_t mode);
void rsa_use_keyslot(uint32_t keyslot);
-int rsa_verify(const void* data, uint32_t size, const void* sig, uint32_t mode);
+int rsa_verify(const void *data, uint32_t size, const void *sig, uint32_t mode);
typedef enum {
NCCHTYPE_EXHEADER = 1,
NCCHTYPE_ROMFS = 3,
} ctr_ncchtypes;
-void ncch_getctr(const ncch_h* ncch, uint8_t* ctr, uint8_t type);
+void ncch_getctr(const ncch_h *ncch, uint8_t *ctr, uint8_t type);
#endif
#include "fcram.h"
-void* fcram_temp = (void*)0x23000000;
+void *fcram_temp = (void *)0x23000000;
#include "../std/unused.h"
-extern void* fcram_temp;
+extern void *fcram_temp;
// Space between most of the locations
#define FCRAM_SPACING 0x100000
#include "../common.h"
-firm_h* firm_loc = (firm_h*)FCRAM_FIRM_LOC;
+firm_h *firm_loc = (firm_h *)FCRAM_FIRM_LOC;
static uint32_t firm_size = FCRAM_SPACING;
firm_section_h firm_proc9;
-exefs_h* firm_p9_exefs;
+exefs_h *firm_p9_exefs;
-firm_h* twl_firm_loc = (firm_h*)FCRAM_TWL_FIRM_LOC;
+firm_h *twl_firm_loc = (firm_h *)FCRAM_TWL_FIRM_LOC;
static uint32_t twl_firm_size = FCRAM_SPACING * 2;
firm_section_h twl_firm_proc9;
-exefs_h* twl_firm_p9_exefs;
+exefs_h *twl_firm_p9_exefs;
-firm_h* agb_firm_loc = (firm_h*)FCRAM_AGB_FIRM_LOC;
+firm_h *agb_firm_loc = (firm_h *)FCRAM_AGB_FIRM_LOC;
static uint32_t agb_firm_size = FCRAM_SPACING;
firm_section_h agb_firm_proc9;
-exefs_h* agb_firm_p9_exefs;
+exefs_h *agb_firm_p9_exefs;
static int update_96_keys = 0;
-static volatile uint32_t* const a11_entry = (volatile uint32_t*)0x1FFFFFF8;
+static volatile uint32_t *const a11_entry = (volatile uint32_t *)0x1FFFFFF8;
void
slot0x11key96_init()
// 9.6 crypto may need us to get the key from somewhere else.
// Unless the console already has the key initialized, that is.
uint8_t key[AES_BLOCK_SIZE];
- if (read_file(key, PATH_SLOT0X11KEY96, AES_BLOCK_SIZE) ||
- read_file(key, PATH_ALT_SLOT0X11KEY96, AES_BLOCK_SIZE)) {
+ if (read_file(key, PATH_SLOT0X11KEY96, AES_BLOCK_SIZE) || read_file(key, PATH_ALT_SLOT0X11KEY96, AES_BLOCK_SIZE)) {
// Read key successfully.
aes_setkey(0x11, key, AES_KEYNORMAL, AES_INPUT_BE | AES_INPUT_NORMAL);
}
int
-decrypt_firm_title(firm_h* dest, ncch_h* ncch, uint32_t* size, void* key)
+decrypt_firm_title(firm_h *dest, ncch_h *ncch, uint32_t *size, void *key)
{
uint8_t firm_iv[16] = { 0 };
uint8_t exefs_key[16] = { 0 };
fprintf(BOTTOM_SCREEN, "n");
aes_setkey(0x16, key, AES_KEYNORMAL, AES_INPUT_BE | AES_INPUT_NORMAL);
aes_use_keyslot(0x16);
- aes(ncch, ncch, *size / AES_BLOCK_SIZE, firm_iv, AES_CBC_DECRYPT_MODE,
- AES_INPUT_BE | AES_INPUT_NORMAL);
+ aes(ncch, ncch, *size / AES_BLOCK_SIZE, firm_iv, AES_CBC_DECRYPT_MODE, AES_INPUT_BE | AES_INPUT_NORMAL);
if (ncch->magic != NCCH_MAGIC)
return 1;
ncch_getctr(ncch, exefs_iv, NCCHTYPE_EXEFS);
// Get the exefs offset and size from the NCCH
- exefs_h* exefs = (exefs_h*)((void*)ncch + ncch->exeFSOffset * MEDIA_UNITS);
+ exefs_h *exefs = (exefs_h *)((void *)ncch + ncch->exeFSOffset * MEDIA_UNITS);
uint32_t exefs_size = ncch->exeFSSize * MEDIA_UNITS;
fprintf(BOTTOM_SCREEN, "e");
aes_setkey(0x2C, exefs_key, AES_KEYY, AES_INPUT_BE | AES_INPUT_NORMAL);
aes_use_keyslot(0x2C);
- aes(exefs, exefs, exefs_size / AES_BLOCK_SIZE, exefs_iv, AES_CTR_MODE,
- AES_INPUT_BE | AES_INPUT_NORMAL);
+ aes(exefs, exefs, exefs_size / AES_BLOCK_SIZE, exefs_iv, AES_CTR_MODE, AES_INPUT_BE | AES_INPUT_NORMAL);
// Get the decrypted FIRM
// We assume the firm.bin is always the first file
- firm_h* firm = (firm_h*)&exefs[1]; // The offset right behind the exefs
- // header; the first file.
+ firm_h *firm = (firm_h *)&exefs[1]; // The offset right behind the exefs
+ // header; the first file.
*size = exefs->fileHeaders[0].size;
if (firm->magic != FIRM_MAGIC)
}
int
-decrypt_arm9bin(arm9bin_h* header, uint64_t firm_title, uint8_t version)
+decrypt_arm9bin(arm9bin_h *header, uint64_t firm_title, uint8_t version)
{
uint8_t slot = 0x15;
slot = 0x16;
aes_use_keyslot(0x11);
- aes(decrypted_keyx, header->slot0x16keyX, 1, NULL, AES_ECB_DECRYPT_MODE,
- 0);
- aes_setkey(slot, decrypted_keyx, AES_KEYX,
- AES_INPUT_BE | AES_INPUT_NORMAL);
+ aes(decrypted_keyx, header->slot0x16keyX, 1, NULL, AES_ECB_DECRYPT_MODE, 0);
+ aes_setkey(slot, decrypted_keyx, AES_KEYX, AES_INPUT_BE | AES_INPUT_NORMAL);
}
aes_setkey(slot, header->keyy, AES_KEYY, AES_INPUT_BE | AES_INPUT_NORMAL);
aes_setiv(header->ctr, AES_INPUT_BE | AES_INPUT_NORMAL);
- void* arm9bin = (uint8_t*)header + 0x800;
+ void *arm9bin = (uint8_t *)header + 0x800;
int size = atoi(header->size);
aes_use_keyslot(slot);
- aes(arm9bin, arm9bin, size / AES_BLOCK_SIZE, header->ctr, AES_CTR_MODE,
- AES_INPUT_BE | AES_INPUT_NORMAL);
+ aes(arm9bin, arm9bin, size / AES_BLOCK_SIZE, header->ctr, AES_CTR_MODE, AES_INPUT_BE | AES_INPUT_NORMAL);
if (firm_title == NATIVE_FIRM_TITLEID)
- return *(uint32_t*)arm9bin != ARM9BIN_MAGIC;
+ return *(uint32_t *)arm9bin != ARM9BIN_MAGIC;
else if (firm_title == AGB_FIRM_TITLEID || firm_title == TWL_FIRM_TITLEID)
- return *(uint32_t*)arm9bin != LGY_ARM9BIN_MAGIC;
+ return *(uint32_t *)arm9bin != LGY_ARM9BIN_MAGIC;
else
return 0;
}
int
-decrypt_firm(firm_h* dest, char* path_firmkey, uint32_t* size)
+decrypt_firm(firm_h *dest, char *path_firmkey, uint32_t *size)
{
uint8_t firm_key[AES_BLOCK_SIZE];
}
fprintf(BOTTOM_SCREEN, "d");
- if (decrypt_firm_title(dest, (void*)dest, size, firm_key) != 0) {
+ if (decrypt_firm_title(dest, (void *)dest, size, firm_key) != 0) {
fprintf(BOTTOM_SCREEN, "!");
return 1;
}
extern int patch_services();
int
-load_firm(firm_h* dest, char* path, char* path_firmkey, uint32_t* size,
- uint64_t firm_title)
+load_firm(firm_h *dest, char *path, char *path_firmkey, uint32_t *size, uint64_t firm_title)
{
int status = 0;
int firmware_changed = 0;
fprintf(BOTTOM_SCREEN, "_");
}
- struct firm_signature* fsig = get_firm_info(dest);
+ struct firm_signature *fsig = get_firm_info(dest);
// The N3DS firm has an additional encryption layer for ARM9
if (fsig->console == console_n3ds) {
// Look for the arm9 section
- for (firm_section_h* section = dest->section;
- section < dest->section + 4; section++) {
+ for (firm_section_h *section = dest->section; section < dest->section + 4; section++) {
if (section->type == FIRM_TYPE_ARM9) {
// Check whether the arm9bin is encrypted.
int arm9bin_iscrypt = 0;
- uint32_t magic =
- *(uint32_t*)((uintptr_t)dest + section->offset + 0x800);
+ uint32_t magic = *(uint32_t *)((uintptr_t)dest + section->offset + 0x800);
if (firm_title == NATIVE_FIRM_TITLEID)
arm9bin_iscrypt = (magic != ARM9BIN_MAGIC);
- else if (firm_title == AGB_FIRM_TITLEID ||
- firm_title == TWL_FIRM_TITLEID)
+ else if (firm_title == AGB_FIRM_TITLEID || firm_title == TWL_FIRM_TITLEID)
arm9bin_iscrypt = (magic != LGY_ARM9BIN_MAGIC);
if (arm9bin_iscrypt) {
// Decrypt the arm9bin.
- if (decrypt_arm9bin(
- (arm9bin_h*)((uintptr_t)dest + section->offset),
- firm_title, fsig->version)) {
- fprintf(BOTTOM_SCREEN,
- "\nCouldn't decrypt ARM9 FIRM binary.\n"
- "Check if you have the needed key at:\n"
- " " PATH_SLOT0X11KEY96 "\n");
+ if (decrypt_arm9bin((arm9bin_h *)((uintptr_t)dest + section->offset), firm_title, fsig->version)) {
+ fprintf(BOTTOM_SCREEN, "\nCouldn't decrypt ARM9 FIRM binary.\n"
+ "Check if you have the needed key at:\n"
+ " " PATH_SLOT0X11KEY96 "\n");
status = 1;
goto exit_error;
}
firmware_changed = 1; // Decryption of arm9bin performed.
} else {
- fprintf(BOTTOM_SCREEN,
- "_");
- if (firm_title == NATIVE_FIRM_TITLEID &&
- fsig->version > 0x0F) {
+ fprintf(BOTTOM_SCREEN, "_");
+ if (firm_title == NATIVE_FIRM_TITLEID && fsig->version > 0x0F) {
slot0x11key96_init(); // This has to be loaded
// regardless, otherwise boot will
// fail.
// Patch the entrypoint to skip arm9loader
if (firm_title == NATIVE_FIRM_TITLEID) {
dest->a9Entry = 0x0801B01C;
- } else if (firm_title == AGB_FIRM_TITLEID ||
- firm_title == TWL_FIRM_TITLEID) {
+ } else if (firm_title == AGB_FIRM_TITLEID || firm_title == TWL_FIRM_TITLEID) {
dest->a9Entry = 0x0801301C;
}
// The entrypoints seem to be the same across different FIRM versions,
*a11_entry = 0; // Don't wait for us
// Disables the LCD.
- *(volatile uint32_t*)0x10202A44 = 0;
- *(volatile uint32_t*)0x10202244 = 0;
- *(volatile uint32_t*)0x1020200C = 0;
- *(volatile uint32_t*)0x10202014 = 0;
+ *(volatile uint32_t *)0x10202A44 = 0;
+ *(volatile uint32_t *)0x10202244 = 0;
+ *(volatile uint32_t *)0x1020200C = 0;
+ *(volatile uint32_t *)0x10202014 = 0;
while (!*a11_entry)
;
void
boot_firm()
{
- struct firm_signature* fsig = get_firm_info(firm_loc);
+ struct firm_signature *fsig = get_firm_info(firm_loc);
// Set up the keys needed to boot a few firmwares, due to them being unset,
// depending on which firmware you're booting from.
// TODO: Don't use the hardcoded offset.
- if (update_96_keys && fsig->console == console_n3ds &&
- fsig->version > 0x0F) {
- void* keydata = NULL;
+ if (update_96_keys && fsig->console == console_n3ds && fsig->version > 0x0F) {
+ void *keydata = NULL;
if (fsig->version == 0x1B || fsig->version == 0x1F) {
- keydata = (void*)((uintptr_t)firm_loc +
- firm_loc->section[2].offset + 0x89814);
+ keydata = (void *)((uintptr_t)firm_loc + firm_loc->section[2].offset + 0x89814);
} else if (fsig->version == 0x21) {
- keydata = (void*)((uintptr_t)firm_loc +
- firm_loc->section[2].offset + 0x89A14);
+ keydata = (void *)((uintptr_t)firm_loc + firm_loc->section[2].offset + 0x89A14);
}
aes_use_keyslot(0x11);
for (int slot = 0x19; slot < 0x20; slot++) {
aes(keyx, keydata, 1, NULL, AES_ECB_DECRYPT_MODE, 0);
aes_setkey(slot, keyx, AES_KEYX, AES_INPUT_BE | AES_INPUT_NORMAL);
- *(uint8_t*)(keydata + 0xF) += 1;
+ *(uint8_t *)(keydata + 0xF) += 1;
}
fprintf(BOTTOM_SCREEN, "Updated keyX keyslots\n");
fumount(); // Unmount SD. No longer needed.
fprintf(BOTTOM_SCREEN, "SD Unmounted.\n");
- for (firm_section_h* section = firm_loc->section;
- section < firm_loc->section + 4 && section->address != 0; section++) {
- memcpy((void*)section->address, (void*)firm_loc + section->offset,
- section->size);
+ for (firm_section_h *section = firm_loc->section; section < firm_loc->section + 4 && section->address != 0; section++) {
+ memcpy((void *)section->address, (void *)firm_loc + section->offset, section->size);
}
fprintf(BOTTOM_SCREEN, "Copied FIRM\n");
}
int
-find_proc9(firm_h* firm, firm_section_h* process9, exefs_h** p9exefs)
+find_proc9(firm_h *firm, firm_section_h *process9, exefs_h **p9exefs)
{
- for (firm_section_h* section = firm->section; section < firm->section + 4;
- section++) {
+ for (firm_section_h *section = firm->section; section < firm->section + 4; section++) {
if (section->address == 0)
break;
if (section->type == FIRM_TYPE_ARM9) {
- void* arm9section = (void*)firm + section->offset;
+ void *arm9section = (void *)firm + section->offset;
while (arm9section < arm9section + section->size) {
if (!memcmp(arm9section, "Process9", 8)) { // Process9
- ncch_h* ncch = (ncch_h*)(arm9section - sizeof(ncch_h));
+ ncch_h *ncch = (ncch_h *)(arm9section - sizeof(ncch_h));
if (ncch->magic == NCCH_MAGIC) {
// Found Process9
- ncch_ex_h* p9exheader = (ncch_ex_h*)(ncch + 1);
- *p9exefs = (exefs_h*)(p9exheader + 1);
+ ncch_ex_h *p9exheader = (ncch_ex_h *)(ncch + 1);
+ *p9exefs = (exefs_h *)(p9exheader + 1);
process9->address = p9exheader->sci.textCodeSet.address;
process9->size = (*p9exefs)->fileHeaders[0].size;
- process9->offset =
- (void*)((*p9exefs) + 1) - (void*)firm;
+ process9->offset = (void *)((*p9exefs) + 1) - (void *)firm;
fprintf(BOTTOM_SCREEN, "p");
return 0;
}
int
load_firms()
{
- if (firm_loaded)
- return 0;
+ if (firm_loaded)
+ return 0;
fprintf(BOTTOM_SCREEN, "FIRM load triggered.\n");
fprintf(BOTTOM_SCREEN, "NATIVE_FIRM\n [");
- if (load_firm(firm_loc, PATH_NATIVE_F, PATH_NATIVE_FIRMKEY, &firm_size,
- NATIVE_FIRM_TITLEID) != 0)
+ if (load_firm(firm_loc, PATH_NATIVE_F, PATH_NATIVE_FIRMKEY, &firm_size, NATIVE_FIRM_TITLEID) != 0)
return 1;
find_proc9(firm_loc, &firm_proc9, &firm_p9_exefs);
fprintf(BOTTOM_SCREEN, "]\nTWL_FIRM\n [");
- if (load_firm(twl_firm_loc, PATH_TWL_F, PATH_TWL_FIRMKEY, &twl_firm_size,
- TWL_FIRM_TITLEID))
+ if (load_firm(twl_firm_loc, PATH_TWL_F, PATH_TWL_FIRMKEY, &twl_firm_size, TWL_FIRM_TITLEID))
fprintf(BOTTOM_SCREEN, " \nTWL_FIRM failed to load.\n");
else
find_proc9(twl_firm_loc, &twl_firm_proc9, &twl_firm_p9_exefs);
fprintf(BOTTOM_SCREEN, "]\nAGB_FIRM\n [");
- if (load_firm(agb_firm_loc, PATH_AGB_F, PATH_AGB_FIRMKEY, &agb_firm_size,
- AGB_FIRM_TITLEID))
+ if (load_firm(agb_firm_loc, PATH_AGB_F, PATH_AGB_FIRMKEY, &agb_firm_size, AGB_FIRM_TITLEID))
fprintf(BOTTOM_SCREEN, " \nAGB_FIRM failed to load.\n");
else
find_proc9(agb_firm_loc, &agb_firm_proc9, &agb_firm_p9_exefs);
- fprintf(BOTTOM_SCREEN, "]\n");
+ fprintf(BOTTOM_SCREEN, "]\n");
- firm_loaded = 1; // Loaded.
+ firm_loaded = 1; // Loaded.
return 0;
}
boot_cfw()
{
fprintf(BOTTOM_SCREEN, "Loading firmware...\n");
- load_firms();
+ load_firms();
fprintf(BOTTOM_SCREEN, "Patching firmware...\n");
if (patch_firm_all() != 0)
enum consoles console;
};
-extern firm_h* firm_loc;
-extern struct firm_signature* current_firm;
+extern firm_h *firm_loc;
+extern struct firm_signature *current_firm;
extern firm_section_h firm_proc9;
-extern exefs_h* firm_p9_exefs;
+extern exefs_h *firm_p9_exefs;
-extern firm_h* twl_firm_loc;
-extern struct firm_signature* current_twl_firm;
+extern firm_h *twl_firm_loc;
+extern struct firm_signature *current_twl_firm;
extern firm_section_h twl_firm_proc9;
-extern exefs_h* twl_firm_p9_exefs;
+extern exefs_h *twl_firm_p9_exefs;
-extern firm_h* agb_firm_loc;
-extern struct firm_signature* current_agb_firm;
+extern firm_h *agb_firm_loc;
+extern struct firm_signature *current_agb_firm;
extern firm_section_h agb_firm_proc9;
-extern exefs_h* agb_firm_p9_exefs;
+extern exefs_h *agb_firm_p9_exefs;
-struct firm_signature* get_firm_info(firm_h* firm);
+struct firm_signature *get_firm_info(firm_h *firm);
void slot0x11key96_init();
int load_firms();
// http://3dbrew.org/wiki/NCCH
typedef struct ncch_h
{
- uint8_t sig[0x100]; // RSA-2048 signature of the NCCH header, using SHA-256.
- uint32_t magic; // NCCH
+ uint8_t sig[0x100]; // RSA-2048 signature of the NCCH header, using SHA-256.
+ uint32_t magic; // NCCH
uint32_t contentSize; // Content size, in media units (1 media unit = 0x200
// bytes)
uint8_t partitionID[8];
typedef struct exefs_h
{
- exefs_file_h
- fileHeaders[10]; // File headers (10 headers maximum, 16 bytes each)
+ exefs_file_h fileHeaders[10]; // File headers (10 headers maximum, 16 bytes each)
uint8_t reserved[0x20];
exefs_file_hash fileHashes[10]; // File hashes (10 hashes maximum, 32 bytes
// each, one for each header), SHA256 over
{
uint8_t sig[0x100]; // RSA-2048 signature of the NCSD header, using SHA-256.
uint32_t magic; // NCSD
- uint32_t size; // Size of the NCSD image, in media units (1 media unit =
- // 0x200 bytes)
+ uint32_t size; // Size of the NCSD image, in media units (1 media unit =
+ // 0x200 bytes)
uint8_t mediaID[8];
- uint8_t fsType[8]; // Partitions FS type (0=None, 1=Normal, 3=FIRM,
- // 4=AGB_FIRM save)
- uint8_t cryptType[8]; // Partitions crypt type
- ncsd_partition_table
- ptable[8]; // Offset & Length partition table, in media units
+ uint8_t fsType[8]; // Partitions FS type (0=None, 1=Normal, 3=FIRM,
+ // 4=AGB_FIRM save)
+ uint8_t cryptType[8]; // Partitions crypt type
+ ncsd_partition_table ptable[8]; // Offset & Length partition table, in media units
uint8_t spec[0xA0];
} ncsd_h;
// We use the firm's section 0's hash to identify the version
struct firm_signature firm_signatures[] = {
- {.sig = { 0xEE, 0xE2, 0x81, 0x2E, 0xB9, 0x10, 0x0D, 0x03, 0xFE, 0xA2, 0x3F,
- 0x44, 0xB5, 0x1C, 0xB3, 0x5E },
+ {.sig = { 0xEE, 0xE2, 0x81, 0x2E, 0xB9, 0x10, 0x0D, 0x03, 0xFE, 0xA2, 0x3F, 0x44, 0xB5, 0x1C, 0xB3, 0x5E },
.version = 0x1F,
.version_string = "4.1.0",
.console = console_o3ds },
- {.sig = { 0x8C, 0x29, 0xDA, 0x7B, 0xB5, 0x5F, 0xFE, 0x44, 0x1F, 0x66, 0x79,
- 0x70, 0x8E, 0xE4, 0x42, 0xE3 },
+ {.sig = { 0x8C, 0x29, 0xDA, 0x7B, 0xB5, 0x5F, 0xFE, 0x44, 0x1F, 0x66, 0x79, 0x70, 0x8E, 0xE4, 0x42, 0xE3 },
.version = 0x2A,
.version_string = "6.1.0",
.console = console_o3ds },
- {.sig = { 0x1D, 0x96, 0x80, 0xD9, 0x0A, 0xA9, 0xDB, 0xE8, 0x29, 0x77, 0xCB,
- 0x7D, 0x90, 0x55, 0xB7, 0xF9 },
+ {.sig = { 0x1D, 0x96, 0x80, 0xD9, 0x0A, 0xA9, 0xDB, 0xE8, 0x29, 0x77, 0xCB, 0x7D, 0x90, 0x55, 0xB7, 0xF9 },
.version = 0x30,
.version_string = "7.2.0",
.console = console_o3ds },
- {.sig = { 0x3B, 0x61, 0x2E, 0xBA, 0x42, 0xAE, 0x24, 0x46, 0xAD, 0x60, 0x2F,
- 0x7B, 0x52, 0x16, 0x82, 0x91 },
+ {.sig = { 0x3B, 0x61, 0x2E, 0xBA, 0x42, 0xAE, 0x24, 0x46, 0xAD, 0x60, 0x2F, 0x7B, 0x52, 0x16, 0x82, 0x91 },
.version = 0x37,
.version_string = "8.0.0",
.console = console_o3ds },
- {.sig = { 0x3F, 0xBF, 0x14, 0x06, 0x33, 0x77, 0x82, 0xDE, 0xB2, 0x68, 0x83,
- 0x01, 0x6B, 0x1A, 0x71, 0x69 },
+ {.sig = { 0x3F, 0xBF, 0x14, 0x06, 0x33, 0x77, 0x82, 0xDE, 0xB2, 0x68, 0x83, 0x01, 0x6B, 0x1A, 0x71, 0x69 },
.version = 0x38,
.version_string = "9.0.0",
.console = console_o3ds },
- {.sig = { 0x5C, 0x6A, 0x51, 0xF3, 0x79, 0x4D, 0x21, 0x91, 0x0B, 0xBB, 0xFD,
- 0x17, 0x7B, 0x72, 0x6B, 0x59 },
+ {.sig = { 0x5C, 0x6A, 0x51, 0xF3, 0x79, 0x4D, 0x21, 0x91, 0x0B, 0xBB, 0xFD, 0x17, 0x7B, 0x72, 0x6B, 0x59 },
.version = 0x49,
.version_string = "9.6.0",
.console = console_o3ds },
- {.sig = { 0xF5, 0x7E, 0xC3, 0x86, 0x1F, 0x8D, 0x8E, 0xFB, 0x44, 0x61, 0xF3,
- 0x16, 0x51, 0x0A, 0x57, 0x7D },
+ {.sig = { 0xF5, 0x7E, 0xC3, 0x86, 0x1F, 0x8D, 0x8E, 0xFB, 0x44, 0x61, 0xF3, 0x16, 0x51, 0x0A, 0x57, 0x7D },
.version = 0x50,
.version_string = "10.4.0",
.console = console_o3ds },
- {.sig = { 0xE9, 0xAD, 0x74, 0x9D, 0x46, 0x9C, 0x9C, 0xF4, 0x96, 0x9E, 0x1A,
- 0x7A, 0xDF, 0x40, 0x2A, 0x82 },
+ {.sig = { 0xE9, 0xAD, 0x74, 0x9D, 0x46, 0x9C, 0x9C, 0xF4, 0x96, 0x9E, 0x1A, 0x7A, 0xDF, 0x40, 0x2A, 0x82 },
.version = 0x52,
.version_string = "11.0.0",
.console = console_o3ds },
- {.sig = { 0x31, 0xCC, 0x46, 0xCD, 0x61, 0x7A, 0xE7, 0x13, 0x7F, 0xE5, 0xFC,
- 0x20, 0x46, 0x91, 0x6A, 0xBB },
+ {.sig = { 0x31, 0xCC, 0x46, 0xCD, 0x61, 0x7A, 0xE7, 0x13, 0x7F, 0xE5, 0xFC, 0x20, 0x46, 0x91, 0x6A, 0xBB },
.version = 0x04,
.version_string = "9.0.0",
.console = console_n3ds },
- {.sig = { 0x40, 0x35, 0x6C, 0x9A, 0x24, 0x36, 0x93, 0x7B, 0x76, 0xFE, 0x5D,
- 0xB1, 0x4D, 0x05, 0x06, 0x52 },
+ {.sig = { 0x40, 0x35, 0x6C, 0x9A, 0x24, 0x36, 0x93, 0x7B, 0x76, 0xFE, 0x5D, 0xB1, 0x4D, 0x05, 0x06, 0x52 },
.version = 0x0F,
.version_string = "9.5.0",
.console = console_n3ds },
- {.sig = { 0x07, 0xFE, 0x9A, 0x62, 0x3F, 0xDE, 0x54, 0xC1, 0x9B, 0x06, 0x91,
- 0xD8, 0x4F, 0x44, 0x9C, 0x21 },
+ {.sig = { 0x07, 0xFE, 0x9A, 0x62, 0x3F, 0xDE, 0x54, 0xC1, 0x9B, 0x06, 0x91, 0xD8, 0x4F, 0x44, 0x9C, 0x21 },
.version = 0x1B,
.version_string = "10.2.0",
.console = console_n3ds },
- {.sig = { 0x1A, 0x56, 0x5C, 0xFF, 0xC9, 0xCC, 0x62, 0xBB, 0x2B, 0xC2, 0x23,
- 0xB6, 0x4F, 0x48, 0xD1, 0xCC },
+ {.sig = { 0x1A, 0x56, 0x5C, 0xFF, 0xC9, 0xCC, 0x62, 0xBB, 0x2B, 0xC2, 0x23, 0xB6, 0x4F, 0x48, 0xD1, 0xCC },
.version = 0x1F,
.version_string = "10.4.0",
.console = console_n3ds },
- {.sig = { 0x52, 0x30, 0x0F, 0x55, 0xA2, 0x64, 0x4E, 0xFF, 0x96, 0x90, 0xF0,
- 0xE5, 0x6E, 0xC8, 0x2E, 0xB3 },
+ {.sig = { 0x52, 0x30, 0x0F, 0x55, 0xA2, 0x64, 0x4E, 0xFF, 0x96, 0x90, 0xF0, 0xE5, 0x6E, 0xC8, 0x2E, 0xB3 },
.version = 0x21,
.version_string = "11.0.0",
.console = console_n3ds },
- {.sig = { 0xE8, 0xB8, 0x82, 0xF5, 0x8C, 0xC4, 0x1B, 0x24, 0x05, 0x60, 0x6D,
- 0xB8, 0x74, 0xF5, 0xE5, 0xDD },
+ {.sig = { 0xE8, 0xB8, 0x82, 0xF5, 0x8C, 0xC4, 0x1B, 0x24, 0x05, 0x60, 0x6D, 0xB8, 0x74, 0xF5, 0xE5, 0xDD },
.version = 0x16,
.version_string = "6.2.0_TWL",
.console = console_o3ds },
- {.sig = { 0x0F, 0x05, 0xC5, 0xF3, 0x60, 0x83, 0x8B, 0x9D, 0xC8, 0x44, 0x3F,
- 0xB3, 0x06, 0x4D, 0x30, 0xC7 },
+ {.sig = { 0x0F, 0x05, 0xC5, 0xF3, 0x60, 0x83, 0x8B, 0x9D, 0xC8, 0x44, 0x3F, 0xB3, 0x06, 0x4D, 0x30, 0xC7 },
.version = 0x00,
.version_string = "9.0.0_TWL",
.console = console_n3ds },
- {.sig = { 0x65, 0xB7, 0x55, 0x78, 0x97, 0xE6, 0x5C, 0xD6, 0x11, 0x74, 0x95,
- 0xDD, 0x61, 0xE8, 0x08, 0x40 },
+ {.sig = { 0x65, 0xB7, 0x55, 0x78, 0x97, 0xE6, 0x5C, 0xD6, 0x11, 0x74, 0x95, 0xDD, 0x61, 0xE8, 0x08, 0x40 },
.version = 0x0B,
.version_string = "6.0.0_AGB",
.console = console_o3ds },
- {.sig = { 0xAF, 0x81, 0xA1, 0xAB, 0xBA, 0xAC, 0xAC, 0xA7, 0x30, 0xE8, 0xD8,
- 0x74, 0x7C, 0x47, 0x1C, 0x5D },
+ {.sig = { 0xAF, 0x81, 0xA1, 0xAB, 0xBA, 0xAC, 0xAC, 0xA7, 0x30, 0xE8, 0xD8, 0x74, 0x7C, 0x47, 0x1C, 0x5D },
.version = 0x00,
.version_string = "9.0.0_AGB",
.console = console_n3ds },
{.version = 0xFF } // Terminate list
};
-struct firm_signature*
-get_firm_info(firm_h* firm)
+struct firm_signature *
+get_firm_info(firm_h *firm)
{
- for (struct firm_signature* signature = firm_signatures;
- signature->version != 0xFF; signature++) {
+ for (struct firm_signature *signature = firm_signatures; signature->version != 0xFF; signature++) {
if (memcmp(signature->sig, firm->section[0].hash, 0x10) == 0) {
return signature;
}
{
uint8_t bus_id, reg_addr;
} dev_data[] = {
- { 0, 0x4A }, { 0, 0x7A }, { 0, 0x78 }, { 1, 0x4A }, { 1, 0x78 },
- { 1, 0x2C }, { 1, 0x2E }, { 1, 0x40 }, { 1, 0x44 }, { 2, 0xD6 },
- { 2, 0xD0 }, { 2, 0xD2 }, { 2, 0xA4 }, { 2, 0x9A }, { 2, 0xA0 },
+ { 0, 0x4A }, { 0, 0x7A }, { 0, 0x78 }, { 1, 0x4A }, { 1, 0x78 }, { 1, 0x2C }, { 1, 0x2E }, { 1, 0x40 },
+ { 1, 0x44 }, { 2, 0xD6 }, { 2, 0xD0 }, { 2, 0xD2 }, { 2, 0xA4 }, { 2, 0x9A }, { 2, 0xA0 },
};
uint8_t
//-----------------------------------------------------------------------------
-static volatile uint8_t* const reg_data_addrs[] = {
- (volatile uint8_t*)(I2C1_REG_OFF + I2C_REG_DATA),
- (volatile uint8_t*)(I2C2_REG_OFF + I2C_REG_DATA),
- (volatile uint8_t*)(I2C3_REG_OFF + I2C_REG_DATA),
+static volatile uint8_t *const reg_data_addrs[] = {
+ (volatile uint8_t *)(I2C1_REG_OFF + I2C_REG_DATA), (volatile uint8_t *)(I2C2_REG_OFF + I2C_REG_DATA), (volatile uint8_t *)(I2C3_REG_OFF + I2C_REG_DATA),
};
-volatile uint8_t*
+volatile uint8_t *
i2cGetDataReg(uint8_t bus_id)
{
return reg_data_addrs[bus_id];
//-----------------------------------------------------------------------------
-static volatile uint8_t* const reg_cnt_addrs[] = {
- (volatile uint8_t*)(I2C1_REG_OFF + I2C_REG_CNT),
- (volatile uint8_t*)(I2C2_REG_OFF + I2C_REG_CNT),
- (volatile uint8_t*)(I2C3_REG_OFF + I2C_REG_CNT),
+static volatile uint8_t *const reg_cnt_addrs[] = {
+ (volatile uint8_t *)(I2C1_REG_OFF + I2C_REG_CNT), (volatile uint8_t *)(I2C2_REG_OFF + I2C_REG_CNT), (volatile uint8_t *)(I2C3_REG_OFF + I2C_REG_CNT),
};
-volatile uint8_t*
+volatile uint8_t *
i2cGetCntReg(uint8_t bus_id)
{
return reg_cnt_addrs[bus_id];
uint8_t dev_addr = i2cGetDeviceRegAddr(dev_id);
for (size_t i = 0; i < 8; i++) {
- if (i2cSelectDevice(bus_id, dev_addr) &&
- i2cSelectRegister(bus_id, reg)) {
+ if (i2cSelectDevice(bus_id, dev_addr) && i2cSelectRegister(bus_id, reg)) {
if (i2cSelectDevice(bus_id, dev_addr | 1)) {
i2cWaitBusy(bus_id);
i2cStop(bus_id, 1);
}
int
-i2cReadRegisterBuffer(unsigned int dev_id, int reg, uint8_t* buffer,
- size_t buf_size)
+i2cReadRegisterBuffer(unsigned int dev_id, int reg, uint8_t *buffer, size_t buf_size)
{
uint8_t bus_id = i2cGetDeviceBusId(dev_id);
uint8_t dev_addr = i2cGetDeviceRegAddr(dev_id);
size_t j = 0;
- while (!i2cSelectDevice(bus_id, dev_addr) ||
- !i2cSelectRegister(bus_id, reg) ||
- !i2cSelectDevice(bus_id, dev_addr | 1)) {
+ while (!i2cSelectDevice(bus_id, dev_addr) || !i2cSelectRegister(bus_id, reg) || !i2cSelectDevice(bus_id, dev_addr | 1)) {
i2cWaitBusy(bus_id);
*i2cGetCntReg(bus_id) = 0xC5;
i2cWaitBusy(bus_id);
uint8_t dev_addr = i2cGetDeviceRegAddr(dev_id);
for (int i = 0; i < 8; i++) {
- if (i2cSelectDevice(bus_id, dev_addr) &&
- i2cSelectRegister(bus_id, reg)) {
+ if (i2cSelectDevice(bus_id, dev_addr) && i2cSelectRegister(bus_id, reg)) {
i2cWaitBusy(bus_id);
*i2cGetDataReg(bus_id) = data;
*i2cGetCntReg(bus_id) = 0xC1;
uint8_t i2cGetDeviceBusId(uint8_t device_id);
uint8_t i2cGetDeviceRegAddr(uint8_t device_id);
-volatile uint8_t* i2cGetDataReg(uint8_t bus_id);
-volatile uint8_t* i2cGetCntReg(uint8_t bus_id);
+volatile uint8_t *i2cGetDataReg(uint8_t bus_id);
+volatile uint8_t *i2cGetCntReg(uint8_t bus_id);
void i2cWaitBusy(uint8_t bus_id);
int i2cGetResult(uint8_t bus_id);
uint8_t i2cReadRegister(uint8_t dev_id, uint8_t reg);
int i2cWriteRegister(uint8_t dev_id, uint8_t reg, uint8_t data);
-int i2cReadRegisterBuffer(unsigned int dev_id, int reg, uint8_t* buffer,
- size_t buf_size);
+int i2cReadRegisterBuffer(unsigned int dev_id, int reg, uint8_t *buffer, size_t buf_size);
#endif
#define BUTTON_ANY 0xFFF
-#define HID_PAD ((*(volatile uint32_t*)0x10146000) ^ BUTTON_ANY)
+#define HID_PAD ((*(volatile uint32_t *)0x10146000) ^ BUTTON_ANY)
#endif
#include <stdint.h>
#include <stddef.h>
#ifndef LOADER
- #include "std/unused.h"
- #include "std/memory.h"
- #include "firm/firm.h"
- #include "config.h"
- #include "common.h"
+#include "std/unused.h"
+#include "std/memory.h"
+#include "firm/firm.h"
+#include "config.h"
+#include "common.h"
#endif
-#define OP_NOP 0x00
-#define OP_REL 0x01
-#define OP_FIND 0x02
-#define OP_BACK 0x03
-#define OP_FWD 0x04
-#define OP_SET 0x05
-#define OP_TEST 0x06
-#define OP_JMP 0x07
+#define OP_NOP 0x00
+#define OP_REL 0x01
+#define OP_FIND 0x02
+#define OP_BACK 0x03
+#define OP_FWD 0x04
+#define OP_SET 0x05
+#define OP_TEST 0x06
+#define OP_JMP 0x07
#define OP_REWIND 0x08
-#define OP_AND 0x09
-#define OP_TITLE 0x0A
-#define OP_NEXT 0xFF
+#define OP_AND 0x09
+#define OP_TITLE 0x0A
+#define OP_NEXT 0xFF
#ifdef LOADER
- #define log(a) logstr(a)
- #define abort(a) { logstr(a) ; svcBreak(USERBREAK_ASSERT) ; }
+#define log(a) logstr(a)
+#define abort(a) \
+ { \
+ logstr(a); \
+ svcBreak(USERBREAK_ASSERT); \
+ }
#else
- #define log(a) fprintf(stderr, a)
+#define log(a) fprintf(stderr, a)
#endif
-struct mode {
- uint8_t* memory;
- uint32_t size;
+struct mode
+{
+ uint8_t *memory;
+ uint32_t size;
};
struct mode modes[19];
int init_bytecode = 0;
-int exec_bytecode(uint8_t* bytecode, uint32_t len, int debug) {
- if (!init_bytecode) {
+int
+exec_bytecode(uint8_t *bytecode, uint32_t len, int debug)
+{
+ if (!init_bytecode) {
#ifndef LOADER
- modes[0].memory = (uint8_t*)firm_loc;
- modes[0].size = FCRAM_SPACING; // NATIVE_FIRM
-
- modes[1].memory = (uint8_t*)agb_firm_loc;
- modes[1].size = FCRAM_SPACING; // AGB_FIRM
-
- modes[2].memory = (uint8_t*)twl_firm_loc;
- modes[2].size = FCRAM_SPACING; // TWL_FIRM
-
- // NATIVE_FIRM Process9 (This is also the default mode.)
- modes[3].memory = (uint8_t*)firm_p9_exefs + sizeof(exefs_h) + firm_p9_exefs->fileHeaders[0].offset;
- modes[3].size = firm_p9_exefs->fileHeaders[0].size;
- // AGB_FIRM Process9
- modes[4].memory = (uint8_t*)agb_firm_p9_exefs + sizeof(exefs_h) + firm_p9_exefs->fileHeaders[0].offset;
- modes[4].size = firm_p9_exefs->fileHeaders[0].size;
- // TWL_FIRM Process9
- modes[5].memory = (uint8_t*)twl_firm_p9_exefs + sizeof(exefs_h) + firm_p9_exefs->fileHeaders[0].offset;
- modes[5].size = firm_p9_exefs->fileHeaders[0].size;
-
- // NATIVE_FIRM Sect 0
- modes[6].memory = (uint8_t*)&firm_loc->section[0] + firm_loc->section[0].offset;
- modes[6].size = firm_loc->section[0].size;
- // NATIVE_FIRM Sect 1
- modes[7].memory = (uint8_t*)&firm_loc->section[1] + firm_loc->section[1].offset;
- modes[7].size = firm_loc->section[1].size;
- // NATIVE_FIRM Sect 2
- modes[8].memory = (uint8_t*)&firm_loc->section[2] + firm_loc->section[2].offset;
- modes[8].size = firm_loc->section[2].size;
- // NATIVE_FIRM Sect 3
- modes[9].memory = (uint8_t*)&firm_loc->section[3] + firm_loc->section[3].offset;
- modes[9].size = firm_loc->section[3].size;
-
- // AGB_FIRM Sect 0
- modes[10].memory = (uint8_t*)&agb_firm_loc->section[0] + agb_firm_loc->section[0].offset;
- modes[10].size = agb_firm_loc->section[0].size;
- // AGB_FIRM Sect 1
- modes[11].memory = (uint8_t*)&agb_firm_loc->section[1] + agb_firm_loc->section[1].offset;
- modes[11].size = agb_firm_loc->section[1].size;
- // AGB_FIRM Sect 2
- modes[12].memory = (uint8_t*)&agb_firm_loc->section[2] + agb_firm_loc->section[2].offset;
- modes[12].size = agb_firm_loc->section[2].size;
- // AGB_FIRM Sect 3
- modes[13].memory = (uint8_t*)&agb_firm_loc->section[3] + agb_firm_loc->section[3].offset;
- modes[13].size = agb_firm_loc->section[3].size;
-
- // TWL_FIRM Sect 0
- modes[14].memory = (uint8_t*)&twl_firm_loc->section[0] + twl_firm_loc->section[0].offset;
- modes[14].size = twl_firm_loc->section[0].size;
- // TWL_FIRM Sect 1
- modes[15].memory = (uint8_t*)&twl_firm_loc->section[1] + twl_firm_loc->section[1].offset;
- modes[15].size = twl_firm_loc->section[1].size;
- // TWL_FIRM Sect 2
- modes[16].memory = (uint8_t*)&twl_firm_loc->section[2] + twl_firm_loc->section[2].offset;
- modes[16].size = twl_firm_loc->section[2].size;
- // TWL_FIRM Sect 3
- modes[17].memory = (uint8_t*)&twl_firm_loc->section[3] + twl_firm_loc->section[3].offset;
- modes[17].size = twl_firm_loc->section[3].size;
+ modes[0].memory = (uint8_t *)firm_loc;
+ modes[0].size = FCRAM_SPACING; // NATIVE_FIRM
+
+ modes[1].memory = (uint8_t *)agb_firm_loc;
+ modes[1].size = FCRAM_SPACING; // AGB_FIRM
+
+ modes[2].memory = (uint8_t *)twl_firm_loc;
+ modes[2].size = FCRAM_SPACING; // TWL_FIRM
+
+ // NATIVE_FIRM Process9 (This is also the default mode.)
+ modes[3].memory = (uint8_t *)firm_p9_exefs + sizeof(exefs_h) + firm_p9_exefs->fileHeaders[0].offset;
+ modes[3].size = firm_p9_exefs->fileHeaders[0].size;
+ // AGB_FIRM Process9
+ modes[4].memory = (uint8_t *)agb_firm_p9_exefs + sizeof(exefs_h) + firm_p9_exefs->fileHeaders[0].offset;
+ modes[4].size = firm_p9_exefs->fileHeaders[0].size;
+ // TWL_FIRM Process9
+ modes[5].memory = (uint8_t *)twl_firm_p9_exefs + sizeof(exefs_h) + firm_p9_exefs->fileHeaders[0].offset;
+ modes[5].size = firm_p9_exefs->fileHeaders[0].size;
+
+ // NATIVE_FIRM Sect 0
+ modes[6].memory = (uint8_t *)&firm_loc->section[0] + firm_loc->section[0].offset;
+ modes[6].size = firm_loc->section[0].size;
+ // NATIVE_FIRM Sect 1
+ modes[7].memory = (uint8_t *)&firm_loc->section[1] + firm_loc->section[1].offset;
+ modes[7].size = firm_loc->section[1].size;
+ // NATIVE_FIRM Sect 2
+ modes[8].memory = (uint8_t *)&firm_loc->section[2] + firm_loc->section[2].offset;
+ modes[8].size = firm_loc->section[2].size;
+ // NATIVE_FIRM Sect 3
+ modes[9].memory = (uint8_t *)&firm_loc->section[3] + firm_loc->section[3].offset;
+ modes[9].size = firm_loc->section[3].size;
+
+ // AGB_FIRM Sect 0
+ modes[10].memory = (uint8_t *)&agb_firm_loc->section[0] + agb_firm_loc->section[0].offset;
+ modes[10].size = agb_firm_loc->section[0].size;
+ // AGB_FIRM Sect 1
+ modes[11].memory = (uint8_t *)&agb_firm_loc->section[1] + agb_firm_loc->section[1].offset;
+ modes[11].size = agb_firm_loc->section[1].size;
+ // AGB_FIRM Sect 2
+ modes[12].memory = (uint8_t *)&agb_firm_loc->section[2] + agb_firm_loc->section[2].offset;
+ modes[12].size = agb_firm_loc->section[2].size;
+ // AGB_FIRM Sect 3
+ modes[13].memory = (uint8_t *)&agb_firm_loc->section[3] + agb_firm_loc->section[3].offset;
+ modes[13].size = agb_firm_loc->section[3].size;
+
+ // TWL_FIRM Sect 0
+ modes[14].memory = (uint8_t *)&twl_firm_loc->section[0] + twl_firm_loc->section[0].offset;
+ modes[14].size = twl_firm_loc->section[0].size;
+ // TWL_FIRM Sect 1
+ modes[15].memory = (uint8_t *)&twl_firm_loc->section[1] + twl_firm_loc->section[1].offset;
+ modes[15].size = twl_firm_loc->section[1].size;
+ // TWL_FIRM Sect 2
+ modes[16].memory = (uint8_t *)&twl_firm_loc->section[2] + twl_firm_loc->section[2].offset;
+ modes[16].size = twl_firm_loc->section[2].size;
+ // TWL_FIRM Sect 3
+ modes[17].memory = (uint8_t *)&twl_firm_loc->section[3] + twl_firm_loc->section[3].offset;
+ modes[17].size = twl_firm_loc->section[3].size;
#endif
- // Loader (not valid in bootmode)
- // modes[18] = { 0, 0 };
+ // Loader (not valid in bootmode)
+ // modes[18] = { 0, 0 };
- init_bytecode = 1;
- }
+ init_bytecode = 1;
+ }
#ifdef LOADER
- uint32_t set_mode = 18;
+ uint32_t set_mode = 18;
#else
- uint32_t set_mode = 3;
+ uint32_t set_mode = 3;
#endif
- struct mode* current_mode = &modes[set_mode];
-
- uint32_t offset = 0;
- uint8_t test_was_false = 0;
-
- uint32_t i;
-
- uint8_t* code = bytecode;
- uint8_t* end = code + len;
- while (code < end && code >= bytecode) {
- switch(*code) {
- case OP_NOP:
- if (debug)
- log("nop\n");
- code++;
- test_was_false = 0;
- break;
- case OP_REL: // Change relativity.
+ struct mode *current_mode = &modes[set_mode];
+
+ uint32_t offset = 0;
+ uint8_t test_was_false = 0;
+
+ uint32_t i;
+
+ uint8_t *code = bytecode;
+ uint8_t *end = code + len;
+ while (code < end && code >= bytecode) {
+ switch (*code) {
+ case OP_NOP:
+ if (debug)
+ log("nop\n");
+ code++;
+ test_was_false = 0;
+ break;
+ case OP_REL: // Change relativity.
#ifdef LOADER
- // Loader doesn't support this. Just treat it like a two-byte NOP.
- code += 2;
+ // Loader doesn't support this. Just treat it like a two-byte NOP.
+ code += 2;
#else
- if (debug)
- log("rel\n");
- code++;
- if (!test_was_false)
- current_mode = &modes[*code];
- else
- test_was_false = 0;
- set_mode = *code;
- code++;
+ if (debug)
+ log("rel\n");
+ code++;
+ if (!test_was_false)
+ current_mode = &modes[*code];
+ else
+ test_was_false = 0;
+ set_mode = *code;
+ code++;
#endif
- break;
- case OP_FIND: // Find pattern.
- if (debug)
- log("find\n");
- code += 2;
- if (!test_was_false) {
- offset = (uint32_t)memfind(current_mode->memory+offset, current_mode->size - offset, code, *(code-1));
- if ((uint8_t*)offset == NULL) {
- // Error. Abort.
- abort("Find opcode failed.\n");
- }
- offset = offset - (uint32_t)current_mode->memory;
- } else {
- test_was_false = 0;
- }
- code += *(code-1);
- break;
- case OP_BACK:
- if (debug)
- log("back\n");
- code++;
- if (!test_was_false) {
- if (offset < *code) {
- // Went out of bounds. Error.
- abort("Back underflowed.\n");
- }
- offset -= *code;
- } else {
- test_was_false = 0;
- }
- code++;
- break;
- case OP_FWD:
- if (debug)
- log("fwd\n");
- code++;
- if (!test_was_false) {
- offset += *code;
- if (offset >= current_mode->size) {
- // Went out of bounds. Error.
- abort("Fwd overflowed.\n");
- }
- } else {
- test_was_false = 0;
- }
- code++;
- break;
- case OP_SET: // Set data.
- if (debug)
- log("set\n");
- code += 2;
- if (!test_was_false)
- memcpy(current_mode->memory+offset, code, *(code-1));
- else
- test_was_false = 0;
- offset += *(code-1);
- code += *(code-1);
- break;
- case OP_TEST: // Test data.
- if (debug)
- log("test\n");
- code += 2;
- if(memcmp(current_mode->memory+offset, code, *(code-1))) {
- test_was_false = 1;
- if (debug)
- log("false\n");
- } else if (debug) {
- log("true\n");
- }
- code += *(code-1);
- break;
- case OP_JMP: // Jump to offset.
- if (debug)
- log("jmp\n");
- code++;
- if (!test_was_false) {
- code = bytecode + code[1] + ( code[0] * 0x100 );
- } else {
- code += 2;
- test_was_false = 0;
- }
- break;
- case OP_REWIND:
- if (debug)
- log("rewind\n");
- code++;
- if (!test_was_false)
- offset = 0;
- else
- test_was_false = 0;
- break;
- case OP_AND:
- if (debug)
- log("and\n");
- code += 2;
- if (!test_was_false) {
- for(i=0; i < *(code-1); i++) {
- *(current_mode->memory + offset) &= code[i];
- }
- offset += *(code-1);
- } else {
- test_was_false = 0;
- }
- code += *(code-1);
- break;
- case OP_NEXT:
- bytecode = code + 1;
+ break;
+ case OP_FIND: // Find pattern.
+ if (debug)
+ log("find\n");
+ code += 2;
+ if (!test_was_false) {
+ offset = (uint32_t)memfind(current_mode->memory + offset, current_mode->size - offset, code, *(code - 1));
+ if ((uint8_t *)offset == NULL) {
+ // Error. Abort.
+ abort("Find opcode failed.\n");
+ }
+ offset = offset - (uint32_t)current_mode->memory;
+ } else {
+ test_was_false = 0;
+ }
+ code += *(code - 1);
+ break;
+ case OP_BACK:
+ if (debug)
+ log("back\n");
+ code++;
+ if (!test_was_false) {
+ if (offset < *code) {
+ // Went out of bounds. Error.
+ abort("Back underflowed.\n");
+ }
+ offset -= *code;
+ } else {
+ test_was_false = 0;
+ }
+ code++;
+ break;
+ case OP_FWD:
+ if (debug)
+ log("fwd\n");
+ code++;
+ if (!test_was_false) {
+ offset += *code;
+ if (offset >= current_mode->size) {
+ // Went out of bounds. Error.
+ abort("Fwd overflowed.\n");
+ }
+ } else {
+ test_was_false = 0;
+ }
+ code++;
+ break;
+ case OP_SET: // Set data.
+ if (debug)
+ log("set\n");
+ code += 2;
+ if (!test_was_false)
+ memcpy(current_mode->memory + offset, code, *(code - 1));
+ else
+ test_was_false = 0;
+ offset += *(code - 1);
+ code += *(code - 1);
+ break;
+ case OP_TEST: // Test data.
+ if (debug)
+ log("test\n");
+ code += 2;
+ if (memcmp(current_mode->memory + offset, code, *(code - 1))) {
+ test_was_false = 1;
+ if (debug)
+ log("false\n");
+ } else if (debug) {
+ log("true\n");
+ }
+ code += *(code - 1);
+ break;
+ case OP_JMP: // Jump to offset.
+ if (debug)
+ log("jmp\n");
+ code++;
+ if (!test_was_false) {
+ code = bytecode + code[1] + (code[0] * 0x100);
+ } else {
+ code += 2;
+ test_was_false = 0;
+ }
+ break;
+ case OP_REWIND:
+ if (debug)
+ log("rewind\n");
+ code++;
+ if (!test_was_false)
+ offset = 0;
+ else
+ test_was_false = 0;
+ break;
+ case OP_AND:
+ if (debug)
+ log("and\n");
+ code += 2;
+ if (!test_was_false) {
+ for (i = 0; i < *(code - 1); i++) {
+ *(current_mode->memory + offset) &= code[i];
+ }
+ offset += *(code - 1);
+ } else {
+ test_was_false = 0;
+ }
+ code += *(code - 1);
+ break;
+ case OP_NEXT:
+ bytecode = code + 1;
#ifndef LOADER
- set_mode = 3;
- current_mode = &modes[set_mode];
+ set_mode = 3;
+ current_mode = &modes[set_mode];
#endif
- offset = 0;
- test_was_false = 0;
- code = bytecode;
- break;
- case OP_TITLE:
- if (debug)
- log("title\n");
- // FIXME - NYI
- default:
+ offset = 0;
+ test_was_false = 0;
+ code = bytecode;
+ break;
+ case OP_TITLE:
+ if (debug)
+ log("title\n");
+ // FIXME - NYI
+ default:
#ifndef LOADER
- // Panic; not proper opcode.
- fprintf(stderr, "Invalid opcode. State:\n"
- " Relative: %u\n"
- " Actual: %x:%u\n"
- " Memory: %x\n"
- " Actual: %x\n"
- " Code Loc: %x\n"
- " Actual: %x\n"
- " Opcode: %u\n",
- set_mode,
- current_mode->memory, current_mode->size,
- offset,
- current_mode->memory + offset,
- code - bytecode,
- code,
- *code);
+ // Panic; not proper opcode.
+ fprintf(stderr, "Invalid opcode. State:\n"
+ " Relative: %u\n"
+ " Actual: %x:%u\n"
+ " Memory: %x\n"
+ " Actual: %x\n"
+ " Code Loc: %x\n"
+ " Actual: %x\n"
+ " Opcode: %u\n",
+ set_mode, current_mode->memory, current_mode->size, offset, current_mode->memory + offset, code - bytecode, code, *code);
#endif
- abort("Halting startup.\n");
- break;
- }
- }
+ abort("Halting startup.\n");
+ break;
+ }
+ }
- return 0;
+ return 0;
}
#ifdef LOADER
-int execb(uint64_t tid, uint8_t* search_mem, uint32_t search_len) {
+int
+execb(uint64_t tid, uint8_t *search_mem, uint32_t search_len)
+{
#else
-int execb(char* filename) {
+int
+execb(char *filename)
+{
#endif
- uint32_t patch_len;
+ uint32_t patch_len;
#ifdef LOADER
- char cache_path[] = PATH_LOADER_CACHE "/0000000000000000";
- int len = strlen(cache_path) - 16;
+ char cache_path[] = PATH_LOADER_CACHE "/0000000000000000";
+ int len = strlen(cache_path) - 16;
- uint8_t* title_buf = (uint8_t*)&tid;
+ uint8_t *title_buf = (uint8_t *)&tid;
- for(int j = 0; j < 8; j++) {
- cache_path[len+(j*2)] = ("0123456789ABCDEF")[(title_buf[j] >> 4) & 0x0f];
- cache_path[len+(j*2)+1] = ("0123456789ABCDEF")[ title_buf[j] & 0x0f];
- }
+ for (int j = 0; j < 8; j++) {
+ cache_path[len + (j * 2)] = ("0123456789ABCDEF")[(title_buf[j] >> 4) & 0x0f];
+ cache_path[len + (j * 2) + 1] = ("0123456789ABCDEF")[title_buf[j] & 0x0f];
+ }
- static uint8_t patch_dat[MAX_PATCHSIZE];
+ static uint8_t patch_dat[MAX_PATCHSIZE];
- Handle file;
- u32 total;
+ Handle file;
+ u32 total;
// Open file.
if (!R_SUCCEEDED(fileOpen(&file, ARCHIVE_SDMC, cache_path, FS_OPEN_READ))) {
return 0; // No patches.
}
- log(" patch: ");
- log(cache_path);
- log("\n");
+ log(" patch: ");
+ log(cache_path);
+ log("\n");
- u64 file_size;
+ u64 file_size;
- if (!R_SUCCEEDED(FSFILE_GetSize(file, &file_size))) {
+ if (!R_SUCCEEDED(FSFILE_GetSize(file, &file_size))) {
FSFILE_Close(file); // Read to memory.
- return 1;
- }
+ return 1;
+ }
- if (file_size > MAX_PATCHSIZE) {
- log(" too large (please report)\n");
+ if (file_size > MAX_PATCHSIZE) {
+ log(" too large (please report)\n");
FSFILE_Close(file); // Read to memory.
- return 1;
- }
+ return 1;
+ }
// Read file.
if (!R_SUCCEEDED(FSFILE_Read(file, &total, 0, patch_dat, file_size))) {
FSFILE_Close(file); // Done reading in.
- // Set memory.
- modes[18].memory = search_mem;
- modes[18].size = search_len;
+ // Set memory.
+ modes[18].memory = search_mem;
+ modes[18].size = search_len;
- log(" exec\n");
+ log(" exec\n");
- uint8_t* patch_mem = (uint8_t*)patch_dat;
- patch_len = file_size;
+ uint8_t *patch_mem = (uint8_t *)patch_dat;
+ patch_len = file_size;
#else
- struct system_patch* patch;
- uint8_t* patch_mem;
- // Read patch to scrap memory.
+ struct system_patch *patch;
+ uint8_t *patch_mem;
+ // Read patch to scrap memory.
- FILE* f = fopen(filename, "r");
- size_t len = fsize(f);
- fread((uint8_t*)FCRAM_PATCH_LOC, 1, len, f);
- fclose(f);
+ FILE *f = fopen(filename, "r");
+ size_t len = fsize(f);
+ fread((uint8_t *)FCRAM_PATCH_LOC, 1, len, f);
+ fclose(f);
- patch = (struct system_patch*)FCRAM_PATCH_LOC;
+ patch = (struct system_patch *)FCRAM_PATCH_LOC;
- // Make sure various bits are correct.
- if (memcmp(patch->magic, "AIDA", 4)) {
- // Incorrect magic.
- return 1;
- }
+ // Make sure various bits are correct.
+ if (memcmp(patch->magic, "AIDA", 4)) {
+ // Incorrect magic.
+ return 1;
+ }
- patch_mem = (uint8_t*)patch + sizeof(struct system_patch) + (patch->depends * 8) + (patch->titles * 8);
- patch_len = patch->size;
+ patch_mem = (uint8_t *)patch + sizeof(struct system_patch) + (patch->depends * 8) + (patch->titles * 8);
+ patch_len = patch->size;
- if (patch->titles != 0) {
- // Not an error, per se, but it means this patch is meant for loader, not us.
- // Patches intended for use during boot will always be applied to zero titles.
- // We should generate a cache for loader in a file intended for titleid.
- uint8_t* title_buf = (uint8_t*)patch + sizeof(struct system_patch);
+ if (patch->titles != 0) {
+ // Not an error, per se, but it means this patch is meant for loader, not us.
+ // Patches intended for use during boot will always be applied to zero titles.
+ // We should generate a cache for loader in a file intended for titleid.
+ uint8_t *title_buf = (uint8_t *)patch + sizeof(struct system_patch);
- fprintf(stderr, "patch: %s\n", patch->name);
+ fprintf(stderr, "patch: %s\n", patch->name);
- for(uint32_t i=0; i < patch->titles; i++, title_buf += 8) {
- // FIXME - This is outputting once per boot. We need to detect and nuke the cache.
- char cache_path[] = PATH_LOADER_CACHE "/0000000000000000";
- int len = strlen(cache_path) - 16;
+ for (uint32_t i = 0; i < patch->titles; i++, title_buf += 8) {
+ // FIXME - This is outputting once per boot. We need to detect and nuke the cache.
+ char cache_path[] = PATH_LOADER_CACHE "/0000000000000000";
+ int len = strlen(cache_path) - 16;
- for(int j = 0; j < 8; j++) {
- cache_path[len+(j*2)] = ("0123456789ABCDEF")[(title_buf[j] >> 4) & 0x0f];
- cache_path[len+(j*2)+1] = ("0123456789ABCDEF")[ title_buf[j] & 0x0f];
- }
+ for (int j = 0; j < 8; j++) {
+ cache_path[len + (j * 2)] = ("0123456789ABCDEF")[(title_buf[j] >> 4) & 0x0f];
+ cache_path[len + (j * 2) + 1] = ("0123456789ABCDEF")[title_buf[j] & 0x0f];
+ }
- fprintf(stderr, " cache: %s\n", &cache_path[len]);
+ fprintf(stderr, " cache: %s\n", &cache_path[len]);
- char reset = 0xFF;
+ char reset = 0xFF;
- FILE* cache = fopen(cache_path, "w");
- fseek(cache, 0, SEEK_END);
- fwrite(patch_mem, 1, patch_len, cache);
- fwrite(&reset, 1, 1, cache);
- fclose(cache);
- // Add to cache.
- }
+ FILE *cache = fopen(cache_path, "w");
+ fseek(cache, 0, SEEK_END);
+ fwrite(patch_mem, 1, patch_len, cache);
+ fwrite(&reset, 1, 1, cache);
+ fclose(cache);
+ // Add to cache.
+ }
- return 0;
- }
+ return 0;
+ }
- fprintf(stderr, "Patch: %s\n", patch->name);
+ fprintf(stderr, "Patch: %s\n", patch->name);
#endif
- return exec_bytecode(patch_mem, patch_len, 0);
+ return exec_bytecode(patch_mem, patch_len, 0);
}
#ifndef __INTERP_H
#define __INTERP_H
-uint8_t* execb(char* filename);
-int exec_bytecode(uint8_t* bytecode, uint32_t len, int debug);
+uint8_t *execb(char *filename);
+int exec_bytecode(uint8_t *bytecode, uint32_t len, int debug);
#endif
{
if (fmount()) {
// Failed to mount SD. Bomb out.
- fprintf(BOTTOM_SCREEN, "%pFailed to mount SD card.\n",
- COLOR(RED, BLACK));
+ fprintf(BOTTOM_SCREEN, "%pFailed to mount SD card.\n", COLOR(RED, BLACK));
}
load_config(); // Load configuration.
// Patches.
{ 0, "\x1b[32;40mPatches\x1b[0m", not_option, 0, 0 },
- { OPTION_SIGPATCH, "Signature Patch", boolean_val, 0, 0 },
+ { OPTION_SIGPATCH, "Signature Patch", boolean_val, 0, 0 },
- { OPTION_FIRMPROT, "FIRM Protection", boolean_val, 0, 0 },
+ { OPTION_FIRMPROT, "FIRM Protection", boolean_val, 0, 0 },
- { OPTION_LOADER, "System Modules", boolean_val, 0, 0 },
- { OPTION_LOADER_CPU_L2, " CPU - L2 cache", boolean_val, 0, 0 },
+ { OPTION_LOADER, "System Modules", boolean_val, 0, 0 },
+ { OPTION_LOADER_CPU_L2, " CPU - L2 cache", boolean_val, 0, 0 },
{ OPTION_LOADER_CPU_800MHZ, " CPU - 800Mhz", boolean_val, 0, 0 },
- { OPTION_LOADER_LANGEMU, " Language Emulation", boolean_val, 0, 0 },
+ { OPTION_LOADER_LANGEMU, " Language Emulation", boolean_val, 0, 0 },
- { OPTION_SERVICES, "Service Replacement", boolean_val, 0, 0 },
+ { OPTION_SERVICES, "Service Replacement", boolean_val, 0, 0 },
- { OPTION_AADOWNGRADE, "Anti-anti-downgrade", boolean_val, 0, 0 },
+ { OPTION_AADOWNGRADE, "Anti-anti-downgrade", boolean_val, 0, 0 },
// space
{ 0, "", not_option, 0, 0 },
// Patches.
{ 0, "\x1b[32;40mPatches (Developer)\x1b[0m", not_option, 0, 0 },
- { OPTION_UNITINFO, "Developer UNITINFO", boolean_val, 0, 0 },
- { OPTION_MEMEXEC, "Disable XN on MPU", boolean_val, 0, 0 },
+ { OPTION_UNITINFO, "Developer UNITINFO", boolean_val, 0, 0 },
+ { OPTION_MEMEXEC, "Disable XN on MPU", boolean_val, 0, 0 },
{ OPTION_REPLACE_ALLOCATED_SVC, "Force service replace", boolean_val, 0, 0 },
-// { OPTION_ARM9THREAD, "ARM9 Thread", boolean_val, 0, 0 },
+ // { OPTION_ARM9THREAD, "ARM9 Thread", boolean_val, 0, 0 },
// space
{ 0, "", not_option, 0, 0 },
// Patches.
{ 0, "\x1b[32;40mOptions\x1b[0m", not_option, 0, 0 },
- { OPTION_AUTOBOOT, "Autoboot", boolean_val, 0, 0 },
- { OPTION_SILENCE, " Stealth mode", boolean_val, 0, 0 },
- { OPTION_TRACE, "Debug pauses during operation", boolean_val, 0, 0 },
+ { OPTION_AUTOBOOT, "Autoboot", boolean_val, 0, 0 },
+ { OPTION_SILENCE, " Stealth mode", boolean_val, 0, 0 },
+ { OPTION_TRACE, "Debug pauses during operation", boolean_val, 0, 0 },
-// { OPTION_TRANSP_BG, "Black -> transparent", boolean_val, 0, 0 },
-// { OPTION_NO_CLEAR_BG, "Preserve framebuffer", boolean_val, 0, 0 },
+ // { OPTION_TRANSP_BG, "Black -> transparent", boolean_val, 0, 0 },
+ // { OPTION_NO_CLEAR_BG, "Preserve framebuffer", boolean_val, 0, 0 },
- { OPTION_READ_ME, "Hide `Help`", boolean_val, 0, 0 },
+ { OPTION_READ_ME, "Hide `Help`", boolean_val, 0, 0 },
-// { IGNORE_PATCH_DEPS, "Ignore dependencies", boolean_val, 0, 0 },
-// { IGNORE_BROKEN_SHIT, "Allow unsafe options", boolean_val, 0, 0 },
+ // { IGNORE_PATCH_DEPS, "Ignore dependencies", boolean_val, 0, 0 },
+ // { IGNORE_BROKEN_SHIT, "Allow unsafe options", boolean_val, 0, 0 },
// Sentinel.
{ -1, "", 0, -1, -1 }, // cursor_min and cursor_max are stored in the last two.
}
void
-header(char* append)
+header(char *append)
{
fprintf(stdout, "\x1b[30;42m.corbenik//%s %s\x1b[0m\n", VERSION, append);
}
// Figure out the max if unset.
if (cursor_max == -1) {
- cursor_max=0;
- while(options[cursor_max].index != -1)
+ cursor_max = 0;
+ while (options[cursor_max].index != -1)
++cursor_max;
- while(options[cursor_max].allowed == not_option)
- --cursor_max;
+ while (options[cursor_max].allowed == not_option)
+ --cursor_max;
}
// Figure out the max if unset.
if (cursor_min == -1) {
- cursor_min=0;
- while(options[cursor_min].allowed == not_option)
+ cursor_min = 0;
+ while (options[cursor_min].allowed == not_option)
++cursor_min;
- cursor_y = cursor_min;
+ cursor_y = cursor_min;
}
header("A:Enter B:Back DPAD:Nav");
int i = 0;
while (options[i].index != -1) { // -1 Sentinel.
- if (options[i].allowed == boolean_val) {
- if (cursor_y == i)
- fprintf(TOP_SCREEN, "\x1b[32m>>\x1b[0m ");
- else
- fprintf(TOP_SCREEN, " ");
-
- if (need_redraw)
- fprintf(TOP_SCREEN, "[%c] %s\n",
- (config.options[options[i].index] ? 'X' : ' '),
- options[i].name);
- else {
- // Yes, this is weird. printf does a large number of extra things we
- // don't
- // want computed at the moment; this is faster.
- putc(TOP_SCREEN, '[');
- putc(TOP_SCREEN, (config.options[options[i].index] ? 'X' : ' '));
- putc(TOP_SCREEN, ']');
- putc(TOP_SCREEN, '\n');
- }
- } else if (options[i].allowed == not_option) {
- fprintf(TOP_SCREEN, "%s\n", options[i].name);
- }
+ if (options[i].allowed == boolean_val) {
+ if (cursor_y == i)
+ fprintf(TOP_SCREEN, "\x1b[32m>>\x1b[0m ");
+ else
+ fprintf(TOP_SCREEN, " ");
+
+ if (need_redraw)
+ fprintf(TOP_SCREEN, "[%c] %s\n", (config.options[options[i].index] ? 'X' : ' '), options[i].name);
+ else {
+ // Yes, this is weird. printf does a large number of extra things we
+ // don't
+ // want computed at the moment; this is faster.
+ putc(TOP_SCREEN, '[');
+ putc(TOP_SCREEN, (config.options[options[i].index] ? 'X' : ' '));
+ putc(TOP_SCREEN, ']');
+ putc(TOP_SCREEN, '\n');
+ }
+ } else if (options[i].allowed == not_option) {
+ fprintf(TOP_SCREEN, "%s\n", options[i].name);
+ }
++i;
}
switch (key) {
case BUTTON_UP:
cursor_y -= 1;
- while(options[cursor_y].allowed == not_option && cursor_y >= cursor_min)
- cursor_y--;
+ while (options[cursor_y].allowed == not_option && cursor_y >= cursor_min)
+ cursor_y--;
break;
case BUTTON_DOWN:
cursor_y += 1;
- while(options[cursor_y].allowed == not_option && cursor_y < cursor_max)
- cursor_y++;
+ while (options[cursor_y].allowed == not_option && cursor_y < cursor_max)
+ cursor_y++;
break;
case BUTTON_LEFT:
cursor_y -= 5;
- while(options[cursor_y].allowed == not_option && cursor_y >= cursor_min)
- cursor_y--;
+ while (options[cursor_y].allowed == not_option && cursor_y >= cursor_min)
+ cursor_y--;
break;
case BUTTON_RIGHT:
cursor_y += 5;
- while(options[cursor_y].allowed == not_option && cursor_y < cursor_max)
- cursor_y++;
+ while (options[cursor_y].allowed == not_option && cursor_y < cursor_max)
+ cursor_y++;
break;
case BUTTON_A:
// TODO - Value options
- config.options[options[cursor_y].index] =
- !config.options[options[cursor_y].index];
+ config.options[options[cursor_y].index] = !config.options[options[cursor_y].index];
break;
case BUTTON_B:
need_redraw = 1;
int
menu_info()
{
- // This menu requres firm to be loaded. Unfortunately.
- load_firms(); // Lazy load!
+ // This menu requres firm to be loaded. Unfortunately.
+ load_firms(); // Lazy load!
clear_screen(TOP_SCREEN);
set_cursor(TOP_SCREEN, 0, 0);
header("Any:Back");
- struct firm_signature* native = get_firm_info(firm_loc);
- struct firm_signature* agb = get_firm_info(agb_firm_loc);
- struct firm_signature* twl = get_firm_info(twl_firm_loc);
+ struct firm_signature *native = get_firm_info(firm_loc);
+ struct firm_signature *agb = get_firm_info(agb_firm_loc);
+ struct firm_signature *twl = get_firm_info(twl_firm_loc);
fprintf(stdout, "\nNATIVE_FIRM / Firmware:\n"
" Version: %s (%x)\n"
" Version: %s (%x)\n"
"TWL_FIRM / DSi Firmware:\n"
" Version: %s (%x)\n",
- native->version_string, native->version, agb->version_string,
- agb->version, twl->version_string, twl->version);
+ native->version_string, native->version, agb->version_string, agb->version, twl->version_string, twl->version);
while (1) {
if (wait_key() & BUTTON_ANY)
break;
{
set_cursor(TOP_SCREEN, 0, 0);
- const char* list[] = { "Options", "Patches", "Info",
- "Help/Readme", "Reset", "Power off",
- "Boot firmware" };
+ const char *list[] = { "Options", "Patches", "Info", "Help/Readme", "Reset", "Power off", "Boot firmware" };
int menu_max = 7;
header("A:Enter DPAD:Nav");
cursor_y = 0;
if (ret == MENU_BOOTME)
return MENU_BOOTME; // Boot meh, damnit!
- clear_screen(TOP_SCREEN);
- if (ret == MENU_OPTIONS)
- cursor_y = cursor_min; // Fixup positions
+ clear_screen(TOP_SCREEN);
+ if (ret == MENU_OPTIONS)
+ cursor_y = cursor_min; // Fixup positions
return ret;
}
PATCH(modules)
{
// TODO - load other module cxis here
- FILE* f = fopen(PATH_MODULES "/loader.cxi", "r");
+ FILE *f = fopen(PATH_MODULES "/loader.cxi", "r");
if (!f) {
fprintf(stderr, "Module: loader.cxi not found on FS\n");
return 2;
}
uint32_t size = fsize(f);
- fread((uint8_t*)FCRAM_JUNK_LOCATION, 1, size, f);
+ fread((uint8_t *)FCRAM_JUNK_LOCATION, 1, size, f);
fclose(f);
// Look for the section that holds all the sysmodules
- firm_section_h* sysmodule_section = NULL;
- for (firm_section_h* section = firm_loc->section;
- section < firm_loc->section + 4; section++) {
- if (section->address == 0x1FF00000 &&
- section->type == FIRM_TYPE_ARM11) {
+ firm_section_h *sysmodule_section = NULL;
+ for (firm_section_h *section = firm_loc->section; section < firm_loc->section + 4; section++) {
+ if (section->address == 0x1FF00000 && section->type == FIRM_TYPE_ARM11) {
sysmodule_section = section;
break;
}
return 1;
}
- ncch_h* module = (ncch_h*)FCRAM_JUNK_LOCATION;
- ncch_h* sysmodule =
- (ncch_h*)((uint32_t)firm_loc + sysmodule_section->offset);
+ ncch_h *module = (ncch_h *)FCRAM_JUNK_LOCATION;
+ ncch_h *sysmodule = (ncch_h *)((uint32_t)firm_loc + sysmodule_section->offset);
// Check if we want to replace an existing sysmodule
while (sysmodule->magic == NCCH_MAGIC) {
if (memcmp(sysmodule->programID, module->programID, 8) == 0) {
// Expand firmware module size if needed to accomodate replacement.
if (module->contentSize > sysmodule->contentSize) {
- uint32_t need_units =
- (module->contentSize - sysmodule->contentSize);
- fprintf(stderr, "Module: Would grow %d units but NYI\n",
- need_units);
+ uint32_t need_units = (module->contentSize - sysmodule->contentSize);
+ fprintf(stderr, "Module: Would grow %d units but NYI\n", need_units);
continue;
// TODO - so in a nutshell, the reason Luma works is because it
// Move the remaining modules closer
if (module->contentSize < sysmodule->contentSize) {
- fprintf(stderr, "Module: Shrink %d units\n",
- sysmodule->contentSize - module->contentSize);
+ fprintf(stderr, "Module: Shrink %d units\n", sysmodule->contentSize - module->contentSize);
int remaining_size =
- sysmodule_section->size -
- (((uint32_t)sysmodule + sysmodule->contentSize * 0x200) -
- ((uint32_t)firm_loc + sysmodule_section->offset));
+ sysmodule_section->size - (((uint32_t)sysmodule + sysmodule->contentSize * 0x200) - ((uint32_t)firm_loc + sysmodule_section->offset));
// Sysmodule section size - (End location of this sysmodule -
// Sysmodule section) =>
- memmove((uint8_t*)sysmodule + module->contentSize * 0x200,
- (uint8_t*)sysmodule + sysmodule->contentSize * 0x200,
- remaining_size);
+ memmove((uint8_t *)sysmodule + module->contentSize * 0x200, (uint8_t *)sysmodule + sysmodule->contentSize * 0x200, remaining_size);
// Move end of section to be adjacent
}
memcpy(sysmodule, module, module->contentSize * 0x200);
break;
}
- sysmodule =
- (ncch_h*)((uintptr_t)sysmodule + sysmodule->contentSize * 0x200);
+ sysmodule = (ncch_h *)((uintptr_t)sysmodule + sysmodule->contentSize * 0x200);
}
fprintf(stderr, "Module: injected modules.\n");
#include "../common.h"
#include "../interp.h"
-exefs_h* get_firm_proc9_exefs();
-exefs_h* get_twl_proc9_exefs();
-exefs_h* get_agb_proc9_exefs();
+exefs_h *get_firm_proc9_exefs();
+exefs_h *get_twl_proc9_exefs();
+exefs_h *get_agb_proc9_exefs();
#define PATCH(name) int patch_##name()
#elif MODULE
// Please note that the actual code for services is in `external/service`.
-uint32_t*
-getSvcAndExceptions(uint8_t* pos, uint32_t size, uint32_t** exceptionsPage)
+uint32_t *
+getSvcAndExceptions(uint8_t *pos, uint32_t size, uint32_t **exceptionsPage)
{
uint8_t pattern[] = { 0x00, 0xB0, 0x9C, 0xE5 }; // cpsid aif
- *exceptionsPage = (uint32_t*)memfind(pos, size, pattern, 4) - 0xB;
+ *exceptionsPage = (uint32_t *)memfind(pos, size, pattern, 4) - 0xB;
- uint32_t svcOffset =
- (-(((*exceptionsPage)[2] & 0xFFFFFF) << 2) & (0xFFFFFF << 2)) -
- 8; // Branch offset + 8 for prefetch
- uint32_t* svcTable = (uint32_t*)(pos +
- *(uint32_t*)(pos + 0xFFFF0008 - svcOffset -
- 0xFFF00000 + 8) -
- 0xFFF00000); // SVC handler address
+ uint32_t svcOffset = (-(((*exceptionsPage)[2] & 0xFFFFFF) << 2) & (0xFFFFFF << 2)) - 8; // Branch offset + 8 for prefetch
+ uint32_t *svcTable = (uint32_t *)(pos + *(uint32_t *)(pos + 0xFFFF0008 - svcOffset - 0xFFF00000 + 8) - 0xFFF00000); // SVC handler address
while (*svcTable)
svcTable++; // Look for SVC0 (NULL)
return svcTable;
}
-uint32_t* freeSpace = NULL;
+uint32_t *freeSpace = NULL;
PATCH(services)
{
// Make sure svcBackdoor is there.
- uint8_t* arm11Section1 = (uint8_t*)firm_loc + firm_loc->section[1].offset;
- uint32_t* exceptionsPage;
- uint32_t* svcTable = getSvcAndExceptions(
- arm11Section1, firm_loc->section[1].size, &exceptionsPage);
+ uint8_t *arm11Section1 = (uint8_t *)firm_loc + firm_loc->section[1].offset;
+ uint32_t *exceptionsPage;
+ uint32_t *svcTable = getSvcAndExceptions(arm11Section1, firm_loc->section[1].size, &exceptionsPage);
fprintf(stderr, "Svc: table at %x\n", (uint32_t)svcTable);
char str[] = PATH_SERVICES "/00.bin";
- char* at = str + (strlen(str) - 6);
- // FIXME - This is really slow. Some way to optimize it?
+ char *at = str + (strlen(str) - 6);
+ // FIXME - This is really slow. Some way to optimize it?
for (uint32_t i = 0; i <= 0xf; i++) {
- // Get string for svc.
- at[0] = ("0123456789abcdef")[i];
+ // Get string for svc.
+ at[0] = ("0123456789abcdef")[i];
- for (uint32_t j = 0; j < 0xf; j++) {
- // This is just hexdump. Nothing complicated.
- at[1] = ("0123456789abcdef")[j];
+ for (uint32_t j = 0; j < 0xf; j++) {
+ // This is just hexdump. Nothing complicated.
+ at[1] = ("0123456789abcdef")[j];
- FILE* data = fopen(str, "r");
- if (!data)
- continue; // No file for svc. Move on.
+ FILE *data = fopen(str, "r");
+ if (!data)
+ continue; // No file for svc. Move on.
- uint32_t svc = (i << 4) & j;
+ uint32_t svc = (i << 4) & j;
- // Refuse to replace non-NULL services unless the user says to.
- if (svcTable[svc] && !config.options[OPTION_REPLACE_ALLOCATED_SVC]) {
- fclose(data);
- fprintf(stderr, "Svc: %x non-null, moving on\n", i);
- continue;
- }
+ // Refuse to replace non-NULL services unless the user says to.
+ if (svcTable[svc] && !config.options[OPTION_REPLACE_ALLOCATED_SVC]) {
+ fclose(data);
+ fprintf(stderr, "Svc: %x non-null, moving on\n", i);
+ continue;
+ }
- uint32_t size = fsize(data);
- uint8_t* read_to = (void*)FCRAM_JUNK_LOCATION;
+ uint32_t size = fsize(data);
+ uint8_t *read_to = (void *)FCRAM_JUNK_LOCATION;
- fprintf(stderr, "Svc: %s, %d bytes\n", at, size);
+ fprintf(stderr, "Svc: %s, %d bytes\n", at, size);
- fread(read_to, 1, size, data);
+ fread(read_to, 1, size, data);
- fclose(data);
+ fclose(data);
- if (!freeSpace) {
- for (freeSpace = exceptionsPage; *freeSpace != 0xFFFFFFFF;
- freeSpace++)
- ;
- }
+ if (!freeSpace) {
+ for (freeSpace = exceptionsPage; *freeSpace != 0xFFFFFFFF; freeSpace++)
+ ;
+ }
- fprintf(stderr, "Svc: Copy code to %x\n", (uint32_t)freeSpace);
+ fprintf(stderr, "Svc: Copy code to %x\n", (uint32_t)freeSpace);
- memcpy(freeSpace, read_to, size);
- svcTable[svc] =
- 0xFFFF0000 + ((uint8_t*)freeSpace - (uint8_t*)exceptionsPage);
+ memcpy(freeSpace, read_to, size);
+ svcTable[svc] = 0xFFFF0000 + ((uint8_t *)freeSpace - (uint8_t *)exceptionsPage);
- freeSpace +=
- size; // We keep track of this because there's more than 7B free.
+ freeSpace += size; // We keep track of this because there's more than 7B free.
- fprintf(stderr, "Svc: entry set as %x\n", svcTable[svc]);
- }
+ fprintf(stderr, "Svc: entry set as %x\n", svcTable[svc]);
+ }
}
return 0;
#define NATIVE_FIRM_TITLEID 0x0004013800000002llu // NATIVE_FIRM
#define NATIVE_FIRM_N3DS_TITLEID 0x0004013820000002llu // NATIVE_FIRM, n3ds
-#define TWL_FIRM_TITLEID 0x0004013000000102llu // TWL_FIRM (DSi Firmware)
-#define TWL_FIRM_N3DS_TITLEID \
- 0x0004013020000102llu // TWL_FIRM, n3ds (DSi Firmware)
+#define TWL_FIRM_TITLEID 0x0004013000000102llu // TWL_FIRM (DSi Firmware)
+#define TWL_FIRM_N3DS_TITLEID 0x0004013020000102llu // TWL_FIRM, n3ds (DSi Firmware)
#define AGB_FIRM_TITLEID 0x0004013000000202llu // AGB_FIRM (GBA firmware)
#define AGB_FIRM_N3DS_TITLEID 0x0004013020000202llu // AGB_FIRM (GBA firmware)
#define LOADER_TITLEID 0x0004013000001302llu // Loader is handled specially.
-#define PATCH_MANDATORY (1 << 0) // Patch must be applied for successful boot.
-#define PATCH_FAIL_ABORT \
- (1 << 1) // If patch fails to apply, abort and show an error.
-#define PATCH_DISABLED \
- (1 << 2) // Do not allow changing this patch's status. With PATCH_MANDATORY,
- // this prevents disabling it.
+#define PATCH_MANDATORY (1 << 0) // Patch must be applied for successful boot.
+#define PATCH_FAIL_ABORT (1 << 1) // If patch fails to apply, abort and show an error.
+#define PATCH_DISABLED (1 << 2) // Do not allow changing this patch's status. With PATCH_MANDATORY,
+ // this prevents disabling it.
// You can redefine this in the Makefile, if you'd like.
// Recommended names for being silly:
#define PATH_LOADER_CACHE PATH_CFW "/lib/loader" // Cached patch bytecode for loader.
-#define PATH_TEMP \
- PATH_CFW "/tmp" // Files that are transient (user can delete them and they
- // will be regenerated)
-#define PATH_KEYS \
- PATH_CFW "/share/keys" // Keyfiles will be loaded from this dir, and
- // additionally the root if not found.
-#define PATH_EXEFS \
- PATH_CFW "/lib/exe" // ExeFS overrides, named like '<titleid>.exefs'
+#define PATH_TEMP PATH_CFW "/tmp" // Files that are transient (user can delete them and they
+ // will be regenerated)
+#define PATH_KEYS PATH_CFW "/share/keys" // Keyfiles will be loaded from this dir, and
+ // additionally the root if not found.
+#define PATH_EXEFS PATH_CFW "/lib/exe" // ExeFS overrides, named like '<titleid>.exefs'
#define PATH_NATIVE_F PATH_FIRMWARES "/native"
#define PATH_AGB_F PATH_FIRMWARES "/agb"
#define PATH_SLOT0X11KEY96 PATH_KEYS "/11.key"
-#define PATH_ALT_SLOT0X11KEY96 \
- "/slot0x11key96.bin" // Hey, your perrogative, buddy. I like cleaned up
- // paths.
+#define PATH_ALT_SLOT0X11KEY96 "/slot0x11key96.bin" // Hey, your perrogative, buddy. I like cleaned up
+ // paths.
#define PATCH_FLAG_REQUIRE (1 << 0) // Force enable patch unless 'Unsafe Options' is checked.
#define PATCH_FLAG_DEVMODE (1 << 1) // Require 'Developer Options' to be checked.
// Structure of a patch file.
struct system_patch
{
- char magic[4]; // "AIDA" for shits and giggles and because we like .hack.
- uint8_t version; // Version of the patch itself.
+ char magic[4]; // "AIDA" for shits and giggles and because we like .hack.
+ uint8_t version; // Version of the patch itself.
- char name[64]; // User-readable name for patch in menu.
- char desc[256]; // User-readable description for patch in menu.
- uint64_t uuid; // Unique ID for patch. Each unique patch should provide
- // a unique ID.
+ char name[64]; // User-readable name for patch in menu.
+ char desc[256]; // User-readable description for patch in menu.
+ uint64_t uuid; // Unique ID for patch. Each unique patch should provide
+ // a unique ID.
- uint32_t flags; // Extra flags for patch.
+ uint32_t flags; // Extra flags for patch.
- uint32_t titles; // How many titles this patch should be applied to (listed later)
+ uint32_t titles; // How many titles this patch should be applied to (listed later)
- uint32_t depends; // How many deps there are.
+ uint32_t depends; // How many deps there are.
- uint32_t size; // Size of the patch bytecode in bytes.
+ uint32_t size; // Size of the patch bytecode in bytes.
- // This stuff needs to be read not as part of the struct, but is technically part of it.
+ // This stuff needs to be read not as part of the struct, but is technically part of it.
// uint64_t tids[titles] // TitleIDs.
// uint64_t deps[depends] // Dependencies as uuid refs.
int
patch_firm_all()
{
- // Remove cache
- f_unlink(PATH_LOADER_CACHE);
- f_mkdir(PATH_LOADER_CACHE);
-
- // Loader only uses TID cache bytecode, so run through these.
- execb(PATH_PATCHES "/block_nim_update.vco");
- execb(PATH_PATCHES "/block_eshop_update.vco");
- execb(PATH_PATCHES "/block_cart_update.vco");
- execb(PATH_PATCHES "/errdisp.vco");
- execb(PATH_PATCHES "/friends_ver.vco");
- execb(PATH_PATCHES "/mset_str.vco");
-// execb(PATH_PATCHES "/ns_force_menu.vco");
- execb(PATH_PATCHES "/regionfree.vco");
- execb(PATH_PATCHES "/secinfo_sigs.vco");
- execb(PATH_PATCHES "/ro_sigs.vco");
+ // Remove cache
+ f_unlink(PATH_LOADER_CACHE);
+ f_mkdir(PATH_LOADER_CACHE);
+
+ // Loader only uses TID cache bytecode, so run through these.
+ execb(PATH_PATCHES "/block_nim_update.vco");
+ execb(PATH_PATCHES "/block_eshop_update.vco");
+ execb(PATH_PATCHES "/block_cart_update.vco");
+ execb(PATH_PATCHES "/errdisp.vco");
+ execb(PATH_PATCHES "/friends_ver.vco");
+ execb(PATH_PATCHES "/mset_str.vco");
+ // execb(PATH_PATCHES "/ns_force_menu.vco");
+ execb(PATH_PATCHES "/regionfree.vco");
+ execb(PATH_PATCHES "/secinfo_sigs.vco");
+ execb(PATH_PATCHES "/ro_sigs.vco");
// Replace loader?
if (config.options[OPTION_LOADER]) {
abort("Fatal. Service patch has failed.");
}
// This requires OPTION_SIGPATCH.
- wait();
+ wait();
}
// Inject services?
if (patch_services()) {
abort("Fatal. Service patch has failed.");
}
- wait();
+ wait();
}
// Use ARM9 hook thread?
// Yes.
// FIXME - NYI
- wait();
+ wait();
}
// Use builtin signature patcher?
if (config.options[OPTION_SIGPATCH]) {
// TODO - Patch menu. This is okay-ish for now.
- if(execb(PATH_PATCHES "/sig.vco")) {
+ if (execb(PATH_PATCHES "/sig.vco")) {
abort("Fatal. Sigpatch has failed.");
}
- wait();
+ wait();
}
if (config.options[OPTION_FIRMPROT]) {
- if(execb(PATH_PATCHES "/prot.vco")) {
+ if (execb(PATH_PATCHES "/prot.vco")) {
abort("Fatal. Firmprot has failed.");
}
- wait();
+ wait();
}
- if (config.options[OPTION_AADOWNGRADE]) {
- if(execb(PATH_PATCHES "/aadowngrade.vco")) {
+ if (config.options[OPTION_AADOWNGRADE]) {
+ if (execb(PATH_PATCHES "/aadowngrade.vco")) {
abort("Anti-anti-downgrade patch failed.");
}
- wait();
- }
+ wait();
+ }
- if (config.options[OPTION_UNITINFO]) {
- if(execb(PATH_PATCHES "/unitinfo.vco")) {
+ if (config.options[OPTION_UNITINFO]) {
+ if (execb(PATH_PATCHES "/unitinfo.vco")) {
abort("UNITINFO patch failed.");
}
- wait();
- }
+ wait();
+ }
- if (config.options[OPTION_MEMEXEC]) {
- if(execb(PATH_PATCHES "/memexec.vco")) {
+ if (config.options[OPTION_MEMEXEC]) {
+ if (execb(PATH_PATCHES "/memexec.vco")) {
abort("MPU execution patch failed.");
}
- wait();
- }
+ wait();
+ }
return 0;
}
int menu_poweroff();
uint32_t wait_key();
-#define abort(x...) \
- { \
- fprintf(stderr, x); \
- wait_key(); \
- menu_poweroff(); \
+#define abort(x...) \
+ { \
+ fprintf(stderr, x); \
+ wait_key(); \
+ menu_poweroff(); \
}
#endif
};
void
-clear_disp(uint8_t* screen)
+clear_disp(uint8_t *screen)
{
if (screen == TOP_SCREEN)
screen = framebuffers->top_left;
#ifdef BUFFER
void
-clear_text(uint8_t* screen)
+clear_text(uint8_t *screen)
{
if (screen == TOP_SCREEN)
screen = framebuffers->top_left;
#endif
void
-clear_screen(uint8_t* screen)
+clear_screen(uint8_t *screen)
{
clear_disp(screen);
#ifdef BUFFER
}
void
-set_cursor(void* channel, unsigned int x, unsigned int y)
+set_cursor(void *channel, unsigned int x, unsigned int y)
{
if (channel == TOP_SCREEN) {
top_cursor_x = x;
}
void
-draw_character(uint8_t* screen, const char character, const unsigned int buf_x,
- const unsigned int buf_y, const uint32_t color_fg,
- const uint32_t color_bg)
+draw_character(uint8_t *screen, const char character, const unsigned int buf_x, const unsigned int buf_y, const uint32_t color_fg, const uint32_t color_bg)
{
if (!isprint(character))
return; // Don't output non-printables.
unsigned char char_pos = font[character * 8 + y];
for (int x = 7; x >= 0; x--) {
- int screen_pos =
- (pos_x * height * 3 + (height - y - pos_y - 1) * 3) +
- (7 - x) * 3 * height;
+ int screen_pos = (pos_x * height * 3 + (height - y - pos_y - 1) * 3) + (7 - x) * 3 * height;
screen[screen_pos] = color_bg >> 16;
screen[screen_pos + 1] = color_bg >> 8;
}
void
-putc(void* buf, const int c)
+putc(void *buf, const int c)
{
if (buf == stdout || buf == stderr) {
if (kill_output)
unsigned int width = 0;
_UNUSED unsigned int height = 0;
- unsigned int* cursor_x = NULL;
- unsigned int* cursor_y = NULL;
+ unsigned int *cursor_x = NULL;
+ unsigned int *cursor_y = NULL;
#ifdef BUFFER
- char* colorbuf = NULL;
- char* strbuf = NULL;
+ char *colorbuf = NULL;
+ char *strbuf = NULL;
#else
- uint8_t* screen = NULL;
+ uint8_t *screen = NULL;
#endif
- unsigned char* color = NULL;
+ unsigned char *color = NULL;
if (buf == TOP_SCREEN) {
width = TEXT_TOP_WIDTH;
memset(&strbuf[y * width], 0, width);
memset(&colorbuf[y * width], 0, width);
strncpy(&strbuf[y * width], &strbuf[(y + 1) * width], width);
- strncpy(&colorbuf[y * width], &colorbuf[(y + 1) * width],
- width);
+ strncpy(&colorbuf[y * width], &colorbuf[(y + 1) * width], width);
}
memset(&strbuf[(height - 1) * width], 0, width);
memset(&colorbuf[(height - 1) * width], 0, width);
cursor_y[0]--;
#else
- clear_disp(buf);
- cursor_x[0] = 0;
- cursor_y[0] = 0;
+ clear_disp(buf);
+ cursor_x[0] = 0;
+ cursor_y[0] = 0;
/* uint32_t col = SCREEN_TOP_HEIGHT * SCREEN_DEPTH;
- uint32_t one_c = 8 * SCREEN_DEPTH;
- for (unsigned int x = 0; x < width * 8; x++) {
- memmove(&screen[x * col + one_c], &screen[x * col + one_c], col - one_c);
- } */
+ uint32_t one_c = 8 * SCREEN_DEPTH;
+ for (unsigned int x = 0; x < width * 8; x++) {
+ memmove(&screen[x * col + one_c], &screen[x * col + one_c], col - one_c);
+ } */
#endif
}
colorbuf[cursor_y[0] * width + cursor_x[0]] = *color;
if (cursor_x[0] + 1 < width) {
- strbuf[cursor_y[0] * width + cursor_x[0] + 1] =
- 0; // Terminate.
+ strbuf[cursor_y[0] * width + cursor_x[0] + 1] = 0; // Terminate.
colorbuf[cursor_y[0] * width + cursor_x[0] + 1] = 0;
}
#else
- draw_character(screen, c, cursor_x[0], cursor_y[0], colors[(*color >> 4) & 0xF], colors[*color & 0xF]);
+ draw_character(screen, c, cursor_x[0], cursor_y[0], colors[(*color >> 4) & 0xF], colors[*color & 0xF]);
#endif
cursor_x[0]++;
}
} else {
// FILE*, not stdin or stdout.
- fwrite(&c, 1, 1, (FILE*)buf);
+ fwrite(&c, 1, 1, (FILE *)buf);
}
}
void
-puts(void* buf, const char* string)
+puts(void *buf, const char *string)
{
if ((buf == stdout || buf == stderr) && kill_output)
return;
- char* ref = (char*)string;
+ char *ref = (char *)string;
while (*ref != '\0') {
putc(buf, *ref);
}
void
-put_int64(void* channel, int64_t n, int length)
+put_int64(void *channel, int64_t n, int length)
{
char conv[32], out[32];
memset(conv, 0, 32);
}
void
-put_uint64(void* channel, uint64_t n, int length)
+put_uint64(void *channel, uint64_t n, int length)
{
char conv[32], out[32];
memset(conv, 0, 32);
}
void
-put_hexdump(void* channel, unsigned int num)
+put_hexdump(void *channel, unsigned int num)
{
- uint8_t* num_8 = (uint8_t*)#
+ uint8_t *num_8 = (uint8_t *)#
for (int i = 3; i >= 0; i--) {
uint8_t high = (num_8[i] >> 4) & 0xf;
uint8_t low = num_8[i] & 0xf;
}
void
-put_uint(void* channel, unsigned int n, int length)
+put_uint(void *channel, unsigned int n, int length)
{
put_uint64(channel, n, length);
}
void
-put_int(void* channel, int n, int length)
+put_int(void *channel, int n, int length)
{
put_int64(channel, n, length);
}
void
-fflush(void* channel)
+fflush(void *channel)
{
if (channel == TOP_SCREEN) {
#ifdef BUFFER
char c = text_buffer_top[y * TEXT_TOP_WIDTH + x];
if (c == 0)
break;
- uint32_t color_fg = colors[(
- (color_buffer_top[y * TEXT_TOP_WIDTH + x] >> 4) & 0x0f)];
- uint32_t color_bg =
- colors[(color_buffer_top[y * TEXT_TOP_WIDTH + x] & 0x0f)];
- draw_character(framebuffers->top_left, c, x, y, color_fg,
- color_bg);
+ uint32_t color_fg = colors[((color_buffer_top[y * TEXT_TOP_WIDTH + x] >> 4) & 0x0f)];
+ uint32_t color_bg = colors[(color_buffer_top[y * TEXT_TOP_WIDTH + x] & 0x0f)];
+ draw_character(framebuffers->top_left, c, x, y, color_fg, color_bg);
}
}
#endif
char c = text_buffer_bottom[y * TEXT_BOTTOM_WIDTH + x];
if (c == 0)
break;
- uint32_t color_fg = colors[(
- (color_buffer_bottom[y * TEXT_BOTTOM_WIDTH + x] >> 4) &
- 0x0f)];
- uint32_t color_bg = colors[(
- color_buffer_bottom[y * TEXT_BOTTOM_WIDTH + x] & 0x0f)];
- draw_character(framebuffers->bottom, c, x, y, color_fg,
- color_bg);
+ uint32_t color_fg = colors[((color_buffer_bottom[y * TEXT_BOTTOM_WIDTH + x] >> 4) & 0x0f)];
+ uint32_t color_bg = colors[(color_buffer_bottom[y * TEXT_BOTTOM_WIDTH + x] & 0x0f)];
+ draw_character(framebuffers->bottom, c, x, y, color_fg, color_bg);
}
}
#endif
} else {
- f_sync(&(((FILE*)channel)->handle)); // Sync to disk.
+ f_sync(&(((FILE *)channel)->handle)); // Sync to disk.
}
}
int disable_format = 0;
void
-vfprintf(void* channel, const char* format, va_list ap)
+vfprintf(void *channel, const char *format, va_list ap)
{
if ((channel == stdout || channel == stderr) && kill_output)
return;
- char* ref = (char*)format;
+ char *ref = (char *)format;
- unsigned char* color;
+ unsigned char *color;
if (channel == TOP_SCREEN)
color = &color_top;
else if (channel == TOP_SCREEN)
color = &color_bottom;
while (*ref != '\0') {
- if (*ref == 0x1B && *(++ref) == '[' &&
- (channel == stdout || channel == stderr)) {
+ if (*ref == 0x1B && *(++ref) == '[' && (channel == stdout || channel == stderr)) {
ansi_codes:
// Ansi escape code.
++ref;
break;
case 's':
// Using puts isn't correct here...
- disable_format = 1; // Disable format strings.
- fprintf(channel, va_arg(ap, char*));
- disable_format = 0; // Reenable.
+ disable_format = 1; // Disable format strings.
+ fprintf(channel, va_arg(ap, char *));
+ disable_format = 0; // Reenable.
break;
case 'c':
putc(channel, va_arg(ap, int));
break;
case 'p':
- puts(channel, va_arg(ap, char*));
+ puts(channel, va_arg(ap, char *));
break;
case '%':
putc(channel, '%');
}
void
-fprintf(void* channel, const char* format, ...)
+fprintf(void *channel, const char *format, ...)
{
// The output suppression is in all the functions to minimize overhead.
// Function calls and format conversions take time and we don't just want
#define SCREEN_DEPTH 3
#define SCREEN_TOP_SIZE (SCREEN_TOP_WIDTH * SCREEN_TOP_HEIGHT * SCREEN_DEPTH)
-#define SCREEN_BOTTOM_SIZE \
- (SCREEN_BOTTOM_WIDTH * SCREEN_BOTTOM_HEIGHT * SCREEN_DEPTH)
+#define SCREEN_BOTTOM_SIZE (SCREEN_BOTTOM_WIDTH * SCREEN_BOTTOM_HEIGHT * SCREEN_DEPTH)
#define CHARA_HEIGHT 8
#define CHARA_WIDTH 8
_UNUSED static struct framebuffers
{
- uint8_t* top_left;
- uint8_t* top_right;
- uint8_t* bottom;
-}* framebuffers = (struct framebuffers*)0x23FFFE00;
+ uint8_t *top_left;
+ uint8_t *top_right;
+ uint8_t *bottom;
+} *framebuffers = (struct framebuffers *)0x23FFFE00;
// This is marked unused since it occurs in all files.
#define TOP_FB framebuffers->top_left
#define BOTTOM_FB framebuffers->bottom
-void clear_screen(uint8_t* screen);
+void clear_screen(uint8_t *screen);
void clear_screens();
-void draw_character(uint8_t* screen, const char character,
- const unsigned int pos_x, const unsigned int pos_y,
- const uint32_t color_fg, const uint32_t color_bg);
+void draw_character(uint8_t *screen, const char character, const unsigned int pos_x, const unsigned int pos_y, const uint32_t color_fg,
+ const uint32_t color_bg);
-#define TOP_SCREEN ((void*)0)
-#define BOTTOM_SCREEN ((void*)2)
+#define TOP_SCREEN ((void *)0)
+#define BOTTOM_SCREEN ((void *)2)
#define stdout TOP_SCREEN
#define stderr BOTTOM_SCREEN
-void putc(void* buf, const int c);
-void puts(void* buf, const char* string);
-void fflush(void* channel);
+void putc(void *buf, const int c);
+void puts(void *buf, const char *string);
+void fflush(void *channel);
-void set_cursor(void* channel, unsigned int x, unsigned int y);
+void set_cursor(void *channel, unsigned int x, unsigned int y);
// Like printf. Supports the following format specifiers:
// %s - char*
// Formats are also supported (but are subject to replacement)
// %p - unsigned char, changes color of text (will be replaced with ANSI codes
// eventually)
-void fprintf(void* channel, const char* format, ...);
+void fprintf(void *channel, const char *format, ...);
#define BLACK 0
#define BLUE 1
#define __STD_FONT_H
static const unsigned char font[] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x81, 0xa5, 0x81,
- 0xbd, 0x99, 0x81, 0x7e, 0x7e, 0xff, 0xdb, 0xff, 0xc3, 0xe7, 0xff, 0x7e,
- 0x6c, 0xfe, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x10, 0x38, 0x7c, 0xfe,
- 0x7c, 0x38, 0x10, 0x00, 0x3c, 0x3c, 0x18, 0xff, 0xe7, 0x18, 0x3c, 0x00,
- 0x10, 0x38, 0x7c, 0xfe, 0xee, 0x10, 0x38, 0x00, 0x00, 0x00, 0x18, 0x3c,
- 0x3c, 0x18, 0x00, 0x00, 0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff,
- 0x00, 0x3c, 0x66, 0x42, 0x42, 0x66, 0x3c, 0x00, 0xff, 0xc3, 0x99, 0xbd,
- 0xbd, 0x99, 0xc3, 0xff, 0x0f, 0x07, 0x0f, 0x7d, 0xcc, 0xcc, 0xcc, 0x78,
- 0x3c, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x18, 0x08, 0x0c, 0x0a, 0x0a,
- 0x08, 0x78, 0xf0, 0x00, 0x18, 0x14, 0x1a, 0x16, 0x72, 0xe2, 0x0e, 0x1c,
- 0x10, 0x54, 0x38, 0xee, 0x38, 0x54, 0x10, 0x00, 0x80, 0xe0, 0xf8, 0xfe,
- 0xf8, 0xe0, 0x80, 0x00, 0x02, 0x0e, 0x3e, 0xfe, 0x3e, 0x0e, 0x02, 0x00,
- 0x18, 0x3c, 0x5a, 0x18, 0x5a, 0x3c, 0x18, 0x00, 0x66, 0x66, 0x66, 0x66,
- 0x66, 0x00, 0x66, 0x00, 0x7f, 0xdb, 0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x00,
- 0x1c, 0x22, 0x38, 0x44, 0x44, 0x38, 0x88, 0x70, 0x00, 0x00, 0x00, 0x00,
- 0x7e, 0x7e, 0x7e, 0x00, 0x18, 0x3c, 0x5a, 0x18, 0x5a, 0x3c, 0x18, 0x7e,
- 0x18, 0x3c, 0x5a, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18,
- 0x5a, 0x3c, 0x18, 0x00, 0x00, 0x18, 0x0c, 0xfe, 0x0c, 0x18, 0x00, 0x00,
- 0x00, 0x30, 0x60, 0xfe, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0,
- 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x24, 0x42, 0xff, 0x42, 0x24, 0x00, 0x00,
- 0x00, 0x10, 0x38, 0x7c, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x7c,
- 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x18, 0x3c, 0x3c, 0x18, 0x18, 0x00, 0x18, 0x00, 0x6c, 0x24, 0x24, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0xfe, 0x6c, 0xfe, 0x6c, 0x6c, 0x00,
- 0x10, 0x7c, 0xd0, 0x7c, 0x16, 0xfc, 0x10, 0x00, 0x00, 0x66, 0xac, 0xd8,
- 0x36, 0x6a, 0xcc, 0x00, 0x38, 0x4c, 0x38, 0x78, 0xce, 0xcc, 0x7a, 0x00,
- 0x30, 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x60, 0x60,
- 0x60, 0x30, 0x18, 0x00, 0x60, 0x30, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00,
- 0x00, 0x66, 0x3c, 0xff, 0x3c, 0x66, 0x00, 0x00, 0x00, 0x30, 0x30, 0xfc,
- 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x10, 0x20,
- 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x30, 0x00, 0x02, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x00,
- 0x7c, 0xce, 0xde, 0xf6, 0xe6, 0xe6, 0x7c, 0x00, 0x18, 0x38, 0x78, 0x18,
- 0x18, 0x18, 0x7e, 0x00, 0x7c, 0xc6, 0x06, 0x1c, 0x70, 0xc6, 0xfe, 0x00,
- 0x7c, 0xc6, 0x06, 0x3c, 0x06, 0xc6, 0x7c, 0x00, 0x1c, 0x3c, 0x6c, 0xcc,
- 0xfe, 0x0c, 0x1e, 0x00, 0xfe, 0xc0, 0xfc, 0x06, 0x06, 0xc6, 0x7c, 0x00,
- 0x7c, 0xc6, 0xc0, 0xfc, 0xc6, 0xc6, 0x7c, 0x00, 0xfe, 0xc6, 0x0c, 0x18,
- 0x30, 0x30, 0x30, 0x00, 0x7c, 0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0x7c, 0x00,
- 0x7c, 0xc6, 0xc6, 0x7e, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x30, 0x00, 0x00,
- 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x10, 0x20,
- 0x0c, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0c, 0x00, 0x00, 0x00, 0x7e, 0x00,
- 0x00, 0x7e, 0x00, 0x00, 0x60, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x60, 0x00,
- 0x78, 0xcc, 0x0c, 0x18, 0x30, 0x00, 0x30, 0x00, 0x7c, 0x82, 0x9e, 0xa6,
- 0x9e, 0x80, 0x7c, 0x00, 0x7c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00,
- 0xfc, 0x66, 0x66, 0x7c, 0x66, 0x66, 0xfc, 0x00, 0x7c, 0xc6, 0xc0, 0xc0,
- 0xc0, 0xc6, 0x7c, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x66, 0x66, 0xfc, 0x00,
- 0xfe, 0x62, 0x68, 0x78, 0x68, 0x62, 0xfe, 0x00, 0xfe, 0x62, 0x68, 0x78,
- 0x68, 0x60, 0xf0, 0x00, 0x7c, 0xc6, 0xc6, 0xc0, 0xce, 0xc6, 0x7e, 0x00,
- 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x3c, 0x18, 0x18, 0x18,
- 0x18, 0x18, 0x3c, 0x00, 0x1e, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0x78, 0x00,
- 0xe6, 0x66, 0x6c, 0x78, 0x6c, 0x66, 0xe6, 0x00, 0xf0, 0x60, 0x60, 0x60,
- 0x62, 0x66, 0xfe, 0x00, 0x82, 0xc6, 0xee, 0xfe, 0xd6, 0xc6, 0xc6, 0x00,
- 0xc6, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0xc6, 0x00, 0x7c, 0xc6, 0xc6, 0xc6,
- 0xc6, 0xc6, 0x7c, 0x00, 0xfc, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xf0, 0x00,
- 0x7c, 0xc6, 0xc6, 0xc6, 0xd6, 0xde, 0x7c, 0x06, 0xfc, 0x66, 0x66, 0x7c,
- 0x66, 0x66, 0xe6, 0x00, 0x7c, 0xc6, 0xc0, 0x7c, 0x06, 0xc6, 0x7c, 0x00,
- 0x7e, 0x5a, 0x5a, 0x18, 0x18, 0x18, 0x3c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6,
- 0xc6, 0xc6, 0x7c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00,
- 0xc6, 0xc6, 0xd6, 0xfe, 0xee, 0xc6, 0x82, 0x00, 0xc6, 0x6c, 0x38, 0x38,
- 0x38, 0x6c, 0xc6, 0x00, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x18, 0x3c, 0x00,
- 0xfe, 0xc6, 0x8c, 0x18, 0x32, 0x66, 0xfe, 0x00, 0x78, 0x60, 0x60, 0x60,
- 0x60, 0x60, 0x78, 0x00, 0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x02, 0x00,
- 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0x00, 0x10, 0x38, 0x6c, 0xc6,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
- 0x30, 0x20, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0c,
- 0x7c, 0xcc, 0x76, 0x00, 0xe0, 0x60, 0x60, 0x7c, 0x66, 0x66, 0x7c, 0x00,
- 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc6, 0x7c, 0x00, 0x1c, 0x0c, 0x0c, 0x7c,
- 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0x7c, 0x00,
- 0x1c, 0x36, 0x30, 0x78, 0x30, 0x30, 0x78, 0x00, 0x00, 0x00, 0x76, 0xcc,
- 0xcc, 0x7c, 0x0c, 0x78, 0xe0, 0x60, 0x6c, 0x76, 0x66, 0x66, 0xe6, 0x00,
- 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x0c, 0x00, 0x1c,
- 0x0c, 0x0c, 0xcc, 0x78, 0xe0, 0x60, 0x66, 0x6c, 0x78, 0x6c, 0xe6, 0x00,
- 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0xcc, 0xfe,
- 0xd6, 0xd6, 0xd6, 0x00, 0x00, 0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x00,
- 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0xdc, 0x66,
- 0x66, 0x7c, 0x60, 0xf0, 0x00, 0x00, 0x7c, 0xcc, 0xcc, 0x7c, 0x0c, 0x1e,
- 0x00, 0x00, 0xde, 0x76, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x7c, 0xc0,
- 0x7c, 0x06, 0x7c, 0x00, 0x10, 0x30, 0xfc, 0x30, 0x30, 0x34, 0x18, 0x00,
- 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0xc6, 0xc6,
- 0x6c, 0x38, 0x10, 0x00, 0x00, 0x00, 0xc6, 0xd6, 0xd6, 0xfe, 0x6c, 0x00,
- 0x00, 0x00, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0xcc, 0xcc,
- 0xcc, 0x7c, 0x0c, 0xf8, 0x00, 0x00, 0xfc, 0x98, 0x30, 0x64, 0xfc, 0x00,
- 0x0e, 0x18, 0x18, 0x30, 0x18, 0x18, 0x0e, 0x00, 0x18, 0x18, 0x18, 0x00,
- 0x18, 0x18, 0x18, 0x00, 0xe0, 0x30, 0x30, 0x18, 0x30, 0x30, 0xe0, 0x00,
- 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c,
- 0xc6, 0xc6, 0xfe, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc6, 0x7c, 0x18, 0x70,
- 0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x0e, 0x10, 0x7c, 0xc6,
- 0xfe, 0xc0, 0x7c, 0x00, 0x7c, 0x82, 0x38, 0x0c, 0x7c, 0xcc, 0x76, 0x00,
- 0xcc, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x00, 0xe0, 0x10, 0x78, 0x0c,
- 0x7c, 0xcc, 0x76, 0x00, 0x30, 0x30, 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x00,
- 0x00, 0x00, 0x7c, 0xc0, 0xc0, 0x7c, 0x18, 0x70, 0x7c, 0x82, 0x7c, 0xc6,
- 0xfe, 0xc0, 0x7c, 0x00, 0xc6, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0x7c, 0x00,
- 0xe0, 0x10, 0x7c, 0xc6, 0xfe, 0xc0, 0x7c, 0x00, 0x66, 0x00, 0x38, 0x18,
- 0x18, 0x18, 0x3c, 0x00, 0x7c, 0x82, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00,
- 0xe0, 0x10, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00, 0xc6, 0x00, 0x7c, 0xc6,
- 0xfe, 0xc6, 0xc6, 0x00, 0x38, 0x38, 0x7c, 0xc6, 0xfe, 0xc6, 0xc6, 0x00,
- 0x0e, 0x10, 0xfe, 0x60, 0x78, 0x60, 0xfe, 0x00, 0x00, 0x00, 0x7c, 0x12,
- 0x7e, 0xd0, 0x7e, 0x00, 0x7e, 0xc8, 0xc8, 0xfe, 0xc8, 0xc8, 0xce, 0x00,
- 0x7c, 0x82, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0xc6, 0x00, 0x7c, 0xc6,
- 0xc6, 0xc6, 0x7c, 0x00, 0xe0, 0x10, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
- 0x7c, 0x82, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0xe0, 0x10, 0xcc, 0xcc,
- 0xcc, 0xcc, 0x76, 0x00, 0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0xf8,
- 0xc6, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0xc6, 0x00, 0xc6, 0xc6,
- 0xc6, 0xc6, 0x7c, 0x00, 0x18, 0x7c, 0xd6, 0xd0, 0xd6, 0x7c, 0x18, 0x00,
- 0x38, 0x6c, 0x60, 0xf0, 0x60, 0xf2, 0xdc, 0x00, 0x66, 0x3c, 0x18, 0x7e,
- 0x18, 0x7e, 0x18, 0x00, 0xf8, 0xcc, 0xf8, 0xc4, 0xcc, 0xde, 0xcc, 0x06,
- 0x0e, 0x1b, 0x18, 0x3c, 0x18, 0x18, 0xd8, 0x70, 0x0e, 0x10, 0x78, 0x0c,
- 0x7c, 0xcc, 0x76, 0x00, 0x0e, 0x10, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00,
- 0x0e, 0x10, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x0e, 0x10, 0xcc, 0xcc,
- 0xcc, 0xcc, 0x76, 0x00, 0x66, 0x98, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x00,
- 0x66, 0x98, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0x00, 0x38, 0x0c, 0x3c, 0x34,
- 0x00, 0x7e, 0x00, 0x00, 0x38, 0x6c, 0x6c, 0x38, 0x00, 0x7c, 0x00, 0x00,
- 0x30, 0x00, 0x30, 0x60, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0xfc,
- 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x0c, 0x0c, 0x00, 0x00,
- 0xc0, 0xc8, 0xd0, 0xfe, 0x46, 0x8c, 0x1e, 0x00, 0xc0, 0xc8, 0xd0, 0xec,
- 0x5c, 0xbe, 0x0c, 0x00, 0x18, 0x00, 0x18, 0x18, 0x3c, 0x3c, 0x18, 0x00,
- 0x00, 0x36, 0x6c, 0xd8, 0x6c, 0x36, 0x00, 0x00, 0x00, 0xd8, 0x6c, 0x36,
- 0x6c, 0xd8, 0x00, 0x00, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88,
- 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0xdb, 0x77, 0xdb, 0xee,
- 0xdb, 0x77, 0xdb, 0xee, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
- 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18,
- 0xf8, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x36, 0x36, 0x36,
- 0x00, 0x00, 0x00, 0x00, 0xfe, 0x36, 0x36, 0x36, 0x00, 0x00, 0xf8, 0x18,
- 0xf8, 0x18, 0x18, 0x18, 0x36, 0x36, 0xf6, 0x06, 0xf6, 0x36, 0x36, 0x36,
- 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0xfe, 0x06,
- 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x06, 0xfe, 0x00, 0x00, 0x00,
- 0x36, 0x36, 0x36, 0x36, 0xfe, 0x00, 0x00, 0x00, 0x18, 0x18, 0xf8, 0x18,
- 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x18, 0x18, 0x18,
- 0x18, 0x18, 0x18, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18,
- 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x18, 0x18, 0x18,
- 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
- 0xff, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0xff, 0x18, 0x18, 0x18,
- 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36,
- 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x3f, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x3f, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0x00,
- 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xf7, 0x36, 0x36, 0x36,
- 0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, 0x00, 0x00, 0xff, 0x00,
- 0xff, 0x00, 0x00, 0x00, 0x36, 0x36, 0xf7, 0x00, 0xf7, 0x36, 0x36, 0x36,
- 0x18, 0x18, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36,
- 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x18, 0x18, 0x18,
- 0x00, 0x00, 0x00, 0x00, 0xff, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
- 0x3f, 0x00, 0x00, 0x00, 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
- 0x3f, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff, 0x36, 0x36, 0x36,
- 0x18, 0x18, 0xff, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
- 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x18, 0x18,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
- 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
- 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0xcc, 0xc8, 0xdc, 0x76, 0x00,
- 0x78, 0xcc, 0xd8, 0xcc, 0xc6, 0xc6, 0xdc, 0x40, 0xfe, 0x62, 0x60, 0x60,
- 0x60, 0x60, 0xf0, 0x00, 0x00, 0x02, 0x7e, 0xec, 0x6c, 0x6c, 0x48, 0x00,
- 0xfe, 0x62, 0x30, 0x18, 0x30, 0x62, 0xfe, 0x00, 0x00, 0x00, 0x7e, 0xd0,
- 0xc8, 0xc8, 0x70, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xf8, 0x80,
- 0x00, 0x00, 0x7e, 0xd8, 0x18, 0x18, 0x10, 0x00, 0x38, 0x10, 0x7c, 0xd6,
- 0xd6, 0x7c, 0x10, 0x38, 0x7c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0x7c, 0x00,
- 0x7c, 0xc6, 0xc6, 0xc6, 0x6c, 0x28, 0xee, 0x00, 0x3c, 0x22, 0x18, 0x7c,
- 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x66, 0x99, 0x99, 0x66, 0x00, 0x00,
- 0x00, 0x06, 0x7c, 0x9e, 0xf2, 0x7c, 0xc0, 0x00, 0x00, 0x00, 0x7c, 0xc0,
- 0xf8, 0xc0, 0x7c, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00,
- 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0x00, 0x18, 0x18, 0x7e, 0x18,
- 0x18, 0x00, 0x7e, 0x00, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0x00,
- 0x18, 0x30, 0x60, 0x30, 0x18, 0x00, 0x7c, 0x00, 0x0e, 0x1b, 0x1b, 0x18,
- 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xd8, 0xd8, 0x70,
- 0x00, 0x18, 0x00, 0x7e, 0x00, 0x18, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00,
- 0x76, 0xdc, 0x00, 0x00, 0x38, 0x6c, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x18, 0x00, 0x00, 0x00, 0x0f, 0x0c, 0x0c, 0x0c, 0xec, 0x6c, 0x3c, 0x00,
- 0xd8, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x30, 0xc0, 0xf0,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x3c, 0x3c, 0x3c, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x81, 0xa5, 0x81, 0xbd, 0x99, 0x81, 0x7e, 0x7e, 0xff, 0xdb, 0xff, 0xc3, 0xe7, 0xff, 0x7e, 0x6c, 0xfe,
+ 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x3c, 0x3c, 0x18, 0xff, 0xe7, 0x18, 0x3c, 0x00, 0x10, 0x38, 0x7c, 0xfe,
+ 0xee, 0x10, 0x38, 0x00, 0x00, 0x00, 0x18, 0x3c, 0x3c, 0x18, 0x00, 0x00, 0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff, 0x00, 0x3c, 0x66, 0x42, 0x42, 0x66,
+ 0x3c, 0x00, 0xff, 0xc3, 0x99, 0xbd, 0xbd, 0x99, 0xc3, 0xff, 0x0f, 0x07, 0x0f, 0x7d, 0xcc, 0xcc, 0xcc, 0x78, 0x3c, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x18,
+ 0x08, 0x0c, 0x0a, 0x0a, 0x08, 0x78, 0xf0, 0x00, 0x18, 0x14, 0x1a, 0x16, 0x72, 0xe2, 0x0e, 0x1c, 0x10, 0x54, 0x38, 0xee, 0x38, 0x54, 0x10, 0x00, 0x80, 0xe0,
+ 0xf8, 0xfe, 0xf8, 0xe0, 0x80, 0x00, 0x02, 0x0e, 0x3e, 0xfe, 0x3e, 0x0e, 0x02, 0x00, 0x18, 0x3c, 0x5a, 0x18, 0x5a, 0x3c, 0x18, 0x00, 0x66, 0x66, 0x66, 0x66,
+ 0x66, 0x00, 0x66, 0x00, 0x7f, 0xdb, 0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x00, 0x1c, 0x22, 0x38, 0x44, 0x44, 0x38, 0x88, 0x70, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x7e,
+ 0x7e, 0x00, 0x18, 0x3c, 0x5a, 0x18, 0x5a, 0x3c, 0x18, 0x7e, 0x18, 0x3c, 0x5a, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x5a, 0x3c, 0x18, 0x00,
+ 0x00, 0x18, 0x0c, 0xfe, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x30, 0x60, 0xfe, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x24,
+ 0x42, 0xff, 0x42, 0x24, 0x00, 0x00, 0x00, 0x10, 0x38, 0x7c, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x18, 0x3c, 0x3c, 0x18, 0x18, 0x00, 0x18, 0x00, 0x6c, 0x24, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0xfe, 0x6c, 0xfe, 0x6c,
+ 0x6c, 0x00, 0x10, 0x7c, 0xd0, 0x7c, 0x16, 0xfc, 0x10, 0x00, 0x00, 0x66, 0xac, 0xd8, 0x36, 0x6a, 0xcc, 0x00, 0x38, 0x4c, 0x38, 0x78, 0xce, 0xcc, 0x7a, 0x00,
+ 0x30, 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x60, 0x60, 0x60, 0x30, 0x18, 0x00, 0x60, 0x30, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00, 0x00, 0x66,
+ 0x3c, 0xff, 0x3c, 0x66, 0x00, 0x00, 0x00, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x10, 0x20, 0x00, 0x00, 0x00, 0xfc,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x02, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x00, 0x7c, 0xce, 0xde, 0xf6, 0xe6, 0xe6,
+ 0x7c, 0x00, 0x18, 0x38, 0x78, 0x18, 0x18, 0x18, 0x7e, 0x00, 0x7c, 0xc6, 0x06, 0x1c, 0x70, 0xc6, 0xfe, 0x00, 0x7c, 0xc6, 0x06, 0x3c, 0x06, 0xc6, 0x7c, 0x00,
+ 0x1c, 0x3c, 0x6c, 0xcc, 0xfe, 0x0c, 0x1e, 0x00, 0xfe, 0xc0, 0xfc, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x7c, 0xc6, 0xc0, 0xfc, 0xc6, 0xc6, 0x7c, 0x00, 0xfe, 0xc6,
+ 0x0c, 0x18, 0x30, 0x30, 0x30, 0x00, 0x7c, 0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0x7c, 0x00, 0x7c, 0xc6, 0xc6, 0x7e, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x30, 0x00, 0x00,
+ 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x10, 0x20, 0x0c, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0c, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x7e,
+ 0x00, 0x00, 0x60, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x60, 0x00, 0x78, 0xcc, 0x0c, 0x18, 0x30, 0x00, 0x30, 0x00, 0x7c, 0x82, 0x9e, 0xa6, 0x9e, 0x80, 0x7c, 0x00,
+ 0x7c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0xfc, 0x66, 0x66, 0x7c, 0x66, 0x66, 0xfc, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0xfc, 0x66,
+ 0x66, 0x66, 0x66, 0x66, 0xfc, 0x00, 0xfe, 0x62, 0x68, 0x78, 0x68, 0x62, 0xfe, 0x00, 0xfe, 0x62, 0x68, 0x78, 0x68, 0x60, 0xf0, 0x00, 0x7c, 0xc6, 0xc6, 0xc0,
+ 0xce, 0xc6, 0x7e, 0x00, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x1e, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc,
+ 0x78, 0x00, 0xe6, 0x66, 0x6c, 0x78, 0x6c, 0x66, 0xe6, 0x00, 0xf0, 0x60, 0x60, 0x60, 0x62, 0x66, 0xfe, 0x00, 0x82, 0xc6, 0xee, 0xfe, 0xd6, 0xc6, 0xc6, 0x00,
+ 0xc6, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0xc6, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0xfc, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xf0, 0x00, 0x7c, 0xc6,
+ 0xc6, 0xc6, 0xd6, 0xde, 0x7c, 0x06, 0xfc, 0x66, 0x66, 0x7c, 0x66, 0x66, 0xe6, 0x00, 0x7c, 0xc6, 0xc0, 0x7c, 0x06, 0xc6, 0x7c, 0x00, 0x7e, 0x5a, 0x5a, 0x18,
+ 0x18, 0x18, 0x3c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00, 0xc6, 0xc6, 0xd6, 0xfe, 0xee, 0xc6,
+ 0x82, 0x00, 0xc6, 0x6c, 0x38, 0x38, 0x38, 0x6c, 0xc6, 0x00, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x18, 0x3c, 0x00, 0xfe, 0xc6, 0x8c, 0x18, 0x32, 0x66, 0xfe, 0x00,
+ 0x78, 0x60, 0x60, 0x60, 0x60, 0x60, 0x78, 0x00, 0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x02, 0x00, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0x00, 0x10, 0x38,
+ 0x6c, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x30, 0x20, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0c,
+ 0x7c, 0xcc, 0x76, 0x00, 0xe0, 0x60, 0x60, 0x7c, 0x66, 0x66, 0x7c, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc6, 0x7c, 0x00, 0x1c, 0x0c, 0x0c, 0x7c, 0xcc, 0xcc,
+ 0x76, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0x7c, 0x00, 0x1c, 0x36, 0x30, 0x78, 0x30, 0x30, 0x78, 0x00, 0x00, 0x00, 0x76, 0xcc, 0xcc, 0x7c, 0x0c, 0x78,
+ 0xe0, 0x60, 0x6c, 0x76, 0x66, 0x66, 0xe6, 0x00, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x0c, 0x00, 0x1c, 0x0c, 0x0c, 0xcc, 0x78, 0xe0, 0x60,
+ 0x66, 0x6c, 0x78, 0x6c, 0xe6, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0xcc, 0xfe, 0xd6, 0xd6, 0xd6, 0x00, 0x00, 0x00, 0xdc, 0x66,
+ 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0xdc, 0x66, 0x66, 0x7c, 0x60, 0xf0, 0x00, 0x00, 0x7c, 0xcc, 0xcc, 0x7c,
+ 0x0c, 0x1e, 0x00, 0x00, 0xde, 0x76, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x7c, 0xc0, 0x7c, 0x06, 0x7c, 0x00, 0x10, 0x30, 0xfc, 0x30, 0x30, 0x34, 0x18, 0x00,
+ 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00, 0x00, 0x00, 0xc6, 0xd6, 0xd6, 0xfe, 0x6c, 0x00, 0x00, 0x00,
+ 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0xf8, 0x00, 0x00, 0xfc, 0x98, 0x30, 0x64, 0xfc, 0x00, 0x0e, 0x18, 0x18, 0x30,
+ 0x18, 0x18, 0x0e, 0x00, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00, 0xe0, 0x30, 0x30, 0x18, 0x30, 0x30, 0xe0, 0x00, 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc6, 0x7c, 0x18, 0x70, 0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00,
+ 0x0e, 0x10, 0x7c, 0xc6, 0xfe, 0xc0, 0x7c, 0x00, 0x7c, 0x82, 0x38, 0x0c, 0x7c, 0xcc, 0x76, 0x00, 0xcc, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x00, 0xe0, 0x10,
+ 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x00, 0x30, 0x30, 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x7c, 0xc0, 0xc0, 0x7c, 0x18, 0x70, 0x7c, 0x82, 0x7c, 0xc6,
+ 0xfe, 0xc0, 0x7c, 0x00, 0xc6, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0x7c, 0x00, 0xe0, 0x10, 0x7c, 0xc6, 0xfe, 0xc0, 0x7c, 0x00, 0x66, 0x00, 0x38, 0x18, 0x18, 0x18,
+ 0x3c, 0x00, 0x7c, 0x82, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00, 0xe0, 0x10, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00, 0xc6, 0x00, 0x7c, 0xc6, 0xfe, 0xc6, 0xc6, 0x00,
+ 0x38, 0x38, 0x7c, 0xc6, 0xfe, 0xc6, 0xc6, 0x00, 0x0e, 0x10, 0xfe, 0x60, 0x78, 0x60, 0xfe, 0x00, 0x00, 0x00, 0x7c, 0x12, 0x7e, 0xd0, 0x7e, 0x00, 0x7e, 0xc8,
+ 0xc8, 0xfe, 0xc8, 0xc8, 0xce, 0x00, 0x7c, 0x82, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0xc6, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0xe0, 0x10, 0x7c, 0xc6,
+ 0xc6, 0xc6, 0x7c, 0x00, 0x7c, 0x82, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0xe0, 0x10, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0x7c,
+ 0x0c, 0xf8, 0xc6, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0xc6, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x18, 0x7c, 0xd6, 0xd0, 0xd6, 0x7c, 0x18, 0x00,
+ 0x38, 0x6c, 0x60, 0xf0, 0x60, 0xf2, 0xdc, 0x00, 0x66, 0x3c, 0x18, 0x7e, 0x18, 0x7e, 0x18, 0x00, 0xf8, 0xcc, 0xf8, 0xc4, 0xcc, 0xde, 0xcc, 0x06, 0x0e, 0x1b,
+ 0x18, 0x3c, 0x18, 0x18, 0xd8, 0x70, 0x0e, 0x10, 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x00, 0x0e, 0x10, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x0e, 0x10, 0x7c, 0xc6,
+ 0xc6, 0xc6, 0x7c, 0x00, 0x0e, 0x10, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x66, 0x98, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x98, 0xe6, 0xf6, 0xde, 0xce,
+ 0xc6, 0x00, 0x38, 0x0c, 0x3c, 0x34, 0x00, 0x7e, 0x00, 0x00, 0x38, 0x6c, 0x6c, 0x38, 0x00, 0x7c, 0x00, 0x00, 0x30, 0x00, 0x30, 0x60, 0xc6, 0xc6, 0x7c, 0x00,
+ 0x00, 0x00, 0x00, 0xfc, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x0c, 0x0c, 0x00, 0x00, 0xc0, 0xc8, 0xd0, 0xfe, 0x46, 0x8c, 0x1e, 0x00, 0xc0, 0xc8,
+ 0xd0, 0xec, 0x5c, 0xbe, 0x0c, 0x00, 0x18, 0x00, 0x18, 0x18, 0x3c, 0x3c, 0x18, 0x00, 0x00, 0x36, 0x6c, 0xd8, 0x6c, 0x36, 0x00, 0x00, 0x00, 0xd8, 0x6c, 0x36,
+ 0x6c, 0xd8, 0x00, 0x00, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0xdb, 0x77, 0xdb, 0xee, 0xdb, 0x77,
+ 0xdb, 0xee, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0xf8, 0x18, 0x18, 0x18,
+ 0x36, 0x36, 0x36, 0x36, 0xf6, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x36, 0x36, 0x36, 0x00, 0x00, 0xf8, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x36, 0x36,
+ 0xf6, 0x06, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0xfe, 0x06, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x06,
+ 0xfe, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36, 0xfe, 0x00, 0x00, 0x00, 0x18, 0x18, 0xf8, 0x18, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x30,
+ 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x37, 0x36,
+ 0x36, 0x36, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x36, 0x36, 0xf7, 0x00, 0xf7, 0x36, 0x36, 0x36, 0x18, 0x18, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00,
+ 0x36, 0x36, 0x36, 0x36, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0xff, 0x36, 0x36, 0x36, 0x36, 0x36,
+ 0x36, 0x36, 0x3f, 0x00, 0x00, 0x00, 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
+ 0x3f, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff, 0x36, 0x36, 0x36, 0x18, 0x18, 0xff, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x18, 0x18, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+ 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x74, 0xcc, 0xc8, 0xdc, 0x76, 0x00, 0x78, 0xcc, 0xd8, 0xcc, 0xc6, 0xc6, 0xdc, 0x40, 0xfe, 0x62, 0x60, 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x02, 0x7e, 0xec,
+ 0x6c, 0x6c, 0x48, 0x00, 0xfe, 0x62, 0x30, 0x18, 0x30, 0x62, 0xfe, 0x00, 0x00, 0x00, 0x7e, 0xd0, 0xc8, 0xc8, 0x70, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc,
+ 0xf8, 0x80, 0x00, 0x00, 0x7e, 0xd8, 0x18, 0x18, 0x10, 0x00, 0x38, 0x10, 0x7c, 0xd6, 0xd6, 0x7c, 0x10, 0x38, 0x7c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0x7c, 0x00,
+ 0x7c, 0xc6, 0xc6, 0xc6, 0x6c, 0x28, 0xee, 0x00, 0x3c, 0x22, 0x18, 0x7c, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x66, 0x99, 0x99, 0x66, 0x00, 0x00, 0x00, 0x06,
+ 0x7c, 0x9e, 0xf2, 0x7c, 0xc0, 0x00, 0x00, 0x00, 0x7c, 0xc0, 0xf8, 0xc0, 0x7c, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0xfe, 0x00, 0xfe,
+ 0x00, 0xfe, 0x00, 0x00, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x7e, 0x00, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0x00, 0x18, 0x30, 0x60, 0x30, 0x18, 0x00,
+ 0x7c, 0x00, 0x0e, 0x1b, 0x1b, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xd8, 0xd8, 0x70, 0x00, 0x18, 0x00, 0x7e, 0x00, 0x18, 0x00, 0x00,
+ 0x00, 0x76, 0xdc, 0x00, 0x76, 0xdc, 0x00, 0x00, 0x38, 0x6c, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x0f, 0x0c, 0x0c, 0x0c, 0xec, 0x6c, 0x3c, 0x00, 0xd8, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x30, 0xc0, 0xf0,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x3c, 0x3c, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
return 0;
}
-FILE*
-fopen(const char* filename, const char* mode)
+FILE *
+fopen(const char *filename, const char *mode)
{
if (*mode != 'r' && *mode != 'w' && *mode != 'a')
return NULL; // Mode not valid.
- FILE* fp;
+ FILE *fp;
int i;
for (i = 0; i < MAX_FILES_OPEN; i++) {
if (!files[i].is_open) {
}
void
-fclose(FILE* fp)
+fclose(FILE *fp)
{
f_close(&(fp->handle));
}
void
-fseek(FILE* fp, int64_t offset, int whence)
+fseek(FILE *fp, int64_t offset, int whence)
{
uint32_t fixed_offset;
switch (whence) {
}
size_t
-ftell(FILE* fp)
+ftell(FILE *fp)
{
return f_tell(&(fp->handle));
}
int
-feof(FILE* fp)
+feof(FILE *fp)
{
return f_eof(&(fp->handle));
}
size_t
-fsize(FILE* fp)
+fsize(FILE *fp)
{
return f_size(&(fp->handle));
}
size_t
-fwrite(const void* buffer, size_t elementSize, size_t elementCnt, FILE* fp)
+fwrite(const void *buffer, size_t elementSize, size_t elementCnt, FILE *fp)
{
UINT br;
if (f_write(&(fp->handle), buffer, elementSize * elementCnt, &br))
}
size_t
-fread(void* buffer, size_t elementSize, size_t elementCnt, FILE* fp)
+fread(void *buffer, size_t elementSize, size_t elementCnt, FILE *fp)
{
UINT br;
if (f_read(&(fp->handle), buffer, elementSize * elementCnt, &br))
}
size_t
-write_file(void* data, char* path, size_t size)
+write_file(void *data, char *path, size_t size)
{
- FILE* temp = fopen(path, "w");
+ FILE *temp = fopen(path, "w");
if (!temp)
return 0;
}
size_t
-read_file(void* data, char* path, size_t size)
+read_file(void *data, char *path, size_t size)
{
- FILE* temp = fopen(path, "r");
+ FILE *temp = fopen(path, "r");
if (!temp)
return 0;
int fmount(void);
int fumount(void);
-FILE* fopen(const char* filename, const char* mode);
+FILE *fopen(const char *filename, const char *mode);
-void fclose(FILE* fp);
+void fclose(FILE *fp);
-void fseek(FILE* fp, int64_t offset, int whence);
+void fseek(FILE *fp, int64_t offset, int whence);
-size_t ftell(FILE* fp);
+size_t ftell(FILE *fp);
-int feof(FILE* fp);
+int feof(FILE *fp);
-size_t fsize(FILE* fp);
+size_t fsize(FILE *fp);
-size_t fwrite(const void* buffer, size_t elementSize, size_t elementCnt,
- FILE* fp);
-size_t fread(void* buffer, size_t elementSize, size_t elementCnt, FILE* fp);
+size_t fwrite(const void *buffer, size_t elementSize, size_t elementCnt, FILE *fp);
+size_t fread(void *buffer, size_t elementSize, size_t elementCnt, FILE *fp);
-size_t write_file(void* data, char* path, size_t size);
-size_t read_file(void* data, char* path, size_t size);
+size_t write_file(void *data, char *path, size_t size);
+size_t read_file(void *data, char *path, size_t size);
#endif
#include <stddef.h>
int
-strlen(const char* string)
+strlen(const char *string)
{
- char* string_end = (char*)string;
+ char *string_end = (char *)string;
while (*string_end)
string_end++;
return string_end - string;
}
void
-memcpy(void* dest, const void* src, size_t size)
+memcpy(void *dest, const void *src, size_t size)
{
- char* destc = (char*)dest;
- const char* srcc = (const char*)src;
+ char *destc = (char *)dest;
+ const char *srcc = (const char *)src;
// If we can align both dest and src together...
if ((uintptr_t)srcc % sizeof(size_t) == (uintptr_t)destc % sizeof(size_t)) {
*destc++ = *srcc++;
}
- for (; size >= sizeof(size_t); size -= sizeof(size_t),
- destc += sizeof(size_t),
- srcc += sizeof(size_t)) {
- *(size_t*)destc = *(size_t*)srcc;
+ for (; size >= sizeof(size_t); size -= sizeof(size_t), destc += sizeof(size_t), srcc += sizeof(size_t)) {
+ *(size_t *)destc = *(size_t *)srcc;
}
}
}
void
-memmove(void* dest, const void* src, size_t size)
+memmove(void *dest, const void *src, size_t size)
{
// memcpy does the job of moving backwards just fine
if (dest < src || src + size <= dest) {
}
// Moving forward is just a reverse memcpy
- char* destc = (char*)dest;
- const char* srcc = (const char*)src;
+ char *destc = (char *)dest;
+ const char *srcc = (const char *)src;
// If we can align both dest and src together...
if ((uintptr_t)srcc % sizeof(size_t) == (uintptr_t)destc % sizeof(size_t)) {
while (size >= sizeof(size_t)) {
size -= sizeof(size_t);
- *(size_t*)(destc + size) = *(size_t*)(srcc + size);
+ *(size_t *)(destc + size) = *(size_t *)(srcc + size);
}
}
}
void
-memset(void* dest, const int filler, size_t size)
+memset(void *dest, const int filler, size_t size)
{
- char* destc = (char*)dest;
+ char *destc = (char *)dest;
// Align dest to 4 bytes
while ((uintptr_t)destc % sizeof(size_t) && size--) {
}
// Set 32 bytes at a time
- for (; size >= sizeof(size_t);
- size -= sizeof(size_t), destc += sizeof(size_t)) {
- *(size_t*)destc = filler;
+ for (; size >= sizeof(size_t); size -= sizeof(size_t), destc += sizeof(size_t)) {
+ *(size_t *)destc = filler;
}
// Finish
}
int
-memcmp(const void* buf1, const void* buf2, const size_t size)
+memcmp(const void *buf1, const void *buf2, const size_t size)
{
- const char* buf1c = (const char*)buf1;
- const char* buf2c = (const char*)buf2;
+ const char *buf1c = (const char *)buf1;
+ const char *buf2c = (const char *)buf2;
for (size_t i = 0; i < size; i++) {
int cmp = buf1c[i] - buf2c[i];
if (cmp) {
}
void
-strncpy(void* dest, const void* src, const size_t size)
+strncpy(void *dest, const void *src, const size_t size)
{
- char* destc = (char*)dest;
- const char* srcc = (const char*)src;
+ char *destc = (char *)dest;
+ const char *srcc = (const char *)src;
size_t i;
for (i = 0; i < size && srcc[i] != 0; i++) {
}
int
-strncmp(const void* buf1, const void* buf2, const size_t size)
+strncmp(const void *buf1, const void *buf2, const size_t size)
{
- const char* buf1c = (const char*)buf1;
- const char* buf2c = (const char*)buf2;
+ const char *buf1c = (const char *)buf1;
+ const char *buf2c = (const char *)buf2;
size_t i;
for (i = 0; i < size && buf1c[i] != 0 && buf2c[i] != 0; i++) {
}
int
-atoi(const char* str)
+atoi(const char *str)
{
int res = 0;
while (*str && *str >= '0' && *str <= '9') {
// Quick Search algorithm, adapted from
// http://igm.univ-mlv.fr/~lecroq/string/node19.html#SECTION00190
-uint8_t*
-memfind(uint8_t* startPos, uint32_t size, const void* pattern,
- uint32_t patternSize)
+uint8_t *
+memfind(uint8_t *startPos, uint32_t size, const void *pattern, uint32_t patternSize)
{
- const uint8_t* patternc = (const uint8_t*)pattern;
+ const uint8_t *patternc = (const uint8_t *)pattern;
// Preprocessing
uint32_t table[ALPHABET_LEN];
#include <stdint.h>
#include <stddef.h>
-int strlen(const char* string);
-void memcpy(void* dest, const void* src, size_t size);
-void memmove(void* dest, const void* src, size_t size);
-void memset(void* dest, const int filler, size_t size);
-int memcmp(const void* buf1, const void* buf2, const size_t size);
-void strncpy(void* dest, const void* src, const size_t size);
-int strncmp(const void* buf1, const void* buf2, const size_t size);
-int atoi(const char* str);
-uint8_t* memfind(uint8_t* startPos, uint32_t size, const void* pattern,
- uint32_t patternSize);
+int strlen(const char *string);
+void memcpy(void *dest, const void *src, size_t size);
+void memmove(void *dest, const void *src, size_t size);
+void memset(void *dest, const int filler, size_t size);
+int memcmp(const void *buf1, const void *buf2, const size_t size);
+void strncpy(void *dest, const void *src, const size_t size);
+int strncmp(const void *buf1, const void *buf2, const size_t size);
+int atoi(const char *str);
+uint8_t *memfind(uint8_t *startPos, uint32_t size, const void *pattern, uint32_t patternSize);
int isprint(char c);
#endif
#include <stdint.h>
#include <stdlib.h>
-#define CFG_BOOTENV *(volatile uint32_t*)0x10010000
-#define HID ~*(volatile uint32_t*)0x10146000
-#define PDN_MPCORE_CFG *(uint8_t*)0x10140FFC
+#define CFG_BOOTENV *(volatile uint32_t *)0x10010000
+#define HID ~*(volatile uint32_t *)0x10146000
+#define PDN_MPCORE_CFG *(uint8_t *)0x10140FFC
#endif
projects / corbenik / corbenik.git / commitdiff