CTCaer mod v1.3

* Make button check delay 1s to avoid button repressing from "button ip" state
* Dumping: Fix part logic and honor user actions on ignoring errors
* Add time taken to dump emmc

.gitignore

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

ipl/btn.c

@@ -34,24 +34,9 @@ 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,7 +3,6 @@
 /-----------------------------------------------------------------------------/
 /
 / 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
@@ -23,11 +22,6 @@
 #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(...)
 
 /*--------------------------------------------------------------------------
 
@@ -3259,7 +3253,6 @@ 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 */
@@ -3273,11 +3266,9 @@ 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) */
@@ -3300,14 +3291,8 @@ 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) {
-		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 */
-	}
+	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 */
 
 	/* An FAT volume is found (bsect). Following code initializes the filesystem object */
 
@@ -3318,58 +3303,36 @@ 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) {
-			EFSPRINTF("Error: exFAT - Version check failed!");
-			return FR_NO_FILESYSTEM;	/* Check exFAT version (must be version 1.0) */
-		}
+		if (ld_word(fs->win + BPB_FSVerEx) != 0x100) 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) {
-			EFSPRINTF("Error: exFAT - Cannot handle volume LBA with 32-bit LBA!");
-			return FR_NO_FILESYSTEM;	/* (It cannot be handled in 32-bit LBA) */
-		}
+		if (maxlba >= 0x100000000) 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) {
-			EFSPRINTF("Error: exFAT - Multiple or no file allocation tables found!");
-			return FR_NO_FILESYSTEM;	/* (Supports only 1 FAT) */
-		}
+		if (fs->n_fats != 1) return FR_NO_FILESYSTEM;	/* (Supports only 1 FAT) */
 
 		fs->csize = 1 << fs->win[BPB_SecPerClusEx];		/* Cluster size */
-		if (fs->csize == 0)	{
-			EFSPRINTF("Error: exFAT - Cluster size is not between 1KB - 32KB!");
-			return FR_NO_FILESYSTEM;	/* (Must be 1..32768) */
-		}
+		if (fs->csize == 0)	return FR_NO_FILESYSTEM;	/* (Must be 1..32768) */
 
 		nclst = ld_dword(fs->win + BPB_NumClusEx);		/* Number of clusters */
-		if (nclst > MAX_EXFAT) {
-			EFSPRINTF("Error: exFAT - Total clusters exceed allowed!");
-			return FR_NO_FILESYSTEM;	/* (Too many clusters) */
-		}
+		if (nclst > MAX_EXFAT) 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) {
-			EFSPRINTF("Error: exFAT - Volume size is lower than required!");
-			return FR_NO_FILESYSTEM;	/* (Volume size must not be smaller than the size required) */
-		}
+		if (maxlba < (QWORD)fs->database + nclst * fs->csize) return FR_NO_FILESYSTEM;	/* (Volume size must not be smaller than the size requiered) */
 		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) {
-			EFSPRINTF("Error: exFAT - Bitmap location not at first cluster!");
-			return FR_DISK_ERR;
-		}
+		if (move_window(fs, clst2sect(fs, fs->dirbase)) != FR_OK) 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? */
 		}
@@ -3381,62 +3344,38 @@ 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)) {
-			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) */
-		}
+		if (ld_word(fs->win + BPB_BytsPerSec) != SS(fs)) 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) {
-			EFSPRINTF("Error: FAT - No or more than 2 file allocation tables found!");
-			return FR_NO_FILESYSTEM;	/* (Must be 1 or 2) */
-		}
+		if (fs->n_fats != 1 && fs->n_fats != 2) 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))) {
-			EFSPRINTF("Error: FAT - Cluster size is not a power of 2!");
-			return FR_NO_FILESYSTEM;	/* (Must be power of 2) */
-		}
+		if (fs->csize == 0 || (fs->csize & (fs->csize - 1))) 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)) {
-			EFSPRINTF("Error: FAT - Root directory entries are not sector aligned!");
-			return FR_NO_FILESYSTEM;	/* (Must be sector aligned) */
-		}
+		if (fs->n_rootdir % (SS(fs) / SZDIRE)) 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) {
-			EFSPRINTF("Error: FAT - Zero reserved sectors!");
-			return FR_NO_FILESYSTEM;			/* (Must not be 0) */
-		}
+		if (nrsv == 0) 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) {
-			EFSPRINTF("Error: FAT - Invalid volume size!");
-			return FR_NO_FILESYSTEM;	/* (Invalid volume size) */
-		}
+		if (tsect < sysect) return FR_NO_FILESYSTEM;	/* (Invalid volume size) */
 		nclst = (tsect - sysect) / fs->csize;			/* Number of clusters */
