[sdmmc] Change internal read/write retries

This can fix busy errors when writing to sd cards. Additionally it now returns properly on success
v2.0 (and like always, transfer unmerged PRs)
2018-05-29 02:30:43 +03:00 · 2018-05-29 02:20:03 +03:00 · 2018-05-29 02:11:22 +03:00 · 2018-05-29 02:05:29 +03:00 · 2018-05-25 01:28:03 -07:00 · 2018-05-25 01:28:03 -07:00
11 changed files with 2562 additions and 143 deletions
--- a/ipl/btn.c
+++ b/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;
 }
--- a/ipl/ctc_logo2.h
+++ b/ipl/ctc_logo2.h
--- a/ipl/ff.c
+++ b/ipl/ff.c
@@ -26,7 +26,7 @@
 #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(text, ...) gfx_printf(&gfx_con, "\n\n\n%k[FatFS] "text"%k\n", 0xFF00FFFF, 0xFFFFFFFF)
 //#define EFSPRINTF(...)

 /*--------------------------------------------------------------------------
--- a/ipl/gfx.c
+++ b/ipl/gfx.c
@@ -82,14 +82,21 @@ void gfx_clear(gfx_ctxt_t *ctxt, u32 color)
 		ctxt->fb[i] = color;
 }

+void gfx_con_setfontsz(gfx_con_t *con, u8 font_size)
+{
+	con->fntsz = font_size;
+	con->fontmult = font_size / 8;
+}
+
 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;
+	gfx_con_setfontsz(con, 16);
 }

 void gfx_con_setcol(gfx_con_t *con, u32 fgcol, int fillbg, u32 bgcol)
@@ -117,27 +124,45 @@ void gfx_putc(gfx_con_t *con, char c)
 	{
 		u8 *cbuf = (u8 *)&_gfx_font[8 * (c - 32)];
 		u32 *fb = con->gfx_ctxt->fb + con->x + con->y * con->gfx_ctxt->stride;
-		for (u32 i = 0; i < 8; i++)
+		for (u32 i = 0; i < con->fntsz; i+=con->fontmult)
 		{
 			u8 v = *cbuf++;
-			for (u32 j = 0; j < 8; j++)
+			for (u32 k = 0; k < con->fontmult; k++)
 			{
-				if (v & 1)
-					*fb = con->fgcol;
-				else if (con->fillbg)
-					*fb = con->bgcol;
-				v >>= 1;
-				fb++;
+				for (u32 j = 0; j < con->fntsz; j+=con->fontmult)
+				{
+					if (v & 1)
+					{
+						*fb = con->fgcol;
+						for(u32 l = 0; l < con->fontmult - 1; l++)
+						{
+							fb++;
+							*fb = con->fgcol;
+						}
+					}
+					else if (con->fillbg)
+					{
+						*fb = con->bgcol;
+						for(u32 l = 0; l < con->fontmult - 1; l++)
+						{
+							fb++;
+							*fb = con->bgcol;
+						}
+					}
+					v >>= 1;
+					fb++;
+				}
+				fb += con->gfx_ctxt->stride - con->fntsz;
+				v = *cbuf;
 			}
-			fb += con->gfx_ctxt->stride - 8;
 		}
-		con->x += 8;
+		con->x += con->fntsz;
 	}
 	else if (c == '\n')
 	{
 		con->x = 0;
-		con->y += 8;
-		if (con->y > con->gfx_ctxt->height - 8)
+		con->y += con->fntsz;
+		if (con->y > con->gfx_ctxt->height - con->fntsz)
 			con->y = 0;
 	}
 }
@@ -182,6 +207,13 @@ static void _gfx_putn(gfx_con_t *con, u32 v, int base, char fill, int fcnt)
 	gfx_puts(con, p);
 }

+void gfx_putsep(gfx_con_t *con)
+{
+	gfx_con_setfontsz(con, 8);
+	gfx_putc(con, '\n');
+	gfx_con_setfontsz(con, 16);
+}
+
 void gfx_printf(gfx_con_t *con, const char *fmt, ...)
 {
 	va_list ap;
@@ -255,6 +287,8 @@ void gfx_printf(gfx_con_t *con, const char *fmt, ...)

 void gfx_hexdump(gfx_con_t *con, u32 base, const u8 *buf, u32 len)
 {
+	u8 prevFontSize = con->fntsz;
+	gfx_con_setfontsz(con, 8);
 	for(u32 i = 0; i < len; i++)
 	{
 		if(i % 0x10 == 0)
@@ -277,6 +311,7 @@ void gfx_hexdump(gfx_con_t *con, u32 base, const u8 *buf, u32 len)
 		gfx_printf(con, "%02x ", buf[i]);
 	}
 	gfx_putc(con, '\n');
+	gfx_con_setfontsz(con, prevFontSize);
 }

 static int abs(int x)
@@ -307,3 +342,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;
+		}
+	}
+}
--- a/ipl/gfx.h
+++ b/ipl/gfx.h
@@ -35,6 +35,8 @@ typedef struct _gfx_con_t
 	u32 fgcol;
 	int fillbg;
 	u32 bgcol;
+	u32 fntsz;
+	u32 fontmult;
 } gfx_con_t;

 void gfx_init_ctxt(gfx_ctxt_t *ctxt, u32 *fb, u32 width, u32 height, u32 stride);
@@ -43,6 +45,7 @@ void gfx_con_init(gfx_con_t *con, gfx_ctxt_t *ctxt);
 void gfx_con_setcol(gfx_con_t *con, u32 fgcol, int fillbg, u32 bgcol);
 void gfx_con_getpos(gfx_con_t *con, u32 *x, u32 *y);
 void gfx_con_setpos(gfx_con_t *con, u32 x, u32 y);
+void gfx_con_setfontsz(gfx_con_t *con, u8 font_size);
 void gfx_putc(gfx_con_t *con, char c);
 void gfx_puts(gfx_con_t *con, const char *s);
 void gfx_printf(gfx_con_t *con, const char *fmt, ...);
@@ -50,5 +53,7 @@ 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_putsep(gfx_con_t *con);
+void gfx_set_logo(gfx_ctxt_t *ctxt, const u8 *buf);

 #endif
--- a/ipl/hos.c
+++ b/ipl/hos.c
@@ -145,6 +145,7 @@ int keygen(u8 *keyblob, u32 kb, void *tsec_fw)
 	switch (kb) {
 		case KB_FIRMWARE_VERSION_100_200:
 		case KB_FIRMWARE_VERSION_300:
+		case KB_FIRMWARE_VERSION_301:
 			se_aes_unwrap_key(0x0D, 0x0F, console_keyseed);
 			se_aes_unwrap_key(0x0C, 0x0C, master_keyseed_retail);
 		break;
@@ -212,10 +213,10 @@ static int _read_emmc_pkg1(launch_ctxt_t *ctxt)
 	ctxt->pkg1_id = pkg1_identify(ctxt->pkg1);
 	if (!ctxt->pkg1_id)
 	{
-		DPRINTF("%kCould not identify package 1 version (= '%s').%k\n", 0xFF0000FF, (char *)ctxt->pkg1 + 0x10, 0xFFFFFFFF);
+		DPRINTF("%kCould not identify package1,\nversion (= '%s').%k\n", 0xFF0000FF, (char *)ctxt->pkg1 + 0x10, 0xFFFFFFFF);
 		goto out;
 	}
-	DPRINTF("Identified package1 ('%s'), keyblob version %d\n", (char *)(ctxt->pkg1 + 0x10), ctxt->pkg1_id->kb);
+	DPRINTF("Identified package1 ('%s'),\nkeyblob version %d\n", (char *)(ctxt->pkg1 + 0x10), ctxt->pkg1_id->kb);

 	//Read the correct keyblob.
 	ctxt->keyblob = (u8 *)malloc(NX_EMMC_BLOCKSIZE);
@@ -431,14 +432,25 @@ 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);
+	se_aes_key_clear(0x8);
+	se_aes_key_clear(0xB);
+	
+	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(0xC, 0xFF);
+			se_key_acc_ctrl(0xD, 0xFF);
+			break;
+		default:
+		case KB_FIRMWARE_VERSION_400:
+		case KB_FIRMWARE_VERSION_500:
+			se_key_acc_ctrl(0xC, 0xFF);
+			//se_key_acc_ctrl(0xD, 0xFF);
+			//se_key_acc_ctrl(0xE, 0xFF);
+			se_key_acc_ctrl(0xF, 0xFF);
+			break;
+	}

 	//Clear 'BootConfig'.
 	memset((void *)0x4003D000, 0, 0x3000);
--- a/ipl/main.c
+++ b/ipl/main.c
@@ -53,8 +53,8 @@ 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, 0xFFFFFFFF)
-#define EPRINTFARGS(text, args...) gfx_printf(&gfx_con, "%k"text"%k\n", 0xFF0000FF, args, 0xFFFFFFFF)
+#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;
@@ -69,7 +69,7 @@ int sd_mount()

 	if (!sdmmc_storage_init_sd(&sd_storage, &sd_sdmmc, SDMMC_1, SDMMC_BUS_WIDTH_4, 11))
 	{
-		EPRINTF("Failed to init SD card (make sure that it is inserted).");
+		EPRINTF("Failed to init SD card.\nMake sure that it is inserted.");
 	}
 	else
 	{
@@ -82,7 +82,7 @@ int sd_mount()
 		}
 		else
 		{
-			EPRINTFARGS("Failed to mount SD card (FatFS Error %d).\n(make sure that a FAT32/exFAT partition exists)", res);
+			EPRINTFARGS("Failed to mount SD card (FatFS Error %d).\n(make sure that a FAT type partition exists)", res);
 		}
 	}

@@ -336,22 +336,19 @@ 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", 0xFFFFDD00, 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;
@@ -361,17 +358,17 @@ void print_fuseinfo()
 			else
 				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", 0xFFFFDD00, 0xFFCCCCCC);
 	u32 buf[KFUSE_NUM_WORDS];
 	if (!kfuse_read(buf))
 		EPRINTF("CRC fail.");
@@ -380,14 +377,11 @@ void print_kfuseinfo()

 	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;
@@ -397,14 +391,14 @@ void print_kfuseinfo()
 			else
 				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  = 11;
@@ -422,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 */
@@ -466,7 +460,7 @@ void print_mmc_info()
 		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;
