Added dual emuNAND support, multi-payload loader with built-in screen init (inspired by arm9select, thanks Fix94)

Seems to be more reliable in all conditions

Makefile

@@ -58,7 +58,8 @@ loader: $(dir_out)/rei/loader.bin
 clean:
 	@$(MAKE) $(FLAGS) -C $(dir_mset) clean
 	@$(MAKE) $(FLAGS) -C $(dir_ninjhax) clean
-	rm -rf $(dir_out) $(dir_build) $(dir_loader)/build $(dir_loader)/loader.elf
+	@rm -rf $(dir_out) $(dir_build)
+	@cd $(dir_loader) && make clean
 
 $(dir_out)/$(name).dat: $(dir_build)/main.bin $(dir_out)/rei
 	@$(MAKE) $(FLAGS) -C $(dir_mset) launcher

loader/Makefile

@@ -33,7 +33,7 @@ ARCH	:=	-mthumb -mthumb-interwork
 
 CFLAGS	:=	-g -Wall -O2\
 			-march=armv5te -mtune=arm946e-s -fomit-frame-pointer\
-			-ffast-math -std=c99\
+			-ffast-math -Wno-main -std=c99\
 			$(ARCH)
 
 CFLAGS	+=	$(INCLUDE) -DARM9
@@ -105,7 +105,7 @@ $(BUILD):
 #---------------------------------------------------------------------------------
 clean:
 	@echo clean ...
-	@rm -fr $(BUILD) $(OUTPUT).elf arm9loaderhax.bin
+	@rm -fr $(BUILD) $(OUTPUT).elf
  
  
 #---------------------------------------------------------------------------------

loader/source/buttons.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "types.h"
+
+#define HID_PAD            ((~*(vu16 *)0x10146000) & 0xFFF)
+#define BUTTON_B           (1 << 1)
+#define BUTTON_X           (1 << 10)
+#define BUTTON_Y           (1 << 11)
+#define BUTTON_SELECT      (1 << 2)
+#define BUTTON_START       (1 << 3)
+#define BUTTON_RIGHT       (1 << 4)
+#define BUTTON_LEFT        (1 << 5)
+#define BUTTON_UP          (1 << 6)
+#define BUTTON_DOWN        (1 << 7)

loader/source/fatfs/ff.c

@@ -1314,7 +1314,7 @@ int cmp_lfn (			/* 1:Matched, 0:Not matched */
 }
 
 