-		if (nclst == 0) {
-			EFSPRINTF("Error: FAT - Invalid volume size!");
-			return FR_NO_FILESYSTEM;		/* (Invalid volume size) */
-		}
+		if (nclst == 0) 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) {
-			EFSPRINTF("Error: FAT - Not compatible FAT12/16/32 filesystem!");
-			return FR_NO_FILESYSTEM;
-		}
+		if (fmt == 0) return FR_NO_FILESYSTEM;
 
 		/* Boundaries and Limits */
 		fs->n_fatent = nclst + 2;						/* Number of FAT entries */
@@ -3444,29 +3383,17 @@ 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) {
-				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) */
-			}
+			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) */
 			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)	{
-				EFSPRINTF("Error: FAT - Root entry sector is 0!");
-				return FR_NO_FILESYSTEM;	/* (BPB_RootEntCnt must not be 0) */
-			}
+			if (fs->n_rootdir == 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)) {
-			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 (fs->fsize < (szbfat + (SS(fs) - 1)) / SS(fs)) return FR_NO_FILESYSTEM;	/* (BPB_FATSz must not be less than the size needed) */
 
 #if !FF_FS_READONLY
 		/* Get FSInfo if available */
@@ -3499,7 +3426,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 scratch-pad buffer */
+	fs->dirbuf = DirBuf;	/* Static directory block scratchpad buuffer */
 #endif
 #endif
 #if FF_FS_RPATH != 0
@@ -3577,10 +3504,7 @@ FRESULT f_mount (
 
 	/* Get logical drive number */
 	vol = get_ldnumber(&rp);
-	if (vol < 0) {
-		EFSPRINTF("Error: Invalid drive!");
-		return FR_INVALID_DRIVE;
-	}
+	if (vol < 0) return FR_INVALID_DRIVE;
 	cfs = FatFs[vol];					/* Pointer to fs object */
 
 	if (cfs) {
@@ -3821,14 +3745,8 @@ 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) {
-		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 */
-	}
+	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 */
 	remain = fp->obj.objsize - fp->fptr;
 	if (btr > remain) btr = (UINT)remain;		/* Truncate btr by remaining bytes */
 
@@ -3849,31 +3767,19 @@ FRESULT f_read (
 						clst = get_fat(&fp->obj, fp->clust);	/* Follow cluster chain on the FAT */
 					}
 				}
-				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);
-				}
+				if (clst < 2) ABORT(fs, FR_INT_ERR);
+				if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
 				fp->clust = clst;				/* Update current cluster */
 			}
 			sect = clst2sect(fs, fp->clust);	/* Get current sector */
-			if (sect == 0) {
-				EFSPRINTF("Error: Get current sector error!");
-				ABORT(fs, FR_INT_ERR);
-			}
+			if (sect == 0) 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) {
-					EFSPRINTF("Error: Read - Low level disk I/O!");
-					ABORT(fs, FR_DISK_ERR);
-				}
+				if (disk_read(fs->pdrv, rbuff, sect, cc) != RES_OK) 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) {
@@ -3892,17 +3798,11 @@ 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) {
-						EFSPRINTF("Error: Write-back dirty sector cache!");
-						ABORT(fs, FR_DISK_ERR);
-					}
+					if (disk_write(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);
 					fp->flag &= (BYTE)~FA_DIRTY;
 				}
 #endif
-				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 */
-				}
+				if (disk_read(fs->pdrv, fp->buf, sect, 1) != RES_OK)	ABORT(fs, FR_DISK_ERR);	/* Fill sector cache */
 			}
 #endif
 			fp->sect = sect;
@@ -3944,14 +3844,8 @@ 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) {
-		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 */
-	}
+	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 */
 
 	/* 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) {
@@ -3978,18 +3872,9 @@ FRESULT f_write (
 						clst = create_chain(&fp->obj, fp->clust);	/* Follow or stretch cluster chain on the FAT */
 					}
 				}
-				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);
-				}
+				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);
 				fp->clust = clst;			/* Update current cluster */
 				if (fp->obj.sclust == 0) fp->obj.sclust = clst;	/* Set start cluster if the first write */
 			}
@@ -3997,28 +3882,19 @@ 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) {
-					EFSPRINTF("Error: Write-back sector cache!");
-					ABORT(fs, FR_DISK_ERR);
-				}
+				if (disk_write(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);
 				fp->flag &= (BYTE)~FA_DIRTY;
 			}
 #endif
 			sect = clst2sect(fs, fp->clust);	/* Get current sector */