@@ -509,22 +503,30 @@ void print_mmc_info()
 				 Cmd Classes:   %02X\n\
 				 Capacity:      %s\n\
 				 Max Speed:     %d MB/s (%d MHz)\n\
-				 Type Support:  %s\n\n",
+				 Type Support:  ",
 				storage.csd.mmca_vsn, storage.ext_csd.rev, storage.ext_csd.dev_version, storage.csd.cmdclass,
-				storage.csd.capacity == (4096 * 512) ? "High" : "Low", speed & 0xFFFF, (speed >> 16) & 0xFFFF, card_type_support);
+				storage.csd.capacity == (4096 * 512) ? "High" : "Low", speed & 0xFFFF, (speed >> 16) & 0xFFFF);
+			gfx_con_setfontsz(&gfx_con, 8);
+			gfx_printf(&gfx_con, "%s", card_type_support);
+			gfx_con_setfontsz(&gfx_con, 16);
+			gfx_printf(&gfx_con, "\n\n", card_type_support);

 			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      %k\n    Size: %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_putsep(&gfx_con);
+			gfx_printf(&gfx_con, " 2: %kBOOT1      %k\n    Size: %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_putsep(&gfx_con);
+			gfx_printf(&gfx_con, " 3: %kRPMB       %k\n    Size: %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,
+			gfx_putsep(&gfx_con);
+			gfx_printf(&gfx_con, " 0: %kGPP (USER) %k\n    Size: %5d 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, 0xFFFFFFFF);
+			gfx_putsep(&gfx_con);
+			gfx_printf(&gfx_con, "%kGPP (eMMC USER) partition table:%k\n", 0xFFFFDD00, 0xFFCCCCCC);

 			sdmmc_storage_set_mmc_partition(&storage, 0);
 			LIST_INIT(gpt);
@@ -532,22 +534,23 @@ 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)\n     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);
+				gfx_putsep(&gfx_con);
 			}
 		}
 	}
