v1.6 (and like always, tranfer unmerged PRs)

And remove uneeded double press protection through sleep().

.gitignore

@@ -1,3 +1,4 @@
 .vs
 .vscode
 build_ipl/*
+/ipl.bin

ipl/btn.c

@@ -34,9 +34,24 @@ u32 btn_read()
 u32 btn_wait()
 {
 	u32 res = 0, btn = btn_read();
+	int pwr = 0;
+
+	// Power button down, raise a filter.
+	if (btn & BTN_POWER)
+	{
+		pwr = 1;
+		btn &= 0xFFFFFFFE;
+	}
+
 	do
 	{
 		res = btn_read();
+		// Power button up, remove filter.
+		if (!(res & BTN_POWER) && pwr)
+			pwr = 0;
+		// Power button still down.
+		else if (pwr)
+			res &= 0xFFFFFFFE;
 	} while (btn == res);
 	return res;
 }

ipl/ff.c

@@ -3,6 +3,7 @@
 /-----------------------------------------------------------------------------/
 /
 / Copyright (C) 2017, ChaN, all right reserved.
+/ Copyright (c) 2018 naehrwert
 /
 / FatFs module is an open source software. Redistribution and use of FatFs in
 / source and binary forms, with or without modification, are permitted provided
@@ -22,6 +23,11 @@
 #include "ff.h"			/* Declarations of FatFs API */
 #include "diskio.h"		/* Declarations of device I/O functions */
 