-			if (sect == 0) {
-				EFSPRINTF("Error: Get current sector error!");
-				ABORT(fs, FR_INT_ERR);
-			}
+			if (sect == 0) 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) {
-					EFSPRINTF("Error: Write - Low level disk I/O!");
-					ABORT(fs, FR_DISK_ERR);
-				}
+				if (disk_write(fs->pdrv, wbuff, sect, cc) != RES_OK) 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 */
@@ -4044,7 +3920,6 @@ 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 = 0xFFCCCCCC;
+	con->fgcol = 0xFFFFFFFF;
 	con->fillbg = 0;
-	con->bgcol = 0xFF1B1B1B;
+	con->bgcol = 0xFF000000;
 }
 
 void gfx_con_setcol(gfx_con_t *con, u32 fgcol, int fillbg, u32 bgcol)
@@ -307,16 +307,3 @@ 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,6 +50,5 @@ 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,21 +433,12 @@ DPRINTF("decrypted and unpacked pkg1\n");
 
 	se_aes_key_clear(8);
 	se_aes_key_clear(11);
-	
-	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;
-	}
+	//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);
 
 	//Clear 'BootConfig'.
 	memset((void *)0x4003D000, 0, 0x3000);
@@ -481,6 +472,8 @@ DPRINTF("decrypted and unpacked pkg1\n");
 	*mb_in = 3;
 	sleep(100);
 