+
 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  = 11;
@@ -556,7 +559,7 @@ void print_sdcard_info()
 	{
 		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\
@@ -571,7 +574,7 @@ 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);
+		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,
 			" Cmd Classes:    %02X\n\
@@ -588,19 +591,17 @@ void print_sdcard_info()

 		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;
@@ -615,6 +616,7 @@ void print_tsec_key()
 	const pkg1_id_t *pkg1_id = pkg1_identify(pkg1);
 	if (!pkg1_id)
 	{
+		gfx_con_setfontsz(&gfx_con, 8);
 		EPRINTFARGS("Could not identify package1 version to read TSEC firmware (= '%s').",
 			(char *)pkg1 + 0x10);
 		goto out;
@@ -625,7 +627,7 @@ 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", 0xFFFFDD00, i, 0xFFCCCCCC);
 		if (res >= 0)
 		{
 			for (u32 i = 0; i < 0x10; i++)
@@ -639,7 +641,8 @@ void print_tsec_key()
 out:;
 	free(pkg1);
 	sdmmc_storage_end(&storage);
-	sleep(1000000);
+
+	gfx_puts(&gfx_con, "\nPress any key...\n");
 	btn_wait();
 }

@@ -686,7 +689,8 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 	memcpy(partialIdxFilename, "partial.idx", 11);
 	partialIdxFilename[11] = 0;

-	gfx_printf(&gfx_con, "SD Card free space: %d MiB, Total dump size %d MiB\n",
+	gfx_con_setfontsz(&gfx_con, 8);
+	gfx_printf(&gfx_con, "\nSD Card free space: %d MiB, Total dump size %d MiB\n\n",
 		sd_fs.free_clst * sd_fs.csize >> SECTORS_TO_MIB_COEFF,
 		totalSectors >> SECTORS_TO_MIB_COEFF);

@@ -701,10 +705,11 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 	{
 		isSmallSdCard = 1;

-		gfx_printf(&gfx_con, "%k\nSD 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_con_setfontsz(&gfx_con, 16);
 			EPRINTF("Not enough free space for partial dumping.");

 			return 0;
@@ -713,7 +718,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.
@@ -724,6 +729,7 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)

 		if (!maxSplitParts)
 		{
+			gfx_con_setfontsz(&gfx_con, 16);
 			EPRINTF("Not enough free space for partial dumping.");

 			return 0;
@@ -733,7 +739,7 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 		maxSplitParts += currPartIdx;
 	}
 	else if (isSmallSdCard)
-		gfx_printf(&gfx_con, "%kPartial dumping enabled (with %d MiB parts)...%k\n\n", 0xFF00BAFF, multipartSplitSize >> 20, 0xFFFFFFFF);
+		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)
@@ -772,7 +778,8 @@ 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)
 	{
-		EPRINTFARGS("Error creating file %s.", outFilename);
+		gfx_con_setfontsz(&gfx_con, 16);
+		EPRINTFARGS("Error creating file %s.\n", outFilename);

 		return 0;
 	}
@@ -819,7 +826,8 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 				}
 				else
 				{
-					EPRINTF("\nError creating partial.idx file.");
+					gfx_con_setfontsz(&gfx_con, 16);
+					EPRINTF("\nError creating partial.idx file.\n");

 					free(buf);
 					return 0;
@@ -833,6 +841,7 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 						   Don\'t move the partial.idx file!\n\
 						3. Unplug and re-plug USB while pressing Vol+.\n\
 						4. Run hekate - ipl again and press Dump RAW eMMC or eMMC USER to continue\n");
+					gfx_con_setfontsz(&gfx_con, 16);

 					free(buf);
 					return 1;
@@ -842,7 +851,8 @@ 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)
 			{
-				EPRINTFARGS("Error creating file %s.", outFilename);
+				gfx_con_setfontsz(&gfx_con, 16);
+				EPRINTFARGS("Error creating file %s.\n", outFilename);

 				free(buf);
 				return 0;
@@ -854,14 +864,16 @@ 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))
 		{
-			EPRINTFARGS("Error reading %d blocks @ LBA %08X from eMMC (try %d)",
+			EPRINTFARGS("Error reading %d blocks @ LBA %08X from eMMC (try %d), retrying...",
 				num, lba_curr, ++retryCount);

-			sleep(500000);
-			if (retryCount >= 10)
+			sleep(150000);
+			if (retryCount >= 3)
 			{
-				EPRINTFARGS("\nFailed to read %d blocks @ LBA %08X from eMMC. Aborting..",
+				gfx_con_setfontsz(&gfx_con, 16);
+				EPRINTFARGS("\nFailed to read %d blocks @ LBA %08X\nfrom eMMC. Aborting..\n",
 				num, lba_curr);
+				EPRINTF("\nPress any key and try again.\n");

 				free(buf);
 				f_close(&fp);
@@ -871,8 +883,9 @@ 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_con_setfontsz(&gfx_con, 16);
 			EPRINTFARGS("\nFatal error (%d) when writing to SD Card", res);
-			EPRINTF("\nPress any key and try again.");
+			EPRINTF("\nPress any key and try again.\n");

 			free(buf);
 			f_close(&fp);
@@ -901,13 +914,14 @@ int dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t *part)
 out:;
 	free(buf);
 	f_close(&fp);
+	gfx_con_setfontsz(&gfx_con, 16);
 	// Remove partial dump index file if no fatal errors occurred.
 	if(isSmallSdCard)
 	{
 		f_unlink(partialIdxFilename);
-		gfx_printf(&gfx_con, "\n\nYou can now join the files and get the complete raw eMMC dump.");
+		gfx_printf(&gfx_con, "\n\nYou can now join the files\nand get the complete raw eMMC dump.");
 	}
-	gfx_putc(&gfx_con, '\n');
+	gfx_puts(&gfx_con, "\n\n");

 	return 1;
 }
@@ -924,7 +938,7 @@ 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())
@@ -958,8 +972,8 @@ static void dump_emmc_selected(dumpType_t dumpType)
 			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);