+#include "gfx.h"
+extern gfx_ctxt_t gfx_ctxt;
+extern gfx_con_t gfx_con;
+#define EFSPRINTF(text, ...) gfx_printf(&gfx_con, "\n\n%k[FatFS] "text"%k\n", 0xFF00FFFF, 0xFFFFFFFF)
+//#define EFSPRINTF(...)
 
 /*--------------------------------------------------------------------------
 
@@ -3253,6 +3259,7 @@ FRESULT find_volume (	/* FR_OK(0): successful, !=0: any error occurred */
 		stat = disk_status(fs->pdrv);
 		if (!(stat & STA_NOINIT)) {		/* and the physical drive is kept initialized */
 			if (!FF_FS_READONLY && mode && (stat & STA_PROTECT)) {	/* Check write protection if needed */
+				EFSPRINTF("Error: Write protected!");
 				return FR_WRITE_PROTECTED;
 			}
 			return FR_OK;				/* The filesystem object is valid */
@@ -3266,9 +3273,11 @@ FRESULT find_volume (	/* FR_OK(0): successful, !=0: any error occurred */
 	fs->pdrv = LD2PD(vol);				/* Bind the logical drive and a physical drive */
 	stat = disk_initialize(fs->pdrv);	/* Initialize the physical drive */
 	if (stat & STA_NOINIT) { 			/* Check if the initialization succeeded */
+		EFSPRINTF("Error: Medium not ready or hard error!");
 		return FR_NOT_READY;			/* Failed to initialize due to no medium or hard error */
 	}
 	if (!FF_FS_READONLY && mode && (stat & STA_PROTECT)) { /* Check disk write protection if needed */
+		EFSPRINTF("Error: Write protected!");
 		return FR_WRITE_PROTECTED;
 	}
 #if FF_MAX_SS != FF_MIN_SS				/* Get sector size (multiple sector size cfg only) */
@@ -3291,8 +3300,14 @@ FRESULT find_volume (	/* FR_OK(0): successful, !=0: any error occurred */
 			fmt = bsect ? check_fs(fs, bsect) : 3;	/* Check the partition */
 		} while (LD2PT(vol) == 0 && fmt >= 2 && ++i < 4);
 	}
-	if (fmt == 4) return FR_DISK_ERR;		/* An error occured in the disk I/O layer */
-	if (fmt >= 2) return FR_NO_FILESYSTEM;	/* No FAT volume is found */
+	if (fmt == 4) {
+		EFSPRINTF("Error: Disk I/O error - Could not load boot record!");
+		return FR_DISK_ERR;		/* An error occured in the disk I/O layer */
+	}
+	if (fmt >= 2) {
+		EFSPRINTF("Error: No FAT/FAT32/exFAT filesystem found!");
+		return FR_NO_FILESYSTEM;	/* No FAT volume is found */
+	}
 
 	/* An FAT volume is found (bsect). Following code initializes the filesystem object */
 
@@ -3303,36 +3318,58 @@ FRESULT find_volume (	/* FR_OK(0): successful, !=0: any error occurred */
 		for (i = BPB_ZeroedEx; i < BPB_ZeroedEx + 53 && fs->win[i] == 0; i++) ;	/* Check zero filler */
 		if (i < BPB_ZeroedEx + 53) return FR_NO_FILESYSTEM;
 
-		if (ld_word(fs->win + BPB_FSVerEx) != 0x100) return FR_NO_FILESYSTEM;	/* Check exFAT version (must be version 1.0) */
+		if (ld_word(fs->win + BPB_FSVerEx) != 0x100) {
+			EFSPRINTF("Error: exFAT - Version check failed!");
+			return FR_NO_FILESYSTEM;	/* Check exFAT version (must be version 1.0) */
+		}
 
 		if (1 << fs->win[BPB_BytsPerSecEx] != SS(fs)) {	/* (BPB_BytsPerSecEx must be equal to the physical sector size) */
+			EFSPRINTF("Error: exFAT - Bytes per sector does not match physical sector size!");
 			return FR_NO_FILESYSTEM;
 		}
 
 		maxlba = ld_qword(fs->win + BPB_TotSecEx) + bsect;	/* Last LBA + 1 of the volume */
-		if (maxlba >= 0x100000000) return FR_NO_FILESYSTEM;	/* (It cannot be handled in 32-bit LBA) */
+		if (maxlba >= 0x100000000) {
+			EFSPRINTF("Error: exFAT - Cannot handle volume LBA with 32-bit LBA!");
+			return FR_NO_FILESYSTEM;	/* (It cannot be handled in 32-bit LBA) */
+		}
 
 		fs->fsize = ld_dword(fs->win + BPB_FatSzEx);	/* Number of sectors per FAT */
 
 		fs->n_fats = fs->win[BPB_NumFATsEx];			/* Number of FATs */
-		if (fs->n_fats != 1) return FR_NO_FILESYSTEM;	/* (Supports only 1 FAT) */
+		if (fs->n_fats != 1) {
+			EFSPRINTF("Error: exFAT - Multiple or no file allocation tables found!");
+			return FR_NO_FILESYSTEM;	/* (Supports only 1 FAT) */
+		}
 
 		fs->csize = 1 << fs->win[BPB_SecPerClusEx];		/* Cluster size */
-		if (fs->csize == 0)	return FR_NO_FILESYSTEM;	/* (Must be 1..32768) */
+		if (fs->csize == 0)	{
+			EFSPRINTF("Error: exFAT - Cluster size is not between 1KB - 32KB!");
+			return FR_NO_FILESYSTEM;	/* (Must be 1..32768) */
+		}
 
 		nclst = ld_dword(fs->win + BPB_NumClusEx);		/* Number of clusters */
-		if (nclst > MAX_EXFAT) return FR_NO_FILESYSTEM;	/* (Too many clusters) */
+		if (nclst > MAX_EXFAT) {
+			EFSPRINTF("Error: exFAT - Total clusters exceed allowed!");
+			return FR_NO_FILESYSTEM;	/* (Too many clusters) */
+		}
 		fs->n_fatent = nclst + 2;
 
 		/* Boundaries and Limits */
 		fs->volbase = bsect;
 		fs->database = bsect + ld_dword(fs->win + BPB_DataOfsEx);
 		fs->fatbase = bsect + ld_dword(fs->win + BPB_FatOfsEx);
-		if (maxlba < (QWORD)fs->database + nclst * fs->csize) return FR_NO_FILESYSTEM;	/* (Volume size must not be smaller than the size requiered) */
+		if (maxlba < (QWORD)fs->database + nclst * fs->csize) {
+			EFSPRINTF("Error: exFAT - Volume size is lower than required!");
+			return FR_NO_FILESYSTEM;	/* (Volume size must not be smaller than the size required) */
+		}
 		fs->dirbase = ld_dword(fs->win + BPB_RootClusEx);
 
 		/* Check if bitmap location is in assumption (at the first cluster) */
-		if (move_window(fs, clst2sect(fs, fs->dirbase)) != FR_OK) return FR_DISK_ERR;
+		if (move_window(fs, clst2sect(fs, fs->dirbase)) != FR_OK) {
+			EFSPRINTF("Error: exFAT - Bitmap location not at first cluster!");
+			return FR_DISK_ERR;
+		}
 		for (i = 0; i < SS(fs); i += SZDIRE) {
 			if (fs->win[i] == 0x81 && ld_dword(fs->win + i + 20) == 2) break;	/* 81 entry with cluster #2? */
 		}
@@ -3344,38 +3381,62 @@ FRESULT find_volume (	/* FR_OK(0): successful, !=0: any error occurred */
 	} else
 #endif	/* FF_FS_EXFAT */
 	{
-		if (ld_word(fs->win + BPB_BytsPerSec) != SS(fs)) return FR_NO_FILESYSTEM;	/* (BPB_BytsPerSec must be equal to the physical sector size) */
+		if (ld_word(fs->win + BPB_BytsPerSec) != SS(fs)) {
+			EFSPRINTF("Error: FAT - Bytes per sector does not match physical sector size!");
+			return FR_NO_FILESYSTEM;	/* (BPB_BytsPerSec must be equal to the physical sector size) */
+		}
 
 		fasize = ld_word(fs->win + BPB_FATSz16);		/* Number of sectors per FAT */
 		if (fasize == 0) fasize = ld_dword(fs->win + BPB_FATSz32);
 		fs->fsize = fasize;
 
 		fs->n_fats = fs->win[BPB_NumFATs];				/* Number of FATs */
-		if (fs->n_fats != 1 && fs->n_fats != 2) return FR_NO_FILESYSTEM;	/* (Must be 1 or 2) */
+		if (fs->n_fats != 1 && fs->n_fats != 2) {
+			EFSPRINTF("Error: FAT - No or more than 2 file allocation tables found!");
+			return FR_NO_FILESYSTEM;	/* (Must be 1 or 2) */
+		}
 		fasize *= fs->n_fats;							/* Number of sectors for FAT area */
 
 		fs->csize = fs->win[BPB_SecPerClus];			/* Cluster size */
-		if (fs->csize == 0 || (fs->csize & (fs->csize - 1))) return FR_NO_FILESYSTEM;	/* (Must be power of 2) */
+		if (fs->csize == 0 || (fs->csize & (fs->csize - 1))) {
+			EFSPRINTF("Error: FAT - Cluster size is not a power of 2!");
+			return FR_NO_FILESYSTEM;	/* (Must be power of 2) */
+		}
 
 		fs->n_rootdir = ld_word(fs->win + BPB_RootEntCnt);	/* Number of root directory entries */
-		if (fs->n_rootdir % (SS(fs) / SZDIRE)) return FR_NO_FILESYSTEM;	/* (Must be sector aligned) */
+		if (fs->n_rootdir % (SS(fs) / SZDIRE)) {
+			EFSPRINTF("Error: FAT - Root directory entries are not sector aligned!");
+			return FR_NO_FILESYSTEM;	/* (Must be sector aligned) */
+		}
 
 		tsect = ld_word(fs->win + BPB_TotSec16);		/* Number of sectors on the volume */
 		if (tsect == 0) tsect = ld_dword(fs->win + BPB_TotSec32);
 
 		nrsv = ld_word(fs->win + BPB_RsvdSecCnt);		/* Number of reserved sectors */
-		if (nrsv == 0) return FR_NO_FILESYSTEM;			/* (Must not be 0) */
+		if (nrsv == 0) {
+			EFSPRINTF("Error: FAT - Zero reserved sectors!");
+			return FR_NO_FILESYSTEM;			/* (Must not be 0) */
+		}
 
 		/* Determine the FAT sub type */
 		sysect = nrsv + fasize + fs->n_rootdir / (SS(fs) / SZDIRE);	/* RSV + FAT + DIR */
-		if (tsect < sysect) return FR_NO_FILESYSTEM;	/* (Invalid volume size) */
+		if (tsect < sysect) {
+			EFSPRINTF("Error: FAT - Invalid volume size!");
+			return FR_NO_FILESYSTEM;	/* (Invalid volume size) */
+		}
 		nclst = (tsect - sysect) / fs->csize;			/* Number of clusters */
-		if (nclst == 0) return FR_NO_FILESYSTEM;		/* (Invalid volume size) */
+		if (nclst == 0) {
+			EFSPRINTF("Error: FAT - Invalid volume size!");
+			return FR_NO_FILESYSTEM;		/* (Invalid volume size) */
+		}
 		fmt = 0;
 		if (nclst <= MAX_FAT32) fmt = FS_FAT32;
 		if (nclst <= MAX_FAT16) fmt = FS_FAT16;
 		if (nclst <= MAX_FAT12) fmt = FS_FAT12;
-		if (fmt == 0) return FR_NO_FILESYSTEM;
+		if (fmt == 0) {
+			EFSPRINTF("Error: FAT - Not compatible FAT12/16/32 filesystem!");
+			return FR_NO_FILESYSTEM;
+		}
 
 		/* Boundaries and Limits */
 		fs->n_fatent = nclst + 2;						/* Number of FAT entries */
@@ -3383,17 +3444,29 @@ FRESULT find_volume (	/* FR_OK(0): successful, !=0: any error occurred */
 		fs->fatbase = bsect + nrsv; 					/* FAT start sector */
 		fs->database = bsect + sysect;					/* Data start sector */
 		if (fmt == FS_FAT32) {
-			if (ld_word(fs->win + BPB_FSVer32) != 0) return FR_NO_FILESYSTEM;	/* (Must be FAT32 revision 0.0) */
-			if (fs->n_rootdir != 0) return FR_NO_FILESYSTEM;	/* (BPB_RootEntCnt must be 0) */
+			if (ld_word(fs->win + BPB_FSVer32) != 0) {
+				EFSPRINTF("Error: FAT32 - Not a 0.0 revision!");
+				return FR_NO_FILESYSTEM;	/* (Must be FAT32 revision 0.0) */
+			}
+			if (fs->n_rootdir != 0) {
+				EFSPRINTF("Error: FAT32 - Root entry sector is not 0!");
+				return FR_NO_FILESYSTEM;	/* (BPB_RootEntCnt must be 0) */
+			}
 			fs->dirbase = ld_dword(fs->win + BPB_RootClus32);	/* Root directory start cluster */
 			szbfat = fs->n_fatent * 4;					/* (Needed FAT size) */
 		} else {
-			if (fs->n_rootdir == 0)	return FR_NO_FILESYSTEM;	/* (BPB_RootEntCnt must not be 0) */
+			if (fs->n_rootdir == 0)	{
+				EFSPRINTF("Error: FAT - Root entry sector is 0!");
+				return FR_NO_FILESYSTEM;	/* (BPB_RootEntCnt must not be 0) */
+			}
 			fs->dirbase = fs->fatbase + fasize;			/* Root directory start sector */
 			szbfat = (fmt == FS_FAT16) ?				/* (Needed FAT size) */
 				fs->n_fatent * 2 : fs->n_fatent * 3 / 2 + (fs->n_fatent & 1);
 		}
-		if (fs->fsize < (szbfat + (SS(fs) - 1)) / SS(fs)) return FR_NO_FILESYSTEM;	/* (BPB_FATSz must not be less than the size needed) */
+		if (fs->fsize < (szbfat + (SS(fs) - 1)) / SS(fs)) {
+			EFSPRINTF("Error: FAT - FAT size is not the required size!");
+			return FR_NO_FILESYSTEM;	/* (BPB_FATSz must not be less than the size needed) */
+		}
 
 #if !FF_FS_READONLY
 		/* Get FSInfo if available */
@@ -3426,7 +3499,7 @@ FRESULT find_volume (	/* FR_OK(0): successful, !=0: any error occurred */
 #if FF_USE_LFN == 1
 	fs->lfnbuf = LfnBuf;	/* Static LFN working buffer */
 #if FF_FS_EXFAT
-	fs->dirbuf = DirBuf;	/* Static directory block scratchpad buuffer */
+	fs->dirbuf = DirBuf;	/* Static directory block scratch-pad buffer */
 #endif
 #endif
 #if FF_FS_RPATH != 0
@@ -3504,7 +3577,10 @@ FRESULT f_mount (
 
 	/* Get logical drive number */
 	vol = get_ldnumber(&rp);
-	if (vol < 0) return FR_INVALID_DRIVE;
+	if (vol < 0) {
+		EFSPRINTF("Error: Invalid drive!");
+		return FR_INVALID_DRIVE;
+	}
 	cfs = FatFs[vol];					/* Pointer to fs object */
 
 	if (cfs) {
@@ -3745,8 +3821,14 @@ FRESULT f_read (
 
 	*br = 0;	/* Clear read byte counter */
 	res = validate(&fp->obj, &fs);				/* Check validity of the file object */
-	if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);	/* Check validity */
-	if (!(fp->flag & FA_READ)) LEAVE_FF(fs, FR_DENIED); /* Check access mode */
+	if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) {
+		EFSPRINTF("Error: File object Validation!");
+		LEAVE_FF(fs, res);	/* Check validity */
+	}
+	if (!(fp->flag & FA_READ)) {
+		EFSPRINTF("Error: Access denied!");
+		LEAVE_FF(fs, FR_DENIED);	/* Check access mode */
+	}
 	remain = fp->obj.objsize - fp->fptr;
 	if (btr > remain) btr = (UINT)remain;		/* Truncate btr by remaining bytes */
 
@@ -3767,19 +3849,31 @@ FRESULT f_read (
 						clst = get_fat(&fp->obj, fp->clust);	/* Follow cluster chain on the FAT */
 					}
 				}
-				if (clst < 2) ABORT(fs, FR_INT_ERR);
-				if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
+				if (clst < 2) {
+					EFSPRINTF("Error: Cluster status check or Internal error!");
+					ABORT(fs, FR_INT_ERR);
+				}
+				if (clst == 0xFFFFFFFF) {
+					EFSPRINTF("Error: Disk error (cluster hard error)!");
+					ABORT(fs, FR_DISK_ERR);
+				}
 				fp->clust = clst;				/* Update current cluster */
 			}
 			sect = clst2sect(fs, fp->clust);	/* Get current sector */
-			if (sect == 0) ABORT(fs, FR_INT_ERR);
+			if (sect == 0) {
+				EFSPRINTF("Error: Get current sector error!");
+				ABORT(fs, FR_INT_ERR);
+			}
 			sect += csect;
 			cc = btr / SS(fs);					/* When remaining bytes >= sector size, */
 			if (cc > 0) {						/* Read maximum contiguous sectors directly */
 				if (csect + cc > fs->csize) {	/* Clip at cluster boundary */
 					cc = fs->csize - csect;
 				}
-				if (disk_read(fs->pdrv, rbuff, sect, cc) != RES_OK) ABORT(fs, FR_DISK_ERR);
+				if (disk_read(fs->pdrv, rbuff, sect, cc) != RES_OK) {
+					EFSPRINTF("Error: Read - Low level disk I/O!");
+					ABORT(fs, FR_DISK_ERR);
+				}
 #if !FF_FS_READONLY && FF_FS_MINIMIZE <= 2		/* Replace one of the read sectors with cached data if it contains a dirty sector */
 #if FF_FS_TINY
 				if (fs->wflag && fs->winsect - sect < cc) {
@@ -3798,11 +3892,17 @@ FRESULT f_read (
 			if (fp->sect != sect) {			/* Load data sector if not in cache */
 #if !FF_FS_READONLY
 				if (fp->flag & FA_DIRTY) {		/* Write-back dirty sector cache */
-					if (disk_write(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);
+					if (disk_write(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) {
+						EFSPRINTF("Error: Write-back dirty sector cache!");
+						ABORT(fs, FR_DISK_ERR);
+					}
 					fp->flag &= (BYTE)~FA_DIRTY;
 				}
 #endif
-				if (disk_read(fs->pdrv, fp->buf, sect, 1) != RES_OK)	ABORT(fs, FR_DISK_ERR);	/* Fill sector cache */
+				if (disk_read(fs->pdrv, fp->buf, sect, 1) != RES_OK) {
+					EFSPRINTF("Error: Read - Low level disk I/O!\n(fill sector cache)");
+					ABORT(fs, FR_DISK_ERR);	/* Fill sector cache */
+				}
 			}
 #endif
 			fp->sect = sect;
@@ -3844,8 +3944,14 @@ FRESULT f_write (
 
 	*bw = 0;	/* Clear write byte counter */
 	res = validate(&fp->obj, &fs);			/* Check validity of the file object */
-	if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);	/* Check validity */
-	if (!(fp->flag & FA_WRITE)) LEAVE_FF(fs, FR_DENIED);	/* Check access mode */
+	if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) {
+		EFSPRINTF("Error: File object Validation!");
+		LEAVE_FF(fs, res);	/* Check validity */
+	}
+	if (!(fp->flag & FA_WRITE)) {
+		EFSPRINTF("Error: Access denied!");
+		LEAVE_FF(fs, FR_DENIED);	/* Check access mode */
+	}
 
 	/* Check fptr wrap-around (file size cannot reach 4 GiB at FAT volume) */
 	if ((!FF_FS_EXFAT || fs->fs_type != FS_EXFAT) && (DWORD)(fp->fptr + btw) < (DWORD)fp->fptr) {
@@ -3872,9 +3978,18 @@ FRESULT f_write (
 						clst = create_chain(&fp->obj, fp->clust);	/* Follow or stretch cluster chain on the FAT */
 					}
 				}
-				if (clst == 0) break;		/* Could not allocate a new cluster (disk full) */
-				if (clst == 1) ABORT(fs, FR_INT_ERR);
-				if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
+				if (clst == 0) {
+					EFSPRINTF("Error: Could not allocate a new cluster\n(disk full or low level disk I/O error)!");
+					break;		/* Could not allocate a new cluster (disk full) */
+				}
+				if (clst == 1) {
+					EFSPRINTF("Error: Cluster status check or Internal error!");
+					ABORT(fs, FR_INT_ERR);
+				}
+				if (clst == 0xFFFFFFFF) {
+					EFSPRINTF("Error: Disk error (cluster hard error)!");
+					ABORT(fs, FR_DISK_ERR);
+				}
 				fp->clust = clst;			/* Update current cluster */
 				if (fp->obj.sclust == 0) fp->obj.sclust = clst;	/* Set start cluster if the first write */
 			}
@@ -3882,19 +3997,28 @@ FRESULT f_write (
 			if (fs->winsect == fp->sect && sync_window(fs) != FR_OK) ABORT(fs, FR_DISK_ERR);	/* Write-back sector cache */
 #else
 			if (fp->flag & FA_DIRTY) {		/* Write-back sector cache */
-				if (disk_write(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);
+				if (disk_write(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) {
+					EFSPRINTF("Error: Write-back sector cache!");
+					ABORT(fs, FR_DISK_ERR);
+				}
 				fp->flag &= (BYTE)~FA_DIRTY;
 			}
 #endif
 			sect = clst2sect(fs, fp->clust);	/* Get current sector */
-			if (sect == 0) ABORT(fs, FR_INT_ERR);
+			if (sect == 0) {
+				EFSPRINTF("Error: Get current sector error!");
+				ABORT(fs, FR_INT_ERR);
+			}
 			sect += csect;
 			cc = btw / SS(fs);				/* When remaining bytes >= sector size, */
 			if (cc > 0) {					/* Write maximum contiguous sectors directly */
 				if (csect + cc > fs->csize) {	/* Clip at cluster boundary */
 					cc = fs->csize - csect;
 				}
-				if (disk_write(fs->pdrv, wbuff, sect, cc) != RES_OK) ABORT(fs, FR_DISK_ERR);
+				if (disk_write(fs->pdrv, wbuff, sect, cc) != RES_OK) {
+					EFSPRINTF("Error: Write - Low level disk I/O!");
+					ABORT(fs, FR_DISK_ERR);
+				}
 #if FF_FS_MINIMIZE <= 2
 #if FF_FS_TINY
 				if (fs->winsect - sect < cc) {	/* Refill sector cache if it gets invalidated by the direct write */
@@ -3920,6 +4044,7 @@ FRESULT f_write (
 			if (fp->sect != sect && 		/* Fill sector cache with file data */
 				fp->fptr < fp->obj.objsize &&
 				disk_read(fs->pdrv, fp->buf, sect, 1) != RES_OK) {
+					EFSPRINTF("Error: Read - Low level disk I/O!\n(Could not fill sector cache with file data)");
 					ABORT(fs, FR_DISK_ERR);
 			}
 #endif

ipl/gfx.c

@@ -87,9 +87,9 @@ void gfx_con_init(gfx_con_t *con, gfx_ctxt_t *ctxt)
 	con->gfx_ctxt = ctxt;
 	con->x = 0;
 	con->y = 0;
-	con->fgcol = 0xFFFFFFFF;
+	con->fgcol = 0xFFCCCCCC;
 	con->fillbg = 0;
-	con->bgcol = 0xFF000000;
+	con->bgcol = 0xFF1B1B1B;
 }
 
 void gfx_con_setcol(gfx_con_t *con, u32 fgcol, int fillbg, u32 bgcol)
@@ -307,3 +307,16 @@ void gfx_line(gfx_ctxt_t *ctxt, int x0, int y0, int x1, int y1, u32 color)
 		if (e2 < dy) { err += dx; y0 += sy; }
 	}
 }
+
+void gfx_set_logo(gfx_ctxt_t *ctxt, const u8 *buf)
+{
+	u32 pos = 0;
+	for (u32 y = 1180; y < 1256; y++)
+	{
+		for (u32 x = 538; x < 696; x++)
+		{
+			ctxt->fb[x + y*ctxt->stride] = (0xFF << 24) | buf[pos] | (buf[pos + 1] << 8) | (buf[pos + 2] << 16);
+			pos+=3;
+		}
+	}
+}

ipl/gfx.h

@@ -50,5 +50,6 @@ void gfx_hexdump(gfx_con_t *con, u32 base, const u8 *buf, u32 len);
 
 void gfx_set_pixel(gfx_ctxt_t *ctxt, u32 x, u32 y, u32 color);
 void gfx_line(gfx_ctxt_t *ctxt, int x0, int y0, int x1, int y1, u32 color);
+void gfx_set_logo(gfx_ctxt_t *ctxt, const u8 *buf);
 
 #endif

ipl/hos.c

@@ -433,12 +433,21 @@ DPRINTF("decrypted and unpacked pkg1\n");
 
 	se_aes_key_clear(8);
 	se_aes_key_clear(11);
-	//se_aes_key_clear(13);
-	//se_key_acc_ctrl(10, 0xFF);
-	se_key_acc_ctrl(12, 0xFF);
-	//se_key_acc_ctrl(13, 0xFF);
-	//se_key_acc_ctrl(14, 0xFF);
-	se_key_acc_ctrl(15, 0xFF);
+	
+	switch (ctxt.pkg1_id->kb) {
+		case KB_FIRMWARE_VERSION_100_200:
+		case KB_FIRMWARE_VERSION_300:
+		case KB_FIRMWARE_VERSION_301:
+			se_key_acc_ctrl(12, 0xFF);
+			se_key_acc_ctrl(13, 0xFF);
+		break;
+		default:
+		case KB_FIRMWARE_VERSION_400:
+		case KB_FIRMWARE_VERSION_500:
+			se_key_acc_ctrl(12, 0xFF);
+			se_key_acc_ctrl(15, 0xFF);
+		break;
+	}
 
 	//Clear 'BootConfig'.
 	memset((void *)0x4003D000, 0, 0x3000);

ipl/main.c

@@ -52,6 +52,10 @@
 gfx_ctxt_t gfx_ctxt;
 gfx_con_t gfx_con;
 
+//TODO: Create more macros (info, header, debug, etc) with different colors and utilize them for consistency.
+#define EPRINTF(text) gfx_printf(&gfx_con, "%k"text"%k\n", 0xFF0000FF, 0xFFCCCCCC)
+#define EPRINTFARGS(text, args...) gfx_printf(&gfx_con, "%k"text"%k\n", 0xFF0000FF, args, 0xFFCCCCCC)
+
 //TODO: ugly.
 sdmmc_t sd_sdmmc;
 sdmmc_storage_t sd_storage;
@@ -65,8 +69,7 @@ int sd_mount()
 
 	if (!sdmmc_storage_init_sd(&sd_storage, &sd_sdmmc, SDMMC_1, SDMMC_BUS_WIDTH_4, 11))
 	{
-		gfx_printf(&gfx_con, "%kFailed to init SD card (make sure that it is inserted).%k\n",
-			0xFF0000FF, 0xFFFFFFFF);
+		EPRINTF("Failed to init SD card (make sure that it is inserted).");
 	}
 	else
 	{
@@ -79,8 +82,7 @@ int sd_mount()
 		}
 		else
 		{
-			gfx_printf(&gfx_con, "%kFailed to mount SD card (FatFS Error %d).\n(make sure that a FAT32/exFAT partition exists)%k\n",
-				0xFF0000FF, res, 0xFFFFFFFF);
+			EPRINTFARGS("Failed to mount SD card (FatFS Error %d).\n(make sure that a FAT32/exFAT partition exists)", res);
 		}
 	}
 
@@ -125,6 +127,20 @@ void *sd_file_read(char *path)
 	return buf;
 }
 
+int sd_save_to_file(void * buf, u32 size, const char * filename)
+{
+	FIL fp;
+	if (f_open(&fp, filename, FA_CREATE_ALWAYS | FA_WRITE) != FR_OK) {
+		return 1;
+	}
+
+	f_sync(&fp);
+	f_write(&fp, buf, size, NULL);
+	f_close(&fp);
+
+	return 0;
+}
+
 void panic(u32 val)
 {
 	//Set panic code.
@@ -320,91 +336,79 @@ void config_hw()
 
 void print_fuseinfo()
 {
-	gfx_clear(&gfx_ctxt, 0xFF000000);
+	gfx_clear(&gfx_ctxt, 0xFF1B1B1B);
 	gfx_con_setpos(&gfx_con, 0, 0);
 
-	gfx_printf(&gfx_con, "%k(Unlocked) fuse cache:\n\n%k", 0xFFFF9955, 0xFFFFFFFF);
+	gfx_printf(&gfx_con, "%k(Unlocked) fuse cache:\n\n%k", 0xFFFF9955, 0xFFCCCCCC);
 	gfx_hexdump(&gfx_con, 0x7000F900, (u8 *)0x7000F900, 0x2FC);
 
 	gfx_puts(&gfx_con, "\nPress POWER to dump them to SD Card.\nPress VOL to go to the menu.\n");
 
-	sleep(1000000);
-
 	u32 btn = btn_wait();
 	if (btn & BTN_POWER)
 	{
 		if (sd_mount())
 		{
-			FIL fuseFp;
 			char fuseFilename[9];
 			memcpy(fuseFilename, "fuse.bin", 8);
 			fuseFilename[8] = 0;
-			if (f_open(&fuseFp, fuseFilename, FA_CREATE_ALWAYS | FA_WRITE) == FR_OK)
-			{
-				f_write(&fuseFp, (u8 *)0x7000F900, 0x2FC, NULL);
-				f_close(&fuseFp);
-				gfx_puts(&gfx_con, "\nDone!\n");
-			}
+
+			if (sd_save_to_file((u8 *)0x7000F900, 0x2FC, fuseFilename))
+				EPRINTF("\nError creating fuse.bin file.");
 			else
-				gfx_printf(&gfx_con, "%k\nError creating fuse.bin file.%k\n", 0xFF0000FF, 0xFFFFFFFF);
+				gfx_puts(&gfx_con, "\nDone!\n");				
 		}
-		sleep(2000000);
+
 		btn_wait();
 	}
 }
 
 void print_kfuseinfo()
 {
-	gfx_clear(&gfx_ctxt, 0xFF000000);
+	gfx_clear(&gfx_ctxt, 0xFF1B1B1B);
 	gfx_con_setpos(&gfx_con, 0, 0);
 
-	gfx_printf(&gfx_con, "%kKFuse contents:\n\n%k", 0xFFFF9955, 0xFFFFFFFF);
+	gfx_printf(&gfx_con, "%kKFuse contents:\n\n%k", 0xFFFF9955, 0xFFCCCCCC);
 	u32 buf[KFUSE_NUM_WORDS];
 	if (!kfuse_read(buf))
-		gfx_printf(&gfx_con, "%kCRC fail.\n", 0xFF0000FF);
+		EPRINTF("CRC fail.");
 	else
 		gfx_hexdump(&gfx_con, 0, (u8 *)buf, KFUSE_NUM_WORDS * 4);
 
 	gfx_puts(&gfx_con, "\nPress POWER to dump them to SD Card.\nPress VOL to go to the menu.\n");
 
-	sleep(1000000);
-
 	u32 btn = btn_wait();
 	if (btn & BTN_POWER)
 	{
 		if (sd_mount())
 		{
-			FIL kfuseFp;
 			char kfuseFilename[10];
 			memcpy(kfuseFilename, "kfuse.bin", 9);
 			kfuseFilename[9] = 0;
-			if (f_open(&kfuseFp, kfuseFilename, FA_CREATE_ALWAYS | FA_WRITE) == FR_OK)
-			{
-				f_write(&kfuseFp, (u8 *)buf, KFUSE_NUM_WORDS * 4, NULL);
-				f_close(&kfuseFp);
-				gfx_puts(&gfx_con, "\nDone!\n");
-			}
+
+			if (sd_save_to_file((u8 *)buf, KFUSE_NUM_WORDS * 4, kfuseFilename))
+				EPRINTF("\nError creating kfuse.bin file.");
 			else
-				gfx_printf(&gfx_con, "%k\nError creating kfuse.bin file.%k\n", 0xFF0000FF, 0xFFFFFFFF);
+				gfx_puts(&gfx_con, "\nDone!\n");
 		}
-		sleep(2000000);
+
 		btn_wait();
 	}
 }
 
 void print_mmc_info()
 {
-	gfx_clear(&gfx_ctxt, 0xFF000000);
+	gfx_clear(&gfx_ctxt, 0xFF1B1B1B);
 	gfx_con_setpos(&gfx_con, 0, 0);
 
-	static const u32 SECTORS_TO_MIB_COEFF  = 0x800;
+	static const u32 SECTORS_TO_MIB_COEFF  = 11;
 
 	sdmmc_storage_t storage;
 	sdmmc_t sdmmc;
 
 	if(!sdmmc_storage_init_mmc(&storage, &sdmmc, SDMMC_4, SDMMC_BUS_WIDTH_8, 4))
 	{
-		gfx_printf(&gfx_con, "%kFailed to init eMMC.%k\n", 0xFF0000FF, 0xFFFFFFFF);
+		EPRINTF("Failed to init eMMC.");
 		goto out;
 	}
 	else
@@ -412,7 +416,7 @@ void print_mmc_info()
 		u16 card_type;
 		u32 speed;
 
-		gfx_printf(&gfx_con, "%kCard IDentification:%k\n", 0xFFFFDD00, 0xFFFFFFFF);
+		gfx_printf(&gfx_con, "%kCard IDentification:%k\n", 0xFFFFDD00, 0xFFCCCCCC);
 		switch (storage.csd.mmca_vsn)
 		{
 		case 0: /* MMC v1.0 - v1.2 */
@@ -447,16 +451,16 @@ void print_mmc_info()
 			storage.cid.prv, storage.cid.serial, storage.cid.month, storage.cid.year);
 			break;
 		default:
-			gfx_printf(&gfx_con, "%keMMC has unknown MMCA version %d%k\n", 0xFF0000FF, storage.csd.mmca_vsn, 0xFFFFFFFF);
+			EPRINTFARGS("eMMC has unknown MMCA version %d", storage.csd.mmca_vsn);
 			break;
 		}
 
 		if (storage.csd.structure == 0)
-			gfx_printf(&gfx_con, "%kUnknown CSD structure%k\n", 0xFF0000FF, 0xFFFFFFFF);
+			EPRINTF("Unknown CSD structure.");
 		else
 		{
 			gfx_printf(&gfx_con, "%kExtended Card-Specific Data V1.%d:%k\n",
-				0xFFFFDD00, storage.ext_csd.ext_struct, 0xFFFFFFFF);
+				0xFFFFDD00, storage.ext_csd.ext_struct, 0xFFCCCCCC);
 			card_type = storage.ext_csd.card_type;
 			u8 card_type_support[96];
 			u8 pos_type = 0;
@@ -505,16 +509,16 @@ void print_mmc_info()
 
 			u32 boot_size = storage.ext_csd.boot_mult << 17;
 			u32 rpmb_size = storage.ext_csd.rpmb_mult << 17;
-			gfx_printf(&gfx_con, "%keMMC Partitions:%k\n", 0xFFFFDD00, 0xFFFFFFFF);
-			gfx_printf(&gfx_con, " 1: %kBOOT0      %kSize: %5d KiB (LBA Sectors: 0x%07X)\n", 0xFF00FF96, 0xFFFFFFFF,
+			gfx_printf(&gfx_con, "%keMMC Partitions:%k\n", 0xFFFFDD00, 0xFFCCCCCC);
+			gfx_printf(&gfx_con, " 1: %kBOOT0      %kSize: %5d KiB (LBA Sectors: 0x%07X)\n", 0xFF00FF96, 0xFFCCCCCC,
 				boot_size / 1024, boot_size / 1024 / 512);
-			gfx_printf(&gfx_con, " 2: %kBOOT1      %kSize: %5d KiB (LBA Sectors: 0x%07X)\n", 0xFF00FF96, 0xFFFFFFFF,
+			gfx_printf(&gfx_con, " 2: %kBOOT1      %kSize: %5d KiB (LBA Sectors: 0x%07X)\n", 0xFF00FF96, 0xFFCCCCCC,
 				boot_size / 1024, boot_size / 1024 / 512);
-			gfx_printf(&gfx_con, " 3: %kRPMB       %kSize: %5d KiB (LBA Sectors: 0x%07X)\n", 0xFF00FF96, 0xFFFFFFFF,
+			gfx_printf(&gfx_con, " 3: %kRPMB       %kSize: %5d KiB (LBA Sectors: 0x%07X)\n", 0xFF00FF96, 0xFFCCCCCC,
 				rpmb_size / 1024, rpmb_size / 1024 / 512);
-			gfx_printf(&gfx_con, " 0: %kGPP (USER) %kSize: %05d MiB (LBA Sectors: 0x%07X)\n\n", 0xFF00FF96, 0xFFFFFFFF,
-				storage.sec_cnt / SECTORS_TO_MIB_COEFF, storage.sec_cnt);
-			gfx_printf(&gfx_con, "%kGPP (eMMC USER) partition table:%k\n", 0xFFFFDD00, 0xFFFFFFFF);
+			gfx_printf(&gfx_con, " 0: %kGPP (USER) %kSize: %05d MiB (LBA Sectors: 0x%07X)\n\n", 0xFF00FF96, 0xFFCCCCCC,
+				storage.sec_cnt >> SECTORS_TO_MIB_COEFF, storage.sec_cnt);
+			gfx_printf(&gfx_con, "%kGPP (eMMC USER) partition table:%k\n", 0xFFFFDD00, 0xFFCCCCCC);
 
 			sdmmc_storage_set_mmc_partition(&storage, 0);
 			LIST_INIT(gpt);
@@ -522,31 +526,31 @@ void print_mmc_info()
 			int gpp_idx = 0;
 			LIST_FOREACH_ENTRY(emmc_part_t, part, &gpt, link)
 			{
-				gfx_printf(&gfx_con, " %02d: %k%s%k\n     Size: % 5d MiB (LBA Sectors 0x%07X, LBA Range: %08X-%08X)%k\n",
-					gpp_idx++, 0xFF14FDAE, part->name, 0xFFFFFFFF, (part->lba_end - part->lba_start + 1) / SECTORS_TO_MIB_COEFF,
-					part->lba_end - part->lba_start + 1, part->lba_start, part->lba_end, 0xFFFFFFFF);
+				gfx_printf(&gfx_con, " %02d: %k%s%k\n     Size: % 5d MiB (LBA Sectors 0x%07X, LBA Range: %08X-%08X)\n",
+					gpp_idx++, 0xFF14FDAE, part->name, 0xFFCCCCCC, (part->lba_end - part->lba_start + 1) >> SECTORS_TO_MIB_COEFF,
+					part->lba_end - part->lba_start + 1, part->lba_start, part->lba_end);
 			}
 		}
 	}
+
 out:
 	sdmmc_storage_end(&storage);
-	sleep(1000000);
 
 	btn_wait();
 }
 
 void print_sdcard_info()
 {
-	gfx_clear(&gfx_ctxt, 0xFF000000);
+	gfx_clear(&gfx_ctxt, 0xFF1B1B1B);
 	gfx_con_setpos(&gfx_con, 0, 0);
 
-	static const u32 SECTORS_TO_MIB_COEFF  = 0x800;
+	static const u32 SECTORS_TO_MIB_COEFF  = 11;
 
 	if (sd_mount())
 	{
 		u32 capacity;
 
-		gfx_printf(&gfx_con, "%kCard IDentification:%k\n", 0xFFFFDD00, 0xFFFFFFFF);
+		gfx_printf(&gfx_con, "%kCard IDentification:%k\n", 0xFFFFDD00, 0xFFCCCCCC);
 		gfx_printf(&gfx_con,
 			" Vendor ID:  %02x\n\
 			 OEM ID:     %c%c\n\
@@ -561,49 +565,34 @@ void print_sdcard_info()
 			sd_storage.cid.hwrev, sd_storage.cid.fwrev, sd_storage.cid.serial,
 			sd_storage.cid.month, sd_storage.cid.year);
 
-		gfx_printf(&gfx_con, "%kCard-Specific Data V%d.0:%k\n", 0xFFFFDD00, sd_storage.csd.structure + 1, 0xFFFFFFFF);
-		switch(sd_storage.csd.structure)
-		{
-		case 0:
-			capacity = (sd_storage.csd.capacity << sd_storage.csd.read_blkbits) / 1024 / 1024;
-			gfx_printf(&gfx_con,
-				" Cmd Classes:    %02X\n\
-				 Capacity:       %d MiB\n",
-				sd_storage.csd.cmdclass, capacity);
-			break;
-		case 1:
-			capacity = (sd_storage.csd.c_size << sd_storage.csd.read_blkbits) / 1024;
-			gfx_printf(&gfx_con,
-				" Cmd Classes:    %02X\n\
-				 Capacity:       %d MiB\n",
-				sd_storage.csd.cmdclass, capacity);
-			break;
-		}
+		gfx_printf(&gfx_con, "%kCard-Specific Data V%d.0:%k\n", 0xFFFFDD00, sd_storage.csd.structure + 1, 0xFFCCCCCC);
+		capacity = sd_storage.csd.capacity >> (20 - sd_storage.csd.read_blkbits);
 		gfx_printf(&gfx_con,
-			" Bus Width:      %d\n\
+			" Cmd Classes:    %02X\n\
+			 Capacity:       %d MiB\n\
+			 Bus Width:      %d\n\
 			 Speed Class:    %d\n\
 			 UHS Grade:      U%d\n\
 			 Video Class:    V%d\n\
 			 App perf class: A%d\n\
 			 Write Protect:  %d\n\n",
+			sd_storage.csd.cmdclass, capacity,
 			sd_storage.ssr.bus_width, sd_storage.ssr.speed_class, sd_storage.ssr.uhs_grade,
 			sd_storage.ssr.video_class, sd_storage.ssr.app_class, sd_storage.csd.write_protect);
 
 		gfx_puts(&gfx_con, "Acquiring FAT volume info...\n\n");
 		f_getfree("", &sd_fs.free_clst, NULL);
-		gfx_printf(&gfx_con, "%kFound %s volume:%k\n Free:    %d MiB\n Cluster: %d B\n",
-				0xFFFFDD00, sd_fs.fs_type == FS_EXFAT ? "exFAT" : "FAT32", 0xFFFFFFFF,
-				sd_fs.free_clst * sd_fs.csize / SECTORS_TO_MIB_COEFF, sd_fs.csize * 512);
+		gfx_printf(&gfx_con, "%kFound %s volume:%k\n Free:    %d MiB\n Cluster: %d KiB\n",
+				0xFFFFDD00, sd_fs.fs_type == FS_EXFAT ? "exFAT" : "FAT32", 0xFFCCCCCC,
+				sd_fs.free_clst * sd_fs.csize >> SECTORS_TO_MIB_COEFF, (sd_fs.csize > 1) ? (sd_fs.csize >> 1) : 512);
 	}
 
-	sleep(1000000);
-
 	btn_wait();
 }
 
 void print_tsec_key()
 {
-	gfx_clear(&gfx_ctxt, 0xFF000000);
+	gfx_clear(&gfx_ctxt, 0xFF1B1B1B);
 	gfx_con_setpos(&gfx_con, 0, 0);
 
 	sdmmc_storage_t storage;
@@ -618,8 +607,8 @@ void print_tsec_key()
 	const pkg1_id_t *pkg1_id = pkg1_identify(pkg1);
 	if (!pkg1_id)
 	{
-		gfx_printf(&gfx_con, "%kCould not identify package1 version to read TSEC firmware (= '%s').%k\n",
-			0xFF0000FF, (char *)pkg1 + 0x10, 0xFFFFFFFF);
+		EPRINTFARGS("Could not identify package1 version to read TSEC firmware (= '%s').",
+			(char *)pkg1 + 0x10);
 		goto out;
 	}
 
@@ -628,21 +617,22 @@ void print_tsec_key()
 		u8 key[0x10];
 		int res = tsec_query(key, i, pkg1 + pkg1_id->tsec_off);
 
-		gfx_printf(&gfx_con, "%kTSEC key %d: %k", 0xFFFF9955, i, 0xFFFFFFFF);
+		gfx_printf(&gfx_con, "%kTSEC key %d: %k", 0xFFFF9955, i, 0xFFCCCCCC);
 		if (res >= 0)
 		{
 			for (u32 i = 0; i < 0x10; i++)
 				gfx_printf(&gfx_con, "%02X", key[i]);
 		}
 		else
-			gfx_printf(&gfx_con, "%kERROR %X", 0xFF0000FF, res);
+			EPRINTFARGS("ERROR %X", res);
 		gfx_putc(&gfx_con, '\n');
 	}
 
 out:;
 	free(pkg1);
 	sdmmc_storage_end(&storage);
-	sleep(1000000);
+
+	gfx_puts(&gfx_con, "\nPress any key...\n");
 	btn_wait();
 }
 
@@ -671,9 +661,9 @@ void power_off()
 int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 {
 	static const u32 FAT32_FILESIZE_LIMIT = 0xFFFFFFFF;
-	static const u32 MULTIPART_SPLIT_SIZE = (1u << 31);
-	static const u32 SECTORS_TO_MIB_COEFF  = 0x800;
+	static const u32 SECTORS_TO_MIB_COEFF  = 11;
 
+	u32 multipartSplitSize = (1u << 31);
 	u32 totalSectors = part->lba_end - part->lba_start + 1;
 	u32 currPartIdx = 0;
 	u32 numSplitParts = 0;
@@ -690,21 +680,25 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 	partialIdxFilename[11] = 0;
 
 	gfx_printf(&gfx_con, "SD Card free space: %d MiB, Total dump size %d MiB\n",
-		sd_fs.free_clst * sd_fs.csize / SECTORS_TO_MIB_COEFF,
-		totalSectors / SECTORS_TO_MIB_COEFF);
+		sd_fs.free_clst * sd_fs.csize >> SECTORS_TO_MIB_COEFF,
+		totalSectors >> SECTORS_TO_MIB_COEFF);
 
-	maxSplitParts = (sd_fs.free_clst * sd_fs.csize) / (MULTIPART_SPLIT_SIZE / 512);
+	// 1GB parts for sd cards 8GB and less
+	if ((sd_storage.csd.capacity >> (20 - sd_storage.csd.read_blkbits)) <= 8192)
+		multipartSplitSize = (1u << 30);
+	// Maximum parts fitting the free space available
+	maxSplitParts = (sd_fs.free_clst * sd_fs.csize) / (multipartSplitSize / 512);
 
 	// Check if the USER partition or the RAW eMMC fits the sd card free space
 	if (totalSectors > (sd_fs.free_clst * sd_fs.csize))
 	{
 		isSmallSdCard = 1;
 
-		gfx_printf(&gfx_con, "%kSD card free space is smaller than dump total size.%k\n", 0xFF00BAFF, 0xFFFFFFFF);
+		gfx_printf(&gfx_con, "%k\nSD card free space is smaller than dump total size.%k\n", 0xFF00BAFF, 0xFFCCCCCC);
 
 		if (!maxSplitParts)
 		{
-			gfx_printf(&gfx_con, "%kNot enough free space for partial dumping.%k\n", 0xFF0000FF, 0xFFFFFFFF);
+			EPRINTF("Not enough free space for partial dumping.");
 
 			return 0;
 		}
@@ -712,7 +706,7 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 	// Check if we continuing a previous raw eMMC dump in progress.
 	if (f_open(&partialIdxFp, partialIdxFilename, FA_READ) == FR_OK)
 	{
-		gfx_printf(&gfx_con, "%kFound partial dump in progress. Continuing...%k\n\n", 0xFF14FDAE, 0xFFFFFFFF);
+		gfx_printf(&gfx_con, "%kFound partial dump in progress. Continuing...%k\n\n", 0xFF14FDAE, 0xFFCCCCCC);
 
 		partialDumpInProgress = 1;
 		// Force partial dumping, even if the card is larger.
@@ -723,7 +717,7 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 
 		if (!maxSplitParts)
 		{
-			gfx_printf(&gfx_con, "%kNot enough free space for partial dumping.%k\n", 0xFF0000FF, 0xFFFFFFFF);
+			EPRINTF("Not enough free space for partial dumping.");
 
 			return 0;
 		}
@@ -731,14 +725,14 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 		// Increase maxSplitParts to accommodate previously dumped parts
 		maxSplitParts += currPartIdx;
 	}
-	else
-		gfx_printf(&gfx_con, "%kContinuing with partial dumping...%k\n\n", 0xFF00BAFF, 0xFFFFFFFF);
+	else if (isSmallSdCard)
+		gfx_printf(&gfx_con, "%kPartial dumping enabled (with %d MiB parts)...%k\n\n", 0xFF00BAFF, multipartSplitSize >> 20, 0xFFCCCCCC);
 
 	// Check if filesystem is FAT32 or the free space is smaller and dump in parts
-	if (((sd_fs.fs_type != FS_EXFAT) && totalSectors > (FAT32_FILESIZE_LIMIT/NX_EMMC_BLOCKSIZE)) | isSmallSdCard)
+	if (((sd_fs.fs_type != FS_EXFAT) && totalSectors > (FAT32_FILESIZE_LIMIT / NX_EMMC_BLOCKSIZE)) | isSmallSdCard)
 	{
-		static const u32 MULTIPART_SPLIT_SECTORS = MULTIPART_SPLIT_SIZE/NX_EMMC_BLOCKSIZE;
-		numSplitParts = (totalSectors+MULTIPART_SPLIT_SECTORS-1)/MULTIPART_SPLIT_SECTORS;
+		u32 multipartSplitSectors = multipartSplitSize / NX_EMMC_BLOCKSIZE;
+		numSplitParts = (totalSectors + multipartSplitSectors - 1) / multipartSplitSectors;
 
 		outFilename = alloca(sdPathLen+4);
 		memcpy(outFilename, sd_path, sdPathLen);
@@ -749,11 +743,11 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 			outFilename[sdPathLen] = '0';
 			if (numSplitParts >= 10)
 			{
-				outFilename[sdPathLen+1] = '0';
-				outFilename[sdPathLen+2] = 0;
+				outFilename[sdPathLen + 1] = '0';
+				outFilename[sdPathLen + 2] = 0;
 			}
 			else
-				outFilename[sdPathLen+1] = 0;
+				outFilename[sdPathLen + 1] = 0;
 		}
 		// Continue from where we left, if partial dump in progress.
 		else
@@ -761,7 +755,7 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 			if (numSplitParts >= 10 && currPartIdx < 10)
 			{
 				outFilename[sdPathLen] = '0';
-				itoa(currPartIdx, &outFilename[sdPathLen+1], 10);
+				itoa(currPartIdx, &outFilename[sdPathLen + 1], 10);
 			}
 			else
 				itoa(currPartIdx, &outFilename[sdPathLen], 10);
@@ -771,7 +765,7 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 	FIL fp;
 	if (f_open(&fp, outFilename, FA_CREATE_ALWAYS | FA_WRITE) != FR_OK)
 	{
-		gfx_printf(&gfx_con, "%kError creating file %s.%k\n", 0xFF0000FF, outFilename, 0xFFFFFFFF);
+		EPRINTFARGS("Error creating file %s.", outFilename);
 
 		return 0;
 	}
@@ -787,13 +781,13 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 	// Continue from where we left, if partial dump in progress.
 	if (partialDumpInProgress)
 	{
-		lba_curr += currPartIdx * (MULTIPART_SPLIT_SIZE / NX_EMMC_BLOCKSIZE);
-		totalSectors -= currPartIdx * (MULTIPART_SPLIT_SIZE / NX_EMMC_BLOCKSIZE);
+		lba_curr += currPartIdx * (multipartSplitSize / NX_EMMC_BLOCKSIZE);
+		totalSectors -= currPartIdx * (multipartSplitSize / NX_EMMC_BLOCKSIZE);
 	}
 
 	while(totalSectors > 0)
 	{
-		if (numSplitParts != 0 && bytesWritten >= MULTIPART_SPLIT_SIZE)
+		if (numSplitParts != 0 && bytesWritten >= multipartSplitSize)
 		{
 			f_close(&fp);
 			memset(&fp, 0, sizeof(fp));
@@ -802,7 +796,7 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 			if (numSplitParts >= 10 && currPartIdx < 10)
 			{
 				outFilename[sdPathLen] = '0';
-				itoa(currPartIdx, &outFilename[sdPathLen+1], 10);
+				itoa(currPartIdx, &outFilename[sdPathLen + 1], 10);
 			}
 			else
 				itoa(currPartIdx, &outFilename[sdPathLen], 10);
@@ -818,7 +812,7 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 				}
 				else
 				{
-					gfx_printf(&gfx_con, "%k\nError creating partial.idx file.%k\n", 0xFF0000FF, 0xFFFFFFFF);
+					EPRINTF("\nError creating partial.idx file.");
 
 					free(buf);
 					return 0;
@@ -841,7 +835,7 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 			// Create next part
 			if (f_open(&fp, outFilename, FA_CREATE_ALWAYS | FA_WRITE) != FR_OK)
 			{
-				gfx_printf(&gfx_con, "%kError creating file %s.%k\n", 0xFF0000FF, outFilename, 0xFFFFFFFF);
+				EPRINTFARGS("Error creating file %s.", outFilename);
 
 				free(buf);
 				return 0;
@@ -853,14 +847,14 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 		u32 num = MIN(totalSectors, NUM_SECTORS_PER_ITER);
 		while(!sdmmc_storage_read(storage, lba_curr, num, buf))
 		{
-			gfx_printf(&gfx_con, "%kError reading %d blocks @ LBA %08X from eMMC (try %d)%k\n",
-				0xFF0000FF, num, lba_curr, ++retryCount, 0xFFFFFFFF);
+			EPRINTFARGS("Error reading %d blocks @ LBA %08X from eMMC (try %d), retrying...",
+				num, lba_curr, ++retryCount);
 
 			sleep(500000);
 			if (retryCount >= 10)
 			{
-				gfx_printf(&gfx_con, "%k\nFailed to read %d blocks @ LBA %08X from eMMC. Aborting..%k\n",
-				0xFF0000FF, num, lba_curr, 0xFFFFFFFF);
+				EPRINTFARGS("\nFailed to read %d blocks @ LBA %08X from eMMC. Aborting..",
+				num, lba_curr);
 
 				free(buf);
 				f_close(&fp);
@@ -870,11 +864,8 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 		res = f_write(&fp, buf, NX_EMMC_BLOCKSIZE * num, NULL);
 		if (res)
 		{
-			gfx_printf(&gfx_con, "%k\nFatal error (%d) when writing to SD Card%k\n\n",
-				0xFF0000FF, res, 0xFFFFFFFF);
-
-			gfx_printf(&gfx_con, "%k\nPress any key and try again.%k\n",
-						0xFF0000FF, 0xFFFFFFFF);
+			EPRINTFARGS("\nFatal error (%d) when writing to SD Card", res);
+			EPRINTF("\nPress any key and try again.");
 
 			free(buf);
 			f_close(&fp);
@@ -892,7 +883,7 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 		bytesWritten += num * NX_EMMC_BLOCKSIZE;
 
 		// Force a flush after a lot of data if not splitting
-		if (numSplitParts == 0 && bytesWritten >= MULTIPART_SPLIT_SIZE)
+		if (numSplitParts == 0 && bytesWritten >= multipartSplitSize)
 		{
 			f_sync(&fp);
 			bytesWritten = 0;
@@ -926,13 +917,13 @@ static void dump_emmc_selected(dumpType_t dumpType)
 {
 	int res = 0;
 	u32 timer = 0;
-	gfx_clear(&gfx_ctxt, 0xFF000000);
+	gfx_clear(&gfx_ctxt, 0xFF1B1B1B);
 	gfx_con_setpos(&gfx_con, 0, 0);
 
 	if (!sd_mount())
 		goto out;
 
-	gfx_puts(&gfx_con, "Checking for available free space...\n");
+	gfx_puts(&gfx_con, "Checking for available free space...\n\n");
 	// Get SD Card free space for partial dumping
 	f_getfree("", &sd_fs.free_clst, NULL);
 
@@ -940,7 +931,7 @@ static void dump_emmc_selected(dumpType_t dumpType)
 	sdmmc_t sdmmc;
 	if(!sdmmc_storage_init_mmc(&storage, &sdmmc, SDMMC_4, SDMMC_BUS_WIDTH_8, 4))
 	{
-		gfx_printf(&gfx_con, "%kFailed to init eMMC.%k\n", 0xFF0000FF, 0xFFFFFFFF);
+		EPRINTF("Failed to init eMMC.");
 		goto out;
 	}
 
@@ -954,14 +945,14 @@ static void dump_emmc_selected(dumpType_t dumpType)
 		memset(&bootPart, 0, sizeof(bootPart));
 		bootPart.lba_start = 0;
 		bootPart.lba_end = (BOOT_PART_SIZE/NX_EMMC_BLOCKSIZE)-1;
-		for (i=0; i<2; i++)
+		for (i = 0; i < 2; i++)
 		{
 			memcpy(bootPart.name, "BOOT", 4);
 			bootPart.name[4] = (u8)('0' + i);
 			bootPart.name[5] = 0;
 
 			gfx_printf(&gfx_con, "%k%02d: %s (%08X-%08X)%k\n", 0xFFFFDD00, i,
-				bootPart.name, bootPart.lba_start, bootPart.lba_end, 0xFFFFFFFF);
+				bootPart.name, bootPart.lba_start, bootPart.lba_end, 0xFFCCCCCC);
 
 			sdmmc_storage_set_mmc_partition(&storage, i+1);
 			res = dump_emmc_part(bootPart.name, &storage, &bootPart);
@@ -984,7 +975,7 @@ static void dump_emmc_selected(dumpType_t dumpType)
 					continue;
 
 				gfx_printf(&gfx_con, "%k%02d: %s (%08X-%08X)%k\n", 0xFFFFDD00, i++,
-					part->name, part->lba_start, part->lba_end, 0xFFFFFFFF);
+					part->name, part->lba_start, part->lba_end, 0xFFCCCCCC);
 
 				res = dump_emmc_part(part->name, &storage, part);
 			}
@@ -1001,7 +992,7 @@ static void dump_emmc_selected(dumpType_t dumpType)
 			strcpy(rawPart.name, "rawnand.bin");
 			{
 				gfx_printf(&gfx_con, "%k%02d: %s (%08X-%08X)%k\n", 0xFFFFDD00, i++,
-					rawPart.name, rawPart.lba_start, rawPart.lba_end, 0xFFFFFFFF);
+					rawPart.name, rawPart.lba_start, rawPart.lba_end, 0xFFCCCCCC);
 
 				res = dump_emmc_part(rawPart.name, &storage, &rawPart);
 			}
@@ -1009,13 +1000,12 @@ static void dump_emmc_selected(dumpType_t dumpType)
 	}
 
 	gfx_putc(&gfx_con, '\n');
-	gfx_printf(&gfx_con, "%kTime taken: %d seconds.%k\n", 0xFF00FF96, (get_tmr() - timer) / 1000000, 0xFFFFFFFF);
+	gfx_printf(&gfx_con, "%kTime taken: %d seconds.%k\n", 0xFF00FF96, (get_tmr() - timer) / 1000000, 0xFFCCCCCC);
 	sdmmc_storage_end(&storage);
 	if (res)
 		gfx_puts(&gfx_con, "\nDone. Press any key.\n");
 
 out:;
-	sleep(1000000);
 	btn_wait();
 }
 
@@ -1024,27 +1014,13 @@ void dump_emmc_user() { dump_emmc_selected(DUMP_USER); }
 void dump_emmc_boot() { dump_emmc_selected(DUMP_BOOT); }
 void dump_emmc_rawnand() { dump_emmc_selected(DUMP_RAW); }
 
-u32 save_to_file(void * buf, u32 size, const char * filename)
-{
-	FIL fp;
-	if (f_open(&fp, filename, FA_CREATE_ALWAYS | FA_WRITE) != FR_OK) {
-		return -1;
-	}
-
-	f_sync(&fp);
-	f_write(&fp, buf, size, NULL);
-	f_close(&fp);
-
-	return 0;
-}
-
 void dump_package1()
 {
 	u8 * pkg1 = (u8 *)malloc(0x40000);
 	u8 * warmboot = (u8 *)malloc(0x40000);
 	u8 * secmon = (u8 *)malloc(0x40000);
 
-	gfx_clear(&gfx_ctxt, 0xFF000000);
+	gfx_clear(&gfx_ctxt, 0xFF1B1B1B);
 	gfx_con_setpos(&gfx_con, 0, 0);
 
 	if (!sd_mount())
@@ -1054,7 +1030,7 @@ void dump_package1()
 	sdmmc_t sdmmc;
 	if(!sdmmc_storage_init_mmc(&storage, &sdmmc, SDMMC_4, SDMMC_BUS_WIDTH_8, 4))
 	{
-		gfx_printf(&gfx_con, "%kFailed to init eMMC.%k\n", 0xFF0000FF, 0xFFFFFFFF);
+		EPRINTF("Failed to init eMMC.");
 		goto out;
 	}
 	sdmmc_storage_set_mmc_partition(&storage, 1);
@@ -1065,7 +1041,7 @@ void dump_package1()
 	const pk11_hdr_t *hdr = (pk11_hdr_t *)(pkg1 + pkg1_id->pkg11_off + 0x20);
 	if (!pkg1_id)
 	{
-		gfx_printf(&gfx_con, "%kCould not identify package1 version to read TSEC firmware (= '%s').%k\n", 0xFF0000FF, (char *)pkg1 + 0x10, 0xFFFFFFFF);
+		EPRINTFARGS("Could not identify package1 version to read TSEC firmware (= '%s').", (char *)pkg1 + 0x10);
 		goto out;
 	}
 
@@ -1081,40 +1057,40 @@ void dump_package1()
 	pkg1_unpack(warmboot, secmon, pkg1_id, pkg1);
 
 	// display info
-	gfx_printf(&gfx_con, "%kSecure monitor addr: %08X\n", 0xFF0000FF, pkg1_id->secmon_base);
-	gfx_printf(&gfx_con, "%kSecure monitor size: %08X\n", 0xFF0000FF, hdr->sm_size);
-	gfx_printf(&gfx_con, "%kSecure monitor off: %08X\n", 0xFF0000FF, hdr->sm_off);
+	gfx_printf(&gfx_con, "%kSecure monitor addr: %k%08X\n", 0xFF46EAC7, 0xFFCCCCCC, pkg1_id->secmon_base);
+	gfx_printf(&gfx_con, "%kSecure monitor size: %k%08X\n", 0xFF46EAC7, 0xFFCCCCCC, hdr->sm_size);
+	gfx_printf(&gfx_con, "%kSecure monitor ofst: %k%08X\n", 0xFF46EAC7, 0xFFCCCCCC, hdr->sm_off);
 
 	// dump package1
-	if (save_to_file(pkg1, 0x40000, "pkg_decr.bin") == -1) {
-		gfx_printf(&gfx_con, "Failed to create pkg_decr.bin\n");
+	if (sd_save_to_file(pkg1, 0x40000, "pkg_decr.bin")) {
+		EPRINTF("\nFailed to create pkg_decr.bin");
 		goto out;
 	}
-	gfx_puts(&gfx_con, "%kpackage1 dumped to pkg_decr.bin\n");
+	gfx_puts(&gfx_con, "\npackage1 dumped to pkg_decr.bin\n");
 
 	// dump sm
-	if (save_to_file(secmon, 0x40000, "sm.bin") == -1) {
-		gfx_puts(&gfx_con, "Failed to create sm.bin\n");
+	if (sd_save_to_file(secmon, 0x40000, "sm.bin")) {
+		EPRINTF("\nFailed to create sm.bin");
 		goto out;
 	}
 	gfx_puts(&gfx_con, "Secure Monitor dumped to sm.bin\n");
 
 	// dump warmboot
-	if (save_to_file(warmboot, 0x40000, "warmboot.bin") == -1) {
-		gfx_puts(&gfx_con, "Failed to create warmboot.bin\n");
+	if (sd_save_to_file(warmboot, 0x40000, "warmboot.bin")) {
+		EPRINTF("\nFailed to create warmboot.bin");
 		goto out;
 	}
 	gfx_puts(&gfx_con, "Warmboot dumped to warmboot.bin\n");
 
 
 	sdmmc_storage_end(&storage);
-	gfx_puts(&gfx_con, "Done. Press any key.\n");
+	gfx_puts(&gfx_con, "\nDone. Press any key.\n");
 
 out:;
 	free(pkg1);
 	free(secmon);
 	free(warmboot);
-	sleep(1000000);
+
 	btn_wait();
 }
 
@@ -1123,7 +1099,7 @@ void launch_firmware()
 	ini_sec_t *cfg_sec = NULL;
 	LIST_INIT(ini_sections);
 
-	gfx_clear(&gfx_ctxt, 0xFF000000);
+	gfx_clear(&gfx_ctxt, 0xFF1B1B1B);
 	gfx_con_setpos(&gfx_con, 0, 0);
 
 	if (sd_mount())
@@ -1155,23 +1131,55 @@ void launch_firmware()
 					return;
 			}
 			else
-				gfx_printf(&gfx_con, "%kNo launch configurations found.%k\n", 0xFF0000FF, 0xFFFFFFFF);
+				EPRINTF("No launch configurations found.");
 			free(ments);
 		}
 		else
-			gfx_printf(&gfx_con, "%kFailed to load 'hekate_ipl.ini'.%k\n", 0xFF0000FF, 0xFFFFFFFF);
+			EPRINTF("Could not find or open 'hekate_ipl.ini' from SD Card!\nMake sure it exists.");
 	}
 
 	if (!cfg_sec)
-		gfx_printf(&gfx_con, "Using default launch configuration.\n");
+	{
+		sleep(3000000);
+		gfx_printf(&gfx_con, "Using default launch configuration...\n");
+	}
 
 	if (!hos_launch(cfg_sec))
-		gfx_printf(&gfx_con, "%kFailed to launch firmware.%k\n", 0xFF0000FF, 0xFFFFFFFF);
+		EPRINTF("Failed to launch firmware.");
 
 	//TODO: free ini.
 
 out:;
-	sleep(200000);
+	btn_wait();
+}
+
+void toggle_autorcm(){
+	sdmmc_storage_t storage;
+	sdmmc_t sdmmc;
+	if(!sdmmc_storage_init_mmc(&storage, &sdmmc, SDMMC_4, SDMMC_BUS_WIDTH_8, 4))
+	{
+		EPRINTF("Failed to init eMMC.");
+		goto out;
+	}
+
+	u8 *tempbuf = (u8 *)malloc(0x200);
+	sdmmc_storage_set_mmc_partition(&storage, 1);
+	
+	int i, sect = 0;
+	for (i = 0; i < 4; i++)
+	{
+		sect = (0x200 + (0x4000 * i)) / NX_EMMC_BLOCKSIZE;
+		sdmmc_storage_read(&storage, sect, 1, tempbuf);
+		tempbuf[0x10] ^= 0x77; //xor by arbitrary number to corrupt
+		sdmmc_storage_write(&storage, sect, 1, tempbuf);
+	}
+	
+	free(tempbuf);
+	sdmmc_storage_end(&storage);
+	
+	gfx_printf(&gfx_con, "%kAutoRCM mode toggled!%k\n", 0xFF00EE2C, 0xFFCCCCCC);
+
+out:;
 	btn_wait();
 }
 
@@ -1203,21 +1211,24 @@ void about()
 	"             (/`    ( (`          ) )  '-;   %k[switchbrew]%k\n"
 	"              `      '-;         (-'%k";
 
-	gfx_clear(&gfx_ctxt, 0xFF000000);
+	gfx_clear(&gfx_ctxt, 0xFF1B1B1B);
 	gfx_con_setpos(&gfx_con, 0, 0);
 
-	gfx_printf(&gfx_con, octopus, 0xFFFFCC00, 0xFFFFFFFF,
-		0xFFFFCC00, 0xFFCCFF00, 0xFFFFCC00, 0xFFFFFFFF);
+	gfx_printf(&gfx_con, octopus, 0xFFFFCC00, 0xFFCCCCCC,
+		0xFFFFCC00, 0xFFCCFF00, 0xFFFFCC00, 0xFFCCCCCC);
 
-	sleep(1000000);
 	btn_wait();
 }
 
 ment_t ment_cinfo[] = {
 	MDEF_BACK(),
+	MDEF_CHGLINE(),
+	MDEF_CAPTION("---- SoC Info ----", 0xFFE6B90A),
 	MDEF_HANDLER("Print fuse info", print_fuseinfo),
 	MDEF_HANDLER("Print kfuse info", print_kfuseinfo),
 	MDEF_HANDLER("Print TSEC keys", print_tsec_key),
+	MDEF_CHGLINE(),
+	MDEF_CAPTION("-- Storage Info --", 0xFFE6B90A),
 	MDEF_HANDLER("Print eMMC info", print_mmc_info),
 	MDEF_HANDLER("Print SD Card info", print_sdcard_info),
 	MDEF_END()
@@ -1227,15 +1238,44 @@ menu_t menu_cinfo = {
 	"Console info", 0, 0
 };
 
-ment_t ment_tools[] = {
+ment_t ment_autorcm[] = {
+	MDEF_CAPTION("WARNING: This corrupts your BOOT0 partition!", 0xFF00FFE6),
+	MDEF_BACK(),
+	MDEF_BACK(),
+	MDEF_BACK(),
+	MDEF_BACK(),
+	MDEF_HANDLER("Toggle AutoRCM", toggle_autorcm),
+	MDEF_BACK(),
+	MDEF_BACK(),
+	MDEF_BACK(),
 	MDEF_BACK(),
-	MDEF_HANDLER("Dump RAW eMMC", dump_emmc_rawnand),
-	MDEF_HANDLER("Dump eMMC SYS", dump_emmc_system),
-	MDEF_HANDLER("Dump eMMC USER", dump_emmc_user),
-	MDEF_HANDLER("Dump eMMC BOOT", dump_emmc_boot),
-	MDEF_HANDLER("Dump package1", dump_package1),
 	MDEF_END()
 };
+
+menu_t menu_autorcm = {
+	ment_autorcm,
+	"AutoRCM", 0, 0
+};
+
+ment_t ment_tools[] = {
+	MDEF_BACK(),
+	MDEF_CHGLINE(),
+	MDEF_CAPTION("------ Full --------", 0xFFE6B90A),
+	MDEF_HANDLER("Dump RAW eMMC", dump_emmc_rawnand),
+	MDEF_HANDLER("Dump eMMC BOOT", dump_emmc_boot),
+	MDEF_CHGLINE(),
+	MDEF_CAPTION("-- GP Partitions --", 0xFFE6B90A),
+	MDEF_HANDLER("Dump eMMC SYS", dump_emmc_system),
+	MDEF_HANDLER("Dump eMMC USER", dump_emmc_user),
+	MDEF_CHGLINE(),
+	MDEF_CAPTION("------ Misc -------", 0xFFE6B90A),
+	MDEF_HANDLER("Dump package1", dump_package1),
+	MDEF_CHGLINE(),
+	MDEF_CAPTION("---- Dangerous ----", 0xFF0000FF),
+	MDEF_MENU("AutoRCM", &menu_autorcm),
+	MDEF_END()
+};
+
 menu_t menu_tools = {
 	ment_tools,
 	"Tools", 0, 0
@@ -1243,17 +1283,20 @@ menu_t menu_tools = {
 
 ment_t ment_top[] = {
 	MDEF_HANDLER("Launch firmware", launch_firmware),
+	MDEF_CAPTION("---------------", 0xFF444444),
 	MDEF_MENU("Tools", &menu_tools),
 	MDEF_MENU("Console info", &menu_cinfo),
-	MDEF_HANDLER("Reboot (normal)", reboot_normal),
-	MDEF_HANDLER("Reboot (rcm)", reboot_rcm),
+	MDEF_CAPTION("---------------", 0xFF444444),
+	MDEF_HANDLER("Reboot (Normal)", reboot_normal),
+	MDEF_HANDLER("Reboot (RCM)", reboot_rcm),
 	MDEF_HANDLER("Power off", power_off),
+	MDEF_CAPTION("---------------", 0xFF444444),
 	MDEF_HANDLER("About", about),
 	MDEF_END()
 };
 menu_t menu_top = {
 	ment_top,
-	"hekate - ipl", 0, 0
+	"hekate - ipl (CTCaer mod v1.6)", 0, 0
 };
 
 extern void pivot_stack(u32 stack_top);
@@ -1275,7 +1318,7 @@ void ipl_main()
 	//display_color_screen(0xAABBCCDD);
 	u32 *fb = display_init_framebuffer();
 	gfx_init_ctxt(&gfx_ctxt, fb, 720, 1280, 768);
-	gfx_clear(&gfx_ctxt, 0xFF000000);
+	gfx_clear(&gfx_ctxt, 0xFF1B1B1B);
 	gfx_con_init(&gfx_con, &gfx_ctxt);
 
 	while (1)

ipl/pkg1.c

@@ -42,6 +42,7 @@ PATCHSET_DEF(_secmon_2_patchset,
 
 PATCHSET_DEF(_secmon_3_patchset,
 	//Patch package2 decryption and signature/hash checks.
+	{ 0xAC8 + 0xAB4, _NOP() },
 	{ 0xAC8 + 0xA30, _NOP() }, //Header signature.
 	{ 0xAC8 + 0xAC0, _NOP() }, //Version.
 	{ 0xAC8 + 0xADC, _NOP() }  //Sections SHA2.
@@ -78,7 +79,7 @@ PATCHSET_DEF(_secmon_6_patchset,
 static const pkg1_id_t _pkg1_ids[] = {
 	{ "20161121183008", 0, 0x1900, 0x3FE0, { 2, 1, 0 }, 0x40014020, _secmon_1_patchset }, //1.0.0
 	{ "20170210155124", 0, 0x1900, 0x3FE0, { 0, 1, 2 }, 0x4002D000, _secmon_2_patchset }, //2.0.0
-	{ "20170519101410", 1, 0x1A00, 0x3FE0, { 0, 1, 2 }, 0x4002D000, NULL }, //3.0.0
+	{ "20170519101410", 1, 0x1A00, 0x3FE0, { 0, 1, 2 }, 0x4002D000, _secmon_3_patchset }, //3.0.0
 	{ "20170710161758", 2, 0x1A00, 0x3FE0, { 0, 1, 2 }, 0x4002D000, NULL }, //3.0.1
 	{ "20170921172629", 3, 0x1800, 0x3FE0, { 1, 2, 0 }, 0x4002B000, _secmon_5_patchset }, //4.0.0
 	{ "20180220163747", 4, 0x1900, 0x3FE0, { 1, 2, 0 }, 0x4002B000, _secmon_6_patchset }, //5.0.0

ipl/sdmmc.c

@@ -187,7 +187,7 @@ int sdmmc_storage_write(sdmmc_storage_t *storage, u32 sector, u32 num_sectors, v
 }
 
 /*
-* MMC specific functions. 
+* MMC specific functions.
 */
 
 static int _mmc_storage_get_op_cond_inner(sdmmc_storage_t *storage, u32 *pout, u32 power)
@@ -605,7 +605,7 @@ static int _sd_storage_get_op_cond(sdmmc_storage_t *storage, int is_version_1, i
 			if (cond & SD_ROCR_S18A && supports_low_voltage)
 			{
 				//The low voltage regulator configuration is valid for SDMMC1 only.
-				if (storage->sdmmc->id == SDMMC_1 && 
+				if (storage->sdmmc->id == SDMMC_1 &&
 					_sdmmc_storage_execute_cmd_type1(storage, SD_SWITCH_VOLTAGE, 0, 0, R1_STATE_READY))
 				{
 					if (!sdmmc_enable_low_voltage(storage->sdmmc))

ipl/tui.c

@@ -16,6 +16,7 @@
 
 #include "tui.h"
 #include "btn.h"
+#include "ctc_logo2.h"
 
 void tui_pbar(gfx_con_t *con, int x, int y, u32 val)
 {
@@ -41,37 +42,70 @@ void tui_pbar(gfx_con_t *con, int x, int y, u32 val)
 void *tui_do_menu(gfx_con_t *con, menu_t *menu)
 {
 	int idx = 0, cnt;
+	int prev_idx = 0;
 
-	gfx_clear(con->gfx_ctxt, 0xFF000000);
+	gfx_clear(con->gfx_ctxt, 0xFF1B1B1B);
+	gfx_set_logo(con->gfx_ctxt, Kc_HEKATE_LOGO);
 
 	while (1)
 	{
-		gfx_con_setcol(con, 0xFFFFFFFF, 1, 0xFF000000);
+		gfx_con_setcol(con, 0xFFCCCCCC, 1, 0xFF1B1B1B);
 		gfx_con_setpos(con, menu->x, menu->y);
 		gfx_printf(con, "[%s]\n\n", menu->caption);
 
+		// Skip caption or seperator lines selection
+		while (menu->ents[idx].type == MENT_CAPTION ||
+			menu->ents[idx].type == MENT_CHGLINE)
+		{
+			if (prev_idx <= idx || (!idx && prev_idx == cnt - 1))	
+			{				
+				idx++;
+				if (idx > (cnt - 1))
+				{
+					idx = 0;
+					prev_idx = 0;
+				}
+			}
+			else
+			{
+				idx--;
+				if (idx < 0)
+				{
+					idx = cnt - 1;
+					prev_idx = cnt;
+				}
+			}
+		}
+		prev_idx = idx;
+
+		// Draw the menu
 		for (cnt = 0; menu->ents[cnt].type != MENT_END; cnt++)
 		{
 			if (cnt == idx)
-				gfx_con_setcol(con, 0xFF000000, 1, 0xFFCCCCCC);
+				gfx_con_setcol(con, 0xFF1B1B1B, 1, 0xFFCCCCCC);
 			else
-				gfx_con_setcol(con, 0xFFFFFFFF, 1, 0xFF000000);
-			con->x += 8;
-			gfx_printf(con, "%s", menu->ents[cnt].caption);
+				gfx_con_setcol(con, 0xFFCCCCCC, 1, 0xFF1B1B1B);
+			if (cnt != idx && menu->ents[cnt].type == MENT_CAPTION)
+				gfx_printf(con, "%k %s", menu->ents[cnt].color, menu->ents[cnt].caption);
+			else
+				gfx_printf(con, " %s", menu->ents[cnt].caption);
 			if(menu->ents[cnt].type == MENT_MENU)
 				gfx_printf(con, "%k...", 0xFFEE9900);
-			gfx_putc(con, '\n');
+			gfx_printf(con, " \n");
 		}
-
-		gfx_con_setcol(con, 0xFFFFFFFF, 1, 0xFF000000);
+		gfx_con_setcol(con, 0xFFCCCCCC, 1, 0xFF1B1B1B);
 		gfx_putc(con, '\n');
 
 		u32 btn = btn_wait();
 
-		if (btn & BTN_VOL_DOWN && idx < cnt - 1)
+		if (btn & BTN_VOL_DOWN && idx < (cnt - 1))
 			idx++;
+		else if (btn & BTN_VOL_DOWN && idx == (cnt - 1))
+			idx = 0;
 		if (btn & BTN_VOL_UP && idx > 0)
 			idx--;
+		else if (btn & BTN_VOL_UP && idx == 0)
+			idx = cnt - 1;
 		if (btn & BTN_POWER)
 		{
 			ment_t *ent = &menu->ents[idx];
@@ -89,8 +123,11 @@ void *tui_do_menu(gfx_con_t *con, menu_t *menu)
 			case MENT_BACK:
 				return NULL;
 				break;
+			default:
+				break;
 			}
-			gfx_clear(con->gfx_ctxt, 0xFF000000);
+			gfx_clear(con->gfx_ctxt, 0xFF1B1B1B);
+			gfx_set_logo(con->gfx_ctxt, Kc_HEKATE_LOGO);
 		}
 	}
 

ipl/tui.h

@@ -20,16 +20,19 @@
 #include "types.h"
 #include "gfx.h"
 
-#define MENT_END 0
+#define MENT_END     0
 #define MENT_HANDLER 1
-#define MENT_MENU 2
-#define MENT_CHOICE 3
-#define MENT_BACK 4
+#define MENT_MENU    2
+#define MENT_CHOICE  3
+#define MENT_BACK    4
+#define MENT_CAPTION 5
+#define MENT_CHGLINE 6
 
 typedef struct _ment_t
 {
 	u32 type;
 	const char *caption;
+	u32 color;
 	void *data;
 	union
 	{
@@ -47,10 +50,12 @@ typedef struct _menu_t
 } menu_t;
 
 #define MDEF_END() {MENT_END}
-#define MDEF_HANDLER(caption, _handler) { MENT_HANDLER, caption, NULL, { .handler = _handler } }
-#define MDEF_HANDLER_EX(caption, data, _handler) { MENT_HANDLER, caption, data, { .handler = _handler } }
-#define MDEF_MENU(caption, _menu) { MENT_MENU, caption, NULL, { .menu = _menu } }
+#define MDEF_HANDLER(caption, _handler) { MENT_HANDLER, caption, 0, NULL, { .handler = _handler } }
+#define MDEF_HANDLER_EX(caption, data, _handler) { MENT_HANDLER, caption, 0, data, { .handler = _handler } }
+#define MDEF_MENU(caption, _menu) { MENT_MENU, caption, 0, NULL, { .menu = _menu } }
 #define MDEF_BACK() { MENT_BACK, "Back" }
+#define MDEF_CAPTION(caption, color) { MENT_CAPTION, caption, color }
+#define MDEF_CHGLINE() {MENT_CHGLINE}
 
 void tui_pbar(gfx_con_t *con, int x, int y, u32 val);
 void *tui_do_menu(gfx_con_t *con, menu_t *menu);