+	
+
 	/*PMC(0x4) = 0x7FFFF3;
 	PMC(0x2C4) = 0xFFFFFFFF;
 	PMC(0x2D8) = 0xFFAFFFFF;

ipl/pkg1.c

@@ -30,22 +30,21 @@ PATCHSET_DEF(_secmon_1_patchset,
 	//Patch package2 decryption and signature/hash checks.
 	{ 0x9F0 + 0xADC, _NOP() }, //Header signature.
 	{ 0x9F0 + 0xB8C, _NOP() }, //Version.
-	{ 0x9F0 + 0xBB0, _NOP() }  //Sections SHA2.
+	{ 0x9F0 + 0xBB0, _NOP() } //Sections SHA2.
 );
 
 PATCHSET_DEF(_secmon_2_patchset,
 	//Patch package2 decryption and signature/hash checks.
 	{ 0xAC8 + 0xAAC, _NOP() }, //Header signature.
 	{ 0xAC8 + 0xB3C, _NOP() }, //Version.
-	{ 0xAC8 + 0xB58, _NOP() }  //Sections SHA2.
+	{ 0xAC8 + 0xB58, _NOP() } //Sections SHA2.
 );
 
 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.
+	{ 0xAC8 + 0xADC, _NOP() } //Sections SHA2.
 );
 
 PATCHSET_DEF(_secmon_5_patchset,
@@ -53,11 +52,10 @@ PATCHSET_DEF(_secmon_5_patchset,
 	{ 0x1218 + 0x6E68, _NOP() }, //Header signature.
 	{ 0x1218 + 0x6E74, _NOP() }, //Version.
 	{ 0x1218 + 0x6FE4, _NOP() }, //Sections SHA2.
-	{ 0x1218 + 0x2DC, _NOP() }   //Unknown.
+	{ 0x1218 + 0x2DC, _NOP() } //Unknown.
 );
 
 PATCHSET_DEF(_secmon_6_patchset,
-	//Patch package2 decryption and signature/hash checks.
 	{ 0x12b0 + 0x4d0, _NOP() },
 	{ 0x12b0 + 0x4dc, _NOP() },
 	{ 0x12b0 + 0x794, _NOP() },
@@ -79,8 +77,8 @@ 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, _secmon_3_patchset }, //3.0.0
-	{ "20170710161758", 2, 0x1A00, 0x3FE0, { 0, 1, 2 }, 0x4002D000, NULL }, //3.0.1
+	{ "20170519101410", 1, 0x1A00, 0x3FE0, { 0, 1, 2 }, 0x4002D000, NULL }, //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
 	{ NULL, 0, 0, 0, 0 } //End.

ipl/pkg1.h

@@ -42,6 +42,7 @@ typedef struct _pkg1_id_t
 	patch_t *secmon_patchset;
 } pkg1_id_t;
 
+
 typedef struct _pk11_hdr_t
 {
 	u32 magic;

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))
@@ -824,22 +824,9 @@ int _sd_storage_enable_highspeed_high_volt(sdmmc_storage_t *storage, u8 *buf)
 
 static void _sd_storage_parse_ssr(sdmmc_storage_t *storage)
 {
-	// unstuff_bits supports only 4 u32 so break into 2 x 16byte groups
-	u32 raw_ssr1[4];
-	u32 raw_ssr2[4];
-
-	raw_ssr1[3] = *(u32 *)&storage->raw_ssr[12];
-	raw_ssr1[2] = *(u32 *)&storage->raw_ssr[8];
-	raw_ssr1[1] = *(u32 *)&storage->raw_ssr[4];
-	raw_ssr1[0] = *(u32 *)&storage->raw_ssr[0];
-
-	raw_ssr2[3] = *(u32 *)&storage->raw_ssr[28];
-	raw_ssr2[2] = *(u32 *)&storage->raw_ssr[24];
-	raw_ssr2[1] = *(u32 *)&storage->raw_ssr[20];
-	raw_ssr2[0] = *(u32 *)&storage->raw_ssr[16];
-
-	storage->ssr.bus_width = unstuff_bits(raw_ssr1, 510 - 384, 2) & SD_BUS_WIDTH_4 ? 4 : 1;
-	switch(unstuff_bits(raw_ssr1, 440 - 384, 8))
+	u32 *raw_ssr = (u32 *)&(storage->raw_ssr);
+	storage->ssr.bus_width = unstuff_bits(raw_ssr, 510 - 384, 2) & SD_BUS_WIDTH_4 ? 4 : 1;
+	switch(unstuff_bits(raw_ssr, 440 - 384, 8))
 	{
 	case 0:
 		storage->ssr.speed_class = 0;
@@ -857,13 +844,12 @@ static void _sd_storage_parse_ssr(sdmmc_storage_t *storage)
 		storage->ssr.speed_class = 10;
 		break;
 	default:
-		storage->ssr.speed_class = unstuff_bits(raw_ssr1, 440 - 384, 8);
+		storage->ssr.speed_class = unstuff_bits(raw_ssr, 440 - 384, 8);
 		break;
 	}
-	storage->ssr.uhs_grade = unstuff_bits(raw_ssr1, 396 - 384, 4);
-	storage->ssr.video_class = unstuff_bits(raw_ssr1, 384 - 384, 8);
-
-	storage->ssr.app_class = unstuff_bits(raw_ssr2, 336 - 256, 4);
+	storage->ssr.uhs_grade = unstuff_bits(raw_ssr, 396 - 384, 4);
+	storage->ssr.video_class = unstuff_bits(raw_ssr, 384 - 384, 8);
+	storage->ssr.app_class = unstuff_bits(raw_ssr + 16, 472 + 4 - 384, 4);
 }
 
 static int _sd_storage_get_ssr(sdmmc_storage_t *storage, u8 *buf)
@@ -908,17 +894,17 @@ static void _sd_storage_parse_cid(sdmmc_storage_t *storage)
 	u32 *raw_cid = (u32 *)&(storage->raw_cid);
 
 	storage->cid.manfid = unstuff_bits(raw_cid, 120, 8);
-	storage->cid.oemid  = unstuff_bits(raw_cid, 104, 16);
+	storage->cid.oemid = unstuff_bits(raw_cid, 104, 16);
 	storage->cid.prod_name[0] = unstuff_bits(raw_cid, 96, 8);
 	storage->cid.prod_name[1] = unstuff_bits(raw_cid, 88, 8);
 	storage->cid.prod_name[2] = unstuff_bits(raw_cid, 80, 8);
 	storage->cid.prod_name[3] = unstuff_bits(raw_cid, 72, 8);
 	storage->cid.prod_name[4] = unstuff_bits(raw_cid, 64, 8);
-	storage->cid.hwrev  = unstuff_bits(raw_cid, 60, 4);
-	storage->cid.fwrev  = unstuff_bits(raw_cid, 56, 4);
+	storage->cid.hwrev = unstuff_bits(raw_cid, 60, 4);
+	storage->cid.fwrev = unstuff_bits(raw_cid, 56, 4);
 	storage->cid.serial = unstuff_bits(raw_cid, 24, 32);
-	storage->cid.month  = unstuff_bits(raw_cid, 8, 4);
-	storage->cid.year   = unstuff_bits(raw_cid, 12, 8) + 2000;
+	storage->cid.month = unstuff_bits(raw_cid, 8, 4);
+	storage->cid.year = unstuff_bits(raw_cid, 12, 8) + 2000;
 }
 
 static void _sd_storage_parse_csd(sdmmc_storage_t *storage)
@@ -926,9 +912,8 @@ static void _sd_storage_parse_csd(sdmmc_storage_t *storage)
 	u32 *raw_csd = (u32 *)&(storage->raw_csd);
 
 	storage->csd.structure = unstuff_bits(raw_csd, 126, 2);
-	storage->csd.cmdclass  = unstuff_bits(raw_csd, 84, 12);
-	storage->csd.read_blkbits  = unstuff_bits(raw_csd, 80, 4);
-	storage->csd.write_protect = unstuff_bits(raw_csd, 12, 2);
+	storage->csd.cmdclass = unstuff_bits(raw_csd, 84, 12);
+	storage->csd.read_blkbits = unstuff_bits(raw_csd, 80, 4);
 	switch(storage->csd.structure)
 	{
 	case 0:

ipl/sdmmc.h

@@ -36,17 +36,16 @@ typedef struct _mmc_cid
 
 typedef struct _mmc_csd
 {
-	u8  structure;
-	u8  mmca_vsn;
-	u16 cmdclass;
-	u32 c_size;
-	u32 r2w_factor;
-	u32 max_dtr;
-	u32 erase_size;		/* In sectors */
-	u32 read_blkbits;
-	u32 write_blkbits;
-	u32 capacity;
-	u8  write_protect;  
+	u8		structure;
+	u8		mmca_vsn;
+	u16		cmdclass;
+	u32		c_size;
+	u32		r2w_factor;
+	u32		max_dtr;
+	u32		erase_size;		/* In sectors */
+	u32		read_blkbits;
+	u32		write_blkbits;
+	u32		capacity;
 } mmc_csd_t;
 
 typedef struct _mmc_ext_csd