+			gfx_printf(&gfx_con, "%k%02d: %s (%07X-%07X)%k\n", 0xFFFFDD00, i,
+				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);
@@ -981,8 +995,8 @@ static void dump_emmc_selected(dumpType_t dumpType)
 				if ((dumpType & DUMP_SYSTEM) == 0 && strcmp(part->name, "USER"))
 					continue;

-				gfx_printf(&gfx_con, "%k%02d: %s (%08X-%08X)%k\n", 0xFFFFDD00, i++,
-					part->name, part->lba_start, part->lba_end, 0xFFFFFFFF);
+				gfx_printf(&gfx_con, "%k%02d: %s (%07X-%07X)%k\n", 0xFFFFDD00, i++,
+					part->name, part->lba_start, part->lba_end, 0xFFCCCCCC);

 				res = dump_emmc_part(part->name, &storage, part);
 			}
@@ -998,8 +1012,8 @@ static void dump_emmc_selected(dumpType_t dumpType)
 			rawPart.lba_end = RAW_AREA_NUM_SECTORS-1;
 			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);
+				gfx_printf(&gfx_con, "%k%02d: %s (%07X-%07X)%k\n", 0xFFFFDD00, i++,
+					rawPart.name, rawPart.lba_start, rawPart.lba_end, 0xFFCCCCCC);

 				res = dump_emmc_part(rawPart.name, &storage, &rawPart);
 			}