-
+#if _FS_MINIMIZE <= 1 || _USE_LABEL || _FS_RPATH >= 2
 static
 int pick_lfn (			/* 1:Succeeded, 0:Buffer overflow */
 	WCHAR* lfnbuf,		/* Pointer to the Unicode-LFN buffer */
@@ -1345,6 +1345,7 @@ int pick_lfn (			/* 1:Succeeded, 0:Buffer overflow */
 
 	return 1;
 }
+#endif
 
 
 #if !_FS_READONLY
@@ -1385,7 +1386,7 @@ void fit_lfn (
 /*-----------------------------------------------------------------------*/
 /* Create numbered name                                                  */
 /*-----------------------------------------------------------------------*/
-#if _USE_LFN
+#if _USE_LFN && !_FS_READONLY
 static
 void gen_numname (
 	BYTE* dst,			/* Pointer to the buffer to store numbered SFN */

loader/source/fatfs/option/syscall.c

@@ -1,151 +0,0 @@
-/*------------------------------------------------------------------------*/
-/* Sample code of OS dependent controls for FatFs                         */
-/* (C)ChaN, 2014                                                          */
-/*------------------------------------------------------------------------*/
-
-
-#include "../ff.h"
-
-
-#if _FS_REENTRANT
-/*------------------------------------------------------------------------*/
-/* Create a Synchronization Object */
-/*------------------------------------------------------------------------*/
-/* This function is called in f_mount() function to create a new
-/  synchronization object, such as semaphore and mutex. When a 0 is returned,
-/  the f_mount() function fails with FR_INT_ERR.
-*/
-
-int ff_cre_syncobj (	/* !=0:Function succeeded, ==0:Could not create due to any error */
-	BYTE vol,			/* Corresponding logical drive being processed */
-	_SYNC_t *sobj		/* Pointer to return the created sync object */
-)
-{
-	int ret;
-
-
-	*sobj = CreateMutex(NULL, FALSE, NULL);		/* Win32 */
-	ret = (int)(*sobj != INVALID_HANDLE_VALUE);
-
-//	*sobj = SyncObjects[vol];			/* uITRON (give a static created sync object) */
-//	ret = 1;							/* The initial value of the semaphore must be 1. */
-
-//	*sobj = OSMutexCreate(0, &err);		/* uC/OS-II */
-//	ret = (int)(err == OS_NO_ERR);
-
-//	*sobj = xSemaphoreCreateMutex();	/* FreeRTOS */
-//	ret = (int)(*sobj != NULL);
-
-	return ret;
-}
-
-
-
-/*------------------------------------------------------------------------*/
-/* Delete a Synchronization Object                                        */
-/*------------------------------------------------------------------------*/
-/* This function is called in f_mount() function to delete a synchronization
-/  object that created with ff_cre_syncobj function. When a 0 is returned,
-/  the f_mount() function fails with FR_INT_ERR.
-*/
-
-int ff_del_syncobj (	/* !=0:Function succeeded, ==0:Could not delete due to any error */
-	_SYNC_t sobj		/* Sync object tied to the logical drive to be deleted */
-)
-{
-	int ret;
-
-
-	ret = CloseHandle(sobj);	/* Win32 */
-
-//	ret = 1;					/* uITRON (nothing to do) */
-
-//	OSMutexDel(sobj, OS_DEL_ALWAYS, &err);	/* uC/OS-II */
-//	ret = (int)(err == OS_NO_ERR);
-
-//  vSemaphoreDelete(sobj);		/* FreeRTOS */
-//	ret = 1;
-
-	return ret;
-}
-
-
-
-/*------------------------------------------------------------------------*/
-/* Request Grant to Access the Volume                                     */
-/*------------------------------------------------------------------------*/
-/* This function is called on entering file functions to lock the volume.
-/  When a 0 is returned, the file function fails with FR_TIMEOUT.
-*/
-
-int ff_req_grant (	/* 1:Got a grant to access the volume, 0:Could not get a grant */
-	_SYNC_t sobj	/* Sync object to wait */
-)
-{
-	int ret;
-
-	ret = (int)(WaitForSingleObject(sobj, _FS_TIMEOUT) == WAIT_OBJECT_0);	/* Win32 */
-
-//	ret = (int)(wai_sem(sobj) == E_OK);			/* uITRON */
-
-//	OSMutexPend(sobj, _FS_TIMEOUT, &err));		/* uC/OS-II */
-//	ret = (int)(err == OS_NO_ERR);
-
-//	ret = (int)(xSemaphoreTake(sobj, _FS_TIMEOUT) == pdTRUE);	/* FreeRTOS */
-
-	return ret;
-}
-
-
-
-/*------------------------------------------------------------------------*/
-/* Release Grant to Access the Volume                                     */
-/*------------------------------------------------------------------------*/
-/* This function is called on leaving file functions to unlock the volume.
-*/
-
-void ff_rel_grant (
-	_SYNC_t sobj	/* Sync object to be signaled */
-)
-{
-	ReleaseMutex(sobj);		/* Win32 */
-
-//	sig_sem(sobj);			/* uITRON */
-
-//	OSMutexPost(sobj);		/* uC/OS-II */
-
-//	xSemaphoreGive(sobj);	/* FreeRTOS */
-}
-
-#endif
-
-
-
-
-#if _USE_LFN == 3	/* LFN with a working buffer on the heap */
-/*------------------------------------------------------------------------*/
-/* Allocate a memory block                                                */
-/*------------------------------------------------------------------------*/
-/* If a NULL is returned, the file function fails with FR_NOT_ENOUGH_CORE.
-*/
-
-void* ff_memalloc (	/* Returns pointer to the allocated memory block */
-	UINT msize		/* Number of bytes to allocate */
-)
-{
-	return malloc(msize);	/* Allocate a new memory block with POSIX API */
-}
-
-
-/*------------------------------------------------------------------------*/
-/* Free a memory block                                                    */
-/*------------------------------------------------------------------------*/
-
-void ff_memfree (
-	void* mblock	/* Pointer to the memory block to free */
-)
-{
-	free(mblock);	/* Discard the memory block with POSIX API */
-}
-
-#endif

loader/source/fatfs/sdmmc/common.h

@@ -1,15 +1,4 @@
 #pragma once
 
-#include <stdint.h>
-#include <stddef.h>
 #include <stdbool.h>
-
-#define u8 uint8_t
-#define u16 uint16_t
-#define u32 uint32_t
-#define u64 uint64_t
-
-#define vu8 volatile u8
-#define vu16 volatile u16
-#define vu32 volatile u32
-#define vu64 volatile u64
+#include "../../types.h"

loader/source/fatfs/sdmmc/delay.h

@@ -6,4 +6,4 @@
 
 #include "common.h"
 
-void waitcycles(u32 us);
+void ioDelay(u32 us);

loader/source/fatfs/sdmmc/delay.s

@@ -1,15 +1,17 @@
-.arm
-.global waitcycles
-.type   waitcycles STT_FUNC
+// Copyright 2014 Normmatt
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
 
-@waitcycles ( u32 us )
-waitcycles:
-	PUSH    {R0-R2,LR}
-	STR     R0, [SP,#4]
-	waitcycles_loop:
-		LDR     R3, [SP,#4]
-		SUBS    R2, R3, #1
-		STR     R2, [SP,#4]
-		CMP     R3, #0
-		BNE     waitcycles_loop
-	POP     {R0-R2,PC}
+.arm
+.global ioDelay
+.type   ioDelay STT_FUNC
+
+@ioDelay ( u32 us )
+ioDelay:
+	ldr r1, =0x18000000  @ VRAM
+1:
+	@ Loop doing uncached reads from VRAM to make loop timing more reliable
+	ldr r2, [r1]
+	subs r0, #1
+	bgt 1b
+	bx lr

loader/source/fatfs/sdmmc/sdmmc.c

@@ -286,7 +286,7 @@ static void InitSD()
 static int Nand_Init()
 {
     inittarget(&handleNAND);
-    waitcycles(0xF000);
+    ioDelay(0xF000);
 
     sdmmc_send_command(&handleNAND,0,0);
 
@@ -337,7 +337,7 @@ static int SD_Init()
 {
     inittarget(&handleSD);
 
-    waitcycles(1u << 18); //Card needs a little bit of time to be detected, it seems
+    ioDelay(1u << 18); //Card needs a little bit of time to be detected, it seems
     
     //If not inserted
     if (!(*((vu16*)0x1000601c) & TMIO_STAT0_SIGSTATE)) return -1;

loader/source/fatfs/sdmmc/sdmmc.h

@@ -125,4 +125,3 @@ mmcdevice *getMMCDevice(int drive);
 
 u32 sdmmc_nand_readsectors(u32 sector_no, u32 numsectors, vu8 *out);
 u32 sdmmc_nand_writesectors(u32 sector_no, u32 numsectors, vu8 *in);
-

loader/source/i2c.c

@@ -0,0 +1,149 @@
+#include "i2c.h"
+
+//-----------------------------------------------------------------------------
+
+static const struct { u8 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},
+};
+
+inline u8 i2cGetDeviceBusId(u8 device_id) {
+    return dev_data[device_id].bus_id;
+}
+
+inline u8 i2cGetDeviceRegAddr(u8 device_id) {
+    return dev_data[device_id].reg_addr;
+}
+
+//-----------------------------------------------------------------------------
+
+static vu8* reg_data_addrs[] = {
+    (vu8*)(I2C1_REG_OFF + I2C_REG_DATA),
+    (vu8*)(I2C2_REG_OFF + I2C_REG_DATA),
+    (vu8*)(I2C3_REG_OFF + I2C_REG_DATA),
+};
+
+inline vu8* i2cGetDataReg(u8 bus_id) {
+    return reg_data_addrs[bus_id];
+}
+
+//-----------------------------------------------------------------------------
+
+static vu8* reg_cnt_addrs[] = {
+    (vu8*)(I2C1_REG_OFF + I2C_REG_CNT),
+    (vu8*)(I2C2_REG_OFF + I2C_REG_CNT),
+    (vu8*)(I2C3_REG_OFF + I2C_REG_CNT),
+};
+
+inline vu8* i2cGetCntReg(u8 bus_id) {
+    return reg_cnt_addrs[bus_id];
+}
+
+//-----------------------------------------------------------------------------
+
+inline void i2cWaitBusy(u8 bus_id) {
+    while (*i2cGetCntReg(bus_id) & 0x80);
+}
+
+inline bool i2cGetResult(u8 bus_id) {
+    i2cWaitBusy(bus_id);
+    return (*i2cGetCntReg(bus_id) >> 4) & 1;
+}
+
+void i2cStop(u8 bus_id, u8 arg0) {
+    *i2cGetCntReg(bus_id) = (arg0 << 5) | 0xC0;
+    i2cWaitBusy(bus_id);
+    *i2cGetCntReg(bus_id) = 0xC5;
+}
+
+//-----------------------------------------------------------------------------
+
+bool i2cSelectDevice(u8 bus_id, u8 dev_reg) {
+    i2cWaitBusy(bus_id);
+    *i2cGetDataReg(bus_id) = dev_reg;
+    *i2cGetCntReg(bus_id) = 0xC2;
+    return i2cGetResult(bus_id);
+}
+
+bool i2cSelectRegister(u8 bus_id, u8 reg) {
+    i2cWaitBusy(bus_id);
+    *i2cGetDataReg(bus_id) = reg;
+    *i2cGetCntReg(bus_id) = 0xC0;
+    return i2cGetResult(bus_id);
+}
+
+//-----------------------------------------------------------------------------
+
+u8 i2cReadRegister(u8 dev_id, u8 reg) {
+    u8 bus_id = i2cGetDeviceBusId(dev_id);
+    u8 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 | 1)) {
+                i2cWaitBusy(bus_id);
+                i2cStop(bus_id, 1);
+                i2cWaitBusy(bus_id);
+                return *i2cGetDataReg(bus_id);
+            }
+        }
+        *i2cGetCntReg(bus_id) = 0xC5;
+        i2cWaitBusy(bus_id);
+    }
+    return 0xff;
+}
+
+bool i2cReadRegisterBuffer(unsigned int dev_id, int reg, u8* buffer, size_t buf_size) {
+    u8 bus_id = i2cGetDeviceBusId(dev_id);
+    u8 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))
+    {
+        i2cWaitBusy(bus_id);
+        *i2cGetCntReg(bus_id) = 0xC5;
+        i2cWaitBusy(bus_id);
+        if (++j >= 8)
+            return false;
+    }
+
+    if (buf_size != 1) {
+        for (size_t i = 0; i < buf_size - 1; i++) {
+            i2cWaitBusy(bus_id);
+            *i2cGetCntReg(bus_id) = 0xF0;
+            i2cWaitBusy(bus_id);
+            buffer[i] = *i2cGetDataReg(bus_id);
+        }
+    }
+
+    i2cWaitBusy(bus_id);
+    *i2cGetCntReg(bus_id) = 0xE1;
+    i2cWaitBusy(bus_id);
+    *buffer = *i2cGetDataReg(bus_id);
+    return true;
+}
+
+bool i2cWriteRegister(u8 dev_id, u8 reg, u8 data) {
+    u8 bus_id = i2cGetDeviceBusId(dev_id);
+    u8 dev_addr = i2cGetDeviceRegAddr(dev_id);
+
+    for (int i = 0; i < 8; i++) {
+        if (i2cSelectDevice(bus_id, dev_addr) && i2cSelectRegister(bus_id, reg)) {
+            i2cWaitBusy(bus_id);
+            *i2cGetDataReg(bus_id) = data;
+            *i2cGetCntReg(bus_id) = 0xC1;
+            i2cStop(bus_id, 0);
+            if (i2cGetResult(bus_id))
+                return true;
+        }
+        *i2cGetCntReg(bus_id) = 0xC5;
+        i2cWaitBusy(bus_id);
+    }
+
+    return false;
+}

loader/source/i2c.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "common.h"
+
+#define I2C1_REG_OFF 0x10161000
+#define I2C2_REG_OFF 0x10144000
+#define I2C3_REG_OFF 0x10148000
+
+#define I2C_REG_DATA  0
+#define I2C_REG_CNT   1
+#define I2C_REG_CNTEX 2
+#define I2C_REG_SCL   4
+
+#define I2C_DEV_MCU  3
+#define I2C_DEV_GYRO 10
+#define I2C_DEV_IR   13
+
+u8 i2cGetDeviceBusId(u8 device_id);
+u8 i2cGetDeviceRegAddr(u8 device_id);
+
+vu8* i2cGetDataReg(u8 bus_id);
+vu8* i2cGetCntReg(u8 bus_id);
+
+void i2cWaitBusy(u8 bus_id);
+bool i2cGetResult(u8 bus_id);
+u8 i2cGetData(u8 bus_id);
+void i2cStop(u8 bus_id, u8 arg0);
+
+bool i2cSelectDevice(u8 bus_id, u8 dev_reg);
+bool i2cSelectRegister(u8 bus_id, u8 reg);
+
+u8 i2cReadRegister(u8 dev_id, u8 reg);
+bool i2cWriteRegister(u8 dev_id, u8 reg, u8 data);
+
+bool i2cReadRegisterBuffer(unsigned int dev_id, int reg, u8* buffer, size_t buf_size);

loader/source/main.c

@@ -1,19 +1,42 @@
+#include "types.h"
+#include "buttons.h"
+#include "screeninit.h"
 #include "fatfs/ff.h"
 
 #define PAYLOAD_ADDRESS	0x23F00000
 
-int main()
-{
-    FATFS fs;
+u32 loadPayload(const char *path){
     FIL payload;
     unsigned int br;
-	
-    f_mount(&fs, "0:", 1);
-    if(f_open(&payload, "rei/arm9payload.bin", FA_READ) == FR_OK)
+    if(f_open(&payload, path, FA_READ) == FR_OK)
     {
-        f_read(&payload, (void *)PAYLOAD_ADDRESS, f_size(&payload), &br);
-        ((void (*)())PAYLOAD_ADDRESS)();
-    }
+        f_read(&payload, (void*)PAYLOAD_ADDRESS, f_size(&payload), &br);
+        f_close(&payload);
 
         return 1;
+    }
+
+    return 0;
+}
+
+void main(){
+    FATFS fs;
+    f_mount(&fs, "0:", 1);
+
+    //Get pressed buttons
+    u16 pressed = HID_PAD;
+
+    if(((pressed & BUTTON_B) && loadPayload("/rei/payloads/b.bin")) ||
+       ((pressed & BUTTON_X) && loadPayload("/rei/payloads/x.bin")) ||
+       ((pressed & BUTTON_Y) && loadPayload("/rei/payloads/y.bin")) ||
+       ((pressed & BUTTON_SELECT) && loadPayload("/rei/payloads/select.bin")) ||
+       ((pressed & BUTTON_START) && loadPayload("/rei/payloads/start.bin")) ||
+       ((pressed & BUTTON_RIGHT) && loadPayload("/rei/payloads/right.bin")) ||
+       ((pressed & BUTTON_LEFT) && loadPayload("/rei/payloads/left.bin")) ||
+       ((pressed & BUTTON_UP) && loadPayload("/rei/payloads/up.bin")) ||
+       ((pressed & BUTTON_DOWN) && loadPayload("/rei/payloads/down.bin")) ||
+       loadPayload("/rei/payloads/default.bin")){
+        initLCD();
+        ((void (*)())PAYLOAD_ADDRESS)();
+    }
 }

loader/source/screeninit.c

@@ -0,0 +1,118 @@
+#include "screeninit.h"
+#include "i2c.h"
+
+void initLCD()
+{
+    vu32 *const arm11 = (u32 *)0x1FFFFFF8;
+
+    void __attribute__((naked)) ARM11()
+    {
+        *(vu32 *)0x10141200 = 0x1007F;
+        *(vu32 *)0x10202014 = 0x00000001;
+        *(vu32 *)0x1020200C &= 0xFFFEFFFE;
+        *(vu32 *)0x10202240 = 0x39;
+        *(vu32 *)0x10202A40 = 0x39;
+        *(vu32 *)0x10202244 = 0x1023E;
+        *(vu32 *)0x10202A44 = 0x1023E;
+
+        // Top screen
+        *(vu32 *)0x10400400 = 0x000001c2;
+        *(vu32 *)0x10400404 = 0x000000d1;
+        *(vu32 *)0x10400408 = 0x000001c1;
+        *(vu32 *)0x1040040c = 0x000001c1;
+        *(vu32 *)0x10400410 = 0x00000000;
+        *(vu32 *)0x10400414 = 0x000000cf;
+        *(vu32 *)0x10400418 = 0x000000d1;
+        *(vu32 *)0x1040041c = 0x01c501c1;
+        *(vu32 *)0x10400420 = 0x00010000;
+        *(vu32 *)0x10400424 = 0x0000019d;
+        *(vu32 *)0x10400428 = 0x00000002;
+        *(vu32 *)0x1040042c = 0x00000192;
+        *(vu32 *)0x10400430 = 0x00000192;
+        *(vu32 *)0x10400434 = 0x00000192;
+        *(vu32 *)0x10400438 = 0x00000001;
+        *(vu32 *)0x1040043c = 0x00000002;
+        *(vu32 *)0x10400440 = 0x01960192;
+        *(vu32 *)0x10400444 = 0x00000000;
+        *(vu32 *)0x10400448 = 0x00000000;
+        *(vu32 *)0x1040045C = 0x00f00190;
+        *(vu32 *)0x10400460 = 0x01c100d1;
+        *(vu32 *)0x10400464 = 0x01920002;
+        *(vu32 *)0x10400468 = 0x18300000;
+        *(vu32 *)0x10400470 = 0x80341;
+        *(vu32 *)0x10400474 = 0x00010501;
+        *(vu32 *)0x10400478 = 0;
+        *(vu32 *)0x10400490 = 0x000002D0;
+        *(vu32 *)0x1040049C = 0x00000000;
+
+        // Disco register
+        for(vu32 i = 0; i < 256; i++)
+            *(vu32 *)0x10400484 = 0x10101 * i;
+
+        // Bottom screen
+        *(vu32 *)0x10400500 = 0x000001c2;
+        *(vu32 *)0x10400504 = 0x000000d1;
+        *(vu32 *)0x10400508 = 0x000001c1;
+        *(vu32 *)0x1040050c = 0x000001c1;
+        *(vu32 *)0x10400510 = 0x000000cd;
+        *(vu32 *)0x10400514 = 0x000000cf;
+        *(vu32 *)0x10400518 = 0x000000d1;
+        *(vu32 *)0x1040051c = 0x01c501c1;
+        *(vu32 *)0x10400520 = 0x00010000;
+        *(vu32 *)0x10400524 = 0x0000019d;
+        *(vu32 *)0x10400528 = 0x00000052;
+        *(vu32 *)0x1040052c = 0x00000192;
+        *(vu32 *)0x10400530 = 0x00000192;
+        *(vu32 *)0x10400534 = 0x0000004f;
+        *(vu32 *)0x10400538 = 0x00000050;
+        *(vu32 *)0x1040053c = 0x00000052;
+        *(vu32 *)0x10400540 = 0x01980194;
+        *(vu32 *)0x10400544 = 0x00000000;
+        *(vu32 *)0x10400548 = 0x00000011;
+        *(vu32 *)0x1040055C = 0x00f00140;
+        *(vu32 *)0x10400560 = 0x01c100d1;
+        *(vu32 *)0x10400564 = 0x01920052;
+        *(vu32 *)0x10400568 = 0x18300000 + 0x46500;
+        *(vu32 *)0x10400570 = 0x80301;
+        *(vu32 *)0x10400574 = 0x00010501;
+        *(vu32 *)0x10400578 = 0;
+        *(vu32 *)0x10400590 = 0x000002D0;
+        *(vu32 *)0x1040059C = 0x00000000;
+
+        // Disco register
+        for(vu32 i = 0; i < 256; i++)
+            *(vu32 *)0x10400584 = 0x10101 * i;
+
+        // Enable backlight
+        i2cWriteRegister(I2C_DEV_MCU, 0x22, 0x2A);
+
+        *(vu32 *)0x10400468 = 0x18300000;
+        *(vu32 *)0x1040046c = 0x18300000;
+        *(vu32 *)0x10400494 = 0x18300000;
+        *(vu32 *)0x10400498 = 0x18300000;
+        *(vu32 *)0x10400568 = 0x18346500;
+        *(vu32 *)0x1040056c = 0x18346500;
+
+        //Clear ARM11 entry offset
+        *arm11 = 0;
+
+        //Wait for the entry to be set
+        while(!*arm11);
+        //Jump to it
+        ((void (*)())*arm11)();
+    }
+
+    //Determine if screen was already inited
+    if(*(vu8 *)0x10141200 != 0x1) return;
+
+    //Set CakeBrah framebuffers
+    *(vu32 *)0x23FFFE00 = 0x18300000;
+    *(vu32 *)0x23FFFE04 = 0x18300000;
+    *(vu32 *)0x23FFFE08 = 0x18346500;
+
+    *arm11 = (u32)ARM11;
+
+    //This delay is needed for some reason
+    for(vu32 i = 0; i < 0x2000; ++i);
+    while(*arm11);
+}

loader/source/screeninit.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "types.h"
+
+void initLCD();

loader/source/types.h

@@ -0,0 +1,20 @@
+/*
+*   types.h
+*       by Reisyukaku
+*   Copyright (c) 2015 All Rights Reserved
+*/
+
+#pragma once
+
+#include <stdint.h>
+#include <stdlib.h>
+
+//Common data types
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+typedef volatile u8 vu8;
+typedef volatile u16 vu16;
+typedef volatile u32 vu32;
+typedef volatile u64 vu64;

source/crypto.c

@@ -54,10 +54,10 @@ __asm__\
 }
 #endif /*__thumb__*/
 