ipl/se.h

@@ -26,5 +26,4 @@ void se_aes_key_clear(u32 ks);
 int se_aes_unwrap_key(u32 ks_dst, u32 ks_src, const void *input);
 int se_aes_crypt_block_ecb(u32 ks, u32 enc, void *dst, const void *src);
 int se_aes_crypt_ctr(u32 ks, void *dst, u32 dst_size, const void *src, u32 src_size, void *ctr);
-
 #endif

ipl/tui.c

@@ -16,7 +16,6 @@
 
 #include "tui.h"
 #include "btn.h"
-#include "ctc_logo2.h"
 
 void tui_pbar(gfx_con_t *con, int x, int y, u32 val)
 {
@@ -42,70 +41,37 @@ 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, 0xFF1B1B1B);
-	gfx_set_logo(con->gfx_ctxt, Kc_HEKATE_LOGO);
+	gfx_clear(con->gfx_ctxt, 0xFF000000);
 
 	while (1)
 	{
-		gfx_con_setcol(con, 0xFFCCCCCC, 1, 0xFF1B1B1B);
+		gfx_con_setcol(con, 0xFFFFFFFF, 1, 0xFF000000);
 		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, 0xFF1B1B1B, 1, 0xFFCCCCCC);
+				gfx_con_setcol(con, 0xFF000000, 1, 0xFFCCCCCC);
 			else
-				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);
+				gfx_con_setcol(con, 0xFFFFFFFF, 1, 0xFF000000);
+			con->x += 8;
+			gfx_printf(con, "%s", menu->ents[cnt].caption);
 			if(menu->ents[cnt].type == MENT_MENU)
 				gfx_printf(con, "%k...", 0xFFEE9900);
-			gfx_printf(con, " \n");
+			gfx_putc(con, '\n');
 		}
-		gfx_con_setcol(con, 0xFFCCCCCC, 1, 0xFF1B1B1B);
+
+		gfx_con_setcol(con, 0xFFFFFFFF, 1, 0xFF000000);
 		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];
@@ -123,11 +89,8 @@ void *tui_do_menu(gfx_con_t *con, menu_t *menu)
 			case MENT_BACK:
 				return NULL;
 				break;
-			default:
-				break;
 			}
-			gfx_clear(con->gfx_ctxt, 0xFF1B1B1B);
-			gfx_set_logo(con->gfx_ctxt, Kc_HEKATE_LOGO);
+			gfx_clear(con->gfx_ctxt, 0xFF000000);
 		}
 	}
 

ipl/tui.h

@@ -20,19 +20,16 @@
 #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_CAPTION 5
-#define MENT_CHGLINE 6
+#define MENT_MENU 2
+#define MENT_CHOICE 3
+#define MENT_BACK 4
 
 typedef struct _ment_t
 {
 	u32 type;
 	const char *caption;
-	u32 color;
 	void *data;
 	union
 	{
@@ -50,12 +47,10 @@ typedef struct _menu_t
 } menu_t;
 
 #define MDEF_END() {MENT_END}
-#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_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_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);