@@ -1007,13 +1021,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();
 }

@@ -1028,7 +1041,7 @@ void dump_package1()
 	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())
@@ -1049,6 +1062,7 @@ void dump_package1()
 	const pk11_hdr_t *hdr = (pk11_hdr_t *)(pkg1 + pkg1_id->pkg11_off + 0x20);
 	if (!pkg1_id)
 	{
+		gfx_con_setfontsz(&gfx_con, 8);
 		EPRINTFARGS("Could not identify package1 version to read TSEC firmware (= '%s').", (char *)pkg1 + 0x10);
 		goto out;
 	}
@@ -1065,40 +1079,40 @@ void dump_package1()
 	pkg1_unpack(warmboot, secmon, pkg1_id, pkg1);

 	// display info
-	gfx_printf(&gfx_con, "%kSecure monitor addr: %08X\n", 0xFF00FFA8, pkg1_id->secmon_base);
-	gfx_printf(&gfx_con, "%kSecure monitor size: %08X\n", 0xFF00FFA8, hdr->sm_size);
-	gfx_printf(&gfx_con, "%kSecure monitor off: %08X\n", 0xFF00FFA8, 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 (sd_save_to_file(pkg1, 0x40000, "pkg_decr.bin")) {
-		gfx_printf(&gfx_con, "Failed to create pkg_decr.bin\n");
+		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 (sd_save_to_file(secmon, 0x40000, "sm.bin")) {
-		gfx_puts(&gfx_con, "Failed to create sm.bin\n");
+		EPRINTF("\nFailed to create sm.bin");
 		goto out;
 	}
 	gfx_puts(&gfx_con, "Secure Monitor dumped to sm.bin\n");

 	// dump warmboot
 	if (sd_save_to_file(warmboot, 0x40000, "warmboot.bin")) {
-		gfx_puts(&gfx_con, "Failed to create warmboot.bin\n");
+		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();
 }

@@ -1107,7 +1121,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())
@@ -1143,11 +1157,14 @@ void launch_firmware()
 			free(ments);
 		}
 		else