-void aes_setkey(u8 keyslot, const void* key, u32 keyType, u32 mode)
+static void aes_setkey(u8 keyslot, const void *key, u32 keyType, u32 mode)
 {
 	if(keyslot <= 0x03) return; // Ignore TWL keys for now
-	u32 * key32 = (u32 *)key;
+	u32 *key32 = (u32 *)key;
 	*REG_AESCNT = (*REG_AESCNT & ~(AES_CNT_INPUT_ENDIAN | AES_CNT_INPUT_ORDER)) | mode;
 	*REG_AESKEYCNT = (*REG_AESKEYCNT >> 6 << 6) | keyslot | AES_KEYCNT_WRITE;
 
@@ -67,7 +67,7 @@ void aes_setkey(u8 keyslot, const void* key, u32 keyType, u32 mode)
 	REG_AESKEYFIFO[keyType] = key32[3];
 }
 
-void aes_use_keyslot(u8 keyslot)
+static void aes_use_keyslot(u8 keyslot)
 {
 	if(keyslot > 0x3F)
 		return;
@@ -76,7 +76,7 @@ void aes_use_keyslot(u8 keyslot)
 	*REG_AESCNT = *REG_AESCNT | 0x04000000; /* mystery bit */
 }
 
-void aes_setiv(const void* iv, u32 mode)
+static void aes_setiv(const void *iv, u32 mode)
 {
 	const u32 *iv32 = (const u32 *)iv;
 	*REG_AESCNT = (*REG_AESCNT & ~(AES_CNT_INPUT_ENDIAN | AES_CNT_INPUT_ORDER)) | mode;
@@ -98,9 +98,9 @@ void aes_setiv(const void* iv, u32 mode)
 	}
 }
 