-			EPRINTF("Failed to load 'hekate_ipl.ini'.");
+			EPRINTF("Could not find or open 'hekate_ipl.ini'.\nMake sure it exists in SD Card!.");
 	}

 	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))
 		EPRINTF("Failed to launch firmware.");
@@ -1155,7 +1172,6 @@ void launch_firmware()
 	//TODO: free ini.

 out:;
-	sleep(200000);
 	btn_wait();
 }

@@ -1164,7 +1180,7 @@ void toggle_autorcm(){
 	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;
 	}

@@ -1183,15 +1199,15 @@ void toggle_autorcm(){
 	free(tempbuf);
 	sdmmc_storage_end(&storage);
 	
-	gfx_printf(&gfx_con, "%kAutoRCM mode toggled!%k\n", 0xFF00EE2C, 0xFFFFFFFF);
+	gfx_printf(&gfx_con, "%kAutoRCM mode toggled!%k\n", 0xFF00EE2C, 0xFFCCCCCC);

 out:;
-	sleep(1000000);
 	btn_wait();
 }

 void about()
 {
+	gfx_con_setfontsz(&gfx_con, 8);
 	static const char octopus[] =
 	"hekate (c) 2018 naehrwert, st4rk\n\n"
 	"Thanks to: %kderrek, nedwill, plutoo, shuffle2, smea, thexyz, yellows8%k\n\n"
@@ -1218,21 +1234,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()
@@ -1243,6 +1262,7 @@ menu_t menu_cinfo = {
 };

 ment_t ment_autorcm[] = {
+	MDEF_CAPTION("WARNING: This corrupts your BOOT0 partition!", 0xFF00FFE6),
 	MDEF_BACK(),
 	MDEF_BACK(),
 	MDEF_BACK(),
@@ -1262,11 +1282,19 @@ menu_t menu_autorcm = {

 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_HANDLER("Dump eMMC BOOT", dump_emmc_boot),
+	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()
 };
@@ -1278,17 +1306,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 v2.0)", 0, 0
 };

 extern void pivot_stack(u32 stack_top);
@@ -1310,7 +1341,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)
--- a/ipl/pkg1.c
+++ b/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,8 +79,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, NULL }, //3.0.0
-	{ "20170710161758", 2, 0x1A00, 0x3FE0, { 0, 1, 2 }, 0x4002D000, NULL }, //3.0.1
+	{ "20170519101410", 1, 0x1A00, 0x3FE0, { 0, 1, 2 }, 0x4002D000, _secmon_3_patchset }, //3.0.0
+	{ "20170710161758", 2, 0x1A00, 0x3FE0, { 0, 1, 2 }, 0x4002D000, _secmon_3_patchset }, //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.
--- a/ipl/sdmmc.c
+++ b/ipl/sdmmc.c
@@ -165,15 +165,27 @@ static int _sdmmc_storage_readwrite(sdmmc_storage_t *storage, u32 sector, u32 nu
 	while (num_sectors)
 	{
 		u32 blkcnt = 0;
-		//Retry once on error.
-		if (!_sdmmc_storage_readwrite_ex(storage, &blkcnt, sector, MIN(num_sectors, 0xFFFF), bbuf, is_write))
-			if (!_sdmmc_storage_readwrite_ex(storage, &blkcnt, sector, MIN(num_sectors, 0xFFFF), bbuf, is_write))
-				return 0;
+		//Retry 9 times on error.
+		u32 retries = 10;
+		do
+		{
+			if (_sdmmc_storage_readwrite_ex(storage, &blkcnt, sector, MIN(num_sectors, 0xFFFF), bbuf, is_write))
+				goto out;
+			else
+				retries--;
+
+			sleep(500000);
+
+		} while (retries);
+		return 0;
+
+out:;
 		DPRINTF("readwrite: %08X\n", blkcnt);
 		sector += blkcnt;
 		num_sectors -= blkcnt;
 		bbuf += 512 * blkcnt;
 	}
+	return 1;
 }

 int sdmmc_storage_read(sdmmc_storage_t *storage, u32 sector, u32 num_sectors, void *buf)
--- a/ipl/tui.c
+++ b/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)
 {
@@ -27,12 +28,12 @@ void tui_pbar(gfx_con_t *con, int x, int y, u32 val)

 	gfx_printf(con, "[%3d%%]", val);

-	x += 7 * 8;
+	x += 7 * con->fntsz;
 	
-	for (int i = 0; i < 6; i++)
+	for (int i = 0; i < con->fontmult * 6; i++)
 	{
-		gfx_line(con->gfx_ctxt, x, y + i + 1, x + 3 * val, y + i + 1, 0xFFFFFFFF);
-		gfx_line(con->gfx_ctxt, x + 3 * val, y + i + 1, x + 3 * 100, y + i + 1, 0xFF888888);
+		gfx_line(con->gfx_ctxt, x, y + i + 1, x + 3 * val, y + i + 1, 0xFFCCCCCC);
+		gfx_line(con->gfx_ctxt, x + 3 * val, y + i + 1, x + 3 * 100, y + i + 1, 0xFF555555);
 	}

 	gfx_con_setpos(con, cx, cy);
@@ -41,29 +42,58 @@ 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();
@@ -93,8 +123,12 @@ 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_con_setfontsz(con, 16);
+			gfx_clear(con->gfx_ctxt, 0xFF1B1B1B);
+			gfx_set_logo(con->gfx_ctxt, Kc_HEKATE_LOGO);
 		}
 	}

--- a/ipl/tui.h
+++ b/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);
Author	SHA1	Message	Date
Kostas Missos	391c28d6a2	[sdmmc] Change internal read/write retries This can fix busy errors when writing to sd cards. Additionally it now returns properly on success	2018-05-29 02:30:43 +03:00
Kostas Missos	3877eddc3e	v2.0 (and like always, transfer unmerged PRs) This includes big 16px font support	2018-05-29 02:20:03 +03:00
Kostas Missos	a9ef85f5ff	Add 3.X support through SE patches This includes @jsaowji commits and also adds support for 3.0.1 and 3.0.2	2018-05-29 02:11:22 +03:00
Kostas Missos	0259161b3e	Small cosmetic fixes	2018-05-29 02:05:29 +03:00
Kostas Missos	e268222dae	[Main] Small fixes	2018-05-25 01:28:03 -07:00
Kostas Missos	81eb1d0972	[Main] Filter POWER button down And remove uneeded double press protection through sleep().	2018-05-25 01:28:03 -07:00
Kostas Missos	997e250c43	[Menu] Add captions and seperators Additionally, skip selection of them to retain flow and maintain auto scroll.	2018-05-25 01:28:03 -07:00
Kostas Missos	03729bddd5	[Main] Back/text color to subtle dark/light grey	2018-05-25 01:28:03 -07:00