-void aes_advctr(void *ctr, u32 val, u32 mode)
+static void aes_advctr(void *ctr, u32 val, u32 mode)
 {
-	u32 *ctr32 = (u32*)ctr;
+	u32 *ctr32 = (u32 *)ctr;
 	
 	int i;
 	if(mode & AES_INPUT_BE)
@@ -125,7 +125,7 @@ void aes_advctr(void *ctr, u32 val, u32 mode)
 	}
 }
 
-void aes_change_ctrmode(void *ctr, u32 fromMode, u32 toMode)
+static void aes_change_ctrmode(void *ctr, u32 fromMode, u32 toMode)
 {
 	u32 *ctr32 = (u32 *)ctr;
 	int i;
@@ -147,7 +147,7 @@ void aes_change_ctrmode(void *ctr, u32 fromMode, u32 toMode)
 	}
 }
 
-void aes_batch(void *dst, const void *src, u32 blockCount)
+static void aes_batch(void *dst, const void *src, u32 blockCount)
 {
 	*REG_AESBLKCNT = blockCount << 16;
 	*REG_AESCNT |=	AES_CNT_START;
@@ -180,7 +180,7 @@ void aes_batch(void *dst, const void *src, u32 blockCount)
 	}
 }
 
-void aes(void *dst, const void *src, u32 blockCount, void *iv, u32 mode, u32 ivMode)
+static void aes(void *dst, const void *src, u32 blockCount, void *iv, u32 mode, u32 ivMode)
 {
 	*REG_AESCNT =	mode |
 					AES_CNT_INPUT_ORDER | AES_CNT_OUTPUT_ORDER |
@@ -228,12 +228,12 @@ void aes(void *dst, const void *src, u32 blockCount, void *iv, u32 mode, u32 ivM
 ****************************************************************/
 
 //Nand key#2 (0x12C10)
-const u8 key2[0x10] = {
+static const u8 key2[0x10] = {
     0x42, 0x3F, 0x81, 0x7A, 0x23, 0x52, 0x58, 0x31, 0x6E, 0x75, 0x8E, 0x3A, 0x39, 0x43, 0x2E, 0xD0
 };
 
 //Get Nand CTR key
-void getNandCTR(u8 *buf, u32 console){
+static void getNandCTR(u8 *buf, u32 console){
     u8 *addr = (console ? (u8 *)0x080D8BBC : (u8 *)0x080D797C) + 0x0F;
     for(u8 keyLen = 0x10; keyLen; keyLen--)
         *(buf++) = *(addr--);

source/crypto.h

@@ -1,22 +1,21 @@
 // From http://github.com/b1l1s/ctr
 
-#ifndef CRYPTO_INC
-#define CRYPTO_INC
+#pragma once
 
 #include "types.h"
 
 /**************************AES****************************/
-#define REG_AESCNT				((volatile u32*)0x10009000)
-#define REG_AESBLKCNT			((volatile u32*)0x10009004)
-#define REG_AESWRFIFO			((volatile u32*)0x10009008)
-#define REG_AESRDFIFO			((volatile u32*)0x1000900C)
-#define REG_AESKEYSEL			((volatile u8 *)0x10009010)
-#define REG_AESKEYCNT			((volatile u8 *)0x10009011)
-#define REG_AESCTR				((volatile u32*)0x10009020)
+#define REG_AESCNT		((vu32 *)0x10009000)
+#define REG_AESBLKCNT		((vu32 *)0x10009004)
+#define REG_AESWRFIFO		((vu32 *)0x10009008)
+#define REG_AESRDFIFO		((vu32 *)0x1000900C)
+#define REG_AESKEYSEL		((vu8 *)0x10009010)
+#define REG_AESKEYCNT		((vu8 *)0x10009011)
+#define REG_AESCTR		((vu32 *)0x10009020)
 
-#define REG_AESKEYFIFO			((volatile u32*)0x10009100)
-#define REG_AESKEYXFIFO			((volatile u32*)0x10009104)
-#define REG_AESKEYYFIFO			((volatile u32*)0x10009108)
+#define REG_AESKEYFIFO		((vu32 *)0x10009100)
+#define REG_AESKEYXFIFO		((vu32 *)0x10009104)
+#define REG_AESKEYYFIFO		((vu32 *)0x10009108)
 
 #define AES_CCM_DECRYPT_MODE	(0u << 27)
 #define AES_CCM_ENCRYPT_MODE	(1u << 27)
@@ -52,5 +51,3 @@
 void nandFirm0(u8 *outbuf, u32 size, u32 console);
 void decArm9Bin(u8 *armHdr, u32 mode);
 void setKeyXs(u8 *armHdr);
-
-#endif

source/draw.c

@@ -8,36 +8,41 @@
 #include "fs.h"
 #include "memory.h"
 
-static struct fb *fb = (struct fb *)0x23FFFE00;
+static const struct fb {
+    u8 *top_left;
+    u8 *top_right;
+    u8 *bottom;
+} *const fb = (struct fb *)0x23FFFE00;
 
-void shutdownLCD(void){
+void __attribute__((naked)) shutdownLCD(void){
 
-    vu32 *arm11 = (vu32 *)0x1FFFFFF8;
+    vu32 *const arm11 = (u32 *)0x1FFFFFF8;
 
     //Clear ARM11 entry offset
     *arm11 = 0;
 
     //Shutdown LCDs
-    *(vu32*)0x10202A44 = 0;
-    *(vu32*)0x10202244 = 0;
-    *(vu32*)0x10202014 = 0;
+    *(vu32 *)0x10202A44 = 0;
+    *(vu32 *)0x10202244 = 0;
+    *(vu32 *)0x10202014 = 0;
     
-    //Wait for the ARM11 entrypoint to be set
+    //Wait for the entry to be set
     while(!*arm11);
     //Jump to it
     ((void (*)())*arm11)();
 }
 
-void clearScreen(void){
+static void clearScreen(void){
     memset(fb->top_left, 0, 0x46500);
     memset(fb->top_right, 0, 0x46500);
     memset(fb->bottom, 0, 0x38400);
 }
 
 void loadSplash(void){
-    //Check if it's a no-screen-init A9LH boot via PDN_GPU_CNT
-    if(*(u8 *)0x10141200 == 0x1) return;
     clearScreen();
-    if(!fileRead(fb->top_left, "/rei/splash.bin", 0x46500)) return;
+    //Don't delay boot if no splash image is on the SD
+    if(fileRead(fb->top_left, "/rei/splash.bin", 0x46500) +
+       fileRead(fb->bottom, "/rei/splashbottom.bin", 0x38400)){
         u64 i = 0xFFFFFF; while(--i) __asm("mov r0, r0"); //Less Ghetto sleep func
+    }
 }

source/draw.h

@@ -4,18 +4,9 @@
 *   Copyright (c) 2015 All Rights Reserved
 */
 
-#ifndef DRAW_INC
-#define DRAW_INC
+#pragma once
 
 #include "types.h"
 
-struct fb {
-    u8 *top_left;
-    u8 *top_right;
-    u8 *bottom;
-};
-
 void loadSplash(void);
-void shutdownLCD(void);
-
-#endif
+void __attribute__((naked)) shutdownLCD(void);

source/emunand.c

@@ -8,15 +8,20 @@
 #include "memory.h"
 #include "fatfs/sdmmc/sdmmc.h"
 
-static u8 *temp = (u8 *)0x24300000;
+void getEmunandSect(u32 *off, u32 *head, u32 emuNAND){
+    u8 *const temp = (u8 *)0x24300000;
 
-void getEmunandSect(u32 *off, u32 *head){
     u32 nandSize = getMMCDevice(0)->total_size;
-    if(sdmmc_sdcard_readsectors(nandSize, 1, temp) == 0){
+    u32 nandOffset = emuNAND == 1 ? 0 :
+                                  (nandSize > 0x200000 ? 0x400000 : 0x200000);
+
+    if(sdmmc_sdcard_readsectors(nandOffset + nandSize, 1, temp) == 0){
         if(*(u32 *)(temp + 0x100) == NCSD_MAGIC){
-            *off = 0;
-            *head = nandSize;
+            *off = nandOffset;
+            *head = nandOffset + nandSize;
         }
+        //Fallback to the first emuNAND if there's no second one
+        else if(emuNAND == 2) getEmunandSect(off, head, 1);
     }
 }
 

source/emunand.h

@@ -4,16 +4,13 @@
 *   Copyright (c) 2015 All Rights Reserved
 */
 
-#ifndef EMUNAND_INC
-#define EMUNAND_INC
+#pragma once
 
 #include "types.h"
 
 #define NCSD_MAGIC (0x4453434E)
 
-void getEmunandSect(u32 *off, u32 *head);
+void getEmunandSect(u32 *off, u32 *head, u32 emuNAND);
 void getSDMMC(void *pos, u32 *off, u32 size);
 void getEmuRW(void *pos, u32 size, u32 *readOff, u32 *writeOff);
 void getMPU(void *pos, u32 *off, u32 size);
-
-#endif

source/fatfs/ff.c

@@ -1314,7 +1314,7 @@ int cmp_lfn (			/* 1:Matched, 0:Not matched */
 }
 
 
-
+#if _FS_MINIMIZE <= 1 || _USE_LABEL || _FS_RPATH >= 2
 static
 int pick_lfn (			/* 1:Succeeded, 0:Buffer overflow */
 	WCHAR* lfnbuf,		/* Pointer to the Unicode-LFN buffer */
@@ -1345,6 +1345,7 @@ int pick_lfn (			/* 1:Succeeded, 0:Buffer overflow */
 
 	return 1;
 }
+#endif
 
 
 #if !_FS_READONLY
@@ -1385,7 +1386,7 @@ void fit_lfn (
 /*-----------------------------------------------------------------------*/
 /* Create numbered name                                                  */
 /*-----------------------------------------------------------------------*/
-#if _USE_LFN
+#if _USE_LFN && !_FS_READONLY
 static
 void gen_numname (
 	BYTE* dst,			/* Pointer to the buffer to store numbered SFN */

source/fatfs/option/syscall.c

@@ -1,151 +0,0 @@
-/*------------------------------------------------------------------------*/
-/* Sample code of OS dependent controls for FatFs                         */
-/* (C)ChaN, 2014                                                          */
-/*------------------------------------------------------------------------*/
-
-
-#include "../ff.h"
-
-
-#if _FS_REENTRANT
-/*------------------------------------------------------------------------*/
-/* Create a Synchronization Object */
-/*------------------------------------------------------------------------*/
-/* This function is called in f_mount() function to create a new
-/  synchronization object, such as semaphore and mutex. When a 0 is returned,
-/  the f_mount() function fails with FR_INT_ERR.
-*/
-
-int ff_cre_syncobj (	/* !=0:Function succeeded, ==0:Could not create due to any error */
-	BYTE vol,			/* Corresponding logical drive being processed */
-	_SYNC_t *sobj		/* Pointer to return the created sync object */
-)
-{
-	int ret;
-
-
-	*sobj = CreateMutex(NULL, FALSE, NULL);		/* Win32 */
-	ret = (int)(*sobj != INVALID_HANDLE_VALUE);
-
-//	*sobj = SyncObjects[vol];			/* uITRON (give a static created sync object) */
-//	ret = 1;							/* The initial value of the semaphore must be 1. */
-
-//	*sobj = OSMutexCreate(0, &err);		/* uC/OS-II */
-//	ret = (int)(err == OS_NO_ERR);
-
-//	*sobj = xSemaphoreCreateMutex();	/* FreeRTOS */
-//	ret = (int)(*sobj != NULL);
-
-	return ret;
-}
-
-
-
-/*------------------------------------------------------------------------*/
-/* Delete a Synchronization Object                                        */
-/*------------------------------------------------------------------------*/
-/* This function is called in f_mount() function to delete a synchronization
-/  object that created with ff_cre_syncobj function. When a 0 is returned,
-/  the f_mount() function fails with FR_INT_ERR.
-*/
-
-int ff_del_syncobj (	/* !=0:Function succeeded, ==0:Could not delete due to any error */
-	_SYNC_t sobj		/* Sync object tied to the logical drive to be deleted */
-)
-{
-	int ret;
-
-
-	ret = CloseHandle(sobj);	/* Win32 */
-
-//	ret = 1;					/* uITRON (nothing to do) */
-
-//	OSMutexDel(sobj, OS_DEL_ALWAYS, &err);	/* uC/OS-II */
-//	ret = (int)(err == OS_NO_ERR);
-
-//  vSemaphoreDelete(sobj);		/* FreeRTOS */
-//	ret = 1;
-
-	return ret;
-}
-
-
-
-/*------------------------------------------------------------------------*/
-/* Request Grant to Access the Volume                                     */
-/*------------------------------------------------------------------------*/
-/* This function is called on entering file functions to lock the volume.
-/  When a 0 is returned, the file function fails with FR_TIMEOUT.
-*/
-
-int ff_req_grant (	/* 1:Got a grant to access the volume, 0:Could not get a grant */
-	_SYNC_t sobj	/* Sync object to wait */
-)
-{
-	int ret;
-
-	ret = (int)(WaitForSingleObject(sobj, _FS_TIMEOUT) == WAIT_OBJECT_0);	/* Win32 */
-
-//	ret = (int)(wai_sem(sobj) == E_OK);			/* uITRON */
-
-//	OSMutexPend(sobj, _FS_TIMEOUT, &err));		/* uC/OS-II */
-//	ret = (int)(err == OS_NO_ERR);
-
-//	ret = (int)(xSemaphoreTake(sobj, _FS_TIMEOUT) == pdTRUE);	/* FreeRTOS */
-
-	return ret;
-}
-
-
-
-/*------------------------------------------------------------------------*/
-/* Release Grant to Access the Volume                                     */
-/*------------------------------------------------------------------------*/
-/* This function is called on leaving file functions to unlock the volume.
-*/
-
-void ff_rel_grant (
-	_SYNC_t sobj	/* Sync object to be signaled */
-)
-{
-	ReleaseMutex(sobj);		/* Win32 */
-
-//	sig_sem(sobj);			/* uITRON */
-
-//	OSMutexPost(sobj);		/* uC/OS-II */
-
-//	xSemaphoreGive(sobj);	/* FreeRTOS */
-}
-
-#endif
-
-
-
-
-#if _USE_LFN == 3	/* LFN with a working buffer on the heap */
-/*------------------------------------------------------------------------*/
-/* Allocate a memory block                                                */
-/*------------------------------------------------------------------------*/
-/* If a NULL is returned, the file function fails with FR_NOT_ENOUGH_CORE.
-*/
-
-void* ff_memalloc (	/* Returns pointer to the allocated memory block */
-	UINT msize		/* Number of bytes to allocate */
-)
-{
-	return malloc(msize);	/* Allocate a new memory block with POSIX API */
-}
-
-
-/*------------------------------------------------------------------------*/
-/* Free a memory block                                                    */
-/*------------------------------------------------------------------------*/
-
-void ff_memfree (
-	void* mblock	/* Pointer to the memory block to free */
-)
-{
-	free(mblock);	/* Discard the memory block with POSIX API */
-}
-
-#endif

source/fatfs/sdmmc/common.h

@@ -1,15 +1,4 @@
 #pragma once
 
-#include <stdint.h>
-#include <stddef.h>
 #include <stdbool.h>
-
-#define u8 uint8_t
-#define u16 uint16_t
-#define u32 uint32_t
-#define u64 uint64_t
-
-#define vu8 volatile u8
-#define vu16 volatile u16
-#define vu32 volatile u32
-#define vu64 volatile u64
+#include "../../types.h"

source/fatfs/sdmmc/delay.h

@@ -6,4 +6,4 @@
 
 #include "common.h"
 
-void waitcycles(u32 us);
+void ioDelay(u32 us);

source/fatfs/sdmmc/delay.s

@@ -1,15 +1,17 @@
-.arm
-.global waitcycles
-.type   waitcycles STT_FUNC
+// Copyright 2014 Normmatt
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
 
-@waitcycles ( u32 us )
-waitcycles:
-	PUSH    {R0-R2,LR}
-	STR     R0, [SP,#4]
-	waitcycles_loop:
-		LDR     R3, [SP,#4]
-		SUBS    R2, R3, #1
-		STR     R2, [SP,#4]
-		CMP     R3, #0
-		BNE     waitcycles_loop
-	POP     {R0-R2,PC}
+.arm
+.global ioDelay
+.type   ioDelay STT_FUNC
+
+@ioDelay ( u32 us )
+ioDelay:
+	ldr r1, =0x18000000  @ VRAM
+1:
+	@ Loop doing uncached reads from VRAM to make loop timing more reliable
+	ldr r2, [r1]
+	subs r0, #1
+	bgt 1b
+	bx lr

source/fatfs/sdmmc/sdmmc.c

@@ -286,7 +286,7 @@ static void InitSD()
 static int Nand_Init()
 {
     inittarget(&handleNAND);
-    waitcycles(0xF000);
+    ioDelay(0xF000);
 
     sdmmc_send_command(&handleNAND,0,0);
 
@@ -337,7 +337,7 @@ static int SD_Init()
 {
     inittarget(&handleSD);
 
-    waitcycles(1u << 18); //Card needs a little bit of time to be detected, it seems
+    ioDelay(1u << 18); //Card needs a little bit of time to be detected, it seems
     
     //If not inserted
     if (!(*((vu16*)0x1000601c) & TMIO_STAT0_SIGSTATE)) return -1;

source/fatfs/sdmmc/sdmmc.h

@@ -125,4 +125,3 @@ mmcdevice *getMMCDevice(int drive);
 
 u32 sdmmc_nand_readsectors(u32 sector_no, u32 numsectors, vu8 *out);
 u32 sdmmc_nand_writesectors(u32 sector_no, u32 numsectors, vu8 *in);
-

source/firm.c

@@ -13,24 +13,24 @@
 #include "draw.h"
 #include "loader.h"
 
-firmHeader *firmLocation = (firmHeader *)0x24000000;
-firmSectionHeader *section;
-u32 firmSize = 0,
+static firmHeader *const firmLocation = (firmHeader *)0x24000000;
+static const firmSectionHeader *section;
+static u32 firmSize = 0,
            mode = 1,
            console = 1,
            emuNAND = 0,
            a9lhSetup = 0,
            updatedSys = 0,
            usePatchedFirm = 0;
-u16 pressed;
-char *firmPathPatched = NULL;
+static u16 pressed;
+static const char *firmPathPatched = NULL;
 
 void setupCFW(void){
 
-    //Determine if booting with A9LH via PDN_SPI_CNT
-    u8 a9lhBoot = (*(u8 *)0x101401C0 == 0x0) ? 1 : 0;
-    //Retrieve the last booted FIRM via CFG_BOOTENV
-    u8 previousFirm = *(u8 *)0x10010000;
+    //Determine if booting with A9LH
+    u32 a9lhBoot = (PDN_SPI_CNT == 0x0) ? 1 : 0;
+    //Retrieve the last booted FIRM
+    u8 previousFirm = CFG_BOOTENV;
     u32 overrideConfig = 0;
     const char lastConfigPath[] = "rei/lastbootcfg";
 
@@ -53,11 +53,11 @@ void setupCFW(void){
         fileRead(&tempConfig, lastConfigPath, 1);
 
         //Always force a sysNAND boot when quitting AGB_FIRM
-        if(previousFirm == 0x7) {
+        if(previousFirm == 0x7){
             if(!updatedSys) mode = tempConfig & 0x1;
             overrideConfig = 1;
         //Else, force the last used boot options unless A is pressed
-        } else if(!(pressed & BUTTON_A)) {
+        } else if(!(pressed & BUTTON_A)){
             mode = tempConfig & 0x1;
             emuNAND = (tempConfig >> 1) & 0x1;
             overrideConfig = 1;
@@ -69,6 +69,9 @@ void setupCFW(void){
         //If L and R are pressed, chainload an external payload
         if(a9lhBoot && (pressed & BUTTON_L1R1) == BUTTON_L1R1) loadPayload();
 
+        //Check if it's a no-screen-init A9LH boot
+        if(PDN_GPU_CNT != 0x1) loadSplash();
+
         /* If L is pressed, and on an updated SysNAND setup the SAFE MODE combo
            is not pressed, boot 9.0 FIRM */
         if((pressed & BUTTON_L1) && !(updatedSys && pressed == SAFEMODE)) mode = 0;
@@ -76,7 +79,11 @@ void setupCFW(void){
         /* If L or R aren't pressed on a 9.0/9.2 SysNAND, or the 9.0 FIRM is selected
            or R is pressed on a > 9.2 SysNAND, boot emuNAND */
         if((updatedSys && (!mode || ((pressed & BUTTON_R1) && pressed != SAFEMODE))) ||
-           (!updatedSys && mode && !(pressed & BUTTON_R1))) emuNAND = 1;
+           (!updatedSys && mode && !(pressed & BUTTON_R1))){
+            //If not 9.0 FIRM and B is pressed, attempt booting the second emuNAND
+            if(mode && (pressed & BUTTON_B)) emuNAND = 2;
+            else emuNAND = 1;
+        }
 
         //Write the current boot options on A9LH
         if(a9lhBoot){
@@ -85,7 +92,8 @@ void setupCFW(void){
         }
     }
 
-    if(mode) firmPathPatched = emuNAND ? "/rei/patched_firmware_emu.bin" :
+    if(mode) firmPathPatched = emuNAND ? (emuNAND == 1 ? "/rei/patched_firmware_emu.bin" :
+                                                        "/rei/patched_firmware_em2.bin") :
                                                         "/rei/patched_firmware_sys.bin";
 
     //Skip decrypting and patching FIRM
@@ -128,15 +136,15 @@ u32 loadFirm(void){
 }
 
 //Nand redirection
-u32 loadEmu(void){
+static u32 loadEmu(void){
 
-    u32 emuOffset = 0,
-        emuHeader = 0,
-        emuRead = 0,
-        emuWrite = 0,
-        sdmmcOffset = 0,
-        mpuOffset = 0,
-        emuCodeOffset = 0;
+    u32 emuOffset = 1,
+        emuHeader = 1,
+        emuRead,
+        emuWrite,
+        sdmmcOffset,
+        mpuOffset,
+        emuCodeOffset;
 
     //Read emunand code from SD
     const char path[] = "/rei/emunand/emunand.bin";
@@ -153,7 +161,7 @@ u32 loadEmu(void){
     u32 *pos_offset = (u32 *)memsearch((void *)emuCodeOffset, "NAND", size, 4);
     u32 *pos_header = (u32 *)memsearch((void *)emuCodeOffset, "NCSD", size, 4);
     getSDMMC(firmLocation, &sdmmcOffset, firmSize);
-    getEmunandSect(&emuOffset, &emuHeader);
+    getEmunandSect(&emuOffset, &emuHeader, emuNAND);
     getEmuRW(firmLocation, firmSize, &emuRead, &emuWrite);
     getMPU(firmLocation, &mpuOffset, firmSize);
     *pos_sdmmc = sdmmcOffset;
@@ -194,23 +202,21 @@ u32 patchFirm(void){
     }
 
     //Disable signature checks
-    u32 sigOffset = 0,
-        sigOffset2 = 0;
+    u32 sigOffset,
+        sigOffset2;
 
     getSignatures(firmLocation, firmSize, &sigOffset, &sigOffset2);
     memcpy((void *)sigOffset, sigPat1, sizeof(sigPat1));
     memcpy((void *)sigOffset2, sigPat2, sizeof(sigPat2));
 
     //Patch ARM9 entrypoint on N3DS to skip arm9loader
-    if(console){
-        u32 *arm9 = (u32 *)&firmLocation->arm9Entry;
-        *arm9 = 0x801B01C;
-    }
+    if(console)
+        firmLocation->arm9Entry = (u8 *)0x801B01C;
 
     //Patch FIRM reboots, not on 9.0 FIRM as it breaks firmlaunchhax
     if(mode){
-        u32 rebootOffset = 0,
-            fOpenOffset = 0;
+        u32 rebootOffset,
+            fOpenOffset;
 
         //Read reboot code from SD
         const char path[] = "/rei/reboot/reboot.bin";
@@ -227,7 +233,8 @@ u32 patchFirm(void){
         //Patch path for emuNAND-patched FIRM
         if(emuNAND){
             void *pos_path = memsearch((void *)rebootOffset, L"sy", size, 4);
-            memcpy(pos_path, L"emu", 5);
+            const wchar_t *path = emuNAND == 1 ? L"emu" : L"em2";
+            memcpy(pos_path, path, 5);
         }
     }
 
@@ -248,7 +255,7 @@ void launchFirm(void){
     memcpy(section[2].address, (u8 *)firmLocation + section[2].offset, section[2].size);
 
     //Run ARM11 screen stuff
-    vu32 *arm11 = (vu32 *)0x1FFFFFF8;
+    vu32 *const arm11 = (u32 *)0x1FFFFFF8;
     *arm11 = (u32)shutdownLCD;
     while(*arm11);
 

source/firm.h

@@ -4,22 +4,41 @@
 *   Copyright (c) 2015 All Rights Reserved
 */
 
-#ifndef FIRM_INC
-#define FIRM_INC
+#pragma once
 
 #include "types.h"
 
-#define PDN_MPCORE_CFG     (*(u8*)0x10140FFC)
-#define HID_PAD            ((~*(u16*)0x10146000) & 0xFFF)
+#define PDN_MPCORE_CFG     (*(vu8 *)0x10140FFC)
+#define HID_PAD            ((~*(vu16 *)0x10146000) & 0xFFF)
+#define PDN_SPI_CNT        (*(vu8 *)0x101401C0)
+#define CFG_BOOTENV        (*(vu8 *)0x10010000)
+#define PDN_GPU_CNT        (*(vu8 *)0x10141200)
 #define BUTTON_R1          (1 << 8)
 #define BUTTON_L1          (1 << 9)
 #define BUTTON_L1R1        (BUTTON_R1 | BUTTON_L1)
 #define BUTTON_A           1
+#define BUTTON_B           (1 << 1)
 #define SAFEMODE           (BUTTON_L1R1 | BUTTON_A | (1 << 6))
 
+//FIRM Header layout
+typedef struct firmSectionHeader {
+    u32 offset;
+    u8 *address;
+    u32 size;
+    u32 procType;
+    u8 hash[0x20];
+} firmSectionHeader;
+
+typedef struct firmHeader {
+    u32 magic;
+    u32 reserved1;
+    u8 *arm11Entry;
+    u8 *arm9Entry;
+    u8 reserved2[0x30];
+    firmSectionHeader section[4];
+} firmHeader;
+
 void setupCFW(void);
 u32 loadFirm(void);
 u32 patchFirm(void);
 void launchFirm(void);
-
-#endif

source/fs.c

@@ -52,7 +52,7 @@ u32 fileSize(const char *path){
 
 u32 fileExists(const char *path){
     FIL fp;
-    u8 exists = 0;
+    u32 exists = 0;
 
     if(f_open(&fp, path, FA_READ) == FR_OK) exists = 1;
 

source/fs.h

@@ -2,8 +2,7 @@
 *   fs.h
 */
 
-#ifndef FS_INC
-#define FS_INC
+#pragma once
 
 #include "types.h"
 
@@ -12,5 +11,3 @@ u32 fileRead(u8 *dest, const char *path, u32 size);
 u32 fileWrite(const u8 *buffer, const char *path, u32 size);
 u32 fileSize(const char *path);
 u32 fileExists(const char *path);
-
-#endif

source/loader.c

@@ -8,7 +8,7 @@
 #define PAYLOAD_ADDRESS	0x24F00000
 
 void loadPayload(void){
-    if(fileExists("rei/arm9payload.bin") &&
+    if(fileExists("rei/payloads/default.bin") &&
        fileRead((u8 *)PAYLOAD_ADDRESS, "rei/loader.bin", 0))
         ((void (*)())PAYLOAD_ADDRESS)();
 }

source/loader.h

@@ -2,11 +2,8 @@
 *   loader.h
 */
 
-#ifndef LOADER_INC
-#define LOADER_INC
+#pragma once
 
 #include "types.h"
 
 void loadPayload(void);
-
-#endif

source/main.c

@@ -8,7 +8,6 @@
 
 #include "fs.h"
 #include "firm.h"
-#include "draw.h"
 
 void main(){
     mountSD();
@@ -16,7 +15,6 @@ void main(){
 }
 
 void startCFW(){
-    loadSplash();
     if(!loadFirm()) return;
     if(!patchFirm()) return;
     launchFirm();

source/memory.h

@@ -4,8 +4,7 @@
 *   Copyright (c) 2015 All Rights Reserved
 */
 
-#ifndef MEMORY_INC
-#define MEMORY_INC
+#pragma once
 
 #include "types.h"
 
@@ -13,5 +12,3 @@ void memcpy(void *dest, const void *src, u32 size);
 void memset(void *dest, int filler, u32 size);
 int memcmp(const void *buf1, const void *buf2, u32 size);
 void *memsearch(void *start_pos, const void *search, u32 size, u32 size_search);
-
-#endif

source/patches.h

@@ -4,8 +4,7 @@
 *   Copyright (c) 2015 All Rights Reserved
 */
 
-#ifndef PATCHES_INC
-#define PATCHES_INC
+#pragma once
 
 #include "types.h"
 
@@ -26,5 +25,3 @@ void getSignatures(void *pos, u32 size, u32 *off, u32 *off2);
 void getReboot(void *pos, u32 size, u32 *off);
 void getfOpen(void *pos, u32 size, u32 *off);
 void getFIRMWrite(void *pos, u32 size, u32 *off);
-
-#endif

source/start.s

@@ -50,11 +50,9 @@ _start:
 
     @ Set cache settings
     mov r0, #0x25
-    mov r1, #0x25
-    mov r2, #0x25
     mcr p15, 0, r0, c3, c0, 0	@ Write bufferable 0, 2, 5
-    mcr p15, 0, r1, c2, c0, 0	@ Data cacheable 0, 2, 5
-    mcr p15, 0, r2, c2, c0, 1	@ Inst cacheable 0, 2, 5
+    mcr p15, 0, r0, c2, c0, 0	@ Data cacheable 0, 2, 5
+    mcr p15, 0, r0, c2, c0, 1	@ Inst cacheable 0, 2, 5
 
     bl startCFW
 

source/types.h

@@ -4,8 +4,7 @@
 *   Copyright (c) 2015 All Rights Reserved
 */
 
-#ifndef TYPES_INC
-#define TYPES_INC
+#pragma once
 
 #include <stdint.h>
 #include <stdlib.h>
@@ -15,27 +14,7 @@ typedef uint8_t u8;
 typedef uint16_t u16;
 typedef uint32_t u32;
 typedef uint64_t u64;
-typedef volatile uint8_t vu8;
-typedef volatile uint16_t vu16;
-typedef volatile uint32_t vu32;
-typedef volatile uint64_t vu64;
-
-//FIRM Header layout
-typedef struct firmSectionHeader {
-    u32 offset;
-    u8 *address;
-    u32 size;
-    u32 procType;
-    u8 hash[0x20];
-} firmSectionHeader;
-
-typedef struct firmHeader {
-    u32 magic;
-    u32 reserved1;
-    u8 *arm11Entry;
-    u8 *arm9Entry;
-    u8 reserved2[0x30];
-    firmSectionHeader section[4];
-} firmHeader;
-
-#endif
+typedef volatile u8 vu8;
+typedef volatile u16 vu16;
+typedef volatile u32 vu32;
+typedef volatile u64 vu64;