create some helper functions in gfx.c

- Errors will now be more precise, there are now 2 separate errors for a function lookup failure and a failure inside a function
- Errors will now show which line number they failed at, instead of the character offset
- Minus values are not considered errors anymore, however, printing them does not work well
- Gotos now make a @RETURN variable to make making functions easier

.github/workflows/builder.yml

@@ -0,0 +1,36 @@
+name: TegraExplorer builder
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install devkitpro
+      run: |
+        wget https://github.com/devkitPro/pacman/releases/download/devkitpro-pacman-1.0.1/devkitpro-pacman.deb
+        sudo dpkg -i devkitpro-pacman.deb
+        sudo dkp-pacman -S switch-dev --noconfirm
+        sudo dkp-pacman -S devkitARM --noconfirm
+        
+    - name: Build TegraExplorer
+      run: |
+        echo #     SETTING PATH       #
+        export DEVKITPRO=/opt/devkitpro
+        export DEVKITARM=${DEVKITPRO}/devkitARM
+        export DEVKITPPC=${DEVKITPRO}/devkitPPC
+        export PATH=${DEVKITPRO}/tools/bin:$PATH
+        echo #          MAKE          #
+        make -j$(nproc)
+        
+    - uses: actions/upload-artifact@master
+      with:
+        name: TegraExplorer
+        path: output/TegraExplorer.bin 

Makefile

@@ -9,9 +9,9 @@ include $(DEVKITARM)/base_rules
 ################################################################################
 
 IPL_LOAD_ADDR := 0x40003000
-LPVERSION_MAJOR := 2
+LPVERSION_MAJOR := 3
-LPVERSION_MINOR := 5
+LPVERSION_MINOR := 0
-LPVERSION_BUGFX := 2
+LPVERSION_BUGFX := 4
 
 ################################################################################
 

README.md

@@ -1,33 +1,67 @@
 # TegraExplorer
+
+[![TegraExplorer builder](https://github.com/suchmememanyskill/TegraExplorer/workflows/TegraExplorer%20builder/badge.svg)](https://github.com/suchmememanyskill/TegraExplorer/actions)
+[![Downloads](https://img.shields.io/github/downloads/suchmememanyskill/TegraExplorer/total)](https://github.com/suchmememanyskill/TegraExplorer/releases)
+[![Version](https://img.shields.io/github/v/release/suchmememanyskill/tegraexplorer)](https://github.com/suchmememanyskill/TegraExplorer/releases)
+[![Donations](https://img.shields.io/badge/Support%20on-Ko--Fi-red)](https://ko-fi.com/suchmememanyskill)
+
 A payload-based file explorer for your switch!
 
 ## Usage
 1. Get your favorite payload injector
 2. Inject TegraExplorer as a payload
 
-Navigate around the menu's using the vol+, vol- and power buttons
+Navigate around the menus using the joycons.
+- A: Select
+- B: Back
+- Left Joystick up/down (Dpad or joystick): navigate menus up/down
+- Right Joystick up/down: fast menu navigation up/down
+- Capture (Minerva only): Take a screenshot
+- L3/R3 (Press joysticks in): Recalibrate centerpoint
+
+If you do not have your joycons connected:
+- Power -> A
+- Vol+ -> Left Joystick up
+- Vol- -> Left Joystick down
 
 ## Functions
 - Navigate the SD card
-- Navigate the System partition of your sysnand/sysmmc
+- Navigate the System partition of your sysmmc and emummc
 - Interact with files
-	- Deleting, copying or moving files
+	- Deleting, copying, renaming and moving files
 	- Launching payloads files
 	- Viewing the hex data of a file
+	- Launching special [TegraScript](https://github.com/suchmememanyskill/TegraScript) files
+	- Renaming files
 - Interacting with folders
-	- Deleting or copying folders
+	- Deleting, copying or renaming folders
+	- Creating folders
 - Dumping your current firmware to sd
 - Formatting the sd card
 
+*and more*
+
 ## Support
 
 For general CFW support, go to the [Nintendo Homebrew](https://discord.gg/C29hYvh) discord
 
 For question specifically for TegraExplorer, go to [my discord](https://discord.gg/aH9rsuP)
 
-# Credits
+## Credits
 Based on [Lockpick_RCM](https://github.com/shchmue/Lockpick_RCM), and thus also based on [Hekate](https://github.com/CTCaer/hekate)
 
-Lots of help from:
+Awesome people who helped with this project:
 - shchmue
-- Denn
+- Dennthecafebabe
+
+Other awesome people:
+- PhazonicRidley
+- Dax
+- Huhen
+- Bleck9999
+- Exelix
+- Emmo
+
+## Screenshots
+
+![Preview](/preview.png)

common/memory_map.h

@@ -28,60 +28,74 @@
 
 /* --- DRAM START --- */
 #define DRAM_START     0x80000000
-/* Do not write anything in this area */
+#define  HOS_RSVD       0x1000000 // Do not write anything in this area.
-#define NYX_LOAD_ADDR  0x81000000
-#define  NYX_SZ_MAX     0x1000000
-/* Stack theoretical max: 220MB */
-#define IPL_STACK_TOP  0x90010000
-#define IPL_HEAP_START 0x90020000
-#define  IPL_HEAP_SZ   0x24FE0000 // 592MB.
-/* --- Gap: 0xB5000000 - 0xB5FFFFFF --- */
 
-// SDMMC DMA buffers
+#define NYX_LOAD_ADDR  0x81000000
-#define SDXC_BUF_ALIGNED   0xB6000000
+#define  NYX_SZ_MAX     0x1000000 // 16MB
-#define MIXD_BUF_ALIGNED   0xB7000000
+/* --- Gap: 0x82000000 - 0x82FFFFFF --- */
-#define EMMC_BUF_ALIGNED   MIXD_BUF_ALIGNED
+
-#define  SDMMC_DMA_BUF_SZ   0x1000000 // 16MB (4MB currently used).
+/* Stack theoretical max: 33MB */
-#define SDMMC_UPPER_BUFFER 0xB8000000
+#define IPL_STACK_TOP  0x83100000
-#define  SDMMC_UP_BUF_SZ    0x8000000 // 128MB.
+#define IPL_HEAP_START 0x84000000
+#define  IPL_HEAP_SZ   0x20000000 // 512MB.
+/* --- Gap: 1040MB 0xA4000000 - 0xE4FFFFFF --- */
 
 // Virtual disk / Chainloader buffers.
-#define RAM_DISK_ADDR     0xC1000000
+#define RAM_DISK_ADDR     0xA4000000
-#define  RAM_DISK_SZ      0x20000000
+#define  RAM_DISK_SZ      0x41000000 // 1040MB.
+
 //#define DRAM_LIB_ADDR    0xE0000000
 /* --- Chnldr: 252MB 0xC03C0000 - 0xCFFFFFFF --- */ //! Only used when chainloading.
-/* ---    Gap: 464MB 0xD0000000 - 0xECFFFFFF --- */
+
+// SDMMC DMA buffers 1
+#define SDMMC_UPPER_BUFFER 0xE5000000
+#define  SDMMC_UP_BUF_SZ    0x8000000 // 128MB.
 
 // Nyx buffers.
 #define NYX_STORAGE_ADDR 0xED000000
 #define NYX_RES_ADDR     0xEE000000
+#define  NYX_RES_SZ       0x1000000 // 16MB.
 
-// Framebuffer addresses.
+// SDMMC DMA buffers 2
-#define IPL_FB_ADDRESS   0xF0000000
+#define SDXC_BUF_ALIGNED   0xEF000000
-#define  IPL_FB_SZ         0x384000 // 720 x 1280 x 4.
+#define MIXD_BUF_ALIGNED   0xF0000000
-#define LOG_FB_ADDRESS   0xF0400000
+#define EMMC_BUF_ALIGNED   MIXD_BUF_ALIGNED
-#define  LOG_FB_SZ         0x334000 // 1280 x 656 x 4.
+#define  SDMMC_DMA_BUF_SZ   0x1000000 // 16MB (4MB currently used).
-#define NYX_FB_ADDRESS   0xF0800000
-#define  NYX_FB_SZ         0x384000 // 1280 x 720 x 4.
 
 // Nyx LvGL buffers.
-#define NYX_LV_VDB_ADR   0xF0C00000
+#define NYX_LV_VDB_ADR   0xF1000000
 #define  NYX_FB_SZ         0x384000 // 1280 x 720 x 4.
-#define NYX_LV_MEM_ADR   0xF1000000
+#define NYX_LV_MEM_ADR   0xF1400000
-#define  NYX_LV_MEM_SZ    0x8000000
+#define  NYX_LV_MEM_SZ    0x6600000 // 70MB.
+
+// Framebuffer addresses.
+#define IPL_FB_ADDRESS   0xF5A00000
+#define  IPL_FB_SZ         0x384000 // 720 x 1280 x 4.
+#define LOG_FB_ADDRESS   0xF5E00000
+#define  LOG_FB_SZ         0x334000 // 1280 x 656 x 4.
+#define NYX_FB_ADDRESS   0xF6200000
+#define NYX_FB2_ADDRESS  0xF6600000
+#define  NYX_FB_SZ         0x384000 // 1280 x 720 x 4.
+
+#define DRAM_MEM_HOLE_ADR 0xF6A00000
+#define DRAM_MEM_HOLE_SZ   0x8140000
+/* ---   Hole: 129MB 0xF6A00000 - 0xFEB3FFFF --- */
+#define DRAM_START2       0xFEB40000
 
 // NX BIS driver sector cache.
-#define NX_BIS_CACHE_ADDR 0xF9000000
+#define NX_BIS_CACHE_ADDR 0xFEE00000
 #define  NX_BIS_CACHE_SZ      0x8800
-/* --- Gap: 111MB 0xF9008800 - 0xFFFFFFFF --- */
 
-// #define EXT_PAYLOAD_ADDR    0xC03C0000
+// USB buffers.
-// #define RCM_PAYLOAD_ADDR    (EXT_PAYLOAD_ADDR + ALIGN(PATCHED_RELOC_SZ, 0x10))
+#define USBD_ADDR                 0xFEF00000
-// #define COREBOOT_ADDR       (0xD0000000 - 0x100000)
+#define USB_DESCRIPTOR_ADDR       0xFEF40000
+#define USB_EP_CONTROL_BUF_ADDR   0xFEF80000
+#define USB_EP_BULK_IN_BUF_ADDR   0xFF000000
+#define USB_EP_BULK_OUT_BUF_ADDR  0xFF800000
+#define  USB_EP_BULK_OUT_MAX_XFER   0x800000
 
-// NYX
 // #define EXT_PAYLOAD_ADDR    0xC0000000
 // #define RCM_PAYLOAD_ADDR    (EXT_PAYLOAD_ADDR + ALIGN(PATCHED_RELOC_SZ, 0x10))
-// #define COREBOOT_ADDR       (0xD0000000 - 0x100000)
+// #define COREBOOT_ADDR       (0xD0000000 - rom_size)
 
 #endif

source/config/config.c

@@ -23,14 +23,13 @@
 #include "../gfx/tui.h"
 #include "../libs/fatfs/ff.h"
 #include "../soc/t210.h"
+#include "../storage/nx_sd.h"
 #include "../storage/sdmmc.h"
 #include "../utils/btn.h"
 #include "../utils/list.h"
 #include "../utils/util.h"
 
 extern hekate_config h_cfg;
-extern bool sd_mount();
-extern void sd_unmount();
 
 void set_default_configuration()
 {

source/config/ini.c

@@ -55,19 +55,16 @@ u32 _find_section_name(char *lbuf, u32 lblen, char schar)
 ini_sec_t *_ini_create_section(link_t *dst, ini_sec_t *csec, char *name, u8 type)
 {
 	if (csec)
-	{
 		list_append(dst, &csec->link);
-		csec = NULL;
-	}
 
-	csec = (ini_sec_t *)malloc(sizeof(ini_sec_t));
+	csec = (ini_sec_t *)calloc(sizeof(ini_sec_t), 1);
 	csec->name = _strdup(name);
 	csec->type = type;
 
 	return csec;
 }
 
-int ini_parse(link_t *dst, char *ini_path, bool is_dir)
+int ini_parse(link_t *dst, const char *ini_path, bool is_dir)
 {
 	u32 lblen;
 	u32 pathlen = strlen(ini_path);
@@ -76,6 +73,7 @@ int ini_parse(link_t *dst, char *ini_path, bool is_dir)
 	char *filelist = NULL;
 	FIL fp;
 	ini_sec_t *csec = NULL;
+	bool firstIniRun = true;
 
 	char *filename = (char *)malloc(256);
 
@@ -119,10 +117,17 @@ int ini_parse(link_t *dst, char *ini_path, bool is_dir)
 
 		do
 		{
+			if (firstIniRun){
+				firstIniRun = false;
+				strcpy(lbuf, "[Unknown]");
+				lblen = 9;
+			}
+			else {
 			// Fetch one line.
 			lbuf[0] = 0;
 			f_gets(lbuf, 512, &fp);
 			lblen = strlen(lbuf);
+			}
 
 			// Remove trailing newline. Depends on 'FF_USE_STRFUNC 2' that removes \r.
 			if (lblen && lbuf[lblen - 1] == '\n')
@@ -154,7 +159,7 @@ int ini_parse(link_t *dst, char *ini_path, bool is_dir)
 			{
 				u32 i = _find_section_name(lbuf, lblen, '=');
 
-				ini_kv_t *kv = (ini_kv_t *)malloc(sizeof(ini_kv_t));
+				ini_kv_t *kv = (ini_kv_t *)calloc(sizeof(ini_kv_t), 1);
 				kv->key = _strdup(&lbuf[0]);
 				kv->val = _strdup(&lbuf[i + 1]);
 				list_append(&csec->kvs, &kv->link);

source/config/ini.h

@@ -43,7 +43,7 @@ typedef struct _ini_sec_t
 	u32 color;
 } ini_sec_t;
 
-int ini_parse(link_t *dst, char *ini_path, bool is_dir);
+int ini_parse(link_t *dst, const char *ini_path, bool is_dir);
 char *ini_check_payload_section(ini_sec_t *cfg);
 
 #endif

source/exception_handlers.S

@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) 2019 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * Armv7tdmi Status register.
+ *
+ * bit0: Mode 0.
+ * bit1: Mode 1.
+ * bit2: Mode 2.
+ * bit3: Mode 3.
+ * bit4: Mode 4.
+ * bit5: Thumb state.
+ * bit6: FIQ disable.
+ * bit7: IRQ disable.
+ * bit8-27: Reserved.
+ * bit28: Overflow condition.
+ * bit29: Carry/Borrow/Extend condition.
+ * bit30: Zero condition.
+ * bit31: Negative/Less than condition.
+ *
+ * M[4:0] | Mode | Visible Thumb-state registers             | Visible ARM-state registers
+ * 10000  | USER | r0–r7, SP,     LR,     PC, CPSR           | r0–r14,                   PC, CPSR
+ * 10001  | FIQ  | r0–r7, SP_fiq, LR_fiq, PC, CPSR, SPSR_fiq | r0–r7,  r8_fiq–r14_fiq,   PC, CPSR, SPSR_fiq
+ * 10010  | IRQ  | r0–r7, SP_irq, LR_irq, PC, CPSR, SPSR_irq | r0–r12, r13_irq, r14_irq, PC, CPSR, SPSR_irq
+ * 10011  | SVC  | r0–r7, SP_svc, LR_svc, PC, CPSR, SPSR_svc | r0–r12, r13_svc, r14_svc, PC, CPSR, SPSR_svc
+ * 10111  | ABRT | r0–r7, SP_abt, LR_abt, PC, CPSR, SPSR_abt | r0–r12, r13_abt, r14_abt, PC, CPSR, SPSR_abt
+ * 11011  | UNDF | r0–r7, SP_und, LR_und, PC, CPSR, SPSR_und | r0–r12, r13_und, r14_und, PC, CPSR, SPSR_und
+ * 11111  | SYS  | r0–r7, SP,     LR,     PC, CPSR           | r0–r14,                   PC, CPSR
+ */
+
+#define EXCP_EN_ADDR   0x4003FFFC
+#define EXCP_TYPE_ADDR 0x4003FFF8
+#define EXCP_LR_ADDR   0x4003FFF4
+
+#define EXCP_VEC_BASE  0x6000F000
+#define EVP_COP_RESET_VECTOR          0x200
+#define EVP_COP_UNDEF_VECTOR          0x204
+#define EVP_COP_SWI_VECTOR            0x208
+#define EVP_COP_PREFETCH_ABORT_VECTOR 0x20C
+#define EVP_COP_DATA_ABORT_VECTOR     0x210
+#define EVP_COP_RSVD_VECTOR           0x214
+#define EVP_COP_IRQ_VECTOR            0x218
+#define EVP_COP_FIQ_VECTOR            0x21C
+
+#define MODE_USR  0x10
+#define MODE_FIQ  0x11
+#define MODE_IRQ  0x12
+#define MODE_SVC  0x13
+#define MODE_ABT  0x17
+#define MODE_UDF  0x1B
+#define MODE_SYS  0x1F
+#define MODE_MASK 0x1F
+
+#define FIQ 0x40
+#define IRQ 0x80
+
+.section .text._irq_setup
+.arm
+
+.extern ipl_main
+.type ipl_main, %function
+
+.extern svc_handler
+.type svc_handler, %function
+
+.extern irq_handler
+.type irq_handler, %function
+
+.extern fiq_setup
+.type fiq_setup, %function
+
+.extern fiq_handler
+.type fiq_handler, %function
+
+.globl _irq_setup
+.type _irq_setup, %function
+_irq_setup:
+	MRS R0, CPSR
+	BIC R0, R0, #MODE_MASK              /* Clear mode bits */
+	ORR R0, R0, #(MODE_SVC | IRQ | FIQ) /* SUPERVISOR mode, IRQ/FIQ disabled */
+	MSR CPSR, R0
+
+	/* Setup IRQ stack pointer */
+	MSR CPSR, #(MODE_IRQ | IRQ | FIQ) /* IRQ mode, IRQ/FIQ disabled */
+	LDR SP, =0x40040000
+
+	/* Setup SYS stack pointer */
+	MSR CPSR, #(MODE_SYS | IRQ | FIQ) /* SYSTEM mode, IRQ/FIQ disabled */
+	LDR SP, =0x4003FF00               /* Will be changed later to DRAM */
+
+	MOV LR, PC
+	BL setup_vectors
+	/*BL fiq_setup*/
+
+	/* Enable interrupts */
+	BL irq_enable_cpu_irq_exceptions
+
+	B ipl_main
+	B .
+
+_reset:
+	LDR R0, =EXCP_EN_ADDR
+	LDR R1, =0x30505645 /* EVP0 */
+	STR R1, [R0]        /* EVP0 in EXCP_EN_ADDR */
+	LDR R0, =EXCP_LR_ADDR
+	MOV R1, LR
+	STR R1, [R0]        /* Save LR in EXCP_LR_ADDR */
+	LDR R0, =__bss_start
+	EOR R1, R1, R1
+	LDR R2, =__bss_end
+	SUB R2, R2, R0
+	BL memset
+	B _irq_setup
+
+_reset_handler:
+	LDR R0, =EXCP_TYPE_ADDR
+	LDR R1, =0x545352   /* RST */
+	STR R1, [R0]        /* RST in EXCP_TYPE_ADDR */
+	B _reset
+
+_undefined_handler:
+	LDR R0, =EXCP_TYPE_ADDR
+	LDR R1, =0x464455   /* UDF */
+	STR R1, [R0]        /* UDF in EXCP_TYPE_ADDR */
+	B _reset
+
+_prefetch_abort_handler:
+	LDR R0, =EXCP_TYPE_ADDR
+	LDR R1, =0x54424150 /* PABT */
+	STR R1, [R0]        /* PABT in EXCP_TYPE_ADDR */
+	B _reset
+
+_data_abort_handler:
+	LDR R0, =EXCP_TYPE_ADDR
+	LDR R1, =0x54424144 /* DABT */
+	STR R1, [R0]        /* DABT in EXCP_TYPE_ADDR */
+	B _reset
+
+.globl irq_enable_cpu_irq_exceptions
+.type irq_enable_cpu_irq_exceptions, %function
+irq_enable_cpu_irq_exceptions:
+	MRS R12, CPSR
+	BIC R12, R12, #(IRQ | FIQ) /* IRQ/FIQ enabled */
+	MSR CPSR, R12
+	BX LR
+
+.globl irq_disable_cpu_irq_exceptions
+.type irq_disable_cpu_irq_exceptions, %function
+irq_disable_cpu_irq_exceptions:
+	MRS R12, CPSR
+	ORR R12, R12, #(IRQ | FIQ) /* IRQ/FIQ disabled */
+	MSR CPSR, R12
+	BX LR
+
+_irq_handler:
+	MOV R13, R0    /* Save R0 in R13_IRQ */
+	SUB R0, LR, #4 /* Put return address in R0_SYS */
+	MOV LR, R1     /* Save R1 in R14_IRQ (LR) */
+	MRS R1, SPSR   /* Put the SPSR in R1_SYS */
+
+	MSR CPSR_c, #(MODE_SYS | IRQ)  /* SYSTEM mode, IRQ disabled */
+	STMFD SP!, {R0, R1}            /* SPSR and PC */
+	STMFD SP!, {R2-R3, R12, LR}    /* AAPCS-clobbered registers */
+	MOV R0, SP                     /* Make SP_SYS visible to IRQ mode */
+	SUB SP, SP, #8                 /* Make room for stacking R0 and R1 */
+
+	MSR CPSR_c, #(MODE_IRQ | IRQ) /* IRQ mode, IRQ disabled */
+	STMFD R0!, {R13, R14}         /* Finish saving the context (R0, R1) */
+
+	MSR CPSR_c, #(MODE_SYS | IRQ) /* SYSTEM mode, IRQ disabled */
+	LDR R12, =irq_handler
+	MOV LR, PC                    /* Copy the return address to link register */
+	BX R12                        /* Call the C IRQ handler (ARM/THUMB) */
+
+	MSR CPSR_c, #(MODE_SYS | IRQ | FIQ) /* SYSTEM mode, IRQ/FIQ disabled */
+	MOV R0, SP                          /* Make SP_SYS visible to IRQ mode */
+	ADD SP, SP, #32                     /* Fake unstacking 8 registers from SP_SYS */
+
+	MSR CPSR_c, #(MODE_IRQ | IRQ | FIQ) /* IRQ mode, IRQ/FIQ disabled */
+	MOV SP, R0                          /* Copy SP_SYS to SP_IRQ */
+	LDR R0, [SP, #28]                   /* Load the saved SPSR from the stack */
+	MSR SPSR_cxsf, R0                   /* Copy it into SPSR_IRQ */
+
+	LDMFD SP, {R0-R3, R12, LR}^ /* Unstack all saved USER/SYSTEM registers */
+	NOP                         /* Cant access barked registers immediately */
+	LDR LR, [SP, #24]           /* Load return address from the SYS stack */
+	MOVS PC, LR                 /* Return restoring CPSR from SPSR */
+
+_fiq_handler:
+	BL fiq_handler
+
+setup_vectors:
+	/* Setup vectors */
+	LDR R0, =EXCP_VEC_BASE
+
+	LDR R1, =_reset_handler
+	STR R1, [R0, #EVP_COP_RESET_VECTOR]
+
+	LDR R1, =_undefined_handler
+	STR R1, [R0, #EVP_COP_UNDEF_VECTOR]
+
+	LDR R1, =_reset_handler
+	STR R1, [R0, #EVP_COP_SWI_VECTOR]
+
+	LDR R1, =_prefetch_abort_handler
+	STR R1, [R0, #EVP_COP_PREFETCH_ABORT_VECTOR]
+
+	LDR R1, =_data_abort_handler
+	STR R1, [R0, #EVP_COP_DATA_ABORT_VECTOR]
+
+	LDR R1, =_reset_handler
+	STR R1, [R0, #EVP_COP_RSVD_VECTOR]
+
+	LDR R1, =_irq_handler
+	STR R1, [R0, #EVP_COP_IRQ_VECTOR]
+
+	LDR R1, =_fiq_handler
+	STR R1, [R0, #EVP_COP_FIQ_VECTOR]
+
+	BX LR

source/gfx/gfx.c

@@ -20,7 +20,12 @@
 #include <string.h>
 #include "gfx.h"
 
+gfx_ctxt_t gfx_ctxt;
+gfx_con_t gfx_con;
+
 static const u8 _gfx_font[] = {
+	0x00, 0x0C, 0x12, 0x7E, 0x42, 0x42, 0x7E, 0x00, // Char 030 (folder)
+	0x00, 0x0E, 0x12, 0x22, 0x22, 0x22, 0x3E, 0x00, // Char 031 (file)
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Char 032 ( )
 	0x00, 0x30, 0x30, 0x18, 0x18, 0x00, 0x0C, 0x00, // Char 033 (!)
 	0x00, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, // Char 034 (")
@@ -165,25 +170,27 @@ void gfx_con_setcol(u32 fgcol, int fillbg, u32 bgcol)
 
 void gfx_con_getpos(u32 *x, u32 *y)
 {
-	*x = gfx_con.x;
+	*x = YLEFT - gfx_con.y;
-	*y = gfx_con.y;
+	*y = gfx_con.x;
 }
 
 void gfx_con_setpos(u32 x, u32 y)
 {
-	gfx_con.x = x;
+	gfx_con.x = y;
-	gfx_con.y = y;
+	gfx_con.y = YLEFT - x;
 }
 
+u32 YLeftConfig = YLEFT;
+
 void gfx_putc(char c)
 {
 	// Duplicate code for performance reasons.
 	switch (gfx_con.fntsz)
 	{
 	case 16:
-		if (c >= 32 && c <= 126)
+		if (c >= 30 && c <= 126)
 		{
-			u8 *cbuf = (u8 *)&_gfx_font[8 * (c - 32)];
+			u8 *cbuf = (u8 *)&_gfx_font[8 * (c - 30)];
 			u32 *fb = gfx_ctxt.fb + gfx_con.x + gfx_con.y * gfx_ctxt.stride;
 
 			for (u32 i = 0; i < 16; i+=2)
@@ -196,51 +203,60 @@ void gfx_putc(char c)
 						if (v & 1)
 						{
 							*fb = gfx_con.fgcol;
-							fb++;
+							fb -= gfx_ctxt.stride;
 							*fb = gfx_con.fgcol;
 						}
 						else if (gfx_con.fillbg)
 						{
 							*fb = gfx_con.bgcol;
-							fb++;
+							fb -= gfx_ctxt.stride;
 							*fb = gfx_con.bgcol;
 						}
 						else
-							fb++;
+							fb -= gfx_ctxt.stride;
 						v >>= 1;
-						fb++;
+						fb -= gfx_ctxt.stride;
 					}
-					fb += gfx_ctxt.stride - 16;
+					//fb += gfx_ctxt.stride - 16;
+					//fb = fbtop + 2;
+					fb += (gfx_ctxt.stride * 16) + 1;
 					v = *cbuf;
 				}
 				cbuf++;
 			}
+			/*
 			gfx_con.x += 16;
 			if (gfx_con.x >= gfx_ctxt.width - 16) {
 				gfx_con.x = 0;
 				gfx_con.y += 16;
 			}
+			*/
+			gfx_con.y -= 16;
+			if (gfx_con.y < 16){
+				gfx_con.y = YLeftConfig;
+				gfx_con.x += 16;
+			}
 		}
 		else if (c == '\n')
 		{
-			gfx_con.x = 0;
+			gfx_con.y = YLeftConfig;
-			gfx_con.y +=16;
+			gfx_con.x += 16;
-			if (gfx_con.y > gfx_ctxt.height - 16)
+			if (gfx_con.x > gfx_ctxt.width - 16)
-				gfx_con.y = 0;
+				gfx_con.x = 0;
 		}
 		else if (c == '\e')
-			gfx_con.x = 672;
+			gfx_con.y = 575;
 		else if (c == '\a')
-			gfx_con.x = 608;
+			gfx_con.y = 639;
 		else if (c == '\r')
-			gfx_con.x = 0;
+			gfx_con.y = YLeftConfig;
 
 		break;
 	case 8:
 	default:
-		if (c >= 32 && c <= 126)
+		if (c >= 30 && c <= 126)
 		{
-			u8 *cbuf = (u8 *)&_gfx_font[8 * (c - 32)];
+			u8 *cbuf = (u8 *)&_gfx_font[8 * (c - 30)];
 			u32 *fb = gfx_ctxt.fb + gfx_con.x + gfx_con.y * gfx_ctxt.stride;
 			for (u32 i = 0; i < 8; i++)
 			{
@@ -252,29 +268,31 @@ void gfx_putc(char c)
 					else if (gfx_con.fillbg)
 						*fb = gfx_con.bgcol;
 					v >>= 1;
-					fb++;
+					fb -= gfx_ctxt.stride;
 				}
-				fb += gfx_ctxt.stride - 8;
+				fb += (gfx_ctxt.stride * 8) + 1;
 			}
-			gfx_con.x += 8;
+
-			if (gfx_con.x >= gfx_ctxt.width - 8) {
+			gfx_con.y -= 8;
-				gfx_con.x = 0;
+			if (gfx_con.y < 8){
-				gfx_con.y += 8;
+				gfx_con.y = YLeftConfig;
+				gfx_con.x += 8;
 			}
+
 		}
 		else if (c == '\n')
 		{
-			gfx_con.x = 0;
+			gfx_con.y = YLeftConfig;
-			gfx_con.y += 8;
+			gfx_con.x += 8;
-			if (gfx_con.y > gfx_ctxt.height - 8)
+			if (gfx_con.x > gfx_ctxt.width - 8)
-				gfx_con.y = 0;
+				gfx_con.x = 0;
 		}
 		else if (c == '\e')
-			gfx_con.x = 672;
+			gfx_con.y = 575;
 		else if (c == '\a')
-			gfx_con.x = 608;
+			gfx_con.y = 639;
 		else if (c == '\r')
-			gfx_con.x = 0;
+			gfx_con.y = YLeftConfig;
 
 		break;
 	}
@@ -289,6 +307,46 @@ void gfx_puts(const char *s)
 		gfx_putc(*s);
 }
 
+u32 _strLenLimit(const char *s, u32 limit){
+	u32 len = 0;
+
+	for (; *s; s++){
+		len++;
+		if (len >= limit)
+			return len;
+	}
+
+	return len;
+}
+
+void gfx_puts_limit(const char *s, u32 limit)
+{
+	if (!s || gfx_con.mute)
+		return;
+
+	for (u32 i = 0; i < limit; i++){
+		if (i == limit - 3){
+			if (_strLenLimit(&s[i], 4) >= 4){
+				gfx_puts("...");
+				return;
+			}
+		}
+		gfx_putc(s[i]);
+	}
+
+	/*
+	for (u32 i = 0; *s && i < limit; s++, i++){
+		if (i == limit - 3){
+			if (!(!(*s) || !(*(s + 1)) || !(*(s + 2)))){
+				gfx_puts("...");
+				return;
+			}
+		}
+		gfx_putc(*s);
+	}
+	*/
+}
+
 static void _gfx_putn(u32 v, int base, char fill, int fcnt)
 {
 	char buf[65];
@@ -365,6 +423,11 @@ void gfx_vprintf(const char *fmt, va_list ap)
 			}
 			switch(*fmt)
 			{
+			case 'b':;
+				u32 begin = YLEFT - va_arg(ap, u32);
+				YLeftConfig = begin;
+				gfx_con.y = begin;
+				break;
 			case 'c':
 				gfx_putc(va_arg(ap, u32));
 				break;
@@ -520,19 +583,33 @@ void gfx_set_rect_grey(const u8 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos
 }
 
 void gfx_boxGrey(int x0, int y0, int x1, int y1, u8 shade){
+	for (int y = (YLEFT - x0); y >= (YLEFT - x1); y--){
+		memset(gfx_ctxt.fb + y * gfx_ctxt.stride + y0, shade, (y1 - y0 + 1) * 4);
+	}
+}
+/*
+void gfx_boxGrey_old(int x0, int y0, int x1, int y1, u8 shade){
 	for (int y = y0; y <= y1; y++){
 		memset(gfx_ctxt.fb + y * gfx_ctxt.stride + x0, shade, (x1 - x0) * 4);
 	}
 }
-
+*/
 void gfx_box(int x0, int y0, int x1, int y1, u32 color){
+	for (int y = (YLEFT - x0); y >= (YLEFT - x1); y--){
+		for (int x = y0; x <= y1; x++){
+			gfx_set_pixel(x, y, color);
+		}
+	}
+}
+/*
+void gfx_box_old(int x0, int y0, int x1, int y1, u32 color){
 	for (int x = x0; x < x1 + 1; x++){
 		for (int y = y0; y < y1 + 1; y++){
 			gfx_set_pixel(x, y, color);
 		}
 	}
 }
-
+*/
 void gfx_set_rect_rgb(const u8 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y)
 {
 	u32 pos = 0;

source/gfx/gfx.h

@@ -27,6 +27,8 @@
 #define WPRINTF(text) gfx_printf("%k"text"%k\n", 0xFFFFDD00, 0xFFCCCCCC)
 #define WPRINTFARGS(text, args...) gfx_printf("%k"text"%k\n", 0xFFFFDD00, args, 0xFFCCCCCC)
 
+#define YLEFT 1279
+
 void gfx_init_ctxt(u32 *fb, u32 width, u32 height, u32 stride);
 void gfx_clear_grey(u8 color);
 void gfx_clear_partial_grey(u8 color, u32 pos_x, u32 height);
@@ -51,9 +53,16 @@ void gfx_set_rect_argb(const u32 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 po
 void gfx_render_bmp_argb(const u32 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y);
 void gfx_box(int x0, int y0, int x1, int y1, u32 color);
 void gfx_boxGrey(int x0, int y0, int x1, int y1, u8 shade);
+void gfx_puts_limit(const char *s, u32 limit);
+
+/*
+#define GFX_SETPOSCORRECTED(x, y) gfx_con_setpos(y - YLEFT, x)
+#define GFX_BOXCORRECTED(x0, y0, x1, y1, color) gfx_box_old((y0 - YLEFT), x0, (y1 - YLEFT), x1, color)
+#define GFX_BOXGREYCORRECTED(x0, y0, x1, y1, shade) gfx_boxGrey((y0 - YLEFT), x0, (y1 - YLEFT), x1, shade)
+*/
 
 // Global gfx console and context.
-gfx_ctxt_t gfx_ctxt;
+extern gfx_ctxt_t gfx_ctxt;
-gfx_con_t gfx_con;
+extern gfx_con_t gfx_con;
 
 #endif

source/hid/hid.c

@@ -0,0 +1,116 @@
+#include "hid.h"
+#include "joycon.h"
+#include "../utils/btn.h"
+#include "../gfx/gfx.h"
+#include "../utils/types.h"
+#include "../tegraexplorer/utils/utils.h"
+
+static Inputs inputs = {0};
+u16 LbaseX = 0, LbaseY = 0, RbaseX = 0, RbaseY = 0;
+
+void hidInit(){
+    jc_init_hw();
+}
+
+Inputs *hidRead(){
+    jc_gamepad_rpt_t *controller = joycon_poll();
+    static bool errPrint = false;
+
+    if (controller->cap)
+        utils_takeScreenshot();
+
+
+    u8 btn = btn_read();
+    inputs.volp = (btn & BTN_VOL_UP) ? 1 : 0;
+    inputs.volm = (btn & BTN_VOL_DOWN) ? 1 : 0;
+    inputs.pow = (btn & BTN_POWER) ? 1 : 0;
+
+    inputs.a = controller->a;
+    inputs.b = controller->b;
+    inputs.x = controller->x;
+    inputs.y = controller->y;
+    inputs.r = controller->r;
+    inputs.l = controller->l;
+    inputs.zr = controller->zr;
+    inputs.zl = controller->zl;
+    inputs.minus = controller->minus;
+    inputs.plus = controller->plus;
+    inputs.home = controller->home;
+    inputs.cap = controller->cap;
+
+    if (controller->conn_l && controller->conn_r){
+        if (errPrint){
+            gfx_boxGrey(1008, 703, 1279, 719, 0xFF);
+            errPrint = false;
+        }
+    }
+    else {
+        u32 x, y;
+        gfx_con_getpos(&x, &y);
+        gfx_con_setpos(1008, 703);
+        gfx_printf("%k%K%s %s MISS%k%K", COLOR_DEFAULT, COLOR_WHITE, (controller->conn_l) ? "    " : "JOYL", (controller->conn_r) ? "    " : "JOYR", COLOR_WHITE, COLOR_DEFAULT);
+        gfx_con_setpos(x, y);
+        errPrint = true;
+    }
+
+    if (controller->conn_l){
+        if ((LbaseX == 0 || LbaseY == 0) || controller->l3){
+            LbaseX = controller->lstick_x;
+            LbaseY = controller->lstick_y;
+        }
+
+        inputs.Lup = (controller->up || (controller->lstick_y > LbaseY + 500)) ? 1 : 0;
+        inputs.Ldown = (controller->down || (controller->lstick_y < LbaseY - 500)) ? 1 : 0;
+        inputs.Lleft = (controller->left || (controller->lstick_x < LbaseX - 500)) ? 1 : 0;
+        inputs.Lright = (controller->right || (controller->lstick_x > LbaseX + 500)) ? 1 : 0;
+    }
+    else {
+        inputs.Lup = inputs.volp;
+        inputs.Ldown = inputs.volm;
+    }
+
+    if (controller->conn_r){
+        if ((RbaseX == 0 || RbaseY == 0) || controller->r3){
+            RbaseX = controller->rstick_x;
+            RbaseY = controller->rstick_y;
+        }
+
+        inputs.Rup = (controller->rstick_y > RbaseY + 500) ? 1 : 0;
+        inputs.Rdown = (controller->rstick_y < RbaseY - 500) ? 1 : 0;
+        inputs.Rleft = (controller->rstick_x < RbaseX - 500) ? 1 : 0;
+        inputs.Rright = (controller->rstick_x > RbaseX + 500) ? 1 : 0;
+    }
+    else
+        inputs.a = inputs.pow;
+
+    return &inputs;
+}
+
+Inputs *hidWaitMask(u32 mask){
+    Inputs *in = hidRead();
+
+    while (in->buttons & mask)
+        hidRead();
+
+    while (!(in->buttons & mask)){
+        hidRead();
+    }
+
+    return in;
+}
+
+Inputs *hidWait(){
+    Inputs *in = hidRead();
+
+    while (in->buttons)
+        hidRead();
+
+    while (!(in->buttons))
+        hidRead();
+    return in;
+}
+
+bool hidConnected(){
+    jc_gamepad_rpt_t *controller = joycon_poll();
+    return (controller->conn_l && controller->conn_r) ? 1 : 0;
+}

source/hid/hid.h

@@ -0,0 +1,59 @@
+#pragma once
+#include "../utils/types.h"
+
+#define BIT(n) (1U << n)
+#define KEY_A BIT(3)
+#define KEY_B BIT(2)
+#define KEY_Y BIT(0)
+#define KEY_X BIT(1)
+#define KEY_LUP BIT(18)
+#define KEY_LDOWN BIT(17)
+#define KEY_LRIGHT BIT(19)
+#define KEY_LLEFT BIT(20)
+#define KEY_RUP BIT(7)
+#define KEY_RDOWN BIT(6)
+#define KEY_VOLP BIT(14)
+#define KEY_VOLM BIT(15)
+#define KEY_POW BIT(16)
+
+typedef struct _inputs {
+    union {
+        struct {
+            // Joy-Con (R).
+			u32 y:1;
+			u32 x:1;
+			u32 b:1;
+			u32 a:1;
+			u32 r:1;
+			u32 zr:1;
+            u32 Rdown:1;
+            u32 Rup:1;
+            u32 Rright:1;
+            u32 Rleft:1;
+
+			// Shared
+			u32 minus:1;
+			u32 plus:1;
+			u32 home:1;
+			u32 cap:1;
+            u32 volp:1;
+            u32 volm:1;
+            u32 pow:1;
+
+			// Joy-Con (L).
+			u32 Ldown:1;
+			u32 Lup:1;
+			u32 Lright:1;
+			u32 Lleft:1;
+			u32 l:1;
+			u32 zl:1;
+        };
+        u32 buttons;
+    };
+} Inputs;
+
+void hidInit();
+Inputs *hidRead();
+Inputs *hidWait();
+Inputs *hidWaitMask(u32 mask);
+bool hidConnected();

source/hid/joycon.c

@@ -0,0 +1,807 @@
+/*
+ * Joy-Con UART driver for Nintendo Switch
+ *
+ * Copyright (c) 2019 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <string.h>
+
+#include "joycon.h"
+#include "../gfx/gfx.h"
+#include "../power/max17050.h"
+#include "../power/regulator_5v.h"
+#include "../soc/bpmp.h"
+#include "../soc/clock.h"
+#include "../soc/gpio.h"
+#include "../soc/pinmux.h"
+#include "../soc/uart.h"
+#include "../soc/t210.h"
+#include "../utils/util.h"
+
+// For disabling driver when logging is enabled.
+// #include "../libs/lvgl/lvgl.h"
+
+#define JC_WIRED_CMD        0x91
+#define JC_WIRED_HID        0x92
+#define JC_WIRED_INIT_REPLY 0x94
+#define JC_INIT_HANDSHAKE   0xA5
+
+#define JC_WIRED_CMD_MAC 0x01
+#define JC_WIRED_CMD_10  0x10
+
+#define JC_HID_OUTPUT_RPT 0x01
+#define JC_HID_RUMBLE_RPT 0x10
+
+#define JC_HID_INPUT_RPT  0x30
+#define JC_HID_SUBMCD_RPT 0x21
+
+#define JC_HID_SUBCMD_HCI_STATE  0x06
+#define  HCI_STATE_SLEEP     0x00
+#define  HCI_STATE_RECONNECT 0x01
+#define  HCI_STATE_PAIR      0x02
+#define  HCI_STATE_HOME      0x04
+#define JC_HID_SUBCMD_SPI_READ   0x10
+#define JC_HID_SUBCMD_RUMBLE_CTL 0x48
+#define JC_HID_SUBCMD_SND_RUMBLE 0xFF
+
+#define JC_BTN_MASK_L 0xFF2900 // 0xFFE900: with charge status.
+#define JC_BTN_MASK_R 0x76FF
+
+#define JC_ID_L 1
+#define JC_ID_R 2
+
+enum
+{
+	JC_BATT_EMTPY = 0,
+	JC_BATT_CRIT  = 2,
+	JC_BATT_LOW   = 4,
+	JC_BATT_MID   = 6,
+	JC_BATT_FULL  = 8
+};
+
+static const u8 init_jc[] = {
+	0xA1, 0xA2, 0xA3, 0xA4
+};
+
+static const u8 init_handshake[] = {
+	0x19, 0x01, 0x03, 0x07, 0x00,      // Uart header.
+	JC_INIT_HANDSHAKE, 0x02,           // Wired cmd and wired subcmd.
+	0x01, 0x7E, 0x00, 0x00, 0x00       // Wired subcmd data.
+};
+
+static const u8 init_get_info[]  = {
+	0x19, 0x01, 0x03, 0x07, 0x00,      // Uart header.
+	JC_WIRED_CMD, JC_WIRED_CMD_MAC,    // Wired cmd and subcmd.
+	0x00, 0x00, 0x00, 0x00, 0x24       // Wired subcmd data.
+};
+
+static const u8 init_finilize[]  = {
+	0x19, 0x01, 0x03, 0x07, 0x00,      // Uart header.
+	JC_WIRED_CMD, JC_WIRED_CMD_10,     // Wired cmd and subcmd.
+	0x00, 0x00, 0x00, 0x00, 0x3D       // Wired subcmd data.
+};
+
+static const u8 nx_pad_status[]  = {
+	0x19, 0x01, 0x03, 0x08, 0x00,      // Uart header.
+	JC_WIRED_HID, 0x00,                // Wired cmd and hid cmd.
+	0x01, 0x00, 0x00, 0x69, 0x2D, 0x1F // hid data.
+};
+
+typedef struct _jc_uart_hdr_t
+{
+	u8 magic[3];
+	u8 total_size_lsb;
+	u8 total_size_msb;
+} jc_uart_hdr_t;
+
+typedef struct _jc_wired_hdr_t
+{
+	jc_uart_hdr_t uart_hdr;
+	u8 cmd;
+	u8 data[5];
+	u8 crc;
+	u8 payload[];
+} jc_wired_hdr_t;
+
+typedef struct _jc_hid_out_rpt_t
+{
+	u8 cmd;
+	u8 pkt_id;
+	u8 rumble[8];
+	u8 subcmd;
+	u8 subcmd_data[];
+} jc_hid_out_rpt_t;
+
+typedef struct _jc_hid_out_spi_read_t
+{
+	u32 addr;
+	u8  size;
+} jc_hid_out_spi_read_t;
+
+typedef struct _jc_hid_in_rpt_t
+{
+	u8 cmd;
+	u8 pkt_id;
+	u8 conn_info:4;
+	u8 batt_info:4;
+	u8 btn_right;
+	u8 btn_shared;
+	u8 btn_left;
+	u8 stick_h_left;
+	u8 stick_m_left;
+	u8 stick_v_left;
+	u8 stick_h_right;
+	u8 stick_m_right;
+	u8 stick_v_right;
+	u8 vib_decider;
+	u8 submcd_ack;
+	u8 subcmd;
+	u8 subcmd_data[];
+} jc_hid_in_rpt_t;
+
+typedef struct _jc_hid_in_spi_read_t
+{
+	u32 addr;
+	u8  size;
+	u8  data[];
+} jc_hid_in_spi_read_t;
+
+typedef struct _jc_hid_in_pair_data_t
+{
+	u8  magic;
+	u8  size;
+	u16 checksum;
+	u8  mac[6];
+	u8  ltk[16];
+	u8  pad0[10];
+	u8  bt_caps; // bit3: Secure conn supported host, bit5: Paired to TBFC supported host, bit6: iTBFC page supported
+	u8  pad1;
+} jc_hid_in_pair_data_t;
+
+typedef struct _joycon_ctxt_t
+{
+	u8 buf[0x100]; //FIXME: If heap is used, dumping breaks.
+	u8 uart;
+	u8 type;
+	u8 mac[6];
+	u32 hw_init_done;
+	u32 last_received_time;
+	u32 last_status_req_time;
+	u8 rumble_sent;
+	u8 connected;
+} joycon_ctxt_t;
+
+static joycon_ctxt_t jc_l;
+static joycon_ctxt_t jc_r;
+
+static bool jc_init_done = false;
+static u32 hid_pkt_inc = 0;
+
+static jc_gamepad_rpt_t jc_gamepad;
+
+void jc_power_supply(u8 uart, bool enable);
+
+void joycon_send_raw(u8 uart_port, const u8 *buf, u16 size)
+{
+	uart_send(uart_port, buf, size);
+	uart_wait_idle(uart_port, UART_TX_IDLE);
+}
+
+static u16 jc_packet_add_uart_hdr(jc_wired_hdr_t *out, u8 wired_cmd, u8 *data, u16 size)
+{
+	out->uart_hdr.magic[0] = 0x19;
+	out->uart_hdr.magic[1] = 0x01;
+	out->uart_hdr.magic[2] = 0x3;
+
+	out->uart_hdr.total_size_lsb = 7;
+	out->uart_hdr.total_size_msb = 0;
+	out->cmd = wired_cmd;
+
+	if (data)
+		memcpy(out->data, data, size);
+
+	out->crc = 0; // wired crc8ccit can be skipped.
+
+	return sizeof(jc_wired_hdr_t);
+}
+
+static u16 jc_hid_output_rpt_craft(jc_wired_hdr_t *rpt, u8 *payload, u16 size)
+{
+	u16 pkt_size = jc_packet_add_uart_hdr(rpt, JC_WIRED_HID, NULL, 0);
+	pkt_size += size;
+
+	rpt->uart_hdr.total_size_lsb += size;
+	rpt->data[0] = size >> 8;
+	rpt->data[1] = size & 0xFF;
+
+	if (payload)
+		memcpy(rpt->payload, payload, size);
+
+	return pkt_size;
+}
+
+void jc_send_hid_output_rpt(u8 uart, u8 *payload, u16 size)
+{
+	u8 rpt[0x50];
+	memset(rpt, 0, sizeof(rpt));
+
+	u32 rpt_size = jc_hid_output_rpt_craft((jc_wired_hdr_t *)rpt, payload, size);
+
+	joycon_send_raw(uart, rpt, rpt_size);
+}
+
+static u8 jc_hid_pkt_id_incr()
+{
+	u8 curr_id = hid_pkt_inc;
+	hid_pkt_inc++;
+
+	return (curr_id & 0xF);
+}
+
+void jc_send_hid_cmd(u8 uart, u8 subcmd, u8 *data, u16 size)
+{
+	u8 temp[0x30];
+	u8 rumble_neutral[8] = {0x00, 0x01, 0x40, 0x40, 0x00, 0x01, 0x40, 0x40};
+	u8 rumble_init[8]    = {0xc2, 0xc8, 0x03, 0x72, 0xc2, 0xc8, 0x03, 0x72};
+
+	memset(temp, 0, sizeof(temp));
+
+	jc_hid_out_rpt_t *hid_pkt = (jc_hid_out_rpt_t *)temp;
+
+	memcpy(hid_pkt->rumble, rumble_neutral, sizeof(rumble_neutral));
+
+	if (subcmd == JC_HID_SUBCMD_SND_RUMBLE)
+	{
+		bool send_r_rumble = jc_r.connected && !jc_r.rumble_sent;
+		bool send_l_rumble = jc_l.connected && !jc_l.rumble_sent;
+
+		// Enable rumble.
+		hid_pkt->cmd = JC_HID_OUTPUT_RPT;
+		hid_pkt->pkt_id = jc_hid_pkt_id_incr();
+		hid_pkt->subcmd = JC_HID_SUBCMD_RUMBLE_CTL;
+		hid_pkt->subcmd_data[0] = 1;
+		if (send_r_rumble)
+			jc_send_hid_output_rpt(UART_B, (u8 *)hid_pkt, 0x10);
+		if (send_l_rumble)
+			jc_send_hid_output_rpt(UART_C, (u8 *)hid_pkt, 0x10);
+
+		// Send rumble.
+		hid_pkt->cmd = JC_HID_RUMBLE_RPT;
+		hid_pkt->pkt_id = jc_hid_pkt_id_incr();
+		memcpy(hid_pkt->rumble, rumble_init, sizeof(rumble_init));
+		if (send_r_rumble)
+			jc_send_hid_output_rpt(UART_B, (u8 *)hid_pkt, 10);
+		if (send_l_rumble)
+			jc_send_hid_output_rpt(UART_C, (u8 *)hid_pkt, 10);
+
+		msleep(15);
+
+		// Disable rumble.
+		hid_pkt->cmd = JC_HID_OUTPUT_RPT;
+		hid_pkt->pkt_id = jc_hid_pkt_id_incr();
+		hid_pkt->subcmd = JC_HID_SUBCMD_RUMBLE_CTL;
+		hid_pkt->subcmd_data[0] = 0;
+		memcpy(hid_pkt->rumble, rumble_neutral, sizeof(rumble_neutral));
+		if (send_r_rumble)
+			jc_send_hid_output_rpt(UART_B, (u8 *)hid_pkt, 0x10);
+		if (send_l_rumble)
+			jc_send_hid_output_rpt(UART_C, (u8 *)hid_pkt, 0x10);
+	}
+	else
+	{
+		hid_pkt->cmd = JC_HID_OUTPUT_RPT;
+		hid_pkt->pkt_id = jc_hid_pkt_id_incr();
+		hid_pkt->subcmd = subcmd;
+		if (data)
+			memcpy(hid_pkt->subcmd_data, data, size);
+
+		u8 pkt_size = sizeof(jc_hid_out_rpt_t) + size;
+
+		if (subcmd != JC_HID_SUBCMD_SPI_READ)
+			jc_send_hid_output_rpt(uart, (u8 *)hid_pkt, pkt_size);
+		else
+		{
+			jc_send_hid_output_rpt(UART_B, (u8 *)hid_pkt, pkt_size);
+			jc_send_hid_output_rpt(UART_C, (u8 *)hid_pkt, pkt_size);
+		}
+	}
+}
+
+static void jc_charging_decider(u8 batt, u8 uart)
+{
+	u32 system_batt_enough = max17050_get_cached_batt_volt() > 4000;
+
+	// Power supply control based on battery levels and charging.
+	if ((batt >> 1 << 1) < JC_BATT_LOW) // Level without checking charging.
+		jc_power_supply(uart, true);
+	else if (batt > (system_batt_enough ? JC_BATT_FULL : JC_BATT_MID)) // Addresses the charging bit.
+		jc_power_supply(uart, false);
+}
+
+static void jc_parse_wired_hid(joycon_ctxt_t *jc, const u8* packet, u32 size)
+{
+	u32 btn_tmp;
+	jc_hid_in_rpt_t *hid_pkt = (jc_hid_in_rpt_t *)packet;
+
+	switch (hid_pkt->cmd)
+	{
+	case JC_HID_INPUT_RPT:
+		btn_tmp = hid_pkt->btn_right | hid_pkt->btn_shared << 8 | hid_pkt->btn_left << 16;
+
+		if (jc->type & JC_ID_L)
+		{
+			jc_gamepad.buttons &= ~JC_BTN_MASK_L;
+			jc_gamepad.buttons |= (btn_tmp & JC_BTN_MASK_L);
+
+			jc_gamepad.lstick_x = hid_pkt->stick_h_left | ((hid_pkt->stick_m_left & 0xF) << 8);
+			jc_gamepad.lstick_y = (hid_pkt->stick_m_left >> 4) | (hid_pkt->stick_v_left << 4);
+
+			jc_gamepad.batt_info_l = hid_pkt->batt_info;
+		}
+		else if (jc->type & JC_ID_R)
+		{
+			jc_gamepad.buttons &= ~JC_BTN_MASK_R;
+			jc_gamepad.buttons |= (btn_tmp & JC_BTN_MASK_R);
+
+			jc_gamepad.rstick_x = hid_pkt->stick_h_right | ((hid_pkt->stick_m_right & 0xF) << 8);
+			jc_gamepad.rstick_y = (hid_pkt->stick_m_right >> 4) | (hid_pkt->stick_v_right << 4);
+
+			jc_gamepad.batt_info_r = hid_pkt->batt_info;
+		}
+
+		jc_gamepad.conn_l = jc_l.connected;
+		jc_gamepad.conn_r = jc_r.connected;
+
+		jc_charging_decider(hid_pkt->batt_info, jc->uart);
+		break;
+	case JC_HID_SUBMCD_RPT:
+		if (hid_pkt->subcmd == JC_HID_SUBCMD_SPI_READ)
+		{
+			jc_bt_conn_t *bt_conn;
+
+			if (jc->type & JC_ID_L)
+				bt_conn = &jc_gamepad.bt_conn_l;
+			else
+				bt_conn = &jc_gamepad.bt_conn_r;
+
+			jc_hid_in_spi_read_t  *spi_info = (jc_hid_in_spi_read_t *)hid_pkt->subcmd_data;
+			jc_hid_in_pair_data_t *pair_data = (jc_hid_in_pair_data_t *)spi_info->data;
+
+			// Check if we reply is pairing info.
+			if (spi_info->addr == 0x2000 && spi_info->size == 0x1A && pair_data->magic == 0x95)
+			{
+				bt_conn->type = jc->type;
+
+				memcpy(bt_conn->mac, jc->mac, 6);
+				memcpy(bt_conn->host_mac, pair_data->mac, 6);
+				for (u32 i = 16; i > 0; i--)
+					bt_conn->ltk[16 - i] = pair_data->ltk[i - 1];
+			}
+		}
+		break;
+	default:
+		break;
+	}
+	jc->last_received_time = get_tmr_ms();
+}
+
+static void jc_parse_wired_init(joycon_ctxt_t *jc, const u8* data, u32 size)
+{
+	switch (data[0])
+	{
+	case JC_WIRED_CMD_MAC:
+		for (int i = 12; i > 6; i--)
+			jc->mac[12 - i] = data[i];
+		jc->type = data[6];
+		jc->connected = true;
+	default:
+		break;
+	}
+}
+
+static void jc_uart_pkt_parse(joycon_ctxt_t *jc, const u8* packet, size_t size)
+{
+	jc_wired_hdr_t *pkt = (jc_wired_hdr_t *)packet;
+	switch (pkt->cmd)
+	{
+	case JC_WIRED_HID:
+		jc_parse_wired_hid(jc, pkt->payload, (pkt->data[0] << 8) | pkt->data[1]);
+		break;
+	case JC_WIRED_INIT_REPLY:
+		jc_parse_wired_init(jc, pkt->data, size - sizeof(jc_uart_hdr_t) - 1);
+		break;
+	default:
+		break;
+	}
+}
+
+static void jc_rcv_pkt(joycon_ctxt_t *jc)
+{
+	if (gpio_read(GPIO_PORT_E, GPIO_PIN_6) && jc->uart == UART_C)
+		return;
+	else if (gpio_read(GPIO_PORT_H, GPIO_PIN_6) && jc->uart == UART_B)
+		return;
+
+	// Check if device stopped sending data.
+	u32 uart_irq = uart_get_IIR(jc->uart);
+	if ((uart_irq & 0x8) != 0x8)
+		return;
+
+	u32 len = uart_recv(jc->uart, (u8 *)jc->buf, 0);
+
+	// Check valid size and uart reply magic.
+	if (len > 7 && !memcmp(jc->buf, "\x19\x81\x03", 3))
+	{
+		jc_wired_hdr_t *pkt = (jc_wired_hdr_t *)(jc->buf);
+
+		jc_uart_pkt_parse(jc, jc->buf, pkt->uart_hdr.total_size_lsb + sizeof(jc_uart_hdr_t));
+	}
+}
+
+static bool jc_send_init_rumble(joycon_ctxt_t *jc)
+{
+	// Send init rumble or request nx pad status report.
+	if ((jc_r.connected && !jc_r.rumble_sent) || (jc_l.connected && !jc_l.rumble_sent))
+	{
+		gpio_config(GPIO_PORT_G, GPIO_PIN_0, GPIO_MODE_SPIO);
+		gpio_config(GPIO_PORT_D, GPIO_PIN_1, GPIO_MODE_SPIO);
+
+		jc_send_hid_cmd(jc->uart, JC_HID_SUBCMD_SND_RUMBLE, NULL, 0);
+
+		if (jc_l.connected)
+			jc_l.rumble_sent = true;
+		if (jc_r.connected)
+			jc_r.rumble_sent = true;
+
+		if (jc->uart != UART_B)
+			gpio_config(GPIO_PORT_G, GPIO_PIN_0, GPIO_MODE_GPIO);
+		else
+			gpio_config(GPIO_PORT_D, GPIO_PIN_1, GPIO_MODE_GPIO);
+
+		return 1;
+	}
+
+	return 0;
+}
+
+static void jc_req_nx_pad_status(joycon_ctxt_t *jc)
+{
+	bool sent_rumble = jc_send_init_rumble(jc);
+
+	if (sent_rumble)
+		return;
+
+	if (jc->last_status_req_time > get_tmr_ms() || !jc->connected)
+		return;
+
+	// Turn off Joy-Con detect.
+	if (jc->uart == UART_B)
+		gpio_config(GPIO_PORT_G, GPIO_PIN_0, GPIO_MODE_SPIO);
+	else
+		gpio_config(GPIO_PORT_D, GPIO_PIN_1, GPIO_MODE_SPIO);
+
+	joycon_send_raw(jc->uart, nx_pad_status, sizeof(nx_pad_status));
+
+	// Turn Joy-Con detect on.
+	if (jc->uart == UART_B)
+		gpio_config(GPIO_PORT_G, GPIO_PIN_0, GPIO_MODE_GPIO);
+	else
+		gpio_config(GPIO_PORT_D, GPIO_PIN_1, GPIO_MODE_GPIO);
+
+	jc->last_status_req_time = get_tmr_ms() + 15;
+}
+
+jc_gamepad_rpt_t *jc_get_bt_pairing_info()
+{
+	u8 retries;
+	jc_bt_conn_t *bt_conn;
+
+	bt_conn = &jc_gamepad.bt_conn_l;
+	memset(bt_conn->host_mac, 0, 6);
+	memset(bt_conn->ltk, 0, 16);
+
+	bt_conn = &jc_gamepad.bt_conn_r;
+	memset(bt_conn->host_mac, 0, 6);
+	memset(bt_conn->ltk, 0, 16);
+
+	while (jc_l.last_status_req_time > get_tmr_ms())
+	{
+		jc_rcv_pkt(&jc_r);
+		jc_rcv_pkt(&jc_l);
+	}
+
+	jc_hid_in_spi_read_t subcmd_data;
+	subcmd_data.addr = 0x2000;
+	subcmd_data.size = 0x1A;
+
+	// Turn off Joy-Con detect.
+	gpio_config(GPIO_PORT_G, GPIO_PIN_0, GPIO_MODE_SPIO);
+	gpio_config(GPIO_PORT_D, GPIO_PIN_1, GPIO_MODE_SPIO);
+
+	bool jc_r_found = jc_r.connected ? false : true;
+	bool jc_l_found = jc_l.connected ? false : true;
+
+	u32 total_retries = 5;
+retry:
+	retries = 10;
+	while (retries)
+	{
+		if (jc_l.last_status_req_time < get_tmr_ms())
+		{
+			jc_send_hid_cmd(0, JC_HID_SUBCMD_SPI_READ, (u8 *)&subcmd_data, 5);
+			jc_l.last_status_req_time = get_tmr_ms() + 15;
+			jc_r.last_status_req_time = get_tmr_ms() + 15;
+			retries--;
+		}
+
+		if (!jc_r_found)
+		{
+			memset(jc_r.buf, 0, 0x100);
+			jc_rcv_pkt(&jc_r);
+		}
+
+		if (!jc_l_found)
+		{
+			memset(jc_l.buf, 0, 0x100);
+			jc_rcv_pkt(&jc_l);
+		}
+	}
+
+	if (jc_l.connected &&
+		memcmp(&jc_gamepad.bt_conn_l.ltk[0], "\x00\x00\x00\x00", 4) &&
+		memcmp(&jc_gamepad.bt_conn_l.ltk[8], "\x00\x00\x00\x00", 4))
+		jc_l_found = true;
+
+	if (jc_r.connected &&
+		memcmp(&jc_gamepad.bt_conn_r.ltk[0], "\x00\x00\x00\x00", 4) &&
+		memcmp(&jc_gamepad.bt_conn_r.ltk[8], "\x00\x00\x00\x00", 4))
+		jc_r_found = true;
+
+	if (total_retries && (!jc_l_found || !jc_r_found))
+	{
+		total_retries--;
+		goto retry;
+	}
+
+	// Turn Joy-Con detect on.
+	gpio_config(GPIO_PORT_G, GPIO_PIN_0, GPIO_MODE_GPIO);
+	gpio_config(GPIO_PORT_D, GPIO_PIN_1, GPIO_MODE_GPIO);
+
+	return &jc_gamepad;
+}
+
+void jc_deinit()
+{
+	gpio_config(GPIO_PORT_G, GPIO_PIN_0, GPIO_MODE_SPIO);
+	gpio_config(GPIO_PORT_D, GPIO_PIN_1, GPIO_MODE_SPIO);
+
+	u8 data = HCI_STATE_SLEEP;
+
+	if (jc_r.connected)
+	{
+		jc_send_hid_cmd(UART_B, JC_HID_SUBCMD_HCI_STATE, &data, 1);
+		msleep(1);
+		jc_rcv_pkt(&jc_r);
+	}
+	if (jc_l.connected)
+	{
+		jc_send_hid_cmd(UART_C, JC_HID_SUBCMD_HCI_STATE, &data, 1);
+		msleep(1);
+		jc_rcv_pkt(&jc_l);
+	}
+
+	jc_power_supply(UART_B, false);
+	jc_power_supply(UART_C, false);
+}
+
+static void jc_init_conn(joycon_ctxt_t *jc)
+{
+	if (((u32)get_tmr_ms() - jc->last_received_time) > 1000)
+	{
+		jc_power_supply(jc->uart, true);
+
+		// Turn off Joy-Con detect.
+		if (jc->uart == UART_B)
+		{
+			jc_gamepad.buttons &= ~JC_BTN_MASK_R;
+			jc_gamepad.conn_r = false;
+			gpio_config(GPIO_PORT_G, GPIO_PIN_0, GPIO_MODE_SPIO);
+		}
+		else
+		{
+			jc_gamepad.buttons &= ~JC_BTN_MASK_L;
+			jc_gamepad.conn_l = false;
+			gpio_config(GPIO_PORT_D, GPIO_PIN_1, GPIO_MODE_SPIO);
+		}
+
+		uart_init(jc->uart, 1000000);
+		uart_invert(jc->uart, true, UART_INVERT_TXD);
+		uart_set_IIR(jc->uart);
+
+		joycon_send_raw(jc->uart, init_jc, 4);
+		joycon_send_raw(jc->uart, init_handshake, sizeof(init_handshake));
+
+		msleep(5);
+		jc_rcv_pkt(jc);
+
+		joycon_send_raw(jc->uart, init_get_info, sizeof(init_get_info));
+		msleep(5);
+		jc_rcv_pkt(jc);
+
+		joycon_send_raw(jc->uart, init_finilize, sizeof(init_finilize));
+		msleep(5);
+		jc_rcv_pkt(jc);
+
+		// Turn Joy-Con detect on.
+		if (jc->uart == UART_B)
+			gpio_config(GPIO_PORT_G, GPIO_PIN_0, GPIO_MODE_GPIO);
+		else
+			gpio_config(GPIO_PORT_D, GPIO_PIN_1, GPIO_MODE_GPIO);
+
+		jc->last_received_time = get_tmr_ms();
+
+		if (jc->connected)
+			jc_power_supply(jc->uart, false);
+	}
+}
+
+static void jc_conn_check()
+{
+	// Check if a Joy-Con was disconnected.
+	if (gpio_read(GPIO_PORT_E, GPIO_PIN_6))
+	{
+		jc_power_supply(UART_C, false);
+
+		hid_pkt_inc = 0;
+
+		jc_l.connected = false;
+		jc_l.rumble_sent = false;
+
+		jc_gamepad.buttons &= ~JC_BTN_MASK_L;
+		jc_gamepad.conn_l = false;
+
+		jc_gamepad.batt_info_l = 0;
+		jc_gamepad.bt_conn_l.type = 0;
+	}
+
+	if (gpio_read(GPIO_PORT_H, GPIO_PIN_6))
+	{
+		jc_power_supply(UART_B, false);
+
+		hid_pkt_inc = 0;
+
+		jc_r.connected = false;
+		jc_r.rumble_sent = false;
+
+		jc_gamepad.buttons &= ~JC_BTN_MASK_R;
+		jc_gamepad.conn_r = false;
+
+		jc_gamepad.batt_info_r = 0;
+		jc_gamepad.bt_conn_r.type = 0;
+	}
+}
+
+void jc_power_supply(u8 uart, bool enable)
+{
+	if (enable)
+	{
+		if (regulator_get_5v_dev_enabled(1 << uart))
+			return;
+
+		regulator_enable_5v(1 << uart);
+
+		if (jc_init_done)
+		{
+			if (uart == UART_C)
+				gpio_write(GPIO_PORT_CC, GPIO_PIN_3, GPIO_HIGH);
+			else
+				gpio_write(GPIO_PORT_K, GPIO_PIN_3, GPIO_HIGH);
+			return;
+		}
+
+		if (uart == UART_C)
+		{
+			// Joy-Con(L) Charge Detect.
+			PINMUX_AUX(PINMUX_AUX_SPDIF_IN) = PINMUX_PULL_DOWN | 1;
+			gpio_config(GPIO_PORT_CC, GPIO_PIN_3, GPIO_MODE_GPIO);
+			gpio_output_enable(GPIO_PORT_CC, GPIO_PIN_3, GPIO_OUTPUT_ENABLE);
+			gpio_write(GPIO_PORT_CC, GPIO_PIN_3, GPIO_HIGH);
+		}
+		else
+		{
+			// Joy-Con(R) Charge Detect.
+			PINMUX_AUX(PINMUX_AUX_GPIO_PK3) = PINMUX_DRIVE_4X | PINMUX_PULL_DOWN | 2;
+			gpio_config(GPIO_PORT_K, GPIO_PIN_3, GPIO_MODE_GPIO);
+			gpio_output_enable(GPIO_PORT_K, GPIO_PIN_3, GPIO_OUTPUT_ENABLE);
+			gpio_write(GPIO_PORT_K, GPIO_PIN_3, GPIO_HIGH);
+		}
+	}
+	else
+	{
+		if (!regulator_get_5v_dev_enabled(1 << uart))
+			return;
+
+		regulator_disable_5v(1 << uart);
+
+		if (uart == UART_C)
+			gpio_write(GPIO_PORT_CC, GPIO_PIN_3, GPIO_LOW);
+		else
+			gpio_write(GPIO_PORT_K, GPIO_PIN_3, GPIO_LOW);
+	}
+}
+
+void jc_init_hw()
+{
+	jc_l.uart = UART_C;
+	jc_r.uart = UART_B;
+
+#if (LV_LOG_PRINTF != 1)
+	jc_power_supply(UART_C, true);
+	jc_power_supply(UART_B, true);
+
+	// Joy-Con (R) IsAttached.
+	PINMUX_AUX(PINMUX_AUX_GPIO_PH6) = PINMUX_INPUT_ENABLE | PINMUX_TRISTATE;
+	gpio_config(GPIO_PORT_H, GPIO_PIN_6, GPIO_MODE_GPIO);
+
+	// Joy-Con (L) IsAttached.
+	PINMUX_AUX(PINMUX_AUX_GPIO_PE6) = PINMUX_INPUT_ENABLE | PINMUX_TRISTATE;
+	gpio_config(GPIO_PORT_E, GPIO_PIN_6, GPIO_MODE_GPIO);
+
+	// Configure pinmuxing for UART B and C.
+	pinmux_config_uart(UART_B);
+	pinmux_config_uart(UART_C);
+
+	// Ease the stress to APB.
+	bpmp_clk_rate_set(BPMP_CLK_NORMAL);
+
+	// Enable UART B and C clocks.
+	clock_enable_uart(UART_B);
+	clock_enable_uart(UART_C);
+
+	// Restore OC.
+	bpmp_clk_rate_set(BPMP_CLK_DEFAULT_BOOST);
+
+	// Turn Joy-Con detect on.
+	gpio_config(GPIO_PORT_G, GPIO_PIN_0, GPIO_MODE_GPIO);
+	gpio_config(GPIO_PORT_D, GPIO_PIN_1, GPIO_MODE_GPIO);
+
+	jc_init_done = true;
+#endif
+}
+
+jc_gamepad_rpt_t *joycon_poll()
+{
+	if (!jc_init_done)
+		return NULL;
+
+	if (!gpio_read(GPIO_PORT_H, GPIO_PIN_6))
+		jc_init_conn(&jc_r);
+	if (!gpio_read(GPIO_PORT_E, GPIO_PIN_6))
+		jc_init_conn(&jc_l);
+
+	if (!gpio_read(GPIO_PORT_H, GPIO_PIN_6))
+		jc_req_nx_pad_status(&jc_r);
+	if (!gpio_read(GPIO_PORT_E, GPIO_PIN_6))
+		jc_req_nx_pad_status(&jc_l);
+
+	if (!gpio_read(GPIO_PORT_H, GPIO_PIN_6))
+		jc_rcv_pkt(&jc_r);
+	if (!gpio_read(GPIO_PORT_E, GPIO_PIN_6))
+		jc_rcv_pkt(&jc_l);
+
+	jc_conn_check();
+
+	return &jc_gamepad;
+}

source/hid/joycon.h

@@ -0,0 +1,98 @@
+/*
+ * Ambient light sensor driver for Nintendo Switch's Rohm BH1730
+ *
+ * Copyright (c) 2018 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __JOYCON_H_
+#define __JOYCON_H_
+
+#include "../utils/types.h"
+
+#define JC_BTNS_DIRECTION_PAD 0xF0000
+#define JC_BTNS_PREV_NEXT     0x800080
+#define JC_BTNS_ENTER         0x400008
+#define JC_BTNS_ESC           0x4
+
+#define JC_BTNS_ALL (JC_BTNS_PREV_NEXT | JC_BTNS_ENTER | JC_BTNS_DIRECTION_PAD | JC_BTNS_ESC)
+
+typedef struct _jc_bt_conn_t
+{
+	u8 type;
+	u8 mac[6];
+	u8 host_mac[6];
+	u8 ltk[16];
+} jc_bt_conn_t;
+
+typedef struct _jc_gamepad_rpt_t
+{
+	union
+	{
+		struct
+		{
+			// Joy-Con (R).
+			u32 y:1;
+			u32 x:1;
+			u32 b:1;
+			u32 a:1;
+			u32 sr_r:1;
+			u32 sl_r:1;
+			u32 r:1;
+			u32 zr:1;
+
+			// Shared
+			u32 minus:1;
+			u32 plus:1;
+			u32 r3:1;
+			u32 l3:1;
+			u32 home:1;
+			u32 cap:1;
+			u32 pad:1;
+			u32 wired:1;
+
+			// Joy-Con (L).
+			u32 down:1;
+			u32 up:1;
+			u32 right:1;
+			u32 left:1;
+			u32 sr_l:1;
+			u32 sl_l:1;
+			u32 l:1;
+			u32 zl:1;
+		};
+		u32 buttons;
+	};
+
+	u16 lstick_x;
+	u16 lstick_y;
+	u16 rstick_x;
+	u16 rstick_y;
+	bool center_stick_l;
+	bool center_stick_r;
+	bool conn_l;
+	bool conn_r;
+	u8 batt_info_l;
+	u8 batt_info_r;
+	jc_bt_conn_t bt_conn_l;
+	jc_bt_conn_t bt_conn_r;
+} jc_gamepad_rpt_t;
+
+void jc_power_supply(u8 uart, bool enable);
+void jc_init_hw();
+void jc_deinit();
+jc_gamepad_rpt_t *joycon_poll();
+jc_gamepad_rpt_t *jc_get_bt_pairing_info();
+
+#endif

source/hos/fss.c

@@ -0,0 +1,220 @@
+/*
+ * Atmosphère Fusée Secondary Storage parser.
+ *
+ * Copyright (c) 2019-2020 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <string.h>
+
+#include "fss.h"
+// #include "hos.h"
+#include "../config/config.h"
+#include "../libs/fatfs/ff.h"
+#include "../mem/heap.h"
+#include "../storage/emummc.h"
+#include "../storage/nx_sd.h"
+
+#include "../gfx/gfx.h"
+#define DPRINTF(...)
+
+extern hekate_config h_cfg;
+
+extern bool is_ipl_updated(void *buf, char *path, bool force);
+
+// FSS0 Magic and Meta header offset.
+#define FSS0_MAGIC 0x30535346
+#define FSS0_META_OFFSET 0x4
+
+// FSS0 Content Types.
+#define CNT_TYPE_FSP 0
+#define CNT_TYPE_EXO 1  // Exosphere (Secure Monitor).
+#define CNT_TYPE_WBT 2  // Warmboot (SC7Exit fw).
+#define CNT_TYPE_RBT 3  // Rebootstub (Warmboot based reboot fw).
+#define CNT_TYPE_SP1 4  // Sept Primary (TSEC and Sept Secondary loader).
+#define CNT_TYPE_SP2 5  // Sept Secondary (Acts as pkg11 and derives keys).
+#define CNT_TYPE_KIP 6  // KIP1 (Used for replacement or addition).
+#define CNT_TYPE_BMP 7
+#define CNT_TYPE_EMC 8
+#define CNT_TYPE_KLD 9  // Kernel Loader.
+#define CNT_TYPE_KRN 10 // Kernel.
+
+// FSS0 Content Flags.
+#define CNT_FLAG0_EXPERIMENTAL (1 << 0)
+
+// FSS0 Meta Header.
+typedef struct _fss_meta_t
+{
+	u32 magic;
+	u32 size;
+	u32 crt0_off;
+	u32 cnt_off;
+	u32 cnt_count;
+	u32 hos_ver;
+	u32 version;
+	u32 git_rev;
+} fss_meta_t;
+
+// FSS0 Content Header.
+typedef struct _fss_content_t
+{
+	u32 offset;
+	u32 size;
+	u8 type;
+	u8 flags0;
+	u8 flags1;
+	u8 flags2;
+	u32 rsvd1;
+	char name[0x10];
+} fss_content_t;
+
+int parse_fss(launch_ctxt_t *ctxt, const char *path, fss0_sept_t *sept_ctxt)
+{
+	FIL fp;
+
+	bool stock = false;
+	int sept_used = 0;
+
+	if (!sept_ctxt)
+	{
+		LIST_FOREACH_ENTRY(ini_kv_t, kv, &ctxt->cfg->kvs, link)
+		{
+			if (!strcmp("stock", kv->key))
+				if (kv->val[0] == '1')
+					stock = true;
+		}
+
+		if (stock && ctxt->pkg1_id->kb <= KB_FIRMWARE_VERSION_620 && (!emu_cfg.enabled || h_cfg.emummc_force_disable))
+			return 1;
+	}
+
+	if (f_open(&fp, path, FA_READ) != FR_OK)
+		return 0;
+
+	void *fss = malloc(f_size(&fp));
+
+	// Read first 1024 bytes of the fss file.
+	f_read(&fp, fss, 1024, NULL);
+
+	// Get FSS0 Meta header offset.
+	u32 fss_meta_addr = *(u32 *)(fss + FSS0_META_OFFSET);
+	fss_meta_t *fss_meta = (fss_meta_t *)(fss + fss_meta_addr);
+
+	// Check if valid FSS0 and parse it.
+	if (fss_meta->magic == FSS0_MAGIC)
+	{
+		gfx_printf("Found FSS0, Atmosphere %d.%d.%d-%08x\n"
+			"Max HOS supported: %d.%d.%d\n"
+			"Unpacking and loading components..  ",
+			fss_meta->version >> 24, (fss_meta->version >> 16) & 0xFF, (fss_meta->version >> 8) & 0xFF, fss_meta->git_rev,
+			fss_meta->hos_ver >> 24, (fss_meta->hos_ver >> 16) & 0xFF, (fss_meta->hos_ver >> 8) & 0xFF);
+
+		if (!sept_ctxt)
+		{
+			ctxt->atmosphere = true;
+			ctxt->fss0_hosver = fss_meta->hos_ver;
+		}
+
+		// Parse FSS0 contents.
+		fss_content_t *curr_fss_cnt = (fss_content_t *)(fss + fss_meta->cnt_off);
+		void *content;
+		for (u32 i = 0; i < fss_meta->cnt_count; i++)
+		{
+			content = (void *)(fss + curr_fss_cnt[i].offset);
+
+			// Check if offset is inside limits.
+			if ((curr_fss_cnt[i].offset + curr_fss_cnt[i].size) > fss_meta->size)
+				continue;
+
+			// If content is experimental and experimental flag is not enabled, skip it.
+			if ((curr_fss_cnt[i].flags0 & CNT_FLAG0_EXPERIMENTAL) && !ctxt->fss0_enable_experimental)
+				continue;
+
+			// Parse content.
+			if (!sept_ctxt)
+			{
+				// Prepare content context.
+				switch (curr_fss_cnt[i].type)
+				{
+				case CNT_TYPE_KIP:
+					if (stock)
+						continue;
+					merge_kip_t *mkip1 = (merge_kip_t *)malloc(sizeof(merge_kip_t));
+					mkip1->kip1 = content;
+					list_append(&ctxt->kip1_list, &mkip1->link);
+					DPRINTF("Loaded %s.kip1 from FSS0 (size %08X)\n", curr_fss_cnt[i].name, curr_fss_cnt[i].size);
+					break;
+				case CNT_TYPE_EXO:
+					ctxt->secmon_size = curr_fss_cnt[i].size;
+					ctxt->secmon = content;
+					break;
+				case CNT_TYPE_WBT:
+					ctxt->warmboot_size = curr_fss_cnt[i].size;
+					ctxt->warmboot = content;
+					break;
+				default:
+					continue;
+				}
+
+				// Load content to launch context.
+				f_lseek(&fp, curr_fss_cnt[i].offset);
+				f_read(&fp, content, curr_fss_cnt[i].size, NULL);
+			}
+			else
+			{
+				// Load sept content directly to launch context.
+				switch (curr_fss_cnt[i].type)
+				{
+				case CNT_TYPE_SP1:
+					f_lseek(&fp, curr_fss_cnt[i].offset);
+					f_read(&fp, sept_ctxt->sept_primary, curr_fss_cnt[i].size, NULL);
+					break;
+				case CNT_TYPE_SP2:
+					if (!memcmp(curr_fss_cnt[i].name, (sept_ctxt->kb < KB_FIRMWARE_VERSION_810) ? "septsecondary00" : "septsecondary01", 15))
+					{
+						f_lseek(&fp, curr_fss_cnt[i].offset);
+						f_read(&fp, sept_ctxt->sept_secondary, curr_fss_cnt[i].size, NULL);
+						sept_used = 1;
+						goto out;
+					}
+					break;
+				default:
+					break;
+				}
+			}
+		}
+
+out:
+		gfx_printf("Done!\n");
+		f_close(&fp);
+
+		return (!sept_ctxt ? 1 : sept_used);
+	}
+
+	f_close(&fp);
+	free(fss);
+
+	return 0;
+}
+
+int load_sept_from_ffs0(fss0_sept_t *sept_ctxt)
+{
+	LIST_FOREACH_ENTRY(ini_kv_t, kv, &sept_ctxt->cfg_sec->kvs, link)
+	{
+		if (!strcmp("fss0", kv->key))
+			return parse_fss(NULL, kv->val, sept_ctxt);
+	}
+
+	return 0;
+}

source/hos/fss.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2019 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _FSS_H_
+#define _FSS_H_
+
+#include "hos.h"
+
+typedef struct _fss0_sept_t
+{
+	u32 kb;
+	ini_sec_t *cfg_sec;
+	void *sept_primary;
+	void *sept_secondary;
+
+} fss0_sept_t;
+
+int parse_fss(launch_ctxt_t *ctxt, const char *path, fss0_sept_t *sept_ctxt);
+int load_sept_from_ffs0(fss0_sept_t *sept_ctxt);
+
+#endif

source/hos/hos.h

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2018 naehrwert
+ * Copyright (c) 2018-2020 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _HOS_H_
+#define _HOS_H_
+
+#include "pkg1.h"
+#include "pkg2.h"
+#include "../utils/types.h"
+#include "../config/ini.h"
+#include "../sec/tsec.h"
+
+#include <assert.h>
+
+#define KB_FIRMWARE_VERSION_100_200 0
+#define KB_FIRMWARE_VERSION_300 1
+#define KB_FIRMWARE_VERSION_301 2
+#define KB_FIRMWARE_VERSION_400 3
+#define KB_FIRMWARE_VERSION_500 4
+#define KB_FIRMWARE_VERSION_600 5
+#define KB_FIRMWARE_VERSION_620 6
+#define KB_FIRMWARE_VERSION_700 7
+#define KB_FIRMWARE_VERSION_810 8
+#define KB_FIRMWARE_VERSION_900 9
+#define KB_FIRMWARE_VERSION_910 10
+#define KB_FIRMWARE_VERSION_MAX KB_FIRMWARE_VERSION_910
+
+#define HOS_PKG11_MAGIC 0x31314B50
+#define HOS_EKS_MAGIC   0x30534B45
+
+typedef struct _exo_ctxt_t
+{
+	bool no_user_exceptions;
+	bool user_pmu;
+	bool *cal0_blank;
+	bool *cal0_allow_writes_sys;
+} exo_ctxt_t;
+
+typedef struct _hos_eks_keys_t
+{
+	u8 dkg[0x10];
+	u8 mkk[0x10];
+	u8 fdk[0x10];
+	u8 dkk[0x10];
+} hos_eks_keys_t;
+
+typedef struct _hos_eks_mbr_t
+{
+	u32 magic;
+	u32 enabled;
+	u32 sbk_low[2];
+	hos_eks_keys_t keys[6];
+	u32 magic2;
+	u32 rsvd2[3];
+} hos_eks_mbr_t;
+
+static_assert(sizeof(hos_eks_mbr_t) == 416, "HOS EKS storage bigger than MBR!");
+
+typedef struct _launch_ctxt_t
+{
+	void *keyblob;
+
+	void *pkg1;
+	const pkg1_id_t *pkg1_id;
+	const pkg2_kernel_id_t *pkg2_kernel_id;
+
+	void *warmboot;
+	u32   warmboot_size;
+	void *secmon;
+	u32   secmon_size;
+
+	void *pkg2;
+	u32   pkg2_size;
+	bool  new_pkg2;
+
+	void  *kernel;
+	u32    kernel_size;
+	link_t kip1_list;
+	char*  kip1_patches;
+
+	u32  fss0_hosver;
+	bool svcperm;
+	bool debugmode;
+	bool stock;
+	bool atmosphere;
+	bool fss0_enable_experimental;
+	bool emummc_forced;
+
+	exo_ctxt_t exo_cfg;
+
+	ini_sec_t *cfg;
+} launch_ctxt_t;
+
+typedef struct _merge_kip_t
+{
+	void *kip1;
+	link_t link;
+} merge_kip_t;
+
+void hos_eks_get();
+void hos_eks_save(u32 kb);
+void hos_eks_clear(u32 kb);
+int  hos_launch(ini_sec_t *cfg);
+int  hos_keygen(u8 *keyblob, u32 kb, tsec_ctxt_t *tsec_ctxt, launch_ctxt_t *hos_ctxt);
+
+#endif

source/hos/pkg1.c

@@ -25,7 +25,7 @@
 #define HASH_ORDER_100_100 {2, 3, 4, 0, 5, 6, 1}
 #define HASH_ORDER_200_510 {2, 3, 4, 0, 5, 7, 10, 12, 11, 6, 8, 1}
 #define HASH_ORDER_600_620 {6, 5, 10, 7, 8, 2, 3, 4, 0, 12, 11, 1}
-#define HASH_ORDER_700_9xx {6, 5, 10, 7, 8, 2, 3, 4, 0, 12, 11, 9, 1}
+#define HASH_ORDER_700_10x {6, 5, 10, 7, 8, 2, 3, 4, 0, 12, 11, 9, 1}
 
 static const pkg1_id_t _pkg1_ids[] = {
 	{ "20161121183008", 0, {0x1b517, 0x125bc2, 1, 16,  6, HASH_ORDER_100_100,      0, 0x449dc} }, //1.0.0
@@ -36,13 +36,13 @@ static const pkg1_id_t _pkg1_ids[] = {
 	{ "20180220163747", 4, {0x1f3b4,   0x465b, 0, 16, 11, HASH_ORDER_200_510, 0x5a63, 0x37901} }, //5.0.0 - 5.1.0
 	{ "20180802162753", 5, {0x27350,  0x17ff5, 1,  8, 11, HASH_ORDER_600_620, 0x5674, 0x1d5be} }, //6.0.0 - 6.1.0
 	{ "20181107105733", 6, {0x27350,  0x17ff5, 1,  8, 11, HASH_ORDER_600_620, 0x5674, 0x1d5be} }, //6.2.0
-	{ "20181218175730", 7, {0x29c50,   0x6a73, 0,  8, 12, HASH_ORDER_700_9xx, 0x5563, 0x1d437} }, //7.0.0
+	{ "20181218175730", 7, {0x29c50,   0x6a73, 0,  8, 12, HASH_ORDER_700_10x, 0x5563, 0x1d437} }, //7.0.0
-	{ "20190208150037", 7, {0x29c50,   0x6a73, 0,  8, 12, HASH_ORDER_700_9xx, 0x5563, 0x1d437} }, //7.0.1
+	{ "20190208150037", 7, {0x29c50,   0x6a73, 0,  8, 12, HASH_ORDER_700_10x, 0x5563, 0x1d437} }, //7.0.1
-	{ "20190314172056", 7, {0x29c50,   0x6a73, 0,  8, 12, HASH_ORDER_700_9xx, 0x5563, 0x1d437} }, //8.0.0 - 8.0.1
+	{ "20190314172056", 7, {0x29c50,   0x6a73, 0,  8, 12, HASH_ORDER_700_10x, 0x5563, 0x1d437} }, //8.0.0 - 8.0.1
-	{ "20190531152432", 8, {0x29c50,   0x6a73, 0,  8, 12, HASH_ORDER_700_9xx, 0x5563, 0x1d437} }, //8.1.0
+	{ "20190531152432", 8, {0x29c50,   0x6a73, 0,  8, 12, HASH_ORDER_700_10x, 0x5563, 0x1d437} }, //8.1.0
-	{ "20190809135709", 9, {0x2ec10,   0x5573, 0,  1, 12, HASH_ORDER_700_9xx, 0x6495, 0x1d807} }, //9.0.0 - 9.0.1
+	{ "20190809135709", 9, {0x2ec10,   0x5573, 0,  1, 12, HASH_ORDER_700_10x, 0x6495, 0x1d807} }, //9.0.0 - 9.0.1
-	{ "20191021113848", 10,{0x2ec10,   0x5573, 0,  1, 12, HASH_ORDER_700_9xx, 0x6495, 0x1d807} }, //9.1.0
+	{ "20191021113848", 10,{0x2ec10,   0x5573, 0,  1, 12, HASH_ORDER_700_10x, 0x6495, 0x1d807} }, //9.1.0
-	{ "20200303104606", 11,{0x2ec10,   0x5573, 0,  1, 12, HASH_ORDER_700_9xx, 0x6495, 0x1d807} }, //10.0.0, May or may not be accurate. I just need to feed tsec anyway so this doesn't matter
+	{ "20200303104606", 10,{0x30ea0,   0x5e4b, 0,  1, 12, HASH_ORDER_700_10x, 0x663c, 0x1d9a4} }, //10.0.0
 	{ NULL } //End.
 };
 

source/hos/pkg2.c

@@ -26,6 +26,10 @@
 
 #include "../gfx/gfx.h"
 
+u32 pkg2_newkern_ini1_val;
+u32 pkg2_newkern_ini1_start;
+u32 pkg2_newkern_ini1_end;
+
 /*#include "util.h"
 #define DPRINTF(...) gfx_printf(__VA_ARGS__)
 #define DEBUG_PRINTING*/

source/hos/pkg2.h

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2018 naehrwert
- * Copyright (C) 2018-2020 CTCaer
+ * Copyright (c) 2018-2020 CTCaer
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -28,9 +28,17 @@
 
 #define PKG2_NEWKERN_GET_INI1_HEURISTIC 0xD2800015 // Offset of OP + 12 is the INI1 offset.
 
-u32 pkg2_newkern_ini1_val;
+extern u32 pkg2_newkern_ini1_val;
-u32 pkg2_newkern_ini1_start;
+extern u32 pkg2_newkern_ini1_start;
-u32 pkg2_newkern_ini1_end;
+extern u32 pkg2_newkern_ini1_end;
+
+typedef struct _kernel_patch_t
+{
+	u32 id;
+	u32 off;
+	u32 val;
+	u32 *ptr;
+} kernel_patch_t;
 
 typedef struct _pkg2_hdr_t
 {
@@ -87,6 +95,12 @@ typedef struct _pkg2_kip1_info_t
 	link_t link;
 } pkg2_kip1_info_t;
 
+typedef struct _pkg2_kernel_id_t
+{
+	u8 hash[8];
+	kernel_patch_t *kernel_patchset;
+} pkg2_kernel_id_t;
+
 bool pkg2_parse_kips(link_t *info, pkg2_hdr_t *pkg2, bool *new_pkg2);
 int pkg2_decompress_kip(pkg2_kip1_info_t* ki, u32 sectsToDecomp);
 pkg2_hdr_t *pkg2_decrypt(void *data);

source/hos/sept.c

@@ -17,15 +17,20 @@
 #include <string.h>
 
 #include "sept.h"
+#include "../config/ini.h"
 #include "../gfx/di.h"
+#include "../hos/fss.h"
+#include "../hos/hos.h"
 #include "../libs/fatfs/ff.h"
 #include "../mem/heap.h"
 #include "../soc/hw_init.h"
 #include "../soc/pmc.h"
 #include "../soc/t210.h"
 #include "../storage/nx_emmc.h"
+#include "../storage/nx_sd.h"
 #include "../storage/sdmmc.h"
 #include "../utils/btn.h"
+#include "../utils/list.h"
 #include "../utils/types.h"
 
 #include "../gfx/gfx.h"
@@ -58,48 +63,81 @@ u8 warmboot_reboot[] = {
 
 extern u32 color_idx;
 extern boot_cfg_t b_cfg;
-extern void sd_unmount();
 extern void reloc_patcher(u32 payload_dst, u32 payload_src, u32 payload_size);
 
 int reboot_to_sept(const u8 *tsec_fw, const u32 tsec_size, const u32 kb)
 {
 	FIL fp;
+	bool fss0_sept_used = false;
 
 	// Copy warmboot reboot code and TSEC fw.
 	memcpy((u8 *)(SEPT_PK1T_ADDR - WB_RST_SIZE), (u8 *)warmboot_reboot, sizeof(warmboot_reboot));
 	memcpy((void *)SEPT_PK1T_ADDR, tsec_fw, tsec_size);
 	*(vu32 *)SEPT_TCSZ_ADDR = tsec_size;
 
-	// Copy sept-primary.
+	LIST_INIT(ini_sections);
-	if (f_open(&fp, "sd:/sept/sept-primary.bin", FA_READ))
+	if (ini_parse(&ini_sections, "bootloader/hekate_ipl.ini", false))
-		goto error;
+	{
+		bool found = false;
+		LIST_FOREACH_ENTRY(ini_sec_t, ini_sec, &ini_sections, link)
+		{
+			// Only parse non config sections.
+			if (ini_sec->type == INI_CHOICE && strcmp(ini_sec->name, "config"))
+			{
+				LIST_FOREACH_ENTRY(ini_kv_t, kv, &ini_sec->kvs, link)
+				{
+					if (!strcmp("fss0", kv->key))
+					{
+						fss0_sept_t sept_ctxt;
+						sept_ctxt.kb = kb;
+						sept_ctxt.sept_primary = (void *)SEPT_STG1_ADDR;
+						sept_ctxt.sept_secondary = (void *)SEPT_STG2_ADDR;
+						fss0_sept_used = parse_fss(NULL, kv->val, &sept_ctxt);
 
-	if (f_read(&fp, (u8 *)SEPT_STG1_ADDR, f_size(&fp), NULL))
+						found = true;
-	{
+						break;
-		f_close(&fp);
+					}
-		goto error;
+				}
+			}
+			if (found)
+				break;
+		}
 	}
-	f_close(&fp);
 
-	// Copy sept-secondary.
+
-	if (kb < KB_FIRMWARE_VERSION_810)
+	if (!fss0_sept_used)
 	{
-		if (f_open(&fp, "sd:/sept/sept-secondary_00.enc", FA_READ))
+		// Copy sept-primary.
-			if (f_open(&fp, "sd:/sept/sept-secondary.enc", FA_READ)) // Try the deprecated version.
+		if (f_open(&fp, "sd:/sept/sept-primary.bin", FA_READ))
-				goto error;
-	}
-	else
-	{
-		if (f_open(&fp, "sd:/sept/sept-secondary_01.enc", FA_READ))
 			goto error;
-	}
 
-	if (f_read(&fp, (u8 *)SEPT_STG2_ADDR, f_size(&fp), NULL))
+		if (f_read(&fp, (u8 *)SEPT_STG1_ADDR, f_size(&fp), NULL))
-	{
+		{
+			f_close(&fp);
+			goto error;
+		}
+		f_close(&fp);
+
+		// Copy sept-secondary.
+		if (kb < KB_FIRMWARE_VERSION_810)
+		{
+			if (f_open(&fp, "sd:/sept/sept-secondary_00.enc", FA_READ))
+				if (f_open(&fp, "sd:/sept/sept-secondary.enc", FA_READ)) // Try the deprecated version.
+					goto error;
+		}
+		else
+		{
+			if (f_open(&fp, "sd:/sept/sept-secondary_01.enc", FA_READ))
+				goto error;
+		}
+
+		if (f_read(&fp, (u8 *)SEPT_STG2_ADDR, f_size(&fp), NULL))
+		{
+			f_close(&fp);
+			goto error;
+		}
 		f_close(&fp);
-		goto error;
 	}
-	f_close(&fp);
 
 	// Save auto boot config to sept payload, if any.
 	boot_cfg_t *tmp_cfg = malloc(sizeof(boot_cfg_t));
@@ -107,7 +145,8 @@ int reboot_to_sept(const u8 *tsec_fw, const u32 tsec_size, const u32 kb)
 
 	tmp_cfg->boot_cfg |= BOOT_CFG_SEPT_RUN;
 
-	if (f_open(&fp, "sd:/sept/payload.bin", FA_READ | FA_WRITE)) {
+	if (f_open(&fp, "sd:/sept/payload.bin", FA_READ | FA_WRITE))
+	{
 		free(tmp_cfg);
 		goto error;
 	}

source/ianos/ianos.c

@@ -18,21 +18,18 @@
 #include <string.h>
 
 #include "ianos.h"
-#include "../utils/types.h"
-#include "../libs/elfload/elfload.h"
 #include "../../common/common_module.h"
-#include "../mem/heap.h"
 #include "../gfx/gfx.h"
+#include "../libs/elfload/elfload.h"
+#include "../mem/heap.h"
+#include "../storage/nx_sd.h"
+#include "../utils/types.h"
 
 #define IRAM_LIB_ADDR 0x4002B000
 #define DRAM_LIB_ADDR 0xE0000000
 
 extern heap_t _heap;
 
-extern void *sd_file_read(const char *path, u32 *fsize);
-extern bool sd_mount();
-extern void sd_unmount();
-
 void *elfBuf = NULL;
 void *fileBuf = NULL;
 

source/libs/fatfs/diskio.c

@@ -81,8 +81,10 @@ static inline void _gf256_mul_x_le(void *block) {
 
 static inline int _emmc_xts(u32 ks1, u32 ks2, u32 enc, u8 *tweak, bool regen_tweak, u32 tweak_exp, u64 sec, void *dst, void *src, u32 secsize) {
     int res = 0;
-    u8 *pdst = (u8 *)dst;
+    u8 *temptweak = (u8 *)malloc(0x10);
-    u8 *psrc = (u8 *)src;
+	u32 *pdst = (u32 *)dst;
+    u32 *psrc = (u32 *)src;
+    u32 *ptweak = (u32 *)tweak;
 
     if (regen_tweak) {
         for (int i = 0xF; i >= 0; i--) {
@@ -96,34 +98,33 @@ static inline int _emmc_xts(u32 ks1, u32 ks2, u32 enc, u8 *tweak, bool regen_twe
     for (u32 i = 0; i < tweak_exp * 0x20; i++)
         _gf256_mul_x_le(tweak);
 
-    u8 temptweak[0x10];
     memcpy(temptweak, tweak, 0x10);
 
     //We are assuming a 0x10-aligned sector size in this implementation.
     for (u32 i = 0; i < secsize / 0x10; i++) {
-        for (u32 j = 0; j < 0x10; j++)
+        for (u32 j = 0; j < 4; j++)
-            pdst[j] = psrc[j] ^ tweak[j];
+            pdst[j] = psrc[j] ^ ptweak[j];
         _gf256_mul_x_le(tweak);
-        psrc += 0x10;
+        psrc += 4;
-        pdst += 0x10;
+        pdst += 4;
     }
 
-    se_aes_crypt_ecb(ks2, enc, dst, secsize, src, secsize);
+    se_aes_crypt_ecb(ks2, enc, dst, secsize, dst, secsize);
 
-    pdst = (u8 *)dst;
+    pdst = (u32 *)dst;
 
     memcpy(tweak, temptweak, 0x10);
     for (u32 i = 0; i < secsize / 0x10; i++) {
-        for (u32 j = 0; j < 0x10; j++)
+        for (u32 j = 0; j < 4; j++)
-            pdst[j] = pdst[j] ^ tweak[j];
+            pdst[j] = pdst[j] ^ ptweak[j];
         _gf256_mul_x_le(tweak);
-        pdst += 0x10;
+        pdst += 4;
     }
 
-
     res = 1;
 
 out:;
+    free(temptweak);
     return res;
 }
 

source/libs/fatfs/ff.c

@@ -42,8 +42,8 @@
 #include "../../storage/sdmmc.h"
 extern sdmmc_storage_t sd_storage;
 
-#define EFSPRINTF(text, ...) print_error(); gfx_printf("%k"text"%k\n", 0xFFFFFF00, 0xFFFFFFFF);
+//#define EFSPRINTF(text, ...) print_error(); gfx_printf("%k"text"%k\n", 0xFFFFFF00, 0xFFFFFFFF);
-//#define EFSPRINTF(...)
+#define EFSPRINTF(...)
 
 /*--------------------------------------------------------------------------
 
@@ -5629,7 +5629,8 @@ FRESULT f_forward (
 }
 #endif /* FF_USE_FORWARD */
 
-
+#pragma GCC push_options
+#pragma GCC optimize ("Os")
 
 #if FF_USE_MKFS && !FF_FS_READONLY
 /*-----------------------------------------------------------------------*/
@@ -6094,7 +6095,7 @@ FRESULT f_mkfs (
 	LEAVE_MKFS(FR_OK);
 }
 
-
+#pragma GCC pop_options
 
 #if FF_MULTI_PARTITION
 /*-----------------------------------------------------------------------*/
@@ -6113,9 +6114,6 @@ FRESULT f_fdisk (
 	DWORD sz_disk, p_sect, b_cyl, b_sect;
 	FRESULT res;
 
-	BYTE *empty_buff;
-	empty_buff = ff_memcalloc(sizeof(BYTE), 16384);
-
 	stat = disk_initialize(pdrv);
 	if (stat & STA_NOINIT) return FR_NOT_READY;
 	if (stat & STA_PROTECT) return FR_WRITE_PROTECTED;
@@ -6168,14 +6166,14 @@ FRESULT f_fdisk (
 		st_dword(p + 8, b_sect);			/* Start sector in LBA */
 		st_dword(p + 12, p_sect);			/* Number of sectors */
 		/* Next partition */
-		b_sect += p_sect;
 
-		for (int cursect = 0; cursect < 1024; cursect++){
+		for (u32 cursect = 0; cursect < 512; cursect++){
-			disk_write(pdrv, empty_buff, b_sect + (32 * cursect), 32);
+			disk_write(pdrv, buf + 0x4000, b_sect + (64 * cursect), 64);
 		}
+
+		b_sect += p_sect;
 	}
 	st_word(p, 0xAA55);		/* MBR signature (always at offset 510) */
-	ff_memfree(empty_buff);
 
 	/* Write it to the MBR */
 	res = (disk_write(pdrv, buf, 0, 1) == RES_OK && disk_ioctl(pdrv, CTRL_SYNC, 0) == RES_OK) ? FR_OK : FR_DISK_ERR;

source/link.ld

@@ -6,6 +6,7 @@ SECTIONS {
 	.text : {
 		*(.text._start);
 		*(._boot_cfg);
+		*(.text._irq_setup);
 		*(.text*);
 	}
 	.data : {

source/main.c

@@ -39,17 +39,20 @@
 #include "utils/sprintf.h"
 #include "utils/util.h"
 #include "tegraexplorer/mainmenu.h"
+#include "tegraexplorer/gfx/gfxutils.h"
+#include "storage/nx_sd.h"
 
 //#include "keys/keys.h"
 
-sdmmc_t sd_sdmmc;
+//sdmmc_t sd_sdmmc;
-sdmmc_storage_t sd_storage;
+//sdmmc_storage_t sd_storage;
-__attribute__ ((aligned (16))) FATFS sd_fs;
+//__attribute__ ((aligned (16))) FATFS sd_fs;
-bool sd_mounted, sd_inited;
+//bool sd_mounted, sd_inited;
 volatile nyx_storage_t *nyx_str = (nyx_storage_t *)NYX_STORAGE_ADDR;
 hekate_config h_cfg;
 boot_cfg_t __attribute__((section ("._boot_cfg"))) b_cfg;
 
+/*
 bool sd_mount()
 {
 	if (sd_mounted)
@@ -131,6 +134,7 @@ int sd_save_to_file(void *buf, u32 size, const char *filename)
 
 	return 0;
 }
+*/
 
 // This is a safe and unused DRAM region for our payloads.
 #define RELOC_META_OFF      0x7C
@@ -229,6 +233,7 @@ int launch_payload(char *path)
 	return 1;
 }
 
+/*
 void launch_tools()
 {
 	u8 max_entries = 61;
@@ -403,9 +408,55 @@ void _get_key_generations(char *sysnand_label, char *emunand_label) {
 	free(pkg1);
 	ment_top[1].caption = emunand_label;
 }
+*/
 
-#define IPL_STACK_TOP  0x90010000
+#define EXCP_EN_ADDR   0x4003FFFC
-#define IPL_HEAP_START 0x90020000
+#define  EXCP_MAGIC 0x30505645 // EVP0
+#define EXCP_TYPE_ADDR 0x4003FFF8
+#define  EXCP_TYPE_RESET 0x545352 // RST
+#define  EXCP_TYPE_UNDEF 0x464455 // UDF
+#define  EXCP_TYPE_PABRT 0x54424150 // PABT
+#define  EXCP_TYPE_DABRT 0x54424144 // DABT
+#define EXCP_LR_ADDR   0x4003FFF4
+
+static void _show_errors(){
+	u32 *excp_enabled = (u32 *)EXCP_EN_ADDR;
+	u32 *excp_type = (u32 *)EXCP_TYPE_ADDR;
+	u32 *excp_lr = (u32 *)EXCP_LR_ADDR;
+
+	if (*excp_enabled == EXCP_MAGIC)
+		h_cfg.errors |= ERR_EXCEPT_ENB;
+
+	if (h_cfg.errors & ERR_EXCEPT_ENB){
+		gfx_clearscreen();
+		SWAPCOLOR(COLOR_ORANGE);
+		gfx_printf("\nAn exception has occured while running TegraExplorer!\n(LR %08X)\n\n", *excp_lr);
+
+		SWAPCOLOR(COLOR_VIOLET);
+		gfx_printf("Exception: ");
+		SWAPCOLOR(COLOR_YELLOW);
+		switch (*excp_type){
+			case EXCP_TYPE_RESET:
+				gfx_printf("Reset");
+				break;
+			case EXCP_TYPE_UNDEF:
+				gfx_printf("Undefined instruction");
+				break;
+			case EXCP_TYPE_PABRT:
+				gfx_printf("Prefetch abort");
+				break;
+			case EXCP_TYPE_DABRT:
+				gfx_printf("Data abort");
+				break;
+		}
+
+		RESETCOLOR;
+		gfx_printf("\n\nPress vol+/- or power to continue");
+
+		*excp_enabled = 0;
+		btn_wait();
+	}
+}
 
 extern void pivot_stack(u32 stack_top);
 
@@ -455,6 +506,8 @@ void ipl_main()
 		tui_do_menu(&menu_top);
 	*/
 
+	_show_errors();
+
 	te_main();
 
 	while (true)

source/mem/heap.c

@@ -136,7 +136,7 @@ void *malloc(u32 size)
 void *calloc(u32 num, u32 size)
 {
 	void *res = (void *)_heap_alloc(&_heap, num * size);
-	memset(res, 0, num * size);
+	memset(res, 0, ALIGN(num * size, sizeof(hnode_t))); // Clear the aligned size.
 	return res;
 }
 

source/mem/mc_t210.h

@@ -463,4 +463,54 @@
 #define MC_ERR_APB_ASID_UPDATE_STATUS                           0x9d0
 #define MC_DA_CONFIG0                                           0x9dc
 
+// MC_SECURITY_CARVEOUTX_CFG0
+// Mode of LOCK_MODE.
+#define PROTECT_MODE_SHIFT 0
+#define SEC_CARVEOUT_CFG_SECURE    (0 << PROTECT_MODE_SHIFT0)
+#define SEC_CARVEOUT_CFG_TZ_SECURE (1 << PROTECT_MODE_SHIFT0)
+// Enables PROTECT_MODE.
+#define LOCK_MODE_SHIFT 1
+#define SEC_CARVEOUT_CFG_UNLOCKED (0 << LOCK_MODE_SHIFT)
+#define SEC_CARVEOUT_CFG_LOCKED   (1 << LOCK_MODE_SHIFT)
+
+#define ADDRESS_TYPE_SHIFT 2
+#define SEC_CARVEOUT_CFG_ANY_ADDRESS       (0 << ADDRESS_TYPE_SHIFT)
+#define SEC_CARVEOUT_CFG_UNTRANSLATED_ONLY (1 << ADDRESS_TYPE_SHIFT)
+
+#define READ_ACCESS_LEVEL_SHIFT 3
+#define SEC_CARVEOUT_CFG_RD_ALL       (1 << READ_ACCESS_LEVEL_SHIFT)
+#define SEC_CARVEOUT_CFG_RD_UNK       (2 << READ_ACCESS_LEVEL_SHIFT)
+#define SEC_CARVEOUT_CFG_RD_FALCON_LS (4 << READ_ACCESS_LEVEL_SHIFT)
+#define SEC_CARVEOUT_CFG_RD_FALCON_HS (8 << READ_ACCESS_LEVEL_SHIFT)
+
+#define WRITE_ACCESS_LEVEL_SHIFT 7
+#define SEC_CARVEOUT_CFG_WR_ALL       (1 << WRITE_ACCESS_LEVEL_SHIFT)
+#define SEC_CARVEOUT_CFG_WR_UNK       (2 << WRITE_ACCESS_LEVEL_SHIFT)
+#define SEC_CARVEOUT_CFG_WR_FALCON_LS (4 << WRITE_ACCESS_LEVEL_SHIFT)
+#define SEC_CARVEOUT_CFG_WR_FALCON_HS (8 << WRITE_ACCESS_LEVEL_SHIFT)
+
+#define SEC_CARVEOUT_CFG_APERTURE_ID_MASK (3 << 11)
+
+#define DISABLE_READ_CHECK_ACCESS_LEVEL_SHIFT 14
+#define SEC_CARVEOUT_CFG_DIS_RD_CHECK_L0 (1 << DISABLE_READ_CHECK_ACCESS_LEVEL_SHIFT)
+#define SEC_CARVEOUT_CFG_DIS_RD_CHECK_L1 (2 << DISABLE_READ_CHECK_ACCESS_LEVEL_SHIFT)
+#define SEC_CARVEOUT_CFG_DIS_RD_CHECK_L2 (4 << DISABLE_READ_CHECK_ACCESS_LEVEL_SHIFT)
+#define SEC_CARVEOUT_CFG_DIS_RD_CHECK_L3 (8 << DISABLE_READ_CHECK_ACCESS_LEVEL_SHIFT)
+
+#define DISABLE_WRITE_CHECK_ACCESS_LEVEL_SHIFT 18
+#define SEC_CARVEOUT_CFG_DIS_WR_CHECK_L0 (1 << DISABLE_WRITE_CHECK_ACCESS_LEVEL_SHIFT)
+#define SEC_CARVEOUT_CFG_DIS_WR_CHECK_L1 (2 << DISABLE_WRITE_CHECK_ACCESS_LEVEL_SHIFT)
+#define SEC_CARVEOUT_CFG_DIS_WR_CHECK_L2 (4 << DISABLE_WRITE_CHECK_ACCESS_LEVEL_SHIFT)
+#define SEC_CARVEOUT_CFG_DIS_WR_CHECK_L3 (8 << DISABLE_WRITE_CHECK_ACCESS_LEVEL_SHIFT)
+
+#define SEC_CARVEOUT_CFG_SEND_CFG_TO_GPU (1 << 22)
+
+#define SEC_CARVEOUT_CFG_TZ_GLOBAL_WR_EN_BYPASS_CHECK (1 << 23)
+#define SEC_CARVEOUT_CFG_TZ_GLOBAL_RD_EN_BYPASS_CHECK (1 << 24)
+
+#define SEC_CARVEOUT_CFG_ALLOW_APERTURE_ID_MISMATCH (1 << 25)
+#define SEC_CARVEOUT_CFG_FORCE_APERTURE_ID_MATCH    (1 << 26)
+
+#define SEC_CARVEOUT_CFG_IS_WPR (1 << 27)
+
 #endif

source/mem/minerva.c

@@ -27,6 +27,7 @@
 #include "../soc/t210.h"
 
 extern volatile nyx_storage_t *nyx_str;
+void (*minerva_cfg)(mtc_config_t *mtc_cfg, void *);
 
 u32 minerva_init()
 {
@@ -37,7 +38,7 @@ u32 minerva_init()
 	memset(mtc_cfg, 0, sizeof(mtc_config_t));
 
 	// Set table to nyx storage.
-	mtc_cfg->mtc_table = (emc_table_t *)&nyx_str->mtc_table;
+	mtc_cfg->mtc_table = (emc_table_t *)nyx_str->mtc_table;
 
 	mtc_cfg->sdram_id = (fuse_read_odm(4) >> 3) & 0x1F;
 	mtc_cfg->init_done = MTC_NEW_MAGIC; // Initialize mtc table.

source/mem/minerva.h

@@ -57,7 +57,7 @@ typedef enum
 	FREQ_1600 = 1600000
 } minerva_freq_t;
 
-void (*minerva_cfg)(mtc_config_t *mtc_cfg, void *);
+extern void (*minerva_cfg)(mtc_config_t *mtc_cfg, void *);
 u32  minerva_init();
 void minerva_change_freq(minerva_freq_t freq);
 void minerva_periodic_training();

source/mem/sdram.c

@@ -16,6 +16,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <string.h>
+
 #include "mc.h"
 #include "emc.h"
 #include "sdram_param_t210.h"
@@ -29,7 +31,7 @@
 #include "../soc/t210.h"
 #include "../utils/util.h"
 
-#define CONFIG_SDRAM_COMPRESS_CFG
+#define CONFIG_SDRAM_KEEP_ALIVE
 
 #ifdef CONFIG_SDRAM_COMPRESS_CFG
 #include "../libs/compr/lz.h"
@@ -40,13 +42,57 @@
 
 static u32 _get_sdram_id()
 {
-	u32 sdram_id = (fuse_read_odm(4) & 0x38) >> 3;
+	return ((fuse_read_odm(4) & 0x38) >> 3);
+}
 
-	// Check if id is proper.
+static bool _sdram_wait_emc_status(u32 reg_offset, u32 bit_mask, bool updated_state, s32 emc_channel)
-	if (sdram_id > 7)
+{
-		sdram_id = 0;
+	bool err = true;
 
-	return sdram_id;
+	for (s32 i = 0; i < EMC_STATUS_UPDATE_TIMEOUT; i++)
+	{
+		if (emc_channel)
+		{
+			if (emc_channel != 1)
+				goto done;
+
+			if (((EMC_CH1(reg_offset) & bit_mask) != 0) == updated_state)
+			{
+				err = false;
+				break;
+			}
+		}
+		else if (((EMC(reg_offset) & bit_mask) != 0) == updated_state)
+		{
+			err = false;
+			break;
+		}
+		usleep(1);
+	}
+
+done:
+	return err;
+}
+
+static void _sdram_req_mrr_data(u32 data, bool dual_channel)
+{
+	EMC(EMC_MRR) = data;
+	_sdram_wait_emc_status(EMC_EMC_STATUS, EMC_STATUS_MRR_DIVLD, true, EMC_CHAN0);
+	if (dual_channel)
+		_sdram_wait_emc_status(EMC_EMC_STATUS, EMC_STATUS_MRR_DIVLD, true, EMC_CHAN1);
+}
+
+emc_mr_data_t sdram_read_mrx(emc_mr_t mrx)
+{
+	emc_mr_data_t data;
+	_sdram_req_mrr_data((1 << 31) | (mrx << 16), EMC_CHAN0);
+	data.dev0_ch0 = EMC(EMC_MRR) & 0xFF;
+	data.dev0_ch1 = (EMC(EMC_MRR) & 0xFF00 >> 8);
+	_sdram_req_mrr_data((1 << 30) | (mrx << 16), EMC_CHAN1);
+	data.dev1_ch0 = EMC(EMC_MRR) & 0xFF;
+	data.dev1_ch1 = (EMC(EMC_MRR) & 0xFF00 >> 8);
+
+	return data;
 }
 
 static void _sdram_config(const sdram_params_t *params)
@@ -73,10 +119,14 @@ static void _sdram_config(const sdram_params_t *params)
 	CLOCK(CLK_RST_CONTROLLER_PLLM_MISC1) = params->pllm_setup_control;
 	CLOCK(CLK_RST_CONTROLLER_PLLM_MISC2) = 0;
 
-	// u32 tmp = (params->pllm_feedback_divider << 8) | params->pllm_input_divider | ((params->pllm_post_divider & 0xFFFF) << 20);
+#ifdef CONFIG_SDRAM_KEEP_ALIVE
-	// CLOCK(CLK_RST_CONTROLLER_PLLM_BASE) = tmp;
+	CLOCK(CLK_RST_CONTROLLER_PLLM_BASE) =
-	// CLOCK(CLK_RST_CONTROLLER_PLLM_BASE) = tmp | 0x40000000;
+		(params->pllm_feedback_divider << 8) | params->pllm_input_divider | ((params->pllm_post_divider & 0xFFFF) << 20) | PLLCX_BASE_ENABLE;
-	CLOCK(CLK_RST_CONTROLLER_PLLM_BASE) = (params->pllm_feedback_divider << 8) | params->pllm_input_divider | 0x40000000 | ((params->pllm_post_divider & 0xFFFF) << 20);
+#else
+	u32 pllm_div = (params->pllm_feedback_divider << 8) | params->pllm_input_divider | ((params->pllm_post_divider & 0xFFFF) << 20);
+	CLOCK(CLK_RST_CONTROLLER_PLLM_BASE) = pllm_div;
+	CLOCK(CLK_RST_CONTROLLER_PLLM_BASE) = pllm_div | PLLCX_BASE_ENABLE;
+#endif
 
 	u32 wait_end = get_tmr_us() + 300;
 	while (!(CLOCK(CLK_RST_CONTROLLER_PLLM_BASE) & 0x8000000))
@@ -91,7 +141,7 @@ break_nosleep:
 	if (params->emc_clock_source_dll)
 		CLOCK(CLK_RST_CONTROLLER_CLK_SOURCE_EMC_DLL) = params->emc_clock_source_dll;
 	if (params->clear_clock2_mc1)
-		CLOCK(CLK_RST_CONTROLLER_CLK_ENB_W_CLR) = 0x40000000;
+		CLOCK(CLK_RST_CONTROLLER_CLK_ENB_W_CLR) = 0x40000000; // Clear Reset to MC1.
 
 	CLOCK(CLK_RST_CONTROLLER_CLK_ENB_H_SET) = 0x2000001; // Enable EMC and MEM clocks.
 	CLOCK(CLK_RST_CONTROLLER_CLK_ENB_X_SET) = 0x4000;    // Enable EMC_DLL clock.
@@ -509,9 +559,9 @@ break_nosleep:
 	// ZQ CAL setup (not actually issuing ZQ CAL now).
 	if (params->emc_zcal_warm_cold_boot_enables & 1)
 	{
-		if (params->memory_type == 2)
+		if (params->memory_type == MEMORY_TYPE_DDR3L)
 			EMC(EMC_ZCAL_WAIT_CNT) = params->emc_zcal_wait_cnt << 3;
-		if (params->memory_type == 3)
+		if (params->memory_type == MEMORY_TYPE_LPDDR4)
 		{
 			EMC(EMC_ZCAL_WAIT_CNT) = params->emc_zcal_wait_cnt;
 			EMC(EMC_ZCAL_MRW_CMD) = params->emc_zcal_mrw_cmd;
@@ -527,7 +577,7 @@ break_nosleep:
 
 	// Set clock enable signal.
 	u32 pin_gpio_cfg = (params->emc_pin_gpio_enable << 16) | (params->emc_pin_gpio << 12);
-	if (params->memory_type == 2 || params->memory_type == 3)
+	if (params->memory_type == MEMORY_TYPE_DDR3L || params->memory_type == MEMORY_TYPE_LPDDR4)
 	{
 		EMC(EMC_PIN) = pin_gpio_cfg;
 		(void)EMC(EMC_PIN);
@@ -536,9 +586,9 @@ break_nosleep:
 		(void)EMC(EMC_PIN);
 	}
 
-	if (params->memory_type == 3)
+	if (params->memory_type == MEMORY_TYPE_LPDDR4)
 		usleep(params->emc_pin_extra_wait + 2000);
-	else if (params->memory_type == 2)
+	else if (params->memory_type == MEMORY_TYPE_DDR3L)
 		usleep(params->emc_pin_extra_wait + 500);
 
 	// Enable clock enable signal.
@@ -547,15 +597,15 @@ break_nosleep:
 	usleep(params->emc_pin_program_wait);
 
 	// Send NOP (trigger just needs to be non-zero).
-	if (params->memory_type != 3)
+	if (params->memory_type != MEMORY_TYPE_LPDDR4)
 		EMC(EMC_NOP) = (params->emc_dev_select << 30) + 1;
 
 	// On coldboot w/LPDDR2/3, wait 200 uSec after asserting CKE high.
-	if (params->memory_type == 1)
+	if (params->memory_type == MEMORY_TYPE_LPDDR2)
 		usleep(params->emc_pin_extra_wait + 200);
 
 	// Init zq calibration,
-	if (params->memory_type == 3)
+	if (params->memory_type == MEMORY_TYPE_LPDDR4)
 	{
 		// Patch 6 using BCT spare variables.
 		if (params->emc_bct_spare10)
@@ -596,7 +646,7 @@ break_nosleep:
 	PMC(APBDEV_PMC_DDR_CFG) = params->pmc_ddr_cfg;
 
 	// Start periodic ZQ calibration (LPDDRx only).
-	if (params->memory_type - 1 <= 2)
+	if (params->memory_type && params->memory_type <= MEMORY_TYPE_LPDDR4)
 	{
 		EMC(EMC_ZCAL_INTERVAL) = params->emc_zcal_interval;
 		EMC(EMC_ZCAL_WAIT_CNT) = params->emc_zcal_wait_cnt;
@@ -641,18 +691,47 @@ break_nosleep:
 	MC(MC_SEC_CARVEOUT_REG_CTRL) = params->mc_sec_carveout_protect_write_access;
 	MC(MC_MTS_CARVEOUT_REG_CTRL) = params->mc_mts_carveout_reg_ctrl;
 
-	//Disable write access to a bunch of EMC registers.
+	// Disable write access to a bunch of EMC registers.
 	MC(MC_EMEM_CFG_ACCESS_CTRL) = 1;
 }
 
+#ifndef CONFIG_SDRAM_COMPRESS_CFG
+static void _sdram_patch_model_params(u32 dramid, u32 *params)
+{
+	for (u32 i = 0; i < sizeof(sdram_cfg_vendor_patches) / sizeof(sdram_vendor_patch_t); i++)
+		if (sdram_cfg_vendor_patches[i].dramid & DRAM_ID(dramid))
+			params[sdram_cfg_vendor_patches[i].addr] = sdram_cfg_vendor_patches[i].val;
+}
+#endif
+
 sdram_params_t *sdram_get_params()
 {
+	// Check if id is proper.
+	u32 dramid = _get_sdram_id();
+	if (dramid > 6)
+		dramid = 0;
+
 #ifdef CONFIG_SDRAM_COMPRESS_CFG
 	u8 *buf = (u8 *)SDRAM_PARAMS_ADDR;
 	LZ_Uncompress(_dram_cfg_lz, buf, sizeof(_dram_cfg_lz));
-	return (sdram_params_t *)&buf[sizeof(sdram_params_t) * _get_sdram_id()];
+	return (sdram_params_t *)&buf[sizeof(sdram_params_t) * dramid];
 #else
-	return _dram_cfgs[_get_sdram_id()];
+	sdram_params_t *buf = (sdram_params_t *)SDRAM_PARAMS_ADDR;
+	memcpy(buf, &_dram_cfg_0_samsung_4gb, sizeof(sdram_params_t));
+	switch (dramid)
+	{
+	case DRAM_4GB_SAMSUNG_K4F6E304HB_MGCH:
+	case DRAM_4GB_MICRON_MT53B512M32D2NP_062_WT:
+		break;
+	case DRAM_4GB_HYNIX_H9HCNNNBPUMLHR_NLN:
+	case DRAM_4GB_COPPER_UNK_3:
+	case DRAM_6GB_SAMSUNG_K4FHE3D4HM_MFCH:
+	case DRAM_4GB_COPPER_UNK_5:
+	case DRAM_4GB_COPPER_UNK_6:
+		_sdram_patch_model_params(dramid, (u32 *)buf);
+		break;
+	}
+	return buf;
 #endif
 }
 

source/mem/sdram.h

@@ -17,11 +17,13 @@
 #ifndef _SDRAM_H_
 #define _SDRAM_H_
 
+#include "emc.h"
 #include "sdram_param_t210.h"
 
 void sdram_init();
 sdram_params_t *sdram_get_params();
 sdram_params_t *sdram_get_params_patched();
 void sdram_lp0_save_params(const void *params);
+emc_mr_data_t sdram_read_mrx(emc_mr_t mrx);
 
 #endif

source/mem/sdram_param_t210.h

@@ -26,12 +26,12 @@
 #ifndef _SDRAM_PARAM_T210_H_
 #define _SDRAM_PARAM_T210_H_
 
-#define MEMORY_TYPE_NONE 0
+#define MEMORY_TYPE_NONE   0
-#define MEMORY_TYPE_DDR 0
+#define MEMORY_TYPE_DDR    0
-#define MEMORY_TYPE_LPDDR 0
+#define MEMORY_TYPE_LPDDR  0
-#define MEMORY_TYPE_DDR2 0
+#define MEMORY_TYPE_DDR2   0
 #define MEMORY_TYPE_LPDDR2 1
-#define MEMORY_TYPE_DDR3 2
+#define MEMORY_TYPE_DDR3L  2
 #define MEMORY_TYPE_LPDDR4 3
 
 /**

source/power/bq24193.c

@@ -0,0 +1,170 @@
+/*
+ * Battery charger driver for Nintendo Switch's TI BQ24193
+ *
+ * Copyright (c) 2018 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "bq24193.h"
+#include "../soc/i2c.h"
+#include "../utils/util.h"
+
+#pragma GCC push_options
+#pragma GCC optimize ("Os")
+
+int bq24193_get_property(enum BQ24193_reg_prop prop, int *value)
+{
+	u8 data;
+
+	switch (prop) {
+		case BQ24193_InputVoltageLimit: // Input voltage limit (mV).
+			data = i2c_recv_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_InputSource);
+			data = (data & BQ24193_INCONFIG_VINDPM_MASK) >> 3;
+			*value = 0;
+			*value += ((data >> 0) & 1) ? 80 : 0;
+			*value += ((data >> 1) & 1) ? 160 : 0;
+			*value += ((data >> 2) & 1) ? 320 : 0;
+			*value += ((data >> 3) & 1) ? 640 : 0;
+			*value += 3880;
+			break;
+		case BQ24193_InputCurrentLimit: // Input current limit (mA).
+			data = i2c_recv_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_InputSource);
+			data &= BQ24193_INCONFIG_INLIMIT_MASK;
+			switch (data)
+			{
+			case 0:
+				*value = 100;
+				break;
+			case 1:
+				*value = 150;
+				break;
+			case 2:
+				*value = 500;
+				break;
+			case 3:
+				*value = 900;
+				break;
+			case 4:
+				*value = 1200;
+				break;
+			case 5:
+				*value = 1500;
+				break;
+			case 6:
+				*value = 2000;
+				break;
+			case 7:
+				*value = 3000;
+				break;
+			}
+			break;
+		case BQ24193_SystemMinimumVoltage: // Minimum system voltage limit (mV).
+			data = i2c_recv_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_PORConfig);
+			*value = (data & BQ24193_PORCONFIG_SYSMIN_MASK) >> 1;
+			*value *= 100;
+			*value += 3000;
+			break;
+		case BQ24193_FastChargeCurrentLimit: // Fast charge current limit (mA).
+			data = i2c_recv_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_ChrgCurr);
+			data = (data & BQ24193_CHRGCURR_ICHG_MASK) >> 2;
+			*value = 0;
+			*value += ((data >> 0) & 1) ? 64 : 0;
+			*value += ((data >> 1) & 1) ? 128 : 0;
+			*value += ((data >> 2) & 1) ? 256 : 0;
+			*value += ((data >> 3) & 1) ? 512 : 0;
+			*value += ((data >> 4) & 1) ? 1024 : 0;
+			*value += ((data >> 5) & 1) ? 2048 : 0;
+			*value += 512;
+			data = i2c_recv_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_ChrgCurr);
+			data &= BQ24193_CHRGCURR_20PCT_MASK;
+			if (data)
+				*value = *value * 20 / 100; // Fast charge current limit is 20%.
+			break;
+		case BQ24193_ChargeVoltageLimit: // Charge voltage limit (mV).
+			data = i2c_recv_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_ChrgVolt);
+			data = (data & BQ24193_CHRGVOLT_VREG) >> 2;
+			*value = 0;
+			*value += ((data >> 0) & 1) ? 16 : 0;
+			*value += ((data >> 1) & 1) ? 32 : 0;
+			*value += ((data >> 2) & 1) ? 64 : 0;
+			*value += ((data >> 3) & 1) ? 128 : 0;
+			*value += ((data >> 4) & 1) ? 256 : 0;
+			*value += ((data >> 5) & 1) ? 512 : 0;
+			*value += 3504;
+			break;
+		case BQ24193_RechargeThreshold: // Recharge voltage threshold less than voltage limit (mV).
+			data = i2c_recv_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_ChrgVolt);
+			data &= BQ24193_IRTHERMAL_THERM_MASK;
+			if (data)
+				*value = 300;
+			else
+				*value = 100;
+			break;
+		case BQ24193_ThermalRegulation: // Thermal regulation threshold (oC).
+			data = i2c_recv_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_IRCompThermal);
+			data &= BQ24193_IRTHERMAL_THERM_MASK;
+			switch (data)
+			{
+			case 0:
+				*value = 60;
+				break;
+			case 1:
+				*value = 80;
+				break;
+			case 2:
+				*value = 100;
+				break;
+			case 3:
+				*value = 120;
+				break;
+			}
+			break;
+		case BQ24193_ChargeStatus: // 0: Not charging, 1: Pre-charge, 2: Fast charging, 3: Charge termination done
+			data = i2c_recv_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_Status);
+			*value = (data & BQ24193_STATUS_CHRG_MASK) >> 4;
+			break;
+		case BQ24193_TempStatus: // 0: Normal, 2: Warm, 3: Cool, 5: Cold, 6: Hot.
+			data = i2c_recv_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_FaultReg);
+			*value = data & BQ24193_FAULT_THERM_MASK;
+			break;
+		case BQ24193_DevID: // Dev ID.
+			data = i2c_recv_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_VendorPart);
+			*value = data & BQ24193_VENDORPART_DEV_MASK;
+			break;
+		case BQ24193_ProductNumber: // Product number.
+			data = i2c_recv_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_VendorPart);
+			*value = (data & BQ24193_VENDORPART_PN_MASK) >> 3;
+			break;
+		default:
+			return -1;
+	}
+	return 0;
+}
+
+void bq24193_fake_battery_removal()
+{
+	u8 value;
+
+	// Disable watchdog to keep BATFET disabled.
+	value = i2c_recv_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_ChrgTermTimer);
+	value &= ~BQ24193_CHRGTERM_WATCHDOG_MASK;
+	i2c_send_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_ChrgTermTimer, value);
+
+	// Force BATFET to disabled state. This disconnects the battery from the system.
+	value = i2c_recv_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_Misc);
+	value |= BQ24193_MISC_BATFET_DI_MASK;
+	i2c_send_byte(I2C_1, BQ24193_I2C_ADDR, BQ24193_Misc, value);
+}
+
+#pragma GCC pop_options

source/power/bq24193.h

@@ -0,0 +1,119 @@
+/*
+ * Battery charger driver for Nintendo Switch's TI BQ24193
+ *
+ * Copyright (c) 2018 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __BQ24193_H_
+#define __BQ24193_H_
+
+#define BQ24193_I2C_ADDR 0x6B
+
+// REG 0 masks.
+#define BQ24193_INCONFIG_INLIMIT_MASK (7<<0)
+#define BQ24193_INCONFIG_VINDPM_MASK   0x78
+#define BQ24193_INCONFIG_HIZ_EN_MASK  (1<<7)
+
+// REG 1 masks.
+#define BQ24193_PORCONFIG_BOOST_MASK       (1<<0)
+#define BQ24193_PORCONFIG_SYSMIN_MASK      (7<<1)
+#define BQ24193_PORCONFIG_CHGCONFIG_MASK   (3<<4)
+#define BQ24193_PORCONFIG_I2CWATCHDOG_MASK (1<<6)
+#define BQ24193_PORCONFIG_RESET_MASK       (1<<7)
+
+// REG 2 masks.
+#define BQ24193_CHRGCURR_20PCT_MASK (1<<0)
+#define BQ24193_CHRGCURR_ICHG_MASK   0xFC
+
+// REG 3 masks.
+#define BQ24193_PRECHRG_ITERM   0x0F
+#define BQ24193_PRECHRG_IPRECHG 0xF0
+
+// REG 4 masks.
+#define BQ24193_CHRGVOLT_VTHRES  (1<<0)
+#define BQ24193_CHRGVOLT_BATTLOW (1<<1)
+#define BQ24193_CHRGVOLT_VREG     0xFC
+
+// REG 5 masks.
+#define BQ24193_CHRGTERM_ISET_MASK     (1<<0)
+#define BQ24193_CHRGTERM_CHGTIMER_MASK (3<<1)
+#define BQ24193_CHRGTERM_ENTIMER_MASK  (1<<3)
+#define BQ24193_CHRGTERM_WATCHDOG_MASK (3<<4)
+#define BQ24193_CHRGTERM_TERM_ST_MASK  (1<<6)
+#define BQ24193_CHRGTERM_TERM_EN_MASK  (1<<7)
+
+// REG 6 masks.
+#define BQ24193_IRTHERMAL_THERM_MASK    (3<<0)
+#define BQ24193_IRTHERMAL_VCLAMP_MASK   (7<<2)
+#define BQ24193_IRTHERMAL_BATTCOMP_MASK (7<<5)
+
+// REG 7 masks.
+#define BQ24193_MISC_INT_MASK       (3<<0)
+#define BQ24193_MISC_VSET_MASK      (1<<4)
+#define BQ24193_MISC_BATFET_DI_MASK (1<<5)
+#define BQ24193_MISC_TMR2X_EN_MASK  (1<<6)
+#define BQ24193_MISC_DPDM_EN_MASK   (1<<7)
+
+// REG 8 masks.
+#define BQ24193_STATUS_VSYS_MASK  (1<<0)
+#define BQ24193_STATUS_THERM_MASK (1<<1)
+#define BQ24193_STATUS_PG_MASK    (1<<2)
+#define BQ24193_STATUS_DPM_MASK   (1<<3)
+#define BQ24193_STATUS_CHRG_MASK  (3<<4)
+#define BQ24193_STATUS_VBUS_MASK  (3<<6)
+
+// REG 9 masks.
+#define BQ24193_FAULT_THERM_MASK    (7<<0)
+#define BQ24193_FAULT_BATT_OVP_MASK (1<<3)
+#define BQ24193_FAULT_CHARGE_MASK   (3<<4)
+#define BQ24193_FAULT_BOOST_MASK    (1<<6)
+#define BQ24193_FAULT_WATCHDOG_MASK (1<<7)
+
+// REG A masks.
+#define BQ24193_VENDORPART_DEV_MASK (3<<0)
+#define BQ24193_VENDORPART_PN_MASK  (7<<3)
+
+enum BQ24193_reg {
+	BQ24193_InputSource     = 0x00,
+	BQ24193_PORConfig       = 0x01,
+	BQ24193_ChrgCurr        = 0x02,
+	BQ24193_PreChrgTerm     = 0x03,
+	BQ24193_ChrgVolt        = 0x04,
+	BQ24193_ChrgTermTimer   = 0x05,
+	BQ24193_IRCompThermal   = 0x06,
+	BQ24193_Misc            = 0x07,
+	BQ24193_Status          = 0x08,
+	BQ24193_FaultReg        = 0x09,
+	BQ24193_VendorPart      = 0x0A,
+};
+
+enum BQ24193_reg_prop {
+	BQ24193_InputVoltageLimit,      // REG 0.
+	BQ24193_InputCurrentLimit,      // REG 0.
+	BQ24193_SystemMinimumVoltage,   // REG 1.
+	BQ24193_FastChargeCurrentLimit, // REG 2.
+	BQ24193_ChargeVoltageLimit,     // REG 4.
+	BQ24193_RechargeThreshold,      // REG 4.
+	BQ24193_ThermalRegulation,      // REG 6.
+	BQ24193_ChargeStatus,           // REG 8.
+	BQ24193_TempStatus,             // REG 9.
+	BQ24193_DevID,                  // REG A.
+	BQ24193_ProductNumber,          // REG A.
+};
+
+int bq24193_get_property(enum BQ24193_reg_prop prop, int *value);
+void bq24193_fake_battery_removal();
+
+#endif /* __BQ24193_H_ */

source/power/max17050.c

@@ -46,6 +46,12 @@
 #pragma GCC push_options
 #pragma GCC optimize ("Os")
 
+static u32 battery_voltage = 0;
+u32 max17050_get_cached_batt_volt()
+{
+	return battery_voltage;
+}
+
 int max17050_get_property(enum MAX17050_reg reg, int *value)
 {
 	u16 data;
@@ -74,6 +80,7 @@ int max17050_get_property(enum MAX17050_reg reg, int *value)
 	case MAX17050_VCELL: // Voltage now.
 		i2c_recv_buf_small((u8 *)&data, 2, I2C_1, MAXIM17050_I2C_ADDR, MAX17050_VCELL);
 		*value = data * 625 / 8 / 1000;
+		battery_voltage = *value;
 		break;
 	case MAX17050_AvgVCELL: // Voltage avg.
 		i2c_recv_buf_small((u8 *)&data, 2, I2C_1, MAXIM17050_I2C_ADDR, MAX17050_AvgVCELL);

source/power/max17050.h

@@ -24,6 +24,8 @@
 #ifndef __MAX17050_H_
 #define __MAX17050_H_
 
+#include "../utils/types.h"
+
 #define MAX17050_STATUS_BattAbsent    (1 << 3)
 #define MAX17050_DEFAULT_SNS_RESISTOR 10000
 
@@ -128,5 +130,6 @@ enum MAX17050_reg {
 
 int max17050_get_property(enum MAX17050_reg reg, int *value);
 int max17050_fix_configuration();
+u32 max17050_get_cached_batt_volt();
 
 #endif /* __MAX17050_H_ */

source/power/regulator_5v.c

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2019 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../soc/gpio.h"
+#include "../soc/pinmux.h"
+#include "../soc/pmc.h"
+#include "../soc/t210.h"
+#include "../utils/types.h"
+
+static u8 reg_5v_dev = 0;
+
+void regulator_enable_5v(u8 dev)
+{
+	// The power supply selection from battery or USB is automatic.
+	if (!reg_5v_dev)
+	{
+		// Fan and Rail power from internal 5V regulator (battery).
+		PINMUX_AUX(PINMUX_AUX_SATA_LED_ACTIVE) = 1;
+		gpio_config(GPIO_PORT_A, GPIO_PIN_5, GPIO_MODE_GPIO);
+		gpio_output_enable(GPIO_PORT_A, GPIO_PIN_5, GPIO_OUTPUT_ENABLE);
+		gpio_write(GPIO_PORT_A, GPIO_PIN_5, GPIO_HIGH);
+
+		// Fan and Rail power from USB 5V VDD.
+		PINMUX_AUX(PINMUX_AUX_USB_VBUS_EN0) = PINMUX_LPDR | 1;
+		gpio_config(GPIO_PORT_CC, GPIO_PIN_4, GPIO_MODE_GPIO);
+		gpio_output_enable(GPIO_PORT_CC, GPIO_PIN_4, GPIO_OUTPUT_ENABLE);
+		gpio_write(GPIO_PORT_CC, GPIO_PIN_4, GPIO_HIGH);
+
+		// Make sure GPIO power is enabled.
+		PMC(APBDEV_PMC_NO_IOPOWER) &= ~PMC_NO_IOPOWER_GPIO_IO_EN;
+		// Override power detect for GPIO AO IO rails.
+		PMC(APBDEV_PMC_PWR_DET_VAL) &= ~PMC_PWR_DET_GPIO_IO_EN;
+	}
+	reg_5v_dev |= dev;
+}
+
+void regulator_disable_5v(u8 dev)
+{
+	reg_5v_dev &= ~dev;
+
+	if (!reg_5v_dev)
+	{
+		// Rail power from internal 5V regulator (battery).
+		gpio_write(GPIO_PORT_A, GPIO_PIN_5, GPIO_LOW);
+		gpio_output_enable(GPIO_PORT_A, GPIO_PIN_5, GPIO_OUTPUT_DISABLE);
+		gpio_config(GPIO_PORT_A, GPIO_PIN_5, GPIO_MODE_SPIO);
+		PINMUX_AUX(PINMUX_AUX_SATA_LED_ACTIVE) = PINMUX_PARKED | PINMUX_INPUT_ENABLE;
+
+		// Rail power from USB 5V VDD.
+		gpio_write(GPIO_PORT_CC, GPIO_PIN_4, GPIO_LOW);
+		gpio_output_enable(GPIO_PORT_CC, GPIO_PIN_4, GPIO_OUTPUT_DISABLE);
+		gpio_config(GPIO_PORT_CC, GPIO_PIN_4, GPIO_MODE_SPIO);
+		PINMUX_AUX(PINMUX_AUX_USB_VBUS_EN0) = PINMUX_IO_HV | PINMUX_LPDR | PINMUX_PARKED | PINMUX_INPUT_ENABLE;
+
+		// GPIO AO IO rails.
+		PMC(APBDEV_PMC_PWR_DET_VAL) |= PMC_PWR_DET_GPIO_IO_EN;
+	}
+}
+
+bool regulator_get_5v_dev_enabled(u8 dev)
+{
+	return (reg_5v_dev & dev);
+}

source/power/regulator_5v.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2019 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _REGULATOR_5V_H_
+#define _REGULATOR_5V_H_
+
+#include "../utils/types.h"
+
+enum
+{
+	REGULATOR_5V_FAN  = (1 << 0),
+	REGULATOR_5V_JC_R = (1 << 1),
+	REGULATOR_5V_JC_L = (1 << 2),
+	REGULATOR_5V_ALL  = 0xFF
+};
+
+void regulator_enable_5v(u8 dev);
+void regulator_disable_5v(u8 dev);
+bool regulator_get_5v_dev_enabled(u8 dev);
+
+#endif

source/sec/se.c

@@ -2,7 +2,7 @@
  * Copyright (c) 2018 naehrwert
  * Copyright (c) 2018 CTCaer
  * Copyright (c) 2018 Atmosphère-NX
- * Copyright (c) 2019 shchmue
+ * Copyright (c) 2019-2020 shchmue
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -19,6 +19,7 @@
 
 #include <string.h>
 
+#include "../../common/memory_map.h"
 #include "../sec/se.h"
 #include "../mem/heap.h"
 #include "../soc/bpmp.h"
@@ -94,7 +95,12 @@ static int _se_wait()
 
 static int _se_execute(u32 op, void *dst, u32 dst_size, const void *src, u32 src_size)
 {
-	se_ll_t *ll_dst = (se_ll_t *)0xECFFFFE0, *ll_src = (se_ll_t *)0xECFFFFF0;
+	static se_ll_t *ll_dst = NULL, *ll_src = NULL;
+	if (!ll_dst)
+	{
+		ll_dst = (se_ll_t *)malloc(sizeof(se_ll_t));
+		ll_src = (se_ll_t *)malloc(sizeof(se_ll_t));
+	}
 
 	if (dst)
 	{
@@ -234,6 +240,16 @@ void se_aes_key_set(u32 ks, const void *key, u32 size)
 	}
 }
 
+void se_aes_iv_set(u32 ks, const void *iv, u32 size)
+{
+	u32 *data = (u32 *)iv;
+	for (u32 i = 0; i < size / 4; i++)
+	{
+		SE(SE_KEYTABLE_REG_OFFSET) = SE_KEYTABLE_SLOT(ks) | 8 | i;
+		SE(SE_KEYTABLE_DATA0_REG_OFFSET) = data[i];
+	}
+}
+
 void se_aes_key_read(u32 ks, void *key, u32 size)
 {
 	u32 *data = (u32 *)key;
@@ -320,12 +336,90 @@ int se_aes_crypt_ctr(u32 ks, void *dst, u32 dst_size, const void *src, u32 src_s
 	return 1;
 }
 
+// random calls were derived from Atmosphère's
+int se_initialize_rng(u32 ks)
+{
+	u8 *output_buf = (u8 *)malloc(0x10);
+
+	SE(SE_CONFIG_REG_OFFSET) = SE_CONFIG_ENC_ALG(ALG_RNG) | SE_CONFIG_DST(DST_MEMORY);
+	SE(SE_CRYPTO_REG_OFFSET) = SE_CRYPTO_KEY_INDEX(ks) | SE_CRYPTO_CORE_SEL(CORE_ENCRYPT) |
+		SE_CRYPTO_INPUT_SEL(INPUT_RANDOM);
+	SE(SE_RNG_CONFIG_REG_OFFSET) = SE_RNG_CONFIG_MODE(RNG_MODE_FORCE_INSTANTION) | SE_RNG_CONFIG_SRC(RNG_SRC_ENTROPY);
+	SE(SE_RNG_RESEED_INTERVAL_REG_OFFSET) = 70001;
+	SE(SE_RNG_SRC_CONFIG_REG_OFFSET) = SE_RNG_SRC_CONFIG_ENT_SRC_LOCK(RNG_SRC_RO_ENT_LOCK_ENABLE);
+	SE(SE_BLOCK_COUNT_REG_OFFSET) = 0;
+
+	int res =_se_execute(OP_START, output_buf, 0x10, NULL, 0);
+
+	free(output_buf);
+	return res;
+}
+
+int se_generate_random(u32 ks, void *dst, u32 size)
+{
+	SE(SE_CONFIG_REG_OFFSET) = SE_CONFIG_ENC_ALG(ALG_RNG) | SE_CONFIG_DST(DST_MEMORY);
+	SE(SE_CRYPTO_REG_OFFSET) = SE_CRYPTO_KEY_INDEX(ks) | SE_CRYPTO_CORE_SEL(CORE_ENCRYPT) |
+		SE_CRYPTO_INPUT_SEL(INPUT_RANDOM);
+	SE(SE_RNG_CONFIG_REG_OFFSET) = SE_RNG_CONFIG_MODE(RNG_MODE_NORMAL) | SE_RNG_CONFIG_SRC(RNG_SRC_ENTROPY);
+
+	u32 num_blocks = size >> 4;
+	u32 aligned_size = num_blocks << 4;
+	if (num_blocks)
+	{
+		SE(SE_BLOCK_COUNT_REG_OFFSET) = num_blocks - 1;
+		if (!_se_execute(OP_START, dst, aligned_size, NULL, 0))
+			return 0;
+	}
+	if (size > aligned_size)
+		return _se_execute_one_block(OP_START, dst + aligned_size, size - aligned_size, NULL, 0);
+	return 1;
+}
+
+int se_generate_random_key(u32 ks_dst, u32 ks_src)
+{
+	SE(SE_CONFIG_REG_OFFSET) = SE_CONFIG_ENC_ALG(ALG_RNG) | SE_CONFIG_DST(DST_MEMORY);
+	SE(SE_CRYPTO_REG_OFFSET) = SE_CRYPTO_KEY_INDEX(ks_src) | SE_CRYPTO_CORE_SEL(CORE_ENCRYPT) |
+		SE_CRYPTO_INPUT_SEL(INPUT_RANDOM);
+	SE(SE_RNG_CONFIG_REG_OFFSET) = SE_RNG_CONFIG_MODE(RNG_MODE_NORMAL) | SE_RNG_CONFIG_SRC(RNG_SRC_ENTROPY);
+
+	SE(SE_CRYPTO_KEYTABLE_DST_REG_OFFSET) = SE_CRYPTO_KEYTABLE_DST_KEY_INDEX(ks_dst);
+	if (!_se_execute(OP_START, NULL, 0, NULL, 0))
+		return 0;
+	SE(SE_CRYPTO_KEYTABLE_DST_REG_OFFSET) = SE_CRYPTO_KEYTABLE_DST_KEY_INDEX(ks_dst) | 1;
+	if (!_se_execute(OP_START, NULL, 0, NULL, 0))
+		return 0;
+
+	return 1;
+}
+
+int se_aes_crypt_cbc(u32 ks, u32 enc, void *dst, u32 dst_size, const void *src, u32 src_size)
+{
+	if (enc)
+	{
+		SE(SE_CONFIG_REG_OFFSET) = SE_CONFIG_ENC_ALG(ALG_AES_ENC) | SE_CONFIG_DST(DST_MEMORY);
+		SE(SE_CRYPTO_REG_OFFSET) = SE_CRYPTO_KEY_INDEX(ks) | SE_CRYPTO_VCTRAM_SEL(VCTRAM_AESOUT) |
+			SE_CRYPTO_CORE_SEL(CORE_ENCRYPT) | SE_CRYPTO_XOR_POS(XOR_TOP) | SE_CRYPTO_INPUT_SEL(INPUT_AHB) |
+			SE_CRYPTO_IV_SEL(IV_ORIGINAL);
+	}
+	else
+	{
+		SE(SE_CONFIG_REG_OFFSET) = SE_CONFIG_DEC_ALG(ALG_AES_DEC) | SE_CONFIG_DST(DST_MEMORY);
+		SE(SE_CRYPTO_REG_OFFSET) = SE_CRYPTO_KEY_INDEX(ks) | SE_CRYPTO_VCTRAM_SEL(VCTRAM_PREVAHB) |
+			SE_CRYPTO_CORE_SEL(CORE_DECRYPT) | SE_CRYPTO_XOR_POS(XOR_BOTTOM) | SE_CRYPTO_INPUT_SEL(INPUT_AHB) |
+			SE_CRYPTO_IV_SEL(IV_ORIGINAL);
+	}
+	SE(SE_BLOCK_COUNT_REG_OFFSET) = (src_size >> 4) - 1;
+	return _se_execute(OP_START, dst, dst_size, src, src_size);
+}
+
 int se_aes_xts_crypt_sec(u32 ks1, u32 ks2, u32 enc, u64 sec, void *dst, const void *src, u32 secsize)
 {
 	int res = 0;
 	u8 *tweak = (u8 *)malloc(0x10);
-	u8 *pdst = (u8 *)dst;
+	u8 *temptweak = (u8 *)malloc(0x10);
-	u8 *psrc = (u8 *)src;
+	u32 *pdst = (u32 *)dst;
+    u32 *psrc = (u32 *)src;
+    u32 *ptweak = (u32 *)tweak;
 
 	//Generate tweak.
 	for (int i = 0xF; i >= 0; i--)
@@ -336,23 +430,35 @@ int se_aes_xts_crypt_sec(u32 ks1, u32 ks2, u32 enc, u64 sec, void *dst, const vo
 	if (!se_aes_crypt_block_ecb(ks1, 1, tweak, tweak))
 		goto out;
 
+	memcpy(temptweak, tweak, 0x10);
+
 	//We are assuming a 0x10-aligned sector size in this implementation.
 	for (u32 i = 0; i < secsize / 0x10; i++)
 	{
-		for (u32 j = 0; j < 0x10; j++)
+		for (u32 j = 0; j < 4; j++)
-			pdst[j] = psrc[j] ^ tweak[j];
+			pdst[j] = psrc[j] ^ ptweak[j];
-		if (!se_aes_crypt_block_ecb(ks2, enc, pdst, pdst))
-			goto out;
-		for (u32 j = 0; j < 0x10; j++)
-			pdst[j] = pdst[j] ^ tweak[j];
 		_gf256_mul_x_le(tweak);
-		psrc += 0x10;
+		psrc += 4;
-		pdst += 0x10;
+		pdst += 4;
+	}
+
+	se_aes_crypt_ecb(ks2, enc, dst, secsize, dst, secsize);
+
+	pdst = (u32 *)dst;
+
+	memcpy(tweak, temptweak, 0x10);
+	for (u32 i = 0; i < secsize / 0x10; i++)
+	{
+		for (u32 j = 0; j < 4; j++)
+			pdst[j] = pdst[j] ^ ptweak[j];
+		_gf256_mul_x_le(tweak);
+		pdst += 4;
 	}
 
 	res = 1;
 
 out:;
+	free(temptweak);
 	free(tweak);
 	return res;
 }
@@ -390,17 +496,21 @@ int se_aes_cmac(u32 ks, void *dst, u32 dst_size, const void *src, u32 src_size)
 	se_aes_key_iv_clear(ks);
 
 	u32 num_blocks = (src_size + 0xf) >> 4;
-	if (num_blocks > 1) {
+	if (num_blocks > 1)
+	{
 		SE(SE_BLOCK_COUNT_REG_OFFSET) = num_blocks - 2;
 		if (!_se_execute(OP_START, NULL, 0, src, src_size))
 			goto out;
 		SE(SE_CRYPTO_REG_OFFSET) |= SE_CRYPTO_IV_SEL(IV_UPDATED);
 	}
 
-	if (src_size & 0xf) {
+	if (src_size & 0xf)
+	{
 		memcpy(last_block, src + (src_size & ~0xf), src_size & 0xf);
 		last_block[src_size & 0xf] = 0x80;
-	} else if (src_size >= 0x10) {
+	}
+	else if (src_size >= 0x10)
+	{
 		memcpy(last_block, src + src_size - 0x10, 0x10);
 	}
 
@@ -447,7 +557,8 @@ int se_calc_sha256(void *dst, const void *src, u32 src_size)
 	return res;
 }
 
-int se_calc_hmac_sha256(void *dst, const void *src, u32 src_size, const void *key, u32 key_size) {
+int se_calc_hmac_sha256(void *dst, const void *src, u32 src_size, const void *key, u32 key_size)
+{
 	int res = 0;
 	u8 *secret = (u8 *)malloc(0x40);
 	u8 *ipad = (u8 *)malloc(0x40 + src_size);

source/sec/se.h

@@ -25,12 +25,17 @@ void se_rsa_key_clear(u32 ks);
 int se_rsa_exp_mod(u32 ks, void *dst, u32 dst_size, const void *src, u32 src_size);
 void se_key_acc_ctrl(u32 ks, u32 flags);
 void se_aes_key_set(u32 ks, const void *key, u32 size);
+void se_aes_iv_set(u32 ks, const void *iv, u32 size);
 void se_aes_key_read(u32 ks, void *key, u32 size);
 void se_aes_key_clear(u32 ks);
+int se_initialize_rng(u32 ks);
+int se_generate_random(u32 ks, void *dst, u32 size);
+int se_generate_random_key(u32 ks_dst, u32 ks_src);
 int se_aes_unwrap_key(u32 ks_dst, u32 ks_src, const void *input);
 int se_aes_crypt_ecb(u32 ks, u32 enc, void *dst, u32 dst_size, const void *src, u32 src_size);
 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);
+int se_aes_crypt_cbc(u32 ks, u32 enc, void *dst, u32 dst_size, const void *src, u32 src_size);
 int se_aes_xts_crypt_sec(u32 ks1, u32 ks2, u32 enc, u64 sec, void *dst, const void *src, u32 secsize);
 int se_aes_xts_crypt(u32 ks1, u32 ks2, u32 enc, u64 sec, void *dst, const void *src, u32 secsize, u32 num_secs);
 int se_aes_cmac(u32 ks, void *dst, u32 dst_size, const void *src, u32 src_size);

source/sec/se_t210.h

@@ -70,27 +70,26 @@
 #define SE_CONFIG_DEC_MODE(x)		(x << SE_CONFIG_DEC_MODE_SHIFT)
 
 #define SE_RNG_CONFIG_REG_OFFSET		0x340
-#define DRBG_MODE_SHIFT	0
+#define RNG_MODE_SHIFT	0
-#define DRBG_MODE_NORMAL	0
+#define RNG_MODE_NORMAL	0
-#define DRBG_MODE_FORCE_INSTANTION	1
+#define RNG_MODE_FORCE_INSTANTION	1
-#define DRBG_MODE_FORCE_RESEED		2
+#define RNG_MODE_FORCE_RESEED		2
-#define SE_RNG_CONFIG_MODE(x)		(x << DRBG_MODE_SHIFT)
+#define SE_RNG_CONFIG_MODE(x)		(x << RNG_MODE_SHIFT)
+#define RNG_SRC_SHIFT	2
+#define RNG_SRC_NONE	0
+#define RNG_SRC_ENTROPY	1
+#define RNG_SRC_LFSR	2
+#define SE_RNG_CONFIG_SRC(x)		(x << RNG_SRC_SHIFT)
 
 #define SE_RNG_SRC_CONFIG_REG_OFFSET	0x344
-#define DRBG_RO_ENT_SRC_SHIFT	1
+#define RNG_SRC_RO_ENT_SHIFT	1
-#define DRBG_RO_ENT_SRC_ENABLE	1
+#define RNG_SRC_RO_ENT_ENABLE	1
-#define DRBG_RO_ENT_SRC_DISABLE	0
+#define RNG_SRC_RO_ENT_DISABLE	0
-#define SE_RNG_SRC_CONFIG_RO_ENT_SRC(x)	(x << DRBG_RO_ENT_SRC_SHIFT)
+#define SE_RNG_SRC_CONFIG_ENT_SRC(x)	(x << RNG_SRC_RO_ENT_SHIFT)
-#define DRBG_RO_ENT_SRC_LOCK_SHIFT	0
+#define RNG_SRC_RO_ENT_LOCK_SHIFT	 0
-#define DRBG_RO_ENT_SRC_LOCK_ENABLE	1
+#define RNG_SRC_RO_ENT_LOCK_ENABLE	 1
-#define DRBG_RO_ENT_SRC_LOCK_DISABLE	0
+#define RNG_SRC_RO_ENT_LOCK_DISABLE 0
-#define SE_RNG_SRC_CONFIG_RO_ENT_SRC_LOCK(x) (x << DRBG_RO_ENT_SRC_LOCK_SHIFT)
+#define SE_RNG_SRC_CONFIG_ENT_SRC_LOCK(x) (x << RNG_SRC_RO_ENT_LOCK_SHIFT)
-
-#define DRBG_SRC_SHIFT	2
-#define DRBG_SRC_NONE	0
-#define DRBG_SRC_ENTROPY	1
-#define DRBG_SRC_LFSR	2
-#define SE_RNG_CONFIG_SRC(x)		(x << DRBG_SRC_SHIFT)
 
 #define SE_RNG_RESEED_INTERVAL_REG_OFFSET		0x348
 
@@ -119,6 +118,8 @@
 #define OP_DONE	1
 #define SE_OP_DONE(x, y)	((x) && (y << SE_OP_DONE_SHIFT))
 
+#define SE_CRYPTO_LAST_BLOCK	0x080
+
 #define SE_CRYPTO_REG_OFFSET		0x304
 #define SE_CRYPTO_HASH_SHIFT		0
 #define HASH_DISABLE	0
@@ -191,6 +192,7 @@
 #define SRK		6
 
 #define RSA_KEYTABLE	1
+#define AES_KEYTABLE	2
 #define SE_CONTEXT_SAVE_SRC(x)		(x << SE_CONTEXT_SAVE_SRC_SHIFT)
 
 #define SE_CONTEXT_SAVE_RSA_KEY_INDEX_SHIFT	16

source/sec/tsec.c

@@ -18,6 +18,7 @@
 
 #include <string.h>
 
+#include "../hos/hos.h"
 #include "../sec/tsec.h"
 #include "../sec/tsec_t210.h"
 #include "../sec/se_t210.h"

source/soc/bpmp.c

@@ -1,7 +1,7 @@
 /*
  * BPMP-Lite Cache/MMU and Frequency driver for Tegra X1
  *
- * Copyright (c) 2019 CTCaer
+ * Copyright (c) 2019-2020 CTCaer
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -22,56 +22,101 @@
 #include "../../common/memory_map.h"
 #include "../utils/util.h"
 
+#define BPMP_MMU_CACHE_LINE_SIZE        0x20
+
 #define BPMP_CACHE_CONFIG               0x0
-#define  CFG_ENABLE                     (1 << 0)
+#define  CFG_ENABLE_CACHE               (1 << 0)
+#define  CFG_ENABLE_SKEW_ASSOC          (1 << 1)
+#define  CFG_DISABLE_RANDOM_ALLOC       (1 << 2)
 #define  CFG_FORCE_WRITE_THROUGH        (1 << 3)
+#define  CFG_NEVER_ALLOCATE             (1 << 6)
+#define  CFG_ENABLE_INTERRUPT           (1 << 7)
+#define  CFG_MMU_TAG_MODE(x)            (x << 8)
+#define   TAG_MODE_PARALLEL             0
+#define   TAG_MODE_TAG_FIRST            1
+#define   TAG_MODE_MMU_FIRST            2
 #define  CFG_DISABLE_WRITE_BUFFER       (1 << 10)
 #define  CFG_DISABLE_READ_BUFFER        (1 << 11)
+#define  CFG_ENABLE_HANG_DETECT         (1 << 12)
 #define  CFG_FULL_LINE_DIRTY            (1 << 13)
 #define  CFG_TAG_CHK_ABRT_ON_ERR        (1 << 14)
+#define  CFG_TAG_CHK_CLR_ERR            (1 << 15)
+#define  CFG_DISABLE_SAMELINE           (1 << 16)
+#define  CFG_OBS_BUS_EN                 (1 << 31)
+
 #define BPMP_CACHE_LOCK                 0x4
+#define  LOCK_LINE(x)                   (1 << x)
+
 #define BPMP_CACHE_SIZE                 0xC
 #define BPMP_CACHE_LFSR                 0x10
+
 #define BPMP_CACHE_TAG_STATUS           0x14
+#define  TAG_STATUS_TAG_CHECK_ERROR     (1 << 0)
+#define  TAG_STATUS_CONFLICT_ADDR_MASK  0xFFFFFFE0
+
 #define BPMP_CACHE_CLKEN_OVERRIDE       0x18
+#define  CLKEN_OVERRIDE_WR_MCCIF_CLKEN  (1 << 0)
+#define  CLKEN_OVERRIDE_RD_MCCIF_CLKEN  (1 << 1)
+
 #define BPMP_CACHE_MAINT_ADDR           0x20
 #define BPMP_CACHE_MAINT_DATA           0x24
+
 #define BPMP_CACHE_MAINT_REQ            0x28
 #define  MAINT_REQ_WAY_BITMAP(x)        ((x) << 8)
 
 #define BPMP_CACHE_INT_MASK             0x40
 #define BPMP_CACHE_INT_CLEAR            0x44
-#define  INT_CLR_MAINT_DONE             (1 << 0)
-
 #define BPMP_CACHE_INT_RAW_EVENT        0x48
-#define  INT_RAW_EVENT_MAINT_DONE      (1 << 0)
 #define BPMP_CACHE_INT_STATUS           0x4C
+#define  INT_MAINT_DONE                 (1 << 0)
+#define  INT_MAINT_ERROR                (1 << 1)
 
 #define BPMP_CACHE_RB_CFG               0x80
 #define BPMP_CACHE_WB_CFG               0x84
 
 #define BPMP_CACHE_MMU_FALLBACK_ENTRY   0xA0
 #define BPMP_CACHE_MMU_SHADOW_COPY_MASK 0xA4
+
 #define BPMP_CACHE_MMU_CFG              0xAC
+#define  MMU_CFG_BLOCK_MAIN_ENTRY_WR    (1 << 0)
 #define  MMU_CFG_SEQ_EN                 (1 << 1)
 #define  MMU_CFG_TLB_EN                 (1 << 2)
+#define  MMU_CFG_SEG_CHECK_ALL_ENTRIES  (1 << 3)
 #define  MMU_CFG_ABORT_STORE_LAST       (1 << 4)
+#define  MMU_CFG_CLR_ABORT              (1 << 5)
+
 #define BPMP_CACHE_MMU_CMD              0xB0
 #define  MMU_CMD_NOP                    0
 #define  MMU_CMD_INIT                   1
 #define  MMU_CMD_COPY_SHADOW            2
+
 #define BPMP_CACHE_MMU_ABORT_STAT       0xB4
+#define  ABORT_STAT_UNIT_MASK           0x7
+#define  ABORT_STAT_UNIT_NONE           0
+#define  ABORT_STAT_UNIT_CACHE          1
+#define  ABORT_STAT_UNIT_SEQ            2
+#define  ABORT_STAT_UNIT_TLB            3
+#define  ABORT_STAT_UNIT_SEG            4
+#define  ABORT_STAT_UNIT_FALLBACK       5
+#define  ABORT_STAT_OVERLAP             (1 << 3)
+#define  ABORT_STAT_ENTRY               (0x1F << 4)
+#define  ABORT_STAT_TYPE_MASK           (3 << 16)
+#define  ABORT_STAT_TYPE_EXE            (0 << 16)
+#define  ABORT_STAT_TYPE_RD             (1 << 16)
+#define  ABORT_STAT_TYPE_WR             (2 << 16)
+#define  ABORT_STAT_SIZE                (3 << 18)
+#define  ABORT_STAT_SEQ                 (1 << 20)
+#define  ABORT_STAT_PROT                (1 << 21)
+
 #define BPMP_CACHE_MMU_ABORT_ADDR       0xB8
 #define BPMP_CACHE_MMU_ACTIVE_ENTRIES   0xBC
 
-#define BPMP_MMU_SHADOW_ENTRY_BASE     (BPMP_CACHE_BASE + 0x400)
+#define BPMP_MMU_SHADOW_ENTRY_BASE      (BPMP_CACHE_BASE + 0x400)
-#define BPMP_MMU_MAIN_ENTRY_BASE       (BPMP_CACHE_BASE + 0x800)
+#define BPMP_MMU_MAIN_ENTRY_BASE        (BPMP_CACHE_BASE + 0x800)
-#define  MMU_ENTRY_ADDR_MASK           0xFFFFFFE0
+#define  MMU_EN_CACHED                  (1 << 0)
-
+#define  MMU_EN_EXEC                    (1 << 1)
-#define  MMU_EN_CACHED                (1 << 0)
+#define  MMU_EN_READ                    (1 << 2)
-#define  MMU_EN_EXEC                  (1 << 1)
+#define  MMU_EN_WRITE                   (1 << 3)
-#define  MMU_EN_READ                  (1 << 2)
-#define  MMU_EN_WRITE                 (1 << 3)
 
 bpmp_mmu_entry_t mmu_entries[] =
 {
@@ -81,15 +126,15 @@ bpmp_mmu_entry_t mmu_entries[] =
 
 void bpmp_mmu_maintenance(u32 op, bool force)
 {
-	if (!force && !(BPMP_CACHE_CTRL(BPMP_CACHE_CONFIG) & CFG_ENABLE))
+	if (!force && !(BPMP_CACHE_CTRL(BPMP_CACHE_CONFIG) & CFG_ENABLE_CACHE))
 		return;
 
-	BPMP_CACHE_CTRL(BPMP_CACHE_INT_CLEAR) = INT_CLR_MAINT_DONE;
+	BPMP_CACHE_CTRL(BPMP_CACHE_INT_CLEAR) = INT_MAINT_DONE;
 
 	// This is a blocking operation.
 	BPMP_CACHE_CTRL(BPMP_CACHE_MAINT_REQ) = MAINT_REQ_WAY_BITMAP(0xF) | op;
 
-	while(!(BPMP_CACHE_CTRL(BPMP_CACHE_INT_RAW_EVENT) & INT_RAW_EVENT_MAINT_DONE))
+	while(!(BPMP_CACHE_CTRL(BPMP_CACHE_INT_RAW_EVENT) & INT_MAINT_DONE))
 		;
 
 	BPMP_CACHE_CTRL(BPMP_CACHE_INT_CLEAR) = BPMP_CACHE_CTRL(BPMP_CACHE_INT_RAW_EVENT);
@@ -104,8 +149,8 @@ void bpmp_mmu_set_entry(int idx, bpmp_mmu_entry_t *entry, bool apply)
 
 	if (entry->enable)
 	{
-		mmu_entry->min_addr = entry->min_addr & MMU_ENTRY_ADDR_MASK;
+		mmu_entry->start_addr = ALIGN(entry->start_addr, BPMP_MMU_CACHE_LINE_SIZE);
-		mmu_entry->max_addr = entry->max_addr & MMU_ENTRY_ADDR_MASK;
+		mmu_entry->end_addr = ALIGN_DOWN(entry->end_addr, BPMP_MMU_CACHE_LINE_SIZE);
 		mmu_entry->attr = entry->attr;
 
 		BPMP_CACHE_CTRL(BPMP_CACHE_MMU_SHADOW_COPY_MASK) |= (1 << idx);
@@ -117,7 +162,7 @@ void bpmp_mmu_set_entry(int idx, bpmp_mmu_entry_t *entry, bool apply)
 
 void bpmp_mmu_enable()
 {
-	if (BPMP_CACHE_CTRL(BPMP_CACHE_CONFIG) & CFG_ENABLE)
+	if (BPMP_CACHE_CTRL(BPMP_CACHE_CONFIG) & CFG_ENABLE_CACHE)
 		return;
 
 	// Init BPMP MMU.
@@ -136,7 +181,8 @@ void bpmp_mmu_enable()
 	bpmp_mmu_maintenance(BPMP_MMU_MAINT_INVALID_WAY, true);
 
 	// Enable cache.
-	BPMP_CACHE_CTRL(BPMP_CACHE_CONFIG) = CFG_ENABLE | CFG_FORCE_WRITE_THROUGH | CFG_TAG_CHK_ABRT_ON_ERR;
+	BPMP_CACHE_CTRL(BPMP_CACHE_CONFIG) = CFG_ENABLE_CACHE | CFG_FORCE_WRITE_THROUGH |
+		CFG_MMU_TAG_MODE(TAG_MODE_PARALLEL) | CFG_TAG_CHK_ABRT_ON_ERR;
 
 	// HW bug. Invalidate cache again.
 	bpmp_mmu_maintenance(BPMP_MMU_MAINT_INVALID_WAY, false);
@@ -144,7 +190,7 @@ void bpmp_mmu_enable()
 
 void bpmp_mmu_disable()
 {
-	if (!(BPMP_CACHE_CTRL(BPMP_CACHE_CONFIG) & CFG_ENABLE))
+	if (!(BPMP_CACHE_CTRL(BPMP_CACHE_CONFIG) & CFG_ENABLE_CACHE))
 		return;
 
 	// Clean and invalidate cache.
@@ -154,7 +200,10 @@ void bpmp_mmu_disable()
 	BPMP_CACHE_CTRL(BPMP_CACHE_CONFIG) = 0;
 }
 
-const u8 pllc4_divn[] = {
+// APB clock affects RTC, PWM, MEMFETCH, APE, USB, SOR PWM,
+// I2C host, DC/DSI/DISP. UART gives extra stress.
+// 92: 100% success ratio. 93-94: 595-602MHz has 99% success ratio. 95: 608MHz less.
+const u8 pll_divn[] = {
 	0,   // BPMP_CLK_NORMAL:      408MHz  0% - 136MHz APB.
 	85,  // BPMP_CLK_HIGH_BOOST:  544MHz 33% - 136MHz APB.
 	90,  // BPMP_CLK_SUPER_BOOST: 576MHz 41% - 144MHz APB.
@@ -165,6 +214,28 @@ const u8 pllc4_divn[] = {
 
 bpmp_freq_t bpmp_clock_set = BPMP_CLK_NORMAL;
 
+void bpmp_clk_rate_get()
+{
+	bool clk_src_is_pllp = ((CLOCK(CLK_RST_CONTROLLER_SCLK_BURST_POLICY) >> 4) & 7) == 3;
+
+	if (clk_src_is_pllp)
+		bpmp_clock_set = BPMP_CLK_NORMAL;
+	else
+	{
+		bpmp_clock_set = BPMP_CLK_HIGH_BOOST;
+
+		u8 pll_divn_curr = (CLOCK(CLK_RST_CONTROLLER_PLLC_BASE) >> 10) & 0xFF;
+		for (u32 i = 1; i < sizeof(pll_divn); i++)
+		{
+			if (pll_divn[i] == pll_divn_curr)
+			{
+				bpmp_clock_set = i;
+				break;
+			}
+		}
+	}
+}
+
 void bpmp_clk_rate_set(bpmp_freq_t fid)
 {
 	if (fid > (BPMP_CLK_MAX - 1))
@@ -179,37 +250,26 @@ void bpmp_clk_rate_set(bpmp_freq_t fid)
 		{
 			// Restore to PLLP source during PLLC4 configuration.
 			CLOCK(CLK_RST_CONTROLLER_SCLK_BURST_POLICY) = 0x20003333; // PLLP_OUT.
-			// Wait a bit for clock source change.
+			msleep(1); // Wait a bit for clock source change.
-			msleep(10);
 		}
 
-		CLOCK(CLK_RST_CONTROLLER_PLLC4_MISC) = PLLC4_MISC_EN_LCKDET;
+		// Configure and enable PLLC.
-		CLOCK(CLK_RST_CONTROLLER_PLLC4_BASE) = 4 | (pllc4_divn[fid] << 8) | PLL_BASE_ENABLE; // DIVM: 4, DIVP: 1.
+		clock_enable_pllc(pll_divn[fid]);
 
-		while (!(CLOCK(CLK_RST_CONTROLLER_PLLC4_BASE) & PLLC4_BASE_LOCK))
+		// Set SCLK / HCLK / PCLK.
-			;
+		CLOCK(CLK_RST_CONTROLLER_CLK_SYSTEM_RATE) = 3; // PCLK = HCLK / (3 + 1). HCLK == SCLK.
-
+		CLOCK(CLK_RST_CONTROLLER_SCLK_BURST_POLICY) = 0x20003310; // PLLC_OUT1 for active and CLKM for idle.
-		CLOCK(CLK_RST_CONTROLLER_PLLC4_OUT) = (1 << 8) | PLLC4_OUT3_CLKEN; // 1.5 div.
-		CLOCK(CLK_RST_CONTROLLER_PLLC4_OUT) |= PLLC4_OUT3_RSTN_CLR; // Get divider out of reset.
-
-		// Wait a bit for PLLC4 to stabilize.
-		msleep(10);
-		CLOCK(CLK_RST_CONTROLLER_CLK_SYSTEM_RATE) = 3; // PCLK = HCLK / 4.
-		CLOCK(CLK_RST_CONTROLLER_SCLK_BURST_POLICY) = 0x20003323; // PLLC4_OUT3.
-
-		bpmp_clock_set = fid;
 	}
 	else
 	{
-		CLOCK(CLK_RST_CONTROLLER_SCLK_BURST_POLICY) = 0x20003333; // PLLP_OUT.
+		CLOCK(CLK_RST_CONTROLLER_SCLK_BURST_POLICY) = 0x20003330; // PLLP_OUT for active and CLKM for idle.
+		msleep(1); // Wait a bit for clock source change.
+		CLOCK(CLK_RST_CONTROLLER_CLK_SYSTEM_RATE) = 2; // PCLK = HCLK / (2 + 1). HCLK == SCLK.
 
-		// Wait a bit for clock source change.
+		// Disable PLLC to save power.
-		msleep(10);
+		clock_disable_pllc();
-
-		CLOCK(CLK_RST_CONTROLLER_CLK_SYSTEM_RATE) = 2; // PCLK = HCLK / 3.
-		CLOCK(CLK_RST_CONTROLLER_PLLC4_BASE) &= ~PLL_BASE_ENABLE;
-		bpmp_clock_set = BPMP_CLK_NORMAL;
 	}
+	bpmp_clock_set = fid;
 }
 
 // The following functions halt BPMP to reduce power while sleeping.

source/soc/bpmp.h

@@ -1,7 +1,7 @@
 /*
  * BPMP-Lite Cache/MMU and Frequency driver for Tegra X1
  *
- * Copyright (c) 2019 CTCaer
+ * Copyright (c) 2019-2020 CTCaer
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -21,14 +21,24 @@
 
 #include "../utils/types.h"
 
-#define BPMP_MMU_MAINT_CLEAN_WAY   17
+typedef enum
-#define BPMP_MMU_MAINT_INVALID_WAY 18
+{
-#define BPMP_MMU_MAINT_CLN_INV_WAY 19
+	BPMP_MMU_MAINT_NOP                =  0,
+	BPMP_MMU_MAINT_CLEAN_PHY          =  1,
+	BPMP_MMU_MAINT_INVALID_PHY        =  2,
+	BPMP_MMU_MAINT_CLEAN_INVALID_PHY  =  3,
+	BPMP_MMU_MAINT_CLEAN_LINE         =  9,
+	BPMP_MMU_MAINT_INVALID_LINE       = 10,
+	BPMP_MMU_MAINT_CLEAN_INVALID_LINE = 11,
+	BPMP_MMU_MAINT_CLEAN_WAY          = 17,
+	BPMP_MMU_MAINT_INVALID_WAY        = 18,
+	BPMP_MMU_MAINT_CLN_INV_WAY        = 19
+} bpmp_maintenance_t;
 
 typedef struct _bpmp_mmu_entry_t
 {
-	u32 min_addr;
+	u32 start_addr;
-	u32 max_addr;
+	u32 end_addr;
 	u32 attr;
 	u32 enable;
 } bpmp_mmu_entry_t;
@@ -49,6 +59,7 @@ void bpmp_mmu_maintenance(u32 op, bool force);
 void bpmp_mmu_set_entry(int idx, bpmp_mmu_entry_t *entry, bool apply);
 void bpmp_mmu_enable();
 void bpmp_mmu_disable();
+void bpmp_clk_rate_get();
 void bpmp_clk_rate_set(bpmp_freq_t fid);
 void bpmp_usleep(u32 us);
 void bpmp_msleep(u32 ms);

source/soc/clock.c

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2018 naehrwert
+ * Copyright (c) 2018-2020 CTCaer
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -19,6 +20,17 @@
 #include "../utils/util.h"
 #include "../storage/sdmmc.h"
 
+/*
+ * CLOCK Peripherals:
+ * L   0 -  31
+ * H  32 -  63
+ * U  64 -  95
+ * V  96 - 127
+ * W 128 - 159
+ * X 160 - 191
+ * Y 192 - 223
+ */
+
 /* clock_t: reset, enable, source, index, clk_src, clk_div */
 
 static const clock_t _clock_uart[] = {
@@ -29,7 +41,7 @@ static const clock_t _clock_uart[] = {
 /* UART E */ { CLK_RST_CONTROLLER_RST_DEVICES_Y, CLK_RST_CONTROLLER_CLK_OUT_ENB_Y, CLK_RST_CONTROLLER_CLK_SOURCE_UARTAPE, 20, 0, 2 }
 };
 
-//I2C default parameters - TLOW: 4, THIGH: 2, DEBOUNCE: 0 FM_DIV: 26.
+//I2C default parameters - TLOW: 4, THIGH: 2, DEBOUNCE: 0, FM_DIV: 26.
 static const clock_t _clock_i2c[] = {
 /* I2C1 */ { CLK_RST_CONTROLLER_RST_DEVICES_L, CLK_RST_CONTROLLER_CLK_OUT_ENB_L, CLK_RST_CONTROLLER_CLK_SOURCE_I2C1, 12, 0, 19 }, //20.4MHz -> 100KHz
 /* I2C2 */ { CLK_RST_CONTROLLER_RST_DEVICES_H, CLK_RST_CONTROLLER_CLK_OUT_ENB_H, CLK_RST_CONTROLLER_CLK_SOURCE_I2C2, 22, 0, 4  }, //81.6MHz -> 400KHz
@@ -77,6 +89,10 @@ static clock_t _clock_pwm = {
 	CLK_RST_CONTROLLER_RST_DEVICES_L, CLK_RST_CONTROLLER_CLK_OUT_ENB_L, CLK_RST_CONTROLLER_CLK_SOURCE_PWM,    17, 6, 4 // Fref: 6.2MHz.
 };
 
+static clock_t _clock_sdmmc_legacy_tm = {
+	CLK_RST_CONTROLLER_RST_DEVICES_Y, CLK_RST_CONTROLLER_CLK_OUT_ENB_Y, CLK_RST_CONTROLLER_CLK_SOURCE_SDMMC_LEGACY_TM, 1, 4, 66
+};
+
 void clock_enable(const clock_t *clk)
 {
 	// Put clock into reset.
@@ -112,6 +128,29 @@ void clock_enable_uart(u32 idx)
 	clock_enable(&_clock_uart[idx]);
 }
 
+void clock_disable_uart(u32 idx)
+{
+	clock_disable(&_clock_uart[idx]);
+}
+
+#define UART_SRC_CLK_DIV_EN (1 << 24)
+
+int clock_uart_use_src_div(u32 idx, u32 baud)
+{
+	u32 clk_src_div = CLOCK(_clock_uart[idx].source) & 0xE0000000;
+
+	if (baud == 1000000)
+		CLOCK(_clock_uart[idx].source) = clk_src_div | UART_SRC_CLK_DIV_EN | 49;
+	else
+	{
+		CLOCK(_clock_uart[idx].source) = clk_src_div | 2;
+
+		return 1;
+	}
+
+	return 0;
+}
+
 void clock_enable_i2c(u32 idx)
 {
 	clock_enable(&_clock_i2c[idx]);
@@ -228,6 +267,51 @@ void clock_disable_pwm()
 	clock_disable(&_clock_pwm);
 }
 
+void clock_enable_pllc(u32 divn)
+{
+	u8 pll_divn_curr = (CLOCK(CLK_RST_CONTROLLER_PLLC_BASE) >> 10) & 0xFF;
+
+	// Check if already enabled and configured.
+	if ((CLOCK(CLK_RST_CONTROLLER_PLLC_BASE) & PLLCX_BASE_ENABLE) && (pll_divn_curr == divn))
+		return;
+
+	// Take PLLC out of reset and set basic misc parameters.
+	CLOCK(CLK_RST_CONTROLLER_PLLC_MISC) = 
+		((CLOCK(CLK_RST_CONTROLLER_PLLC_MISC) & 0xFFF0000F) & ~PLLC_MISC_RESET) | (0x80000 << 4); // PLLC_EXT_FRU.
+	CLOCK(CLK_RST_CONTROLLER_PLLC_MISC_2) |= 0xF0 << 8; // PLLC_FLL_LD_MEM.
+
+	// Disable PLL and IDDQ in case they are on.
+	CLOCK(CLK_RST_CONTROLLER_PLLC_BASE) &= ~PLLCX_BASE_ENABLE;
+	CLOCK(CLK_RST_CONTROLLER_PLLC_MISC_1) &= ~PLLC_MISC1_IDDQ;
+	usleep(10);
+
+	// Set PLLC dividers.
+	CLOCK(CLK_RST_CONTROLLER_PLLC_BASE) = (divn << 10) | 4; // DIVM: 4, DIVP: 1.
+
+	// Enable PLLC and wait for Phase and Frequency lock.
+	CLOCK(CLK_RST_CONTROLLER_PLLC_BASE) |= PLLCX_BASE_ENABLE;
+	while (!(CLOCK(CLK_RST_CONTROLLER_PLLC_BASE) & PLLCX_BASE_LOCK))
+		;
+
+	// Disable PLLC_OUT1, enable reset and set div to 1.5.
+	CLOCK(CLK_RST_CONTROLLER_PLLC_OUT) = (1 << 8);
+
+	// Enable PLLC_OUT1 and bring it out of reset.
+	CLOCK(CLK_RST_CONTROLLER_PLLC_OUT) |= (PLLC_OUT1_CLKEN | PLLC_OUT1_RSTN_CLR);
+	msleep(1); // Wait a bit for PLL to stabilize.
+}
+
+void clock_disable_pllc()
+{
+	// Disable PLLC and PLLC_OUT1.
+	CLOCK(CLK_RST_CONTROLLER_PLLC_OUT) &= ~(PLLC_OUT1_CLKEN | PLLC_OUT1_RSTN_CLR);
+	CLOCK(CLK_RST_CONTROLLER_PLLC_BASE) &= ~PLLCX_BASE_ENABLE;
+	CLOCK(CLK_RST_CONTROLLER_PLLC_BASE) |= PLLCX_BASE_REF_DIS;
+	CLOCK(CLK_RST_CONTROLLER_PLLC_MISC_1) |= PLLC_MISC1_IDDQ;
+	CLOCK(CLK_RST_CONTROLLER_PLLC_MISC) |= PLLC_MISC_RESET;
+	usleep(10);
+}
+
 #define L_SWR_SDMMC1_RST (1 << 14)
 #define L_SWR_SDMMC2_RST (1 << 9)
 #define L_SWR_SDMMC4_RST (1 << 15)
@@ -366,56 +450,78 @@ static void _clock_sdmmc_clear_enable(u32 id)
 	}
 }
 
-static u32 _clock_sdmmc_table[8] = { 0 };
+static void _clock_sdmmc_config_legacy_tm()
+{
+	clock_t *clk = &_clock_sdmmc_legacy_tm;
+	if (!(CLOCK(clk->enable) & (1 << clk->index)))
+		clock_enable(clk);
+}
 
-#define PLLP_OUT0      0x0
+typedef struct _clock_sdmmc_t
-static int _clock_sdmmc_config_clock_host(u32 *pout, u32 id, u32 val)
+{
+	u32 clock;
+	u32 real_clock;
+} clock_sdmmc_t;
+
+static clock_sdmmc_t _clock_sdmmc_table[4] = { 0 };
+
+#define SDMMC_CLOCK_SRC_PLLP_OUT0      0x0
+#define SDMMC_CLOCK_SRC_PLLC4_OUT2     0x3
+#define SDMMC4_CLOCK_SRC_PLLC4_OUT2_LJ 0x1
+
+static int _clock_sdmmc_config_clock_host(u32 *pclock, u32 id, u32 val)
 {
 	u32 divisor = 0;
-	u32 source = PLLP_OUT0;
+	u32 source = SDMMC_CLOCK_SRC_PLLP_OUT0;
+
+	if (id > SDMMC_4)
+		return 0;
 
 	// Get IO clock divisor.
 	switch (val)
 	{
 	case 25000:
-		*pout = 24728;
+		*pclock = 24728;
 		divisor = 31; // 16.5 div.
 		break;
 	case 26000:
-		*pout = 25500;
+		*pclock = 25500;
 		divisor = 30; // 16 div.
 		break;
 	case 40800:
-		*pout = 40800;
+		*pclock = 40800;
 		divisor = 18; // 10 div.
 		break;
 	case 50000:
-		*pout = 48000;
+		*pclock = 48000;
 		divisor = 15; // 8.5 div.
 		break;
 	case 52000:
-		*pout = 51000;
+		*pclock = 51000;
 		divisor = 14; // 8 div.
 		break;
 	case 100000:
-		*pout = 90667;
+		*pclock = 90667;
 		divisor = 7;  // 4.5 div.
 		break;
-	case 200000:
+	case 164000:
-		*pout = 163200;
+		*pclock = 163200;
 		divisor = 3;  // 2.5 div.
 		break;
-	case 208000:
+	case 200000:
-		*pout = 204000;
+		*pclock = 204000;
 		divisor = 2;  // 2 div.
 		break;
 	default:
-		*pout = 24728;
+		*pclock = 24728;
 		divisor = 31; // 16.5 div.
 	}
 
-	_clock_sdmmc_table[2 * id] = val;
+	_clock_sdmmc_table[id].clock = val;
-	_clock_sdmmc_table[2 * id + 1] = *pout;
+	_clock_sdmmc_table[id].real_clock = *pclock;
+
+	// Set SDMMC legacy timeout clock.
+	_clock_sdmmc_config_legacy_tm();
 
 	// Set SDMMC clock.
 	switch (id)
@@ -437,70 +543,75 @@ static int _clock_sdmmc_config_clock_host(u32 *pout, u32 id, u32 val)
 	return 1;
 }
 
-void clock_sdmmc_config_clock_source(u32 *pout, u32 id, u32 val)
+void clock_sdmmc_config_clock_source(u32 *pclock, u32 id, u32 val)
 {
-	if (_clock_sdmmc_table[2 * id] == val)
+	if (_clock_sdmmc_table[id].clock == val)
 	{
-		*pout = _clock_sdmmc_table[2 * id + 1];
+		*pclock = _clock_sdmmc_table[id].real_clock;
 	}
 	else
 	{
 		int is_enabled = _clock_sdmmc_is_enabled(id);
 		if (is_enabled)
 			_clock_sdmmc_clear_enable(id);
-		_clock_sdmmc_config_clock_host(pout, id, val);
+		_clock_sdmmc_config_clock_host(pclock, id, val);
 		if (is_enabled)
 			_clock_sdmmc_set_enable(id);
 		_clock_sdmmc_is_reset(id);
 	}
 }
 
-void clock_sdmmc_get_card_clock_div(u32 *pout, u16 *pdivisor, u32 type)
+void clock_sdmmc_get_card_clock_div(u32 *pclock, u16 *pdivisor, u32 type)
 {
 	// Get Card clock divisor.
 	switch (type)
 	{
-	case 0:
+	case SDHCI_TIMING_MMC_ID: // Actual IO Freq: 380.59 KHz.
-		*pout = 26000;
+		*pclock = 26000;
 		*pdivisor = 66;
 		break;
-	case 1:
+	case SDHCI_TIMING_MMC_LS26:
-		*pout = 26000;
+		*pclock = 26000;
 		*pdivisor = 1;
 		break;
-	case 2:
+	case SDHCI_TIMING_MMC_HS52:
-		*pout = 52000;
+		*pclock = 52000;
 		*pdivisor = 1;
 		break;
-	case 3:
+	case SDHCI_TIMING_MMC_HS200:
-	case 4:
+	case SDHCI_TIMING_MMC_HS400:
-	case 11:
+	case SDHCI_TIMING_UHS_SDR104:
-		*pout = 200000;
+		*pclock = 200000;
 		*pdivisor = 1;
 		break;
-	case 5:
+	case SDHCI_TIMING_SD_ID: // Actual IO Freq: 380.43 KHz.
-		*pout = 25000;
+		*pclock = 25000;
 		*pdivisor = 64;
 		break;
-	case 6:
+	case SDHCI_TIMING_SD_DS12:
-	case 8:
+	case SDHCI_TIMING_UHS_SDR12:
-		*pout = 25000;
+		*pclock = 25000;
 		*pdivisor = 1;
 		break;
-	case 7:
+	case SDHCI_TIMING_SD_HS25:
-		*pout = 50000;
+	case SDHCI_TIMING_UHS_SDR25:
+		*pclock = 50000;
 		*pdivisor = 1;
 		break;
-	case 10:
+	case SDHCI_TIMING_UHS_SDR50:
-		*pout = 100000;
+		*pclock = 100000;
 		*pdivisor = 1;
 		break;
-	case 13:
+	case SDHCI_TIMING_UHS_SDR82:
-		*pout = 40800;
+		*pclock = 164000;
 		*pdivisor = 1;
 		break;
-	case 14:
+	case SDHCI_TIMING_UHS_DDR50:
-		*pout = 200000;
+		*pclock = 40800;
+		*pdivisor = 1;
+		break;
+	case SDHCI_TIMING_MMC_DDR52: // Actual IO Freq: 49.92 MHz.
+		*pclock = 200000;
 		*pdivisor = 2;
 		break;
 	}
@@ -513,15 +624,15 @@ int clock_sdmmc_is_not_reset_and_enabled(u32 id)
 
 void clock_sdmmc_enable(u32 id, u32 val)
 {
-	u32 div = 0;
+	u32 clock = 0;
 
 	if (_clock_sdmmc_is_enabled(id))
 		_clock_sdmmc_clear_enable(id);
 	_clock_sdmmc_set_reset(id);
-	_clock_sdmmc_config_clock_host(&div, id, val);
+	_clock_sdmmc_config_clock_host(&clock, id, val);
 	_clock_sdmmc_set_enable(id);
 	_clock_sdmmc_is_reset(id);
-	usleep((100000 + div - 1) / div);
+	usleep((100000 + clock - 1) / clock);
 	_clock_sdmmc_clear_reset(id);
 	_clock_sdmmc_is_reset(id);
 }

source/soc/clock.h

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2018 naehrwert
+ * Copyright (c) 2018-2020 CTCaer
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -35,11 +36,19 @@
 #define CLK_RST_CONTROLLER_MISC_CLK_ENB 0x48
 #define CLK_RST_CONTROLLER_OSC_CTRL 0x50
 #define CLK_RST_CONTROLLER_PLLC_BASE 0x80
+#define CLK_RST_CONTROLLER_PLLC_OUT 0x84
 #define CLK_RST_CONTROLLER_PLLC_MISC 0x88
+#define CLK_RST_CONTROLLER_PLLC_MISC_1 0x8C
 #define CLK_RST_CONTROLLER_PLLM_BASE 0x90
 #define CLK_RST_CONTROLLER_PLLM_MISC1 0x98
 #define CLK_RST_CONTROLLER_PLLM_MISC2 0x9C
 #define CLK_RST_CONTROLLER_PLLP_BASE 0xA0
+#define CLK_RST_CONTROLLER_PLLA_BASE 0xB0
+#define CLK_RST_CONTROLLER_PLLA_OUT 0xB4
+#define CLK_RST_CONTROLLER_PLLA_MISC1 0xB8
+#define CLK_RST_CONTROLLER_PLLA_MISC 0xBC
+#define CLK_RST_CONTROLLER_PLLU_BASE 0xC0
+#define CLK_RST_CONTROLLER_PLLU_MISC 0xCC
 #define CLK_RST_CONTROLLER_PLLD_BASE 0xD0
 #define CLK_RST_CONTROLLER_PLLD_MISC1 0xD8
 #define CLK_RST_CONTROLLER_PLLD_MISC 0xDC
@@ -49,6 +58,7 @@
 #define CLK_RST_CONTROLLER_PLLE_MISC 0xEC
 #define CLK_RST_CONTROLLER_LVL2_CLK_GATE_OVRA 0xF8
 #define CLK_RST_CONTROLLER_LVL2_CLK_GATE_OVRB 0xFC
+#define CLK_RST_CONTROLLER_CLK_SOURCE_I2S2 0x100
 #define CLK_RST_CONTROLLER_CLK_SOURCE_PWM 0x110
 #define CLK_RST_CONTROLLER_CLK_SOURCE_I2C1 0x124
 #define CLK_RST_CONTROLLER_CLK_SOURCE_I2C5 0x128
@@ -67,6 +77,7 @@
 #define CLK_RST_CONTROLLER_CLK_SOURCE_SDMMC3 0x1BC
 #define CLK_RST_CONTROLLER_CLK_SOURCE_UARTD 0x1C0
 #define CLK_RST_CONTROLLER_CLK_SOURCE_CSITE 0x1D4
+#define CLK_RST_CONTROLLER_CLK_SOURCE_I2S1 0x1D8
 #define CLK_RST_CONTROLLER_CLK_SOURCE_TSEC 0x1F4
 #define CLK_RST_CONTROLLER_CLK_OUT_ENB_X 0x280
 #define CLK_RST_CONTROLLER_CLK_ENB_X_SET 0x284
@@ -101,24 +112,32 @@
 #define CLK_RST_CONTROLLER_LVL2_CLK_GATE_OVRD 0x3A4
 #define CLK_RST_CONTROLLER_CLK_SOURCE_MSELECT 0x3B4
 #define CLK_RST_CONTROLLER_CLK_SOURCE_I2C4 0x3C4
+#define CLK_RST_CONTROLLER_CLK_SOURCE_EXTPERIPH1 0x3EC
 #define CLK_RST_CONTROLLER_CLK_SOURCE_SYS 0x400
 #define CLK_RST_CONTROLLER_CLK_SOURCE_SOR1 0x410
 #define CLK_RST_CONTROLLER_CLK_SOURCE_SE 0x42C
+#define CLK_RST_CONTROLLER_RST_DEV_V_SET 0x430
 #define CLK_RST_CONTROLLER_RST_DEV_V_CLR 0x434
+#define CLK_RST_CONTROLLER_RST_DEV_W_SET 0x438
+#define CLK_RST_CONTROLLER_RST_DEV_W_CLR 0x43C
 #define CLK_RST_CONTROLLER_CLK_ENB_V_SET 0x440
 #define CLK_RST_CONTROLLER_CLK_ENB_V_CLR 0x444
 #define CLK_RST_CONTROLLER_CLK_ENB_W_SET 0x448
 #define CLK_RST_CONTROLLER_CLK_ENB_W_CLR 0x44C
 #define CLK_RST_CONTROLLER_RST_CPUG_CMPLX_SET 0x450
 #define CLK_RST_CONTROLLER_RST_CPUG_CMPLX_CLR 0x454
+#define CLK_RST_CONTROLLER_UTMIP_PLL_CFG0 0x480
+#define CLK_RST_CONTROLLER_UTMIP_PLL_CFG1 0x484
 #define CLK_RST_CONTROLLER_UTMIP_PLL_CFG2 0x488
 #define CLK_RST_CONTROLLER_PLLE_AUX 0x48C
 #define CLK_RST_CONTROLLER_AUDIO_SYNC_CLK_I2S0 0x4A0
 #define CLK_RST_CONTROLLER_PLLX_MISC_3 0x518
+#define CLK_RST_CONTROLLER_UTMIPLL_HW_PWRDN_CFG0 0x52C
 #define CLK_RST_CONTROLLER_LVL2_CLK_GATE_OVRE 0x554
 #define CLK_RST_CONTROLLER_SPARE_REG0 0x55C
 #define CLK_RST_CONTROLLER_PLLC4_BASE 0x5A4
 #define CLK_RST_CONTROLLER_PLLC4_MISC 0x5A8
+#define CLK_RST_CONTROLLER_PLLC_MISC_2 0x5D0
 #define CLK_RST_CONTROLLER_PLLC4_OUT 0x5E4
 #define CLK_RST_CONTROLLER_PLLMB_BASE 0x5E8
 #define CLK_RST_CONTROLLER_CLK_SOURCE_DSIA_LP 0x620
@@ -127,16 +146,27 @@
 #define CLK_RST_CONTROLLER_CLK_SOURCE_UART_FST_MIPI_CAL 0x66C
 #define CLK_RST_CONTROLLER_CLK_SOURCE_SDMMC_LEGACY_TM 0x694
 #define CLK_RST_CONTROLLER_CLK_SOURCE_NVENC 0x6A0
+#define CLK_RST_CONTROLLER_CLK_SOURCE_USB2_HSIC_TRK 0x6CC
 #define CLK_RST_CONTROLLER_SE_SUPER_CLK_DIVIDER 0x704
 #define CLK_RST_CONTROLLER_CLK_SOURCE_UARTAPE 0x710
 
 #define CLK_NO_SOURCE 0x0
 
 /*! PLL control and status bits */
-#define PLL_BASE_ENABLE      (1 << 30)
+#define PLLCX_BASE_ENABLE    (1 << 30)
+#define PLLCX_BASE_REF_DIS   (1 << 29)
+#define PLLCX_BASE_LOCK      (1 << 27)
+
+#define PLLA_BASE_IDDQ       (1 << 25)
+#define PLLA_OUT0_CLKEN      (1 << 1)
+#define PLLA_OUT0_RSTN_CLR   (1 << 0)
+
+#define PLLC_MISC_RESET      (1 << 30)
+#define PLLC_MISC1_IDDQ      (1 << 27)
+#define PLLC_OUT1_CLKEN      (1 << 1)
+#define PLLC_OUT1_RSTN_CLR   (1 << 0)
 
 #define PLLC4_MISC_EN_LCKDET (1 << 30)
-#define PLLC4_BASE_LOCK      (1 << 27)
 #define PLLC4_BASE_IDDQ      (1 << 18)
 #define PLLC4_OUT3_CLKEN     (1 << 1)
 #define PLLC4_OUT3_RSTN_CLR  (1 << 0)
@@ -159,6 +189,8 @@ void clock_disable(const clock_t *clk);
 /*! Clock control for specific hardware portions. */
 void clock_enable_fuse(bool enable);
 void clock_enable_uart(u32 idx);
+void clock_disable_uart(u32 idx);
+int  clock_uart_use_src_div(u32 idx, u32 baud);
 void clock_enable_i2c(u32 idx);
 void clock_disable_i2c(u32 idx);
 void clock_enable_se();
@@ -181,9 +213,11 @@ void clock_enable_coresight();
 void clock_disable_coresight();
 void clock_enable_pwm();
 void clock_disable_pwm();
-void clock_sdmmc_config_clock_source(u32 *pout, u32 id, u32 val);
+void clock_enable_pllc(u32 divn);
-void clock_sdmmc_get_card_clock_div(u32 *pout, u16 *pdivisor, u32 type);
+void clock_disable_pllc();
-int clock_sdmmc_is_not_reset_and_enabled(u32 id);
+void clock_sdmmc_config_clock_source(u32 *pclock, u32 id, u32 val);
+void clock_sdmmc_get_card_clock_div(u32 *pclock, u16 *pdivisor, u32 type);
+int  clock_sdmmc_is_not_reset_and_enabled(u32 id);
 void clock_sdmmc_enable(u32 id, u32 val);
 void clock_sdmmc_disable(u32 id);
 

source/soc/fuse.h

@@ -54,6 +54,7 @@
 #define FUSE_PRIVATE_KEY3 0x1B0
 #define FUSE_PRIVATE_KEY4 0x1B4
 #define FUSE_RESERVED_SW 0x1C0
+#define FUSE_USB_CALIB 0x1F0
 #define FUSE_SKU_DIRECT_CONFIG 0x1F4
 #define FUSE_OPT_VENDOR_CODE 0x200
 #define FUSE_OPT_FAB_CODE 0x204
@@ -63,6 +64,7 @@
 #define FUSE_OPT_X_COORDINATE 0x214
 #define FUSE_OPT_Y_COORDINATE 0x218
 #define FUSE_GPU_IDDQ_CALIB	0x228
+#define FUSE_USB_CALIB_EXT 0x350
 
 /*! Fuse commands. */
 #define FUSE_READ 0x1

source/soc/gpio.c

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2018 naehrwert
+ * Copyright (c) 2019 CTCaer
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -14,81 +15,146 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "../soc/gpio.h"
+#include "gpio.h"
-#include "../soc/t210.h"
+#include "irq.h"
+#include "t210.h"
 
-static const u16 _gpio_cnf[31] = {
+#define GPIO_BANK_IDX(port)      (port >> 2)
-	0x000, 0x004, 0x008, 0x00C,
-	0x100, 0x104, 0x108, 0x10C,
-	0x200, 0x204, 0x208, 0x20C,
-	0x300, 0x304, 0x308, 0x30C,
-	0x400, 0x404, 0x408, 0x40C,
-	0x500, 0x504, 0x508, 0x50C,
-	0x600, 0x604, 0x608, 0x60C,
-	0x700, 0x704, 0x708
-};
 
-static const u16 _gpio_oe[31] = {
+#define GPIO_CNF_OFFSET(port)     (0x00 + ((port >> 2) << 8) + ((port % 4) << 2))
-	0x010, 0x014, 0x018, 0x01C,
+#define GPIO_OE_OFFSET(port)      (0x10 + ((port >> 2) << 8) + ((port % 4) << 2))
-	0x110, 0x114, 0x118, 0x11C,
+#define GPIO_OUT_OFFSET(port)     (0x20 + ((port >> 2) << 8) + ((port % 4) << 2))
-	0x210, 0x214, 0x218, 0x21C,
+#define GPIO_IN_OFFSET(port)      (0x30 + ((port >> 2) << 8) + ((port % 4) << 2))
-	0x310, 0x314, 0x318, 0x31C,
+#define GPIO_INT_STA_OFFSET(port) (0x40 + ((port >> 2) << 8) + ((port % 4) << 2))
-	0x410, 0x414, 0x418, 0x41C,
+#define GPIO_INT_ENB_OFFSET(port) (0x50 + ((port >> 2) << 8) + ((port % 4) << 2))
-	0x510, 0x514, 0x518, 0x51C,
+#define GPIO_INT_LVL_OFFSET(port) (0x60 + ((port >> 2) << 8) + ((port % 4) << 2))
-	0x610, 0x614, 0x618, 0x61C,
+#define GPIO_INT_CLR_OFFSET(port) (0x70 + ((port >> 2) << 8) + ((port % 4) << 2))
-	0x710, 0x714, 0x718
-};
 
-static const u16 _gpio_out[31] = {
+#define GPIO_CNF_MASKED_OFFSET(port)     (0x80 + ((port >> 2) << 8) + ((port % 4) << 2))
-	0x020, 0x024, 0x028, 0x02C,
+#define GPIO_OE_MASKED_OFFSET(port)      (0x90 + ((port >> 2) << 8) + ((port % 4) << 2))
-	0x120, 0x124, 0x128, 0x12C,
+#define GPIO_OUT_MASKED_OFFSET(port)     (0xA0 + ((port >> 2) << 8) + ((port % 4) << 2))
-	0x220, 0x224, 0x228, 0x22C,
+#define GPIO_INT_STA_MASKED_OFFSET(port) (0xC0 + ((port >> 2) << 8) + ((port % 4) << 2))
-	0x320, 0x324, 0x328, 0x32C,
+#define GPIO_INT_ENB_MASKED_OFFSET(port) (0xD0 + ((port >> 2) << 8) + ((port % 4) << 2))
-	0x420, 0x424, 0x428, 0x42C,
+#define GPIO_INT_LVL_MASKED_OFFSET(port) (0xE0 + ((port >> 2) << 8) + ((port % 4) << 2))
-	0x520, 0x524, 0x528, 0x52C,
-	0x620, 0x624, 0x628, 0x62C,
-	0x720, 0x724, 0x728
-};
 
-static const u16 _gpio_in[31] = {
+static u8 gpio_bank_irq_ids[8] = {
-	0x030, 0x034, 0x038, 0x03C,
+	IRQ_GPIO1, IRQ_GPIO2, IRQ_GPIO3, IRQ_GPIO4,
-	0x130, 0x134, 0x138, 0x13C,
+	IRQ_GPIO5, IRQ_GPIO6, IRQ_GPIO7, IRQ_GPIO8
-	0x230, 0x234, 0x238, 0x23C,
-	0x330, 0x334, 0x338, 0x33C,
-	0x430, 0x434, 0x438, 0x43C,
-	0x530, 0x534, 0x538, 0x53C,
-	0x630, 0x634, 0x638, 0x63C,
-	0x730, 0x734, 0x738
 };
 
 void gpio_config(u32 port, u32 pins, int mode)
 {
+	u32 offset = GPIO_CNF_OFFSET(port);
+
 	if (mode)
-		GPIO(_gpio_cnf[port]) |= pins;
+		GPIO(offset) |= pins;
 	else
-		GPIO(_gpio_cnf[port]) &= ~pins;
+		GPIO(offset) &= ~pins;
-	(void)GPIO(_gpio_cnf[port]);
+
+	(void)GPIO(offset); // Commit the write.
 }
 
 void gpio_output_enable(u32 port, u32 pins, int enable)
 {
+	u32 port_offset = GPIO_OE_OFFSET(port);
+
 	if (enable)
-		GPIO(_gpio_oe[port]) |= pins;
+		GPIO(port_offset) |= pins;
 	else
-		GPIO(_gpio_oe[port]) &= ~pins;
+		GPIO(port_offset) &= ~pins;
-	(void)GPIO(_gpio_oe[port]);
+
+	(void)GPIO(port_offset); // Commit the write.
 }
 
 void gpio_write(u32 port, u32 pins, int high)
 {
+	u32 port_offset = GPIO_OUT_OFFSET(port);
+
 	if (high)
-		GPIO(_gpio_out[port]) |= pins;
+		GPIO(port_offset) |= pins;
 	else
-		GPIO(_gpio_out[port]) &= ~pins;
+		GPIO(port_offset) &= ~pins;
-	(void)GPIO(_gpio_out[port]);
+
+	(void)GPIO(port_offset); // Commit the write.
 }
 
 int gpio_read(u32 port, u32 pins)
 {
-	return (GPIO(_gpio_in[port]) & pins) ? 1 : 0;
+	u32 port_offset = GPIO_IN_OFFSET(port);
+
+	return (GPIO(port_offset) & pins) ? 1 : 0;
+}
+
+static void _gpio_interrupt_clear(u32 port, u32 pins)
+{
+	u32 port_offset = GPIO_INT_CLR_OFFSET(port);
+
+	GPIO(port_offset) |= pins;
+
+	(void)GPIO(port_offset); // Commit the write.
+}
+
+int gpio_interrupt_status(u32 port, u32 pins)
+{
+	u32 port_offset = GPIO_INT_STA_OFFSET(port);
+	u32 enabled = GPIO(GPIO_INT_ENB_OFFSET(port)) & pins;
+
+	int status = ((GPIO(port_offset) & pins) && enabled) ? 1 : 0;
+
+	// Clear the interrupt status.
+	if (status)
+		_gpio_interrupt_clear(port, pins);
+
+	return status;
+}
+
+void gpio_interrupt_enable(u32 port, u32 pins, int enable)
+{
+	u32 port_offset = GPIO_INT_ENB_OFFSET(port);
+
+	// Clear any possible stray interrupt.
+	_gpio_interrupt_clear(port, pins);
+
+	if (enable)
+		GPIO(port_offset) |= pins;
+	else
+		GPIO(port_offset) &= ~pins;
+
+	(void)GPIO(port_offset); // Commit the write.
+}
+
+void gpio_interrupt_level(u32 port, u32 pins, int high, int edge, int delta)
+{
+	u32 port_offset = GPIO_INT_LVL_OFFSET(port);
+
+	u32 val = GPIO(port_offset);
+
+	if (high)
+		val |= pins;
+	else
+		val &= ~pins;
+
+	if (edge)
+		val |= pins << 8;
+	else
+		val &= ~(pins << 8);
+
+	if (delta)
+		val |= pins << 16;
+	else
+		val &= ~(pins << 16);
+
+	GPIO(port_offset) = val;
+
+	(void)GPIO(port_offset); // Commit the write.
+
+	// Clear any possible stray interrupt.
+	_gpio_interrupt_clear(port, pins);
+}
+
+u32 gpio_get_bank_irq_id(u32 port)
+{
+	u32 bank_idx = GPIO_BANK_IDX(port);
+
+	return gpio_bank_irq_ids[bank_idx];
 }

source/soc/gpio.h

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2018 naehrwert
+ * Copyright (c) 2019 CTCaer
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -21,10 +22,23 @@
 
 #define GPIO_MODE_SPIO 0
 #define GPIO_MODE_GPIO 1
+
 #define GPIO_OUTPUT_DISABLE 0
 #define GPIO_OUTPUT_ENABLE 1
+
+#define GPIO_IRQ_DISABLE 0
+#define GPIO_IRQ_ENABLE 1
+
 #define GPIO_LOW 0
 #define GPIO_HIGH 1
+#define GPIO_FALLING 0
+#define GPIO_RISING 1
+
+#define GPIO_LEVEL 0
+#define GPIO_EDGE 1
+
+#define GPIO_CONFIGURED_EDGE 0
+#define GPIO_ANY_EDGE_CHANGE 1
 
 /*! GPIO pins (0-7 for each port). */
 #define GPIO_PIN_0 (1 << 0)
@@ -72,6 +86,10 @@
 void gpio_config(u32 port, u32 pins, int mode);
 void gpio_output_enable(u32 port, u32 pins, int enable);
 void gpio_write(u32 port, u32 pins, int high);
-int gpio_read(u32 port, u32 pins);
+int  gpio_read(u32 port, u32 pins);
+int  gpio_interrupt_status(u32 port, u32 pins);
+void gpio_interrupt_enable(u32 port, u32 pins, int enable);
+void gpio_interrupt_level(u32 port, u32 pins, int high, int edge, int delta);
+u32  gpio_get_bank_irq_id(u32 port);
 
 #endif

source/soc/hw_init.c

@@ -34,10 +34,10 @@
 #include "../power/max7762x.h"
 #include "../sec/se.h"
 #include "../sec/se_t210.h"
+#include "../storage/nx_sd.h"
 #include "../storage/sdmmc.h"
 #include "../utils/util.h"
 
-extern sdmmc_t sd_sdmmc;
 extern boot_cfg_t b_cfg;
 extern volatile nyx_storage_t *nyx_str;
 
@@ -314,6 +314,9 @@ void config_hw()
 
 	bpmp_mmu_enable();
 	mc_enable_ahb_redirect();
+
+	// Clear flags from PMC_SCRATCH0
+	PMC(APBDEV_PMC_SCRATCH0) &= ~PMC_SCRATCH0_MODE_PAYLOAD;
 }
 
 void reconfig_hw_workaround(bool extra_reconfig, u32 magic)

source/soc/i2c.c

@@ -38,21 +38,39 @@ static void _i2c_wait(vu32 *base)
 
 static int _i2c_send_pkt(u32 idx, u32 x, u8 *buf, u32 size)
 {
-	if (size > 4)
+	if (size > 8)
 		return 0;
 
 	u32 tmp = 0;
-	memcpy(&tmp, buf, size);
 
 	vu32 *base = (vu32 *)i2c_addrs[idx];
-	base[I2C_CMD_ADDR0] = x << 1;                //Set x (send mode).
+	base[I2C_CMD_ADDR0] = x << 1; //Set x (send mode).
-	base[I2C_CMD_DATA1] = tmp;                   //Set value.
+
+	if (size > 4)
+	{
+		memcpy(&tmp, buf, 4);
+		base[I2C_CMD_DATA1] = tmp; //Set value.
+		tmp = 0;
+		memcpy(&tmp, buf + 4, size - 4);
+		base[I2C_CMD_DATA2] = tmp;
+	}
+	else
+	{
+		memcpy(&tmp, buf, size);
+		base[I2C_CMD_DATA1] = tmp; //Set value.
+	}
+
 	base[I2C_CNFG] = ((size - 1) << 1) | 0x2800; //Set size and send mode.
 	_i2c_wait(base);                             //Kick transaction.
 
 	base[I2C_CNFG] = (base[I2C_CNFG] & 0xFFFFFDFF) | 0x200;
+
+	u32 timeout = get_tmr_ms() + 1500;
 	while (base[I2C_STATUS] & 0x100)
-		;
+	{
+		if (get_tmr_ms() > timeout)
+			return 0;
+	}
 
 	if (base[I2C_STATUS] << 28)
 		return 0;
@@ -71,8 +89,13 @@ static int _i2c_recv_pkt(u32 idx, u8 *buf, u32 size, u32 x)
 	_i2c_wait(base);                             // Kick transaction.
 
 	base[I2C_CNFG] = (base[I2C_CNFG] & 0xFFFFFDFF) | 0x200;
+
+	u32 timeout = get_tmr_ms() + 1500;
 	while (base[I2C_STATUS] & 0x100)
-		;
+	{
+		if (get_tmr_ms() > timeout)
+			return 0;
+	}
 
 	if (base[I2C_STATUS] << 28)
 		return 0;
@@ -113,7 +136,7 @@ int i2c_send_buf_small(u32 idx, u32 x, u32 y, u8 *buf, u32 size)
 {
 	u8 tmp[4];
 
-	if (size > 3)
+	if (size > 7)
 		return 0;
 
 	tmp[0] = y;

source/soc/irq.c

@@ -0,0 +1,263 @@
+/*
+ * BPMP-Lite IRQ driver for Tegra X1
+ *
+ * Copyright (c) 2019 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <string.h>
+
+#include "irq.h"
+#include "t210.h"
+#include "../gfx/gfx.h"
+#include "../mem/heap.h"
+
+//#define DPRINTF(...) gfx_printf(__VA_ARGS__)
+#define DPRINTF(...)
+
+extern void irq_disable();
+extern void irq_enable_cpu_irq_exceptions();
+extern void irq_disable_cpu_irq_exceptions();
+
+typedef struct _irq_ctxt_t
+{
+	u32  irq;
+	int  (*handler)(u32 irq, void *data);
+	void *data;
+	u32  flags;
+} irq_ctxt_t;
+
+bool irq_init_done = false;
+irq_ctxt_t irqs[IRQ_MAX_HANDLERS];
+
+static void _irq_enable_source(u32 irq)
+{
+	u32 ctrl_idx = irq >> 5;
+	u32 bit = irq % 32;
+
+	// Set as normal IRQ.
+	ICTLR(ctrl_idx, PRI_ICTLR_COP_IEP_CLASS) &= ~(1 << bit);
+
+	// Enable IRQ source.
+	ICTLR(ctrl_idx, PRI_ICTLR_COP_IER_SET) = 1 << bit;
+}
+
+static void _irq_disable_source(u32 irq)
+{
+	u32 ctrl_idx = irq >> 5;
+	u32 bit = irq % 32;
+
+	// Disable IRQ source.
+	ICTLR(ctrl_idx, PRI_ICTLR_COP_IER_CLR) = 1 << bit;
+}
+
+static void _irq_disable_and_ack_all()
+{
+	// Disable and ack all IRQ sources.
+	for (u32 ctrl_idx = 0; ctrl_idx < 6; ctrl_idx++)
+	{
+		u32 enabled_irqs = ICTLR(ctrl_idx, PRI_ICTLR_COP_IER);
+		ICTLR(ctrl_idx, PRI_ICTLR_COP_IER_CLR) = enabled_irqs;
+		ICTLR(ctrl_idx, PRI_ICTLR_FIR_CLR) = enabled_irqs;
+	}
+}
+
+static void _irq_ack_source(u32 irq)
+{
+	u32 ctrl_idx = irq >> 5;
+	u32 bit = irq % 32;
+
+	// Force stop the interrupt as it's serviced here.
+	ICTLR(ctrl_idx, PRI_ICTLR_FIR_CLR) = 1 << bit;
+}
+
+void irq_free(u32 irq)
+{
+	for (u32 idx = 0; idx < IRQ_MAX_HANDLERS; idx++)
+	{
+		if (irqs[idx].irq == irq && irqs[idx].handler)
+		{
+			irqs[idx].irq = 0;
+			irqs[idx].handler = NULL;
+			irqs[idx].data = NULL;
+			irqs[idx].flags = 0;
+
+			_irq_disable_source(irq);
+		}
+	}
+}
+
+static void _irq_free_all()
+{
+	for (u32 idx = 0; idx < IRQ_MAX_HANDLERS; idx++)
+	{
+		if (irqs[idx].handler)
+		{
+			_irq_disable_source(irqs[idx].irq);
+
+			irqs[idx].irq = 0;
+			irqs[idx].handler = NULL;
+			irqs[idx].data = NULL;
+			irqs[idx].flags = 0;
+		}
+	}
+}
+
+static irq_status_t _irq_handle_source(u32 irq)
+{
+	int status = IRQ_NONE;
+
+	_irq_disable_source(irq);
+	_irq_ack_source(irq);
+
+	u32 idx;
+	for (idx = 0; idx < IRQ_MAX_HANDLERS; idx++)
+	{
+		if (irqs[idx].irq == irq)
+		{
+			status = irqs[idx].handler(irqs[idx].irq, irqs[idx].data);
+
+			if (status == IRQ_HANDLED)
+				break;
+		}
+	}
+
+	if (irqs[idx].flags & IRQ_FLAG_ONE_OFF)
+		irq_free(irq);
+	else
+		_irq_enable_source(irq);
+
+	return status;
+}
+
+void irq_handler()
+{
+	// Get IRQ source.
+	u32 irq = EXCP_VEC(EVP_COP_IRQ_STS) & 0xFF;
+
+	if (!irq_init_done)
+	{
+		_irq_ack_source(irq);
+		return;
+	}
+
+	DPRINTF("IRQ: %d\n", irq);
+
+	int err = _irq_handle_source(irq);
+
+	//TODO: disable if unhandhled.
+	if (err == IRQ_NONE)
+		gfx_printf("Unhandled IRQ: %d\n", irq);
+}
+
+static void _irq_init()
+{
+	_irq_disable_and_ack_all();
+	memset(irqs, 0, sizeof(irq_ctxt_t) * IRQ_MAX_HANDLERS);
+	irq_init_done = true;
+}
+
+void irq_end()
+{
+	_irq_free_all();
+	irq_disable_cpu_irq_exceptions();
+	irq_init_done = false;
+}
+
+void irq_wait_event(u32 irq)
+{
+	irq_disable_cpu_irq_exceptions();
+
+	_irq_enable_source(irq);
+
+	// Halt BPMP and wait for the IRQ. No need to use WAIT_EVENT + LIC_IRQ when BPMP serves the IRQ.
+	FLOW_CTLR(FLOW_CTLR_HALT_COP_EVENTS) = HALT_COP_STOP_UNTIL_IRQ;
+
+	_irq_disable_source(irq);
+	_irq_ack_source(irq);
+
+	irq_enable_cpu_irq_exceptions();
+}
+
+void irq_disable_wait_event()
+{
+	irq_enable_cpu_irq_exceptions();
+}
+
+irq_status_t irq_request(u32 irq, irq_handler_t handler, void *data, irq_flags_t flags)
+{
+	if (!irq_init_done)
+		_irq_init();
+
+	for (u32 idx = 0; idx < IRQ_MAX_HANDLERS; idx++)
+	{
+		if (irqs[idx].handler == NULL ||
+			(irqs[idx].irq == irq && irqs[idx].flags & IRQ_FLAG_REPLACEABLE))
+		{
+			DPRINTF("Registered handler, IRQ: %d, Slot: %d\n", irq, idx);
+			DPRINTF("Handler: %08p, Flags: %x\n", (u32)handler, flags);
+
+			irqs[idx].irq = irq;
+			irqs[idx].handler = handler;
+			irqs[idx].data = data;
+			irqs[idx].flags = flags;
+
+			_irq_enable_source(irq);
+
+			return IRQ_ENABLED;
+		}
+		else if (irqs[idx].irq == irq)
+			return IRQ_ALREADY_REGISTERED;
+	}
+
+	return IRQ_NO_SLOTS_AVAILABLE;
+}
+
+void __attribute__ ((target("arm"))) fiq_setup()
+{
+/*
+	asm volatile("mrs r12, cpsr\n\t"
+		"bic r12, r12, #0x1F\n\t"
+		"orr r12, r12, #0x11\n\t"
+		"msr cpsr_c, r12\n\t");
+
+	register volatile char *text asm ("r8");
+	register volatile char *uart_tx asm ("r9");
+	register int len asm ("r10");
+
+	len = 5;
+	uart_tx = (char *)0x70006040;
+	memcpy((char *)text, "FIQ\r\n", len);
+	*uart_tx = 0;
+
+	asm volatile("mrs r12, cpsr\n"
+		"orr r12, r12, #0x1F\n"
+		"msr cpsr_c, r12");
+*/
+}
+
+void  __attribute__ ((target("arm"), interrupt ("FIQ"))) fiq_handler()
+{
+/*
+	register volatile char *text asm ("r8");
+	register volatile char *uart_tx asm ("r9");
+	register int len asm ("r10");
+
+	while (len)
+	{
+		*uart_tx = *text++;
+		len--;
+	}
+*/
+}

source/soc/irq.h

@@ -0,0 +1,222 @@
+/*
+ * BPMP-Lite IRQ driver for Tegra X1
+ *
+ * Copyright (c) 2019 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef IRQ_H
+#define IRQ_H
+
+#include "../utils/types.h"
+
+#define IRQ_MAX_HANDLERS 16
+
+/* Primary interrupt controller ids */
+#define IRQ_TMR1 0
+#define IRQ_TMR2 1
+#define IRQ_RTC 2
+#define IRQ_CEC 3
+#define IRQ_SHR_SEM_INBOX_FULL 4
+#define IRQ_SHR_SEM_INBOX_EMPTY 5
+#define IRQ_SHR_SEM_OUTBOX_FULL 6
+#define IRQ_SHR_SEM_OUTBOX_EMPTY 7
+#define IRQ_NVJPEG 8
+#define IRQ_NVDEC 9
+#define IRQ_QUAD_SPI 10
+#define IRQ_DPAUX_INT1 11
+#define IRQ_SATA_RX_STAT 13
+#define IRQ_SDMMC1 14
+#define IRQ_SDMMC2 15
+#define IRQ_VGPIO_INT 16
+#define IRQ_VII2C_INT 17
+#define IRQ_SDMMC3 19
+#define IRQ_USB 20
+#define IRQ_USB2 21
+#define IRQ_SATA_CTL 23
+#define IRQ_PMC_INT 24
+#define IRQ_FC_INT 25
+#define IRQ_APB_DMA_CPU 26
+#define IRQ_ARB_SEM_GNT_COP 28
+#define IRQ_ARB_SEM_GNT_CPU 29
+#define IRQ_SDMMC4 31
+
+/* Secondary interrupt controller ids */
+#define IRQ_GPIO1 32
+#define IRQ_GPIO2 33
+#define IRQ_GPIO3 34
+#define IRQ_GPIO4 35
+#define IRQ_UARTA 36
+#define IRQ_UARTB 37
+#define IRQ_I2C 38
+#define IRQ_USB3_HOST_INT 39
+#define IRQ_USB3_HOST_SMI 40
+#define IRQ_TMR3 41
+#define IRQ_TMR4 42
+#define IRQ_USB3_HOST_PME 43
+#define IRQ_USB3_DEV_HOST 44
+#define IRQ_ACTMON 45
+#define IRQ_UARTC 46
+#define IRQ_THERMAL 48
+#define IRQ_XUSB_PADCTL 49
+#define IRQ_TSEC 50
+#define IRQ_EDP 51
+#define IRQ_I2C5 53
+#define IRQ_GPIO5 55
+#define IRQ_USB3_DEV_SMI 56
+#define IRQ_USB3_DEV_PME 57
+#define IRQ_SE 58
+#define IRQ_SPI1 59
+#define IRQ_APB_DMA_COP 60
+#define IRQ_CLDVFS 62
+#define IRQ_I2C6 63
+
+/* Tertiary interrupt controller ids */
+#define IRQ_HOST1X_SYNCPT_COP 64
+#define IRQ_HOST1X_SYNCPT_CPU 65
+#define IRQ_HOST1X_GEN_COP 66
+#define IRQ_HOST1X_GEN_CPU 67
+#define IRQ_NVENC 68
+#define IRQ_VI 69
+#define IRQ_ISPB 70
+#define IRQ_ISP 71
+#define IRQ_VIC 72
+#define IRQ_DISPLAY 73
+#define IRQ_DISPLAYB 74
+#define IRQ_SOR1 75
+#define IRQ_SOR 76
+#define IRQ_MC 77
+#define IRQ_EMC 78
+#define IRQ_TSECB 80
+#define IRQ_HDA 81
+#define IRQ_SPI2 82
+#define IRQ_SPI3 83
+#define IRQ_I2C2 84
+#define IRQ_PMU_EXT 86
+#define IRQ_GPIO6 87
+#define IRQ_GPIO7 89
+#define IRQ_UARTD 90
+#define IRQ_I2C3 92
+#define IRQ_SPI4 93
+
+/* Quaternary interrupt controller ids */
+#define IRQ_DTV 96
+#define IRQ_PCIE_INT 98
+#define IRQ_PCIE_MSI 99
+#define IRQ_AVP_CACHE 101
+#define IRQ_APE_INT1 102
+#define IRQ_APE_INT0 103
+#define IRQ_APB_DMA_CH0 104
+#define IRQ_APB_DMA_CH1 105
+#define IRQ_APB_DMA_CH2 106
+#define IRQ_APB_DMA_CH3 107
+#define IRQ_APB_DMA_CH4 108
+#define IRQ_APB_DMA_CH5 109
+#define IRQ_APB_DMA_CH6 110
+#define IRQ_APB_DMA_CH7 111
+#define IRQ_APB_DMA_CH8 112
+#define IRQ_APB_DMA_CH9 113
+#define IRQ_APB_DMA_CH10 114
+#define IRQ_APB_DMA_CH11 115
+#define IRQ_APB_DMA_CH12 116
+#define IRQ_APB_DMA_CH13 117
+#define IRQ_APB_DMA_CH14 118
+#define IRQ_APB_DMA_CH15 119
+#define IRQ_I2C4 120
+#define IRQ_TMR5 121
+#define IRQ_WDT_CPU 123
+#define IRQ_WDT_AVP 124
+#define IRQ_GPIO8 125
+#define IRQ_CAR 126
+
+/* Quinary interrupt controller ids */
+#define IRQ_APB_DMA_CH16 128
+#define IRQ_APB_DMA_CH17 129
+#define IRQ_APB_DMA_CH18 130
+#define IRQ_APB_DMA_CH19 131
+#define IRQ_APB_DMA_CH20 132
+#define IRQ_APB_DMA_CH21 133
+#define IRQ_APB_DMA_CH22 134
+#define IRQ_APB_DMA_CH23 135
+#define IRQ_APB_DMA_CH24 136
+#define IRQ_APB_DMA_CH25 137
+#define IRQ_APB_DMA_CH26 138
+#define IRQ_APB_DMA_CH27 139
+#define IRQ_APB_DMA_CH28 140
+#define IRQ_APB_DMA_CH29 141
+#define IRQ_APB_DMA_CH30 142
+#define IRQ_APB_DMA_CH31 143
+#define IRQ_CPU0_PMU_INTR 144
+#define IRQ_CPU1_PMU_INTR 145
+#define IRQ_CPU2_PMU_INTR 146
+#define IRQ_CPU3_PMU_INTR 147
+#define IRQ_SDMMC1_SYS 148
+#define IRQ_SDMMC2_SYS 149
+#define IRQ_SDMMC3_SYS 150
+#define IRQ_SDMMC4_SYS 151
+#define IRQ_TMR6 152
+#define IRQ_TMR7 153
+#define IRQ_TMR8 154
+#define IRQ_TMR9 155
+#define IRQ_TMR0 156
+#define IRQ_GPU_STALL 157
+#define IRQ_GPU_NONSTALL 158
+#define IRQ_DPAUX 159
+
+/* Senary interrupt controller ids */
+#define IRQ_MPCORE_AXIERRIRQ 160
+#define IRQ_MPCORE_INTERRIRQ 161
+#define IRQ_EVENT_GPIO_A 162
+#define IRQ_EVENT_GPIO_B 163
+#define IRQ_EVENT_GPIO_C 164
+#define IRQ_FLOW_RSM_CPU 168
+#define IRQ_FLOW_RSM_COP 169
+#define IRQ_TMR_SHARED 170
+#define IRQ_MPCORE_CTIIRQ0 171
+#define IRQ_MPCORE_CTIIRQ1 172
+#define IRQ_MPCORE_CTIIRQ2 173
+#define IRQ_MPCORE_CTIIRQ3 174
+#define IRQ_MSELECT_ERROR 175
+#define IRQ_TMR10 176
+#define IRQ_TMR11 177
+#define IRQ_TMR12 178
+#define IRQ_TMR13 179
+
+typedef int (*irq_handler_t)(u32 irq, void *data);
+
+typedef enum _irq_status_t
+{
+	IRQ_NONE    = 0,
+	IRQ_HANDLED = 1,
+	IRQ_ERROR   = 2,
+
+	IRQ_ENABLED            = 0,
+	IRQ_NO_SLOTS_AVAILABLE = 1,
+	IRQ_ALREADY_REGISTERED = 2
+} irq_status_t;
+
+typedef enum _irq_flags_t
+{
+	IRQ_FLAG_NONE        = 0,
+	IRQ_FLAG_ONE_OFF     = (1 << 0),
+	IRQ_FLAG_REPLACEABLE = (1 << 1)
+} irq_flags_t;
+
+void irq_end();
+void irq_free(u32 irq);
+void irq_wait_event();
+void irq_disable_wait_event();
+irq_status_t irq_request(u32 irq, irq_handler_t handler, void *data, irq_flags_t flags);
+
+#endif

source/soc/pinmux.h

@@ -62,6 +62,7 @@
 #define PINMUX_AUX_LCD_BL_PWM      0x1FC
 #define PINMUX_AUX_LCD_BL_EN       0x200
 #define PINMUX_AUX_LCD_RST         0x204
+#define PINMUX_AUX_LCD_GPIO1       0x208
 #define PINMUX_AUX_LCD_GPIO2       0x20C
 #define PINMUX_AUX_TOUCH_INT       0x220
 #define PINMUX_AUX_MOTION_INT      0x224

source/soc/pmc.h

@@ -25,13 +25,23 @@
 #define APBDEV_PMC_PWRGATE_TOGGLE 0x30
 #define APBDEV_PMC_PWRGATE_STATUS 0x38
 #define APBDEV_PMC_NO_IOPOWER 0x44
+#define  PMC_NO_IOPOWER_GPIO_IO_EN   (1 << 21)
+#define  PMC_NO_IOPOWER_AUDIO_HV     (1 << 18)
 #define  PMC_NO_IOPOWER_SDMMC1_IO_EN (1 << 12)
 #define APBDEV_PMC_SCRATCH0 0x50
+#define  PMC_SCRATCH0_MODE_RECOVERY (1 << 31)
+#define  PMC_SCRATCH0_MODE_FASTBOOT (1 << 30)
+#define  PMC_SCRATCH0_MODE_PAYLOAD  (1 << 29)
+#define  PMC_SCRATCH0_MODE_RCM      (1 << 1)
+#define  PMC_SCRATCH0_MODE_WARMBOOT (1 << 0)
 #define APBDEV_PMC_SCRATCH1 0x54
 #define APBDEV_PMC_SCRATCH20 0xA0
 #define APBDEV_PMC_PWR_DET_VAL 0xE4
+#define  PMC_PWR_DET_GPIO_IO_EN   (1 << 21)
+#define  PMC_PWR_DET_AUDIO_HV     (1 << 18)
 #define  PMC_PWR_DET_SDMMC1_IO_EN (1 << 12)
 #define APBDEV_PMC_DDR_PWR 0xE8
+#define APBDEV_PMC_USB_AO 0xF0
 #define APBDEV_PMC_CRYPTO_OP 0xF4
 #define  PMC_CRYPTO_OP_SE_ENABLE  0
 #define  PMC_CRYPTO_OP_SE_DISABLE 1
@@ -39,6 +49,8 @@
 #define APBDEV_PMC_SCRATCH40 0x13C
 #define APBDEV_PMC_OSC_EDPD_OVER 0x1A4
 #define  PMC_OSC_EDPD_OVER_OSC_CTRL_OVER 0x400000
+#define APBDEV_PMC_CLK_OUT_CNTRL 0x1A8
+#define  PMC_CLK_OUT_CNTRL_CLK1_FORCE_EN (1 << 2)
 #define APBDEV_PMC_RST_STATUS 0x1B4
 #define APBDEV_PMC_IO_DPD_REQ 0x1B8
 #define APBDEV_PMC_IO_DPD2_REQ 0x1C0

source/soc/t210.h

@@ -28,9 +28,11 @@
 #define VIC_BASE 0x54340000
 #define TSEC_BASE 0x54500000
 #define SOR1_BASE 0x54580000
+#define ICTLR_BASE 0x60004000
 #define TMR_BASE 0x60005000
 #define CLOCK_BASE 0x60006000
 #define FLOW_CTLR_BASE 0x60007000
+#define AHBDMA_BASE 0x60008000
 #define SYSREG_BASE 0x6000C000
 #define SB_BASE (SYSREG_BASE + 0x200)
 #define GPIO_BASE 0x6000D000
@@ -44,6 +46,7 @@
 #define GPIO_8_BASE (GPIO_BASE + 0x700)
 #define EXCP_VEC_BASE 0x6000F000
 #define IPATCH_BASE 0x6001DC00
+#define APBDMA_BASE 0x60020000
 #define APB_MISC_BASE 0x70000000
 #define PINMUX_AUX_BASE 0x70003000
 #define UART_BASE 0x70006000
@@ -56,10 +59,16 @@
 #define SE_BASE 0x70012000
 #define MC_BASE 0x70019000
 #define EMC_BASE 0x7001B000
+#define EMC0_BASE 0x7001E000
+#define EMC1_BASE 0x7001F000
 #define MIPI_CAL_BASE 0x700E3000
 #define CL_DVFS_BASE 0x70110000
 #define I2S_BASE 0x702D1000
+#define ADMA_BASE 0x702E2000
 #define TZRAM_BASE 0x7C010000
+#define USB_BASE 0x7D000000
+#define USB_OTG_BASE USB_BASE
+#define USB1_BASE 0x7D004000
 
 #define _REG(base, off) *(vu32 *)((base) + (off))
 
@@ -70,10 +79,12 @@
 #define VIC(off) _REG(VIC_BASE, off)
 #define TSEC(off) _REG(TSEC_BASE, off)
 #define SOR1(off) _REG(SOR1_BASE, off)
+#define ICTLR(cidx, off) _REG(ICTLR_BASE + (0x100 * cidx), off)
 #define TMR(off) _REG(TMR_BASE, off)
 #define CLOCK(off) _REG(CLOCK_BASE, off)
 #define FLOW_CTLR(off) _REG(FLOW_CTLR_BASE, off)
 #define SYSREG(off) _REG(SYSREG_BASE, off)
+#define AHB_GIZMO(off) _REG(SYSREG_BASE, off)
 #define SB(off) _REG(SB_BASE, off)
 #define GPIO(off) _REG(GPIO_BASE, off)
 #define GPIO_1(off) _REG(GPIO_1_BASE, off)
@@ -96,9 +107,14 @@
 #define SE(off) _REG(SE_BASE, off)
 #define MC(off) _REG(MC_BASE, off)
 #define EMC(off) _REG(EMC_BASE, off)
+#define EMC_CH0(off) _REG(EMC0_BASE, off)
+#define EMC_CH1(off) _REG(EMC1_BASE, off)
 #define MIPI_CAL(off) _REG(MIPI_CAL_BASE, off)
-#define I2S(off) _REG(I2S_BASE, off)
 #define CL_DVFS(off) _REG(CL_DVFS_BASE, off)
+#define I2S(off) _REG(I2S_BASE, off)
+#define ADMA(off) _REG(ADMA_BASE, off)
+#define USB(off) _REG(USB_BASE, off)
+#define USB1(off) _REG(USB1_BASE, off)
 #define TEST_REG(off) _REG(0x0, off)
 
 /* HOST1X registers. */
@@ -116,13 +132,40 @@
 #define EVP_COP_RSVD_VECTOR 0x214
 #define EVP_COP_IRQ_VECTOR 0x218
 #define EVP_COP_FIQ_VECTOR 0x21C
+#define EVP_COP_IRQ_STS 0x220
+
+/*! Primary Interrupt Controller registers. */
+#define PRI_ICTLR_FIR 0x14
+#define PRI_ICTLR_FIR_SET 0x18
+#define PRI_ICTLR_FIR_CLR 0x1C
+#define PRI_ICTLR_CPU_IER 0x20
+#define PRI_ICTLR_CPU_IER_SET 0x24
+#define PRI_ICTLR_CPU_IER_CLR 0x28
+#define PRI_ICTLR_CPU_IEP_CLASS 0x2C
+#define PRI_ICTLR_COP_IER 0x30
+#define PRI_ICTLR_COP_IER_SET 0x34
+#define PRI_ICTLR_COP_IER_CLR 0x38
+#define PRI_ICTLR_COP_IEP_CLASS 0x3C
+
+/*! AHB Gizmo registers. */
+#define AHB_ARBITRATION_PRIORITY_CTRL 0x8
+#define  ARBITRATION_PRIORITY_CTRL_ENB_FAST_REARBITRATE (1 << 6)
+#define AHB_GIZMO_AHB_MEM 0x10
+#define  AHB_MEM_ENB_FAST_REARBITRATE (1 << 2)
+#define AHB_GIZMO_USB 0x20
+#define  AHB_GIZMO_USB_IMMEDIATE (1 << 18)
+#define AHB_AHB_MEM_PREFETCH_CFG1 0xF0
+#define  MEM_PREFETCH_ENABLE (1 << 31)
+#define  MEM_PREFETCH_AHB_MST_USB 6
 
 /*! Misc registers. */
 #define APB_MISC_PP_STRAPPING_OPT_A 0x08
 #define APB_MISC_PP_PINMUX_GLOBAL 0x40
 #define APB_MISC_GP_HIDREV 0x804
+#define APB_MISC_GP_AUD_MCLK_CFGPADCTRL 0x8F4
 #define APB_MISC_GP_LCD_BL_PWM_CFGPADCTRL 0xA34
 #define APB_MISC_GP_SDMMC1_PAD_CFGPADCTRL 0xA98
+#define APB_MISC_GP_EMMC2_PAD_CFGPADCTRL 0xA9C
 #define APB_MISC_GP_EMMC4_PAD_CFGPADCTRL 0xAB4
 #define APB_MISC_GP_EMMC4_PAD_PUPD_CFGPADCTRL 0xABC
 #define APB_MISC_GP_WIFI_EN_CFGPADCTRL 0xB64
@@ -170,9 +213,14 @@
 /*! TMR registers. */
 #define TIMERUS_CNTR_1US          (0x10 + 0x0)
 #define TIMERUS_USEC_CFG          (0x10 + 0x4)
+#define TIMER_TMR8_TMR_PTV        0x78
 #define TIMER_TMR9_TMR_PTV        0x80
-#define  TIMER_EN     (1 << 31)
+#define  TIMER_EN          (1 << 31)
-#define  TIMER_PER_EN (1 << 30)
+#define  TIMER_PER_EN      (1 << 30)
+#define TIMER_TMR8_TMR_PCR        0x7C
+#define TIMER_TMR9_TMR_PCR        0x8C
+#define  TIMER_INTR_CLR    (1 << 30)
+
 #define TIMER_WDT4_CONFIG         (0x100 + 0x80)
 #define  TIMER_SRC(TMR) (TMR & 0xF)
 #define  TIMER_PER(PER) ((PER & 0xFF) << 4)
@@ -210,13 +258,15 @@
 
 /*! Flow controller registers. */
 #define FLOW_CTLR_HALT_COP_EVENTS  0x4
-#define  HALT_COP_SEC        (1 << 23)
+#define  HALT_COP_GIC_IRQ        (1 << 9)
-#define  HALT_COP_MSEC       (1 << 24)
+#define  HALT_COP_LIC_IRQ        (1 << 11)
-#define  HALT_COP_USEC       (1 << 25)
+#define  HALT_COP_SEC            (1 << 23)
-#define  HALT_COP_JTAG       (1 << 28)
+#define  HALT_COP_MSEC           (1 << 24)
-#define  HALT_COP_WAIT_EVENT (1 << 30)
+#define  HALT_COP_USEC           (1 << 25)
-#define  HALT_COP_WAIT_IRQ   (1 << 31)
+#define  HALT_COP_JTAG           (1 << 28)
-#define  HALT_COP_MAX_CNT    0xFF
+#define  HALT_COP_WAIT_EVENT     (1 << 30)
+#define  HALT_COP_STOP_UNTIL_IRQ (1 << 31)
+#define  HALT_COP_MAX_CNT        0xFF
 #define FLOW_CTLR_HALT_CPU0_EVENTS 0x0
 #define FLOW_CTLR_HALT_CPU1_EVENTS 0x14
 #define FLOW_CTLR_HALT_CPU2_EVENTS 0x1C
@@ -228,4 +278,9 @@
 #define FLOW_CTLR_RAM_REPAIR 0x40
 #define FLOW_CTLR_BPMP_CLUSTER_CONTROL 0x98
 
+/*! USB controller registers. */
+#define USB1_UTMIP_BAT_CHRG_CFG0 0x830
+#define  BAT_CHRG_CFG0_OP_SRC_EN    (1 << 3)
+#define  BAT_CHRG_CFG0_PWRDOWN_CHRG (1 << 0)
+
 #endif

source/soc/uart.c

@@ -0,0 +1,172 @@
+/*
+* Copyright (c) 2018 naehrwert
+* Copyright (c) 2019-2020 CTCaer
+*
+* This program is free software; you can redistribute it and/or modify it
+* under the terms and conditions of the GNU General Public License,
+* version 2, as published by the Free Software Foundation.
+*
+* This program is distributed in the hope it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+* more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "../soc/uart.h"
+#include "../soc/clock.h"
+#include "../soc/t210.h"
+#include "../utils/util.h"
+
+/* UART A, B, C, D and E. */
+static const u32 uart_baseoff[5] = { 0, 0x40, 0x200, 0x300, 0x400 };
+
+void uart_init(u32 idx, u32 baud)
+{
+	uart_t *uart = (uart_t *)(UART_BASE + uart_baseoff[idx]);
+
+	// Make sure no data is being sent.
+	uart_wait_idle(idx, UART_TX_IDLE);
+
+	// Set clock.
+	bool clk_type = clock_uart_use_src_div(idx, baud);
+
+	// Misc settings.
+	u32 div = clk_type ? ((8 * baud + 408000000) / (16 * baud)) : 1; // DIV_ROUND_CLOSEST.
+	uart->UART_IER_DLAB = 0; // Disable interrupts.
+	uart->UART_LCR = UART_LCR_DLAB | UART_LCR_WORD_LENGTH_8; // Enable DLAB & set 8n1 mode.
+	uart->UART_THR_DLAB = (u8)div; // Divisor latch LSB.
+	uart->UART_IER_DLAB = (u8)(div >> 8); // Divisor latch MSB.
+	uart->UART_LCR = UART_LCR_WORD_LENGTH_8; // Disable DLAB.
+	(void)uart->UART_SPR;
+
+	// Setup and flush fifo.
+	uart->UART_IIR_FCR = UART_IIR_FCR_EN_FIFO;
+	(void)uart->UART_SPR;
+	usleep(20);
+	uart->UART_MCR = 0; // Disable hardware flow control.
+	usleep(96);
+	uart->UART_IIR_FCR = UART_IIR_FCR_EN_FIFO | UART_IIR_FCR_TX_CLR | UART_IIR_FCR_RX_CLR;
+
+	// Wait 3 symbols for baudrate change.
+	usleep(3 * ((baud + 999999) / baud));
+	uart_wait_idle(idx, UART_TX_IDLE | UART_RX_IDLE);
+}
+
+void uart_wait_idle(u32 idx, u32 which)
+{
+	uart_t *uart = (uart_t *)(UART_BASE + uart_baseoff[idx]);
+	if (UART_TX_IDLE & which)
+	{
+		while (!(uart->UART_LSR & UART_LSR_TMTY))
+			;
+	}
+	if (UART_RX_IDLE & which)
+	{
+		while (uart->UART_LSR & UART_LSR_RDR)
+			;
+	}
+}
+
+void uart_send(u32 idx, const u8 *buf, u32 len)
+{
+	uart_t *uart = (uart_t *)(UART_BASE + uart_baseoff[idx]);
+
+	for (u32 i = 0; i != len; i++)
+	{
+		while (!(uart->UART_LSR & UART_LSR_THRE))
+			;
+		uart->UART_THR_DLAB = buf[i];
+	};
+}
+
+u32 uart_recv(u32 idx, u8 *buf, u32 len)
+{
+	uart_t *uart = (uart_t *)(UART_BASE + uart_baseoff[idx]);
+	u32 timeout = get_tmr_us() + 1000;
+	u32 i;
+
+	for (i = 0; ; i++)
+	{
+		while (!(uart->UART_LSR & UART_LSR_RDR))
+		{
+			if (!len)
+			{
+				if (timeout < get_tmr_us())
+					break;
+			}
+			else if (len < i)
+				break;
+		}
+		if (timeout < get_tmr_us())
+			break;
+
+		buf[i] = uart->UART_THR_DLAB;
+		timeout = get_tmr_us() + 1000;
+	};
+
+	return i ? (len ? (i - 1) : i) : 0;
+}
+
+void uart_invert(u32 idx, bool enable, u32 invert_mask)
+{
+	uart_t *uart = (uart_t *)(UART_BASE + uart_baseoff[idx]);
+
+	if (enable)
+		uart->UART_IRDA_CSR |= invert_mask;
+	else
+		uart->UART_IRDA_CSR &= ~invert_mask;
+	(void)uart->UART_SPR;
+}
+
+u32 uart_get_IIR(u32 idx)
+{
+	uart_t *uart = (uart_t *)(UART_BASE + uart_baseoff[idx]);
+
+	return uart->UART_IIR_FCR;
+}
+
+void uart_set_IIR(u32 idx)
+{
+	uart_t *uart = (uart_t *)(UART_BASE + uart_baseoff[idx]);
+
+	uart->UART_IER_DLAB &= ~UART_IER_DLAB_IE_EORD;
+	(void)uart->UART_SPR;
+	uart->UART_IER_DLAB |= UART_IER_DLAB_IE_EORD;
+	(void)uart->UART_SPR;
+}
+
+void uart_empty_fifo(u32 idx, u32 which)
+{
+	uart_t *uart = (uart_t *)(UART_BASE + uart_baseoff[idx]);
+
+	uart->UART_MCR = 0;
+	(void)uart->UART_SPR;
+	usleep(96);
+
+	uart->UART_IIR_FCR = UART_IIR_FCR_EN_FIFO | UART_IIR_FCR_TX_CLR | UART_IIR_FCR_RX_CLR;
+	(void)uart->UART_SPR;
+	usleep(18);
+	u32 tries = 0;
+
+	if (UART_IIR_FCR_TX_CLR & which)
+	{
+		while (tries < 10 && uart->UART_LSR & UART_LSR_TMTY)
+		{
+			tries++;
+			usleep(100);
+		}
+		tries = 0;
+	}
+
+	if (UART_IIR_FCR_RX_CLR & which)
+	{
+		while (tries < 10 && !uart->UART_LSR & UART_LSR_RDR)
+		{
+			tries++;
+			usleep(100);
+		}
+	}
+}

source/soc/uart.h

@@ -0,0 +1,87 @@
+/*
+* Copyright (c) 2018 naehrwert
+* Copyright (c) 2019-2020 CTCaer
+*
+* This program is free software; you can redistribute it and/or modify it
+* under the terms and conditions of the GNU General Public License,
+* version 2, as published by the Free Software Foundation.
+*
+* This program is distributed in the hope it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+* more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _UART_H_
+#define _UART_H_
+
+#include "../utils/types.h"
+
+#define UART_A 0
+#define UART_B 1
+#define UART_C 2
+#define UART_D 3
+#define UART_E 4
+
+#define BAUD_115200 115200
+
+#define UART_TX_IDLE 0x1
+#define UART_RX_IDLE 0x2
+
+#define UART_TX_FIFO_FULL 0x100
+#define UART_RX_FIFO_EMPTY 0x200
+
+#define UART_INVERT_RXD 0x01
+#define UART_INVERT_TXD 0x02
+#define UART_INVERT_CTS 0x04
+#define UART_INVERT_RTS 0x08
+
+#define UART_IER_DLAB_IE_EORD 0x20
+
+#define UART_LCR_DLAB 0x80
+#define UART_LCR_STOP 0x4
+#define UART_LCR_WORD_LENGTH_8 0x3
+
+#define UART_LSR_RDR 0x1
+#define UART_LSR_THRE 0x20
+#define UART_LSR_TMTY 0x40
+#define UART_LSR_FIFOE 0x80
+
+#define UART_IIR_FCR_TX_CLR 0x4
+#define UART_IIR_FCR_RX_CLR 0x2
+#define UART_IIR_FCR_EN_FIFO 0x1
+
+#define UART_MCR_RTS 0x2
+#define UART_MCR_DTR 0x1
+
+typedef struct _uart_t
+{
+	/* 0x00 */ vu32 UART_THR_DLAB;
+	/* 0x04 */ vu32 UART_IER_DLAB;
+	/* 0x08 */ vu32 UART_IIR_FCR;
+	/* 0x0C */ vu32 UART_LCR;
+	/* 0x10 */ vu32 UART_MCR;
+	/* 0x14 */ vu32 UART_LSR;
+	/* 0x18 */ vu32 UART_MSR;
+	/* 0x1C */ vu32 UART_SPR;
+	/* 0x20 */ vu32 UART_IRDA_CSR;
+	/* 0x24 */ vu32 UART_RX_FIFO_CFG;
+	/* 0x28 */ vu32 UART_MIE;
+	/* 0x2C */ vu32 UART_VENDOR_STATUS;
+	/* 0x30 */ u8 _pad_30[0xC];
+	/* 0x3C */ vu32 UART_ASR;
+} uart_t;
+
+void uart_init(u32 idx, u32 baud);
+void uart_wait_idle(u32 idx, u32 which);
+void uart_send(u32 idx, const u8 *buf, u32 len);
+u32  uart_recv(u32 idx, u8 *buf, u32 len);
+void uart_invert(u32 idx, bool enable, u32 invert_mask);
+u32  uart_get_IIR(u32 idx);
+void uart_set_IIR(u32 idx);
+void uart_empty_fifo(u32 idx, u32 which);
+
+#endif

source/start.S

@@ -23,8 +23,8 @@
 .extern memset
 .type memset, %function
 
-.extern ipl_main
+.extern _irq_setup
-.type ipl_main, %function
+.type _irq_setup, %function
 
 .globl _start
 .type _start, %function
@@ -67,7 +67,7 @@ _real_start:
 	LDR R2, =__bss_end
 	SUB R2, R2, R0
 	BL memset
-	BL ipl_main
+	BL _irq_setup
 	B .
 
 .globl pivot_stack

source/storage/emummc.c

@@ -32,6 +32,7 @@ extern sdmmc_storage_t sd_storage;
 extern FATFS sd_fs;
 
 extern hekate_config h_cfg;
+emummc_cfg_t emu_cfg;
 
 extern bool sd_mount();
 extern void sd_unmount();
@@ -47,7 +48,8 @@ bool emummc_load_cfg()
 	emu_cfg.file_based_part_size = 0;
 	emu_cfg.active_part = 0;
 	emu_cfg.fs_ver = 0;
-	emu_cfg.emummc_file_based_path = (char *)malloc(0x80);
+	if (!emu_cfg.emummc_file_based_path)
+		emu_cfg.emummc_file_based_path = (char *)malloc(0x80);
 
 	LIST_INIT(ini_sections);
 	if (ini_parse(&ini_sections, "emuMMC/emummc.ini", false))
@@ -98,7 +100,7 @@ static int emummc_raw_get_part_off(int part_idx)
 int emummc_storage_init_mmc(sdmmc_storage_t *storage, sdmmc_t *sdmmc)
 {
 	FILINFO fno;
-	if (!sdmmc_storage_init_mmc(storage, sdmmc, SDMMC_4, SDMMC_BUS_WIDTH_8, 4))
+	if (!sdmmc_storage_init_mmc(storage, sdmmc, SDMMC_BUS_WIDTH_8, SDHCI_TIMING_MMC_HS400))
 	{
 		EPRINTF("Failed to init eMMC.");
 

source/storage/emummc.h

@@ -47,7 +47,7 @@ typedef struct _emummc_cfg_t
 	int fs_ver;
 } emummc_cfg_t;
 
-emummc_cfg_t emu_cfg;
+extern emummc_cfg_t emu_cfg;
 
 bool emummc_load_cfg();
 int emummc_storage_init_mmc(sdmmc_storage_t *storage, sdmmc_t *sdmmc);

source/storage/mbr_gpt.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2018 naehrwert
+ * Copyright (c) 2019 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MBR_GPT_H
+#define MBR_GPT_H
+
+#include "../utils/types.h"
+
+typedef struct _mbr_chs_t
+{
+	u8 head;
+	u8 sector;
+	u8 cylinder;
+} __attribute__((packed)) mbr_chs_t;
+
+typedef struct _mbr_part_t
+{
+	u8  status;
+	mbr_chs_t start_sct_chs;
+	u8  type;
+	mbr_chs_t end_sct_chs;
+	u32 start_sct;
+	u32 size_sct;
+} __attribute__((packed)) mbr_part_t;
+
+typedef struct _mbr_t
+{
+	u8  bootstrap[0x1B8];
+	u32 signature;
+	u16 copy_protected;
+	mbr_part_t partitions[4];
+	u16 boot_signature;
+} __attribute__((packed)) mbr_t;
+
+typedef struct _gpt_entry_t
+{
+	u8  type_guid[0x10];
+	u8  part_guid[0x10];
+	u64 lba_start;
+	u64 lba_end;
+	u64 attrs;
+	u16 name[36];
+} gpt_entry_t;
+
+typedef struct _gpt_header_t
+{
+	u64 signature; // "EFI PART"
+	u32 revision;
+	u32 size;
+	u32 crc32;
+	u32 res1;
+	u64 my_lba;
+	u64 alt_lba;
+	u64 first_use_lba;
+	u64 last_use_lba;
+	u8  disk_guid[0x10];
+	u64 part_ent_lba;
+	u32 num_part_ents;
+	u32 part_ent_size;
+	u32 part_ents_crc32;
+	u8  res2[420]; // Used as first 3 partition entries backup for HOS.
+} gpt_header_t;
+
+typedef struct _gpt_t
+{
+	gpt_header_t header;
+	gpt_entry_t  entries[128];
+} gpt_t;
+
+#endif

source/storage/mmc.h

@@ -31,7 +31,7 @@
 #define MMC_ALL_SEND_CID          2   /* bcr                     R2  */
 #define MMC_SET_RELATIVE_ADDR     3   /* ac   [31:16] RCA        R1  */
 #define MMC_SET_DSR               4   /* bc   [31:16] RCA            */
-#define MMC_SLEEP_AWAKE		  5   /* ac   [31:16] RCA 15:flg R1b */
+#define MMC_SLEEP_AWAKE           5   /* ac   [31:16] RCA 15:flg R1b */
 #define MMC_SWITCH                6   /* ac   [31:0] See below   R1b */
 #define MMC_SELECT_CARD           7   /* ac   [31:16] RCA        R1  */
 #define MMC_SEND_EXT_CSD          8   /* adtc                    R1  */
@@ -51,7 +51,7 @@
 #define MMC_READ_SINGLE_BLOCK    17   /* adtc [31:0] data addr   R1  */
 #define MMC_READ_MULTIPLE_BLOCK  18   /* adtc [31:0] data addr   R1  */
 #define MMC_SEND_TUNING_BLOCK    19   /* adtc                    R1  */
-#define MMC_SEND_TUNING_BLOCK_HS200	21	/* adtc R1  */
+#define MMC_SEND_TUNING_BLOCK_HS200 21	/* adtc R1  */
 
 /* class 3 */
 #define MMC_WRITE_DAT_UNTIL_STOP 20   /* adtc [31:0] data addr   R1  */

source/storage/nx_emmc.c

@@ -16,6 +16,7 @@
 
 #include <string.h>
 
+#include "mbr_gpt.h"
 #include "nx_emmc.h"
 #include "emummc.h"
 #include "../mem/heap.h"
@@ -23,28 +24,31 @@
 
 void nx_emmc_gpt_parse(link_t *gpt, sdmmc_storage_t *storage)
 {
-	u8 *buf = (u8 *)malloc(NX_GPT_NUM_BLOCKS * NX_EMMC_BLOCKSIZE);
+	gpt_t *gpt_buf = (gpt_t *)calloc(NX_GPT_NUM_BLOCKS, NX_EMMC_BLOCKSIZE);
 
-	emummc_storage_read(storage, NX_GPT_FIRST_LBA, NX_GPT_NUM_BLOCKS, buf);
+	emummc_storage_read(storage, NX_GPT_FIRST_LBA, NX_GPT_NUM_BLOCKS, gpt_buf);
 
-	gpt_header_t *hdr = (gpt_header_t *)buf;
+	for (u32 i = 0; i < gpt_buf->header.num_part_ents; i++)
-	for (u32 i = 0; i < hdr->num_part_ents; i++)
 	{
-		gpt_entry_t *ent = (gpt_entry_t *)(buf + (hdr->part_ent_lba - 1) * NX_EMMC_BLOCKSIZE + i * sizeof(gpt_entry_t));
 		emmc_part_t *part = (emmc_part_t *)calloc(sizeof(emmc_part_t), 1);
-		part->lba_start = ent->lba_start;
+
-		part->lba_end = ent->lba_end;
+		if (gpt_buf->entries[i].lba_start < gpt_buf->header.first_use_lba)
-		part->attrs = ent->attrs;
+			continue;
+
+		part->index = i;
+		part->lba_start = gpt_buf->entries[i].lba_start;
+		part->lba_end = gpt_buf->entries[i].lba_end;
+		part->attrs = gpt_buf->entries[i].attrs;
 
 		// ASCII conversion. Copy only the LSByte of the UTF-16LE name.
-		for (u32 i = 0; i < 36; i++)
+		for (u32 j = 0; j < 36; j++)
-			part->name[i] = ent->name[i];
+			part->name[j] = gpt_buf->entries[i].name[j];
-		part->name[36] = 0;
+		part->name[35] = 0;
 
 		list_append(gpt, &part->link);
 	}
 
-	free(buf);
+	free(gpt_buf);
 }
 
 void nx_emmc_gpt_free(link_t *gpt)

source/storage/nx_emmc.h

@@ -17,38 +17,9 @@
 #ifndef _NX_EMMC_H_
 #define _NX_EMMC_H_
 
+#include "sdmmc.h"
 #include "../utils/types.h"
 #include "../utils/list.h"
-#include "sdmmc.h"
-
-typedef struct _gpt_entry_t
-{
-	u8 type_guid[0x10];
-	u8 part_guid[0x10];
-	u64 lba_start;
-	u64 lba_end;
-	u64 attrs;
-	u16 name[36];
-} gpt_entry_t;
-
-typedef struct _gpt_header_t
-{
-	u64 signature;
-	u32 revision;
-	u32 size;
-	u32 crc32;
-	u32 res1;
-	u64 my_lba;
-	u64 alt_lba;
-	u64 first_use_lba;
-	u64 last_use_lba;
-	u8 disk_guid[0x10];
-	u64 part_ent_lba;
-	u32 num_part_ents;
-	u32 part_ent_size;
-	u32 part_ents_crc32;
-	u8 res2[420];
-} gpt_header_t;
 
 #define NX_GPT_FIRST_LBA 1
 #define NX_GPT_NUM_BLOCKS 33
@@ -56,6 +27,7 @@ typedef struct _gpt_header_t
 
 typedef struct _emmc_part_t
 {
+	u32 index;
 	u32 lba_start;
 	u32 lba_end;
 	u64 attrs;

source/storage/nx_sd.c

@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2018 naehrwert
+ * Copyright (c) 2018-2019 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "nx_sd.h"
+#include "sdmmc.h"
+#include "sdmmc_driver.h"
+#include "../gfx/gfx.h"
+#include "../libs/fatfs/ff.h"
+#include "../mem/heap.h"
+
+bool sd_mounted = false, sd_inited = false;
+static u32  sd_mode = SD_UHS_SDR82;
+
+sdmmc_t sd_sdmmc;
+sdmmc_storage_t sd_storage;
+FATFS sd_fs;
+
+u32 sd_get_mode()
+{
+	return sd_mode;
+}
+
+int sd_init_retry(bool power_cycle)
+{
+	u32 bus_width = SDMMC_BUS_WIDTH_4;
+	u32 type = SDHCI_TIMING_UHS_SDR82;
+
+	// Power cycle SD card.
+	if (power_cycle)
+	{
+		sd_mode--;
+		sdmmc_storage_end(&sd_storage);
+	}
+
+	// Get init parameters.
+	switch (sd_mode)
+	{
+	case SD_INIT_FAIL: // Reset to max.
+		return 0;
+	case SD_1BIT_HS25:
+		bus_width = SDMMC_BUS_WIDTH_1;
+		type = SDHCI_TIMING_SD_HS25;
+		break;
+	case SD_4BIT_HS25:
+		type = SDHCI_TIMING_SD_HS25;
+		break;
+	case SD_UHS_SDR82:
+		type = SDHCI_TIMING_UHS_SDR82;
+		break;
+	default:
+		sd_mode = SD_UHS_SDR82;
+	}
+
+	return sdmmc_storage_init_sd(&sd_storage, &sd_sdmmc, bus_width, type);
+}
+
+bool sd_initialize(bool power_cycle)
+{
+	if (power_cycle)
+		sdmmc_storage_end(&sd_storage);
+
+	int res = !sd_init_retry(false);
+
+	while (true)
+	{
+		if (!res)
+			return true;
+		else if (!sdmmc_get_sd_inserted()) // SD Card is not inserted.
+		{
+			sd_mode = SD_UHS_SDR82;
+			break;
+		}
+		else if (sd_mode == SD_INIT_FAIL)
+			break;
+		else
+			res = !sd_init_retry(true);
+	}
+
+	sdmmc_storage_end(&sd_storage);
+
+	return false;
+}
+
+bool sd_mount()
+{
+	if (sd_mounted)
+		return true;
+
+	sd_inited = sd_initialize(false);
+	int res = !sd_inited;
+
+	if (res)
+	{
+		gfx_con.mute = false;
+		EPRINTF("Failed to init SD card.");
+		if (!sdmmc_get_sd_inserted())
+			EPRINTF("Make sure that it is inserted.");
+		else
+			EPRINTF("SD Card Reader is not properly seated!");
+	}
+	else
+	{
+		res = f_mount(&sd_fs, "", 1);
+		if (res == FR_OK)
+		{
+			sd_mounted = true;
+			return true;
+		}
+		else
+		{
+			gfx_con.mute = false;
+			EPRINTFARGS("Failed to mount SD card (FatFS Error %d).\nMake sure that a FAT partition exists..", res);
+		}
+	}
+
+	return false;
+}
+
+void sd_unmount()
+{
+	sd_mode = SD_UHS_SDR82;
+	if (sd_mounted)
+	{
+		f_mount(NULL, "", 1);
+		sdmmc_storage_end(&sd_storage);
+		sd_mounted = false;
+		sd_inited = false;
+	}
+}
+
+void *sd_file_read(const char *path, u32 *fsize)
+{
+	FIL fp;
+	if (f_open(&fp, path, FA_READ) != FR_OK)
+		return NULL;
+
+	u32 size = f_size(&fp);
+	if (fsize)
+		*fsize = size;
+
+	void *buf = malloc(size);
+
+	if (f_read(&fp, buf, size, NULL) != FR_OK)
+	{
+		free(buf);
+		f_close(&fp);
+
+		return NULL;
+	}
+
+	f_close(&fp);
+
+	return buf;
+}
+
+int sd_save_to_file(void *buf, u32 size, const char *filename)
+{
+	FIL fp;
+	u32 res = 0;
+	res = f_open(&fp, filename, FA_CREATE_ALWAYS | FA_WRITE);
+	if (res)
+	{
+		EPRINTFARGS("Error (%d) creating file\n%s.\n", res, filename);
+		return res;
+	}
+
+	f_write(&fp, buf, size, NULL);
+	f_close(&fp);
+
+	return 0;
+}

source/storage/nx_sd.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2018 naehrwert
+ * Copyright (c) 2018-2019 CTCaer
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef NX_SD_H
+#define NX_SD_H
+
+#include "sdmmc.h"
+#include "sdmmc_driver.h"
+#include "../libs/fatfs/ff.h"
+
+enum
+{
+	SD_INIT_FAIL  = 0,
+	SD_1BIT_HS25  = 1,
+	SD_4BIT_HS25  = 2,
+	SD_UHS_SDR82  = 3,
+};
+
+extern sdmmc_t sd_sdmmc;
+extern sdmmc_storage_t sd_storage;
+extern FATFS sd_fs;
+
+u32  sd_get_mode();
+int  sd_init_retry(bool power_cycle);
+bool sd_initialize(bool power_cycle);
+bool sd_mount();
+void sd_unmount();
+void *sd_file_read(const char *path, u32 *fsize);
+int  sd_save_to_file(void *buf, u32 size, const char *filename);
+
+#endif

source/storage/sd.h

@@ -106,6 +106,11 @@
 #define SD_SET_CURRENT_LIMIT_600	2
 #define SD_SET_CURRENT_LIMIT_800	3
 
+#define SD_MAX_CURRENT_200 (1 << SD_SET_CURRENT_LIMIT_200)
+#define SD_MAX_CURRENT_400 (1 << SD_SET_CURRENT_LIMIT_400)
+#define SD_MAX_CURRENT_600 (1 << SD_SET_CURRENT_LIMIT_600)
+#define SD_MAX_CURRENT_800 (1 << SD_SET_CURRENT_LIMIT_800)
+
 /*
 * SD_SWITCH mode
 */

source/storage/sdmmc.c

@@ -18,6 +18,7 @@
 #include <string.h>
 #include "sdmmc.h"
 #include "mmc.h"
+#include "nx_sd.h"
 #include "sd.h"
 #include "../../common/memory_map.h"
 #include "../gfx/gfx.h"
@@ -135,10 +136,12 @@ static int _sdmmc_storage_check_status(sdmmc_storage_t *storage)
 
 static int _sdmmc_storage_readwrite_ex(sdmmc_storage_t *storage, u32 *blkcnt_out, u32 sector, u32 num_sectors, void *buf, u32 is_write)
 {
+	u32 tmp = 0;
 	sdmmc_cmd_t cmdbuf;
+	sdmmc_req_t reqbuf;
+
 	sdmmc_init_cmd(&cmdbuf, is_write ? MMC_WRITE_MULTIPLE_BLOCK : MMC_READ_MULTIPLE_BLOCK, sector, SDMMC_RSP_TYPE_1, 0);
 
-	sdmmc_req_t reqbuf;
 	reqbuf.buf = buf;
 	reqbuf.num_sectors = num_sectors;
 	reqbuf.blksize = 512;
@@ -148,7 +151,6 @@ static int _sdmmc_storage_readwrite_ex(sdmmc_storage_t *storage, u32 *blkcnt_out
 
 	if (!sdmmc_execute_cmd(storage->sdmmc, &cmdbuf, &reqbuf, blkcnt_out))
 	{
-		u32 tmp = 0;
 		sdmmc_stop_transmission(storage->sdmmc, &tmp);
 		_sdmmc_storage_get_status(storage, &tmp, 0);
 
@@ -171,25 +173,42 @@ int sdmmc_storage_end(sdmmc_storage_t *storage)
 static int _sdmmc_storage_readwrite(sdmmc_storage_t *storage, u32 sector, u32 num_sectors, void *buf, u32 is_write)
 {
 	u8 *bbuf = (u8 *)buf;
-
+	bool first_reinit = false;
 	while (num_sectors)
 	{
 		u32 blkcnt = 0;
-		//Retry 9 times on error.
+		// Retry 5 times if failed.
-		u32 retries = 10;
+		u32 retries = 5;
 		do
 		{
+reinit_try:
 			if (_sdmmc_storage_readwrite_ex(storage, &blkcnt, sector, MIN(num_sectors, 0xFFFF), bbuf, is_write))
 				goto out;
 			else
 				retries--;
 
-			msleep(100);
+			msleep(50);
 		} while (retries);
 
+		// Disk IO failure! Reinit SD Card to a lower speed.
+		if (storage->sdmmc->id == SDMMC_1)
+		{
+			int res;
+			if (!first_reinit)
+				res = sd_initialize(true);
+			else
+				res = sd_init_retry(true);
+
+			retries = 3;
+			first_reinit = true;
+
+			if (res)
+				goto reinit_try;
+		}
+
 		return 0;
 
-out:;
+out:
 DPRINTF("readwrite: %08X\n", blkcnt);
 		sector += blkcnt;
 		num_sectors -= blkcnt;
@@ -201,12 +220,34 @@ DPRINTF("readwrite: %08X\n", blkcnt);
 
 int sdmmc_storage_read(sdmmc_storage_t *storage, u32 sector, u32 num_sectors, void *buf)
 {
-	return _sdmmc_storage_readwrite(storage, sector, num_sectors, buf, 0);
+	// Ensure that buffer resides in DRAM and it's DMA aligned.
+	if (((u32)buf >= DRAM_START) && !((u32)buf % 8))
+		return _sdmmc_storage_readwrite(storage, sector, num_sectors, buf, 0);
+
+	if (num_sectors > (SDMMC_UP_BUF_SZ / 512))
+		return 0;
+
+	u8 *tmp_buf = (u8 *)SDMMC_UPPER_BUFFER;
+	if (_sdmmc_storage_readwrite(storage, sector, num_sectors, tmp_buf, 0))
+	{
+		memcpy(buf, tmp_buf, 512 * num_sectors);
+		return 1;
+	}
+	return 0;
 }
 
 int sdmmc_storage_write(sdmmc_storage_t *storage, u32 sector, u32 num_sectors, void *buf)
 {
-	return _sdmmc_storage_readwrite(storage, sector, num_sectors, buf, 1);
+	// Ensure that buffer resides in DRAM and it's DMA aligned.
+	if (((u32)buf >= DRAM_START) && !((u32)buf % 8))
+		return _sdmmc_storage_readwrite(storage, sector, num_sectors, buf, 1);
+
+	if (num_sectors > (SDMMC_UP_BUF_SZ / 512))
+		return 0;
+
+	u8 *tmp_buf = (u8 *)SDMMC_UPPER_BUFFER;
+	memcpy(tmp_buf, buf, 512 * num_sectors);
+	return _sdmmc_storage_readwrite(storage, sector, num_sectors, tmp_buf, 1);
 }
 
 /*
@@ -401,7 +442,7 @@ static int _mmc_storage_enable_HS(sdmmc_storage_t *storage, int check)
 	if (check && !_sdmmc_storage_check_status(storage))
 		return 0;
 
-	if (!sdmmc_setup_clock(storage->sdmmc, 2))
+	if (!sdmmc_setup_clock(storage->sdmmc, SDHCI_TIMING_MMC_HS52))
 		return 0;
 
 DPRINTF("[MMC] switched to HS\n");
@@ -418,10 +459,10 @@ static int _mmc_storage_enable_HS200(sdmmc_storage_t *storage)
 	if (!_mmc_storage_switch(storage, SDMMC_SWITCH(MMC_SWITCH_MODE_WRITE_BYTE, EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS200)))
 		return 0;
 
-	if (!sdmmc_setup_clock(storage->sdmmc, 3))
+	if (!sdmmc_setup_clock(storage->sdmmc, SDHCI_TIMING_MMC_HS200))
 		return 0;
 
-	if (!sdmmc_config_tuning(storage->sdmmc, 3, MMC_SEND_TUNING_BLOCK_HS200))
+	if (!sdmmc_tuning_execute(storage->sdmmc, SDHCI_TIMING_MMC_HS200, MMC_SEND_TUNING_BLOCK_HS200))
 		return 0;
 
 DPRINTF("[MMC] switched to HS200\n");
@@ -435,7 +476,7 @@ static int _mmc_storage_enable_HS400(sdmmc_storage_t *storage)
 	if (!_mmc_storage_enable_HS200(storage))
 		return 0;
 
-	sdmmc_get_venclkctl(storage->sdmmc);
+	sdmmc_set_tap_value(storage->sdmmc);
 
 	if (!_mmc_storage_enable_HS(storage, 0))
 		return 0;
@@ -446,7 +487,7 @@ static int _mmc_storage_enable_HS400(sdmmc_storage_t *storage)
 	if (!_mmc_storage_switch(storage, SDMMC_SWITCH(MMC_SWITCH_MODE_WRITE_BYTE, EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS400)))
 		return 0;
 
-	if (!sdmmc_setup_clock(storage->sdmmc, 4))
+	if (!sdmmc_setup_clock(storage->sdmmc, SDHCI_TIMING_MMC_HS400))
 		return 0;
 
 DPRINTF("[MMC] switched to HS400\n");
@@ -457,22 +498,20 @@ DPRINTF("[MMC] switched to HS400\n");
 
 static int _mmc_storage_enable_highspeed(sdmmc_storage_t *storage, u32 card_type, u32 type)
 {
-	//TODO: this should be a config item.
+	if (sdmmc_get_io_power(storage->sdmmc) != SDMMC_POWER_1_8)
-	// --v
-	if (!1 || sdmmc_get_voltage(storage->sdmmc) != SDMMC_POWER_1_8)
 		goto out;
 
 	if (sdmmc_get_bus_width(storage->sdmmc) == SDMMC_BUS_WIDTH_8 &&
-		card_type & EXT_CSD_CARD_TYPE_HS400_1_8V && type == 4)
+		card_type & EXT_CSD_CARD_TYPE_HS400_1_8V && type == SDHCI_TIMING_MMC_HS400)
 		return _mmc_storage_enable_HS400(storage);
 
 	if (sdmmc_get_bus_width(storage->sdmmc) == SDMMC_BUS_WIDTH_8 ||
 		(sdmmc_get_bus_width(storage->sdmmc) == SDMMC_BUS_WIDTH_4
 		&& card_type & EXT_CSD_CARD_TYPE_HS200_1_8V
-		&& (type == 4 || type == 3)))
+		&& (type == SDHCI_TIMING_MMC_HS400 || type == SDHCI_TIMING_MMC_HS200)))
 		return _mmc_storage_enable_HS200(storage);
 
-out:;
+out:
 	if (card_type & EXT_CSD_CARD_TYPE_HS_52)
 		return _mmc_storage_enable_HS(storage, 1);
 
@@ -487,13 +526,13 @@ static int _mmc_storage_enable_bkops(sdmmc_storage_t *storage)
 	return _sdmmc_storage_check_status(storage);
 }
 
-int sdmmc_storage_init_mmc(sdmmc_storage_t *storage, sdmmc_t *sdmmc, u32 id, u32 bus_width, u32 type)
+int sdmmc_storage_init_mmc(sdmmc_storage_t *storage, sdmmc_t *sdmmc, u32 bus_width, u32 type)
 {
 	memset(storage, 0, sizeof(sdmmc_storage_t));
 	storage->sdmmc = sdmmc;
 	storage->rca = 2; //TODO: this could be a config item.
 
-	if (!sdmmc_init(sdmmc, id, SDMMC_POWER_1_8, SDMMC_BUS_WIDTH_1, 0, 0))
+	if (!sdmmc_init(sdmmc, SDMMC_4, SDMMC_POWER_1_8, SDMMC_BUS_WIDTH_1, SDHCI_TIMING_MMC_ID, SDMMC_AUTO_CAL_DISABLE))
 		return 0;
 DPRINTF("[MMC] after init\n");
 
@@ -520,7 +559,7 @@ DPRINTF("[MMC] set relative addr\n");
 DPRINTF("[MMC] got csd\n");
 	_mmc_storage_parse_csd(storage);
 
-	if (!sdmmc_setup_clock(storage->sdmmc, 1))
+	if (!sdmmc_setup_clock(storage->sdmmc, SDHCI_TIMING_MMC_LS26))
 		return 0;
 DPRINTF("[MMC] after setup clock\n");
 
@@ -544,35 +583,27 @@ DPRINTF("[MMC] set blocklen to 512\n");
 		return 0;
 DPRINTF("[MMC] switched buswidth\n");
 
-	u8 *ext_csd = (u8 *)malloc(512);
+	if (!_mmc_storage_get_ext_csd(storage, (u8 *)SDMMC_UPPER_BUFFER))
-	if (!_mmc_storage_get_ext_csd(storage, ext_csd))
-	{
-		free(ext_csd);
 		return 0;
-	}
-	free(ext_csd);
 DPRINTF("[MMC] got ext_csd\n");
+
 	_mmc_storage_parse_cid(storage); //This needs to be after csd and ext_csd
 	//gfx_hexdump(0, ext_csd, 512);
 
 	/* When auto BKOPS is enabled the mmc device should be powered all the time until we disable this and check status.
 	   Disable it for now until BKOPS disable added to power down sequence at sdmmc_storage_end().
 	   Additionally this works only when we put the device in idle mode which we don't after enabling it. */
-	if (storage->ext_csd.bkops & 0x1 && !(storage->ext_csd.bkops_en & EXT_CSD_BKOPS_LEVEL_2) && 0)
+	if (0 && storage->ext_csd.bkops & 0x1 && !(storage->ext_csd.bkops_en & EXT_CSD_BKOPS_LEVEL_2))
 	{
 		_mmc_storage_enable_bkops(storage);
 DPRINTF("[MMC] BKOPS enabled\n");
 	}
-	else
-	{
-DPRINTF("[MMC] BKOPS disabled\n");
-	}
 
 	if (!_mmc_storage_enable_highspeed(storage, storage->ext_csd.card_type, type))
 		return 0;
 DPRINTF("[MMC] succesfully switched to HS mode\n");
 
-	sdmmc_sd_clock_ctrl(storage->sdmmc, 1);
+	sdmmc_card_clock_ctrl(storage->sdmmc, SDMMC_AUTO_CAL_ENABLE);
 
 	return 1;
 }
@@ -656,6 +687,7 @@ static int _sd_storage_get_op_cond(sdmmc_storage_t *storage, int is_version_1, i
 			if (cond & SD_OCR_CCS)
 				storage->has_sector_access = 1;
 
+			// Check if card supports 1.8V signaling.
 			if (cond & SD_ROCR_S18A && supports_low_voltage)
 			{
 				//The low voltage regulator configuration is valid for SDMMC1 only.
@@ -804,34 +836,37 @@ int _sd_storage_switch(sdmmc_storage_t *storage, void *buf, int mode, int group,
 	return _sdmmc_storage_check_result(tmp);
 }
 
-void _sd_storage_set_current_limit(sdmmc_storage_t *storage, u8 *buf)
+void _sd_storage_set_current_limit(sdmmc_storage_t *storage, u16 current_limit, u8 *buf)
 {
-	u32 pwr = SD_SET_CURRENT_LIMIT_800;
+	u32 pwr = SD_SET_CURRENT_LIMIT_200;
+
+	if (current_limit & SD_MAX_CURRENT_800)
+		pwr = SD_SET_CURRENT_LIMIT_800;
+	else if (current_limit & SD_MAX_CURRENT_600)
+		pwr = SD_SET_CURRENT_LIMIT_600;
+	else if (current_limit & SD_MAX_CURRENT_400)
+		pwr = SD_SET_CURRENT_LIMIT_400;
+
 	_sd_storage_switch(storage, buf, SD_SWITCH_SET, 3, pwr);
 
-	while (pwr > 0)
+	if (((buf[15] >> 4) & 0x0F) == pwr)
 	{
-		pwr--;
+		switch (pwr)
-		_sd_storage_switch(storage, buf, SD_SWITCH_SET, 3, pwr);
+		{
-		if (((buf[15] >> 4) & 0x0F) == pwr)
+		case SD_SET_CURRENT_LIMIT_800:
+DPRINTF("[SD] power limit raised to 800mA\n");
 			break;
-	}
+		case SD_SET_CURRENT_LIMIT_600:
-
-	switch (pwr)
-	{
-	case SD_SET_CURRENT_LIMIT_800:
-DPRINTF("[SD] power limit raised to 800mA\n");
-		break;
-	case SD_SET_CURRENT_LIMIT_600:
 DPRINTF("[SD] power limit raised to 600mA\n");
-		break;
+			break;
-	case SD_SET_CURRENT_LIMIT_400:
+		case SD_SET_CURRENT_LIMIT_400:
-DPRINTF("[SD] power limit raised to 800mA\n");
+DPRINTF("[SD] power limit raised to 400mA\n");
-		break;
+			break;
-	default:
+		default:
-	case SD_SET_CURRENT_LIMIT_200:
+		case SD_SET_CURRENT_LIMIT_200:
 DPRINTF("[SD] power limit defaulted to 200mA\n");
-		break;
+			break;
+		}
 	}
 }
 
@@ -839,30 +874,33 @@ int _sd_storage_enable_highspeed(sdmmc_storage_t *storage, u32 hs_type, u8 *buf)
 {
 	if (!_sd_storage_switch(storage, buf, SD_SWITCH_CHECK, 0, hs_type))
 		return 0;
-DPRINTF("[SD] SD supports switch to (U)HS check\n");
+DPRINTF("[SD] supports switch to (U)HS mode\n");
 
 	u32 type_out = buf[16] & 0xF;
 	if (type_out != hs_type)
 		return 0;
-DPRINTF("[SD] SD supports selected (U)HS mode\n");
+DPRINTF("[SD] supports selected (U)HS mode\n");
 
-	if ((((u16)buf[0] << 8) | buf[1]) < 0x320)
+	u16 total_pwr_consumption = ((u16)buf[0] << 8) | buf[1];
+DPRINTF("[SD] total max current: %d\n", total_pwr_consumption);
+
+	if (total_pwr_consumption <= 800)
 	{
 		if (!_sd_storage_switch(storage, buf, SD_SWITCH_SET, 0, hs_type))
 			return 0;
 
 		if (type_out != (buf[16] & 0xF))
 			return 0;
-	}
 
-	return 1;
+		return 1;
+	}
+DPRINTF("[SD] card max current over limit\n");
+
+	return 0;
 }
 
 int _sd_storage_enable_uhs_low_volt(sdmmc_storage_t *storage, u32 type, u8 *buf)
 {
-	// Try to raise the current limit to let the card perform better.
-	_sd_storage_set_current_limit(storage, buf);
-
 	if (sdmmc_get_bus_width(storage->sdmmc) != SDMMC_BUS_WIDTH_4)
 		return 0;
 
@@ -870,32 +908,55 @@ int _sd_storage_enable_uhs_low_volt(sdmmc_storage_t *storage, u32 type, u8 *buf)
 		return 0;
 	//gfx_hexdump(0, (u8 *)buf, 64);
 
+	u8  access_mode = buf[13];
+	u16 current_limit = buf[7] | buf[6] << 8;
+
+	// Try to raise the current limit to let the card perform better.
+	_sd_storage_set_current_limit(storage, current_limit, buf);
+
 	u32 hs_type = 0;
 	switch (type)
 	{
-	case 11: // SDR104.
+	case SDHCI_TIMING_UHS_SDR104:
+	case SDHCI_TIMING_UHS_SDR82:
 		// Fall through if not supported.
-		if (buf[13] & SD_MODE_UHS_SDR104)
+		if (access_mode & SD_MODE_UHS_SDR104)
 		{
-			type = 11;
 			hs_type = UHS_SDR104_BUS_SPEED;
 DPRINTF("[SD] bus speed set to SDR104\n");
-			storage->csd.busspeed = 104;
+			switch (type)
+			{
+			case SDHCI_TIMING_UHS_SDR104:
+				storage->csd.busspeed = 104;
+				break;
+			case SDHCI_TIMING_UHS_SDR82:
+				storage->csd.busspeed = 82;
+				break;
+			}
 			break;
 		}
-	case 10: // SDR50.
+	case SDHCI_TIMING_UHS_SDR50:
-		if (buf[13] & SD_MODE_UHS_SDR50)
+		if (access_mode & SD_MODE_UHS_SDR50)
 		{
-			type = 10;
+			type = SDHCI_TIMING_UHS_SDR50;
 			hs_type = UHS_SDR50_BUS_SPEED;
 DPRINTF("[SD] bus speed set to SDR50\n");
 			storage->csd.busspeed = 50;
 			break;
 		}
-	case 8: // SDR12.
+	case SDHCI_TIMING_UHS_SDR25:
-		if (!(buf[13] & SD_MODE_UHS_SDR12))
+		if (access_mode & SD_MODE_UHS_SDR25)
+		{
+			type = SDHCI_TIMING_UHS_SDR25;
+			hs_type = UHS_SDR50_BUS_SPEED;
+DPRINTF("[SD] bus speed set to SDR25\n");
+			storage->csd.busspeed = 25;
+			break;
+		}
+	case SDHCI_TIMING_UHS_SDR12:
+		if (!(access_mode & SD_MODE_UHS_SDR12))
 			return 0;
-		type = 8;
+		type = SDHCI_TIMING_UHS_SDR12;
 		hs_type = UHS_SDR12_BUS_SPEED;
 DPRINTF("[SD] bus speed set to SDR12\n");
 		storage->csd.busspeed = 12;
@@ -907,11 +968,11 @@ DPRINTF("[SD] bus speed set to SDR12\n");
 
 	if (!_sd_storage_enable_highspeed(storage, hs_type, buf))
 		return 0;
-DPRINTF("[SD] SD card accepted UHS\n");
+DPRINTF("[SD] card accepted UHS\n");
 	if (!sdmmc_setup_clock(storage->sdmmc, type))
 		return 0;
 DPRINTF("[SD] setup clock\n");
-	if (!sdmmc_config_tuning(storage->sdmmc, type, MMC_SEND_TUNING_BLOCK))
+	if (!sdmmc_tuning_execute(storage->sdmmc, type, MMC_SEND_TUNING_BLOCK))
 		return 0;
 DPRINTF("[SD] config tuning\n");
 	return _sdmmc_storage_check_status(storage);
@@ -922,16 +983,23 @@ int _sd_storage_enable_hs_high_volt(sdmmc_storage_t *storage, u8 *buf)
 	if (!_sd_storage_switch_get(storage, buf))
 		return 0;
 	//gfx_hexdump(0, (u8 *)buf, 64);
-	if (!(buf[13] & SD_MODE_HIGH_SPEED))
+
+	u8  access_mode = buf[13];
+	u16 current_limit = buf[7] | buf[6] << 8;
+
+	// Try to raise the current limit to let the card perform better.
+	_sd_storage_set_current_limit(storage, current_limit, buf);
+
+	if (!(access_mode & SD_MODE_HIGH_SPEED))
 		return 1;
 
-	if (!_sd_storage_enable_highspeed(storage, 1, buf))
+	if (!_sd_storage_enable_highspeed(storage, HIGH_SPEED_BUS_SPEED, buf))
 		return 0;
 
 	if (!_sdmmc_storage_check_status(storage))
 		return 0;
 
-	return sdmmc_setup_clock(storage->sdmmc, 7);
+	return sdmmc_setup_clock(storage->sdmmc, SDHCI_TIMING_SD_HS25);
 }
 
 static void _sd_storage_parse_ssr(sdmmc_storage_t *storage)
@@ -1055,6 +1123,23 @@ static void _sd_storage_parse_csd(sdmmc_storage_t *storage)
 	}
 }
 
+static bool _sdmmc_storage_supports_low_voltage(u32 bus_width, u32 type)
+{
+	switch (type)
+	{
+	case SDHCI_TIMING_UHS_SDR12:
+	case SDHCI_TIMING_UHS_SDR25:
+	case SDHCI_TIMING_UHS_SDR50:
+	case SDHCI_TIMING_UHS_SDR104:
+	case SDHCI_TIMING_UHS_SDR82:
+	case SDHCI_TIMING_UHS_DDR50:
+		if (bus_width == SDMMC_BUS_WIDTH_4)
+			return true;
+	default:
+		return false;
+	}
+}
+
 void sdmmc_storage_init_wait_sd()
 {
 	u32 sd_poweroff_time = (u32)get_tmr_ms() - sd_power_cycle_time_start;
@@ -1062,7 +1147,7 @@ void sdmmc_storage_init_wait_sd()
 		msleep(100 - sd_poweroff_time);
 }
 
-int sdmmc_storage_init_sd(sdmmc_storage_t *storage, sdmmc_t *sdmmc, u32 id, u32 bus_width, u32 type)
+int sdmmc_storage_init_sd(sdmmc_storage_t *storage, sdmmc_t *sdmmc, u32 bus_width, u32 type)
 {
 	int is_version_1 = 0;
 	u8 *buf = (u8 *)SDMMC_UPPER_BUFFER;
@@ -1073,7 +1158,7 @@ int sdmmc_storage_init_sd(sdmmc_storage_t *storage, sdmmc_t *sdmmc, u32 id, u32
 	memset(storage, 0, sizeof(sdmmc_storage_t));
 	storage->sdmmc = sdmmc;
 
-	if (!sdmmc_init(sdmmc, id, SDMMC_POWER_3_3, SDMMC_BUS_WIDTH_1, 5, 0))
+	if (!sdmmc_init(sdmmc, SDMMC_1, SDMMC_POWER_3_3, SDMMC_BUS_WIDTH_1, SDHCI_TIMING_SD_ID, SDMMC_AUTO_CAL_DISABLE))
 		return 0;
 DPRINTF("[SD] after init\n");
 
@@ -1088,7 +1173,9 @@ DPRINTF("[SD] went to idle state\n");
 		return 0;
 DPRINTF("[SD] after send if cond\n");
 
-	if (!_sd_storage_get_op_cond(storage, is_version_1, bus_width == SDMMC_BUS_WIDTH_4 && type == 11))
+	bool supports_low_voltage = _sdmmc_storage_supports_low_voltage(bus_width, type);
+
+	if (!_sd_storage_get_op_cond(storage, is_version_1, supports_low_voltage))
 		return 0;
 DPRINTF("[SD] got op cond\n");
 
@@ -1122,7 +1209,7 @@ DPRINTF("[SD] unknown CSD structure %d\n", storage->csd.structure);
 
 	if (!storage->is_low_voltage)
 	{
-		if (!sdmmc_setup_clock(storage->sdmmc, 6))
+		if (!sdmmc_setup_clock(storage->sdmmc, SDHCI_TIMING_SD_DS12))
 			return 0;
 DPRINTF("[SD] after setup clock\n");
 	}
@@ -1165,18 +1252,26 @@ DPRINTF("[SD] SD does not support wide bus width\n");
 		if (!_sd_storage_enable_uhs_low_volt(storage, type, buf))
 			return 0;
 DPRINTF("[SD] enabled UHS\n");
+
+		sdmmc_card_clock_ctrl(sdmmc, SDMMC_AUTO_CAL_ENABLE);
 	}
-	else if (type != 6 && (storage->scr.sda_vsn & 0xF) != 0)
+	else if (type != SDHCI_TIMING_SD_DS12 && (storage->scr.sda_vsn & 0xF) != 0)
 	{
 		if (!_sd_storage_enable_hs_high_volt(storage, buf))
 			return 0;
 
 DPRINTF("[SD] enabled HS\n");
-		storage->csd.busspeed = 25;
+		switch (bus_width)
+		{
+		case SDMMC_BUS_WIDTH_4:
+			storage->csd.busspeed = 25;
+			break;
+		case SDMMC_BUS_WIDTH_1:
+			storage->csd.busspeed = 6;
+			break;
+		}
 	}
 
-	sdmmc_sd_clock_ctrl(sdmmc, 1);
-
 	// Parse additional card info from sd status.
 	if (_sd_storage_get_ssr(storage, buf))
 	{
@@ -1222,17 +1317,17 @@ int sdmmc_storage_init_gc(sdmmc_storage_t *storage, sdmmc_t *sdmmc)
 	memset(storage, 0, sizeof(sdmmc_storage_t));
 	storage->sdmmc = sdmmc;
 
-	if (!sdmmc_init(sdmmc, SDMMC_2, SDMMC_POWER_1_8, SDMMC_BUS_WIDTH_8, 14, 0))
+	if (!sdmmc_init(sdmmc, SDMMC_2, SDMMC_POWER_1_8, SDMMC_BUS_WIDTH_8, SDHCI_TIMING_MMC_DDR52, SDMMC_AUTO_CAL_DISABLE))
 		return 0;
 DPRINTF("[gc] after init\n");
 
 	usleep(1000 + (10000 + sdmmc->divisor - 1) / sdmmc->divisor);
 
-	if (!sdmmc_config_tuning(storage->sdmmc, 14, MMC_SEND_TUNING_BLOCK_HS200))
+	if (!sdmmc_tuning_execute(storage->sdmmc, SDHCI_TIMING_MMC_DDR52, MMC_SEND_TUNING_BLOCK_HS200))
 		return 0;
 DPRINTF("[gc] after tuning\n");
 
-	sdmmc_sd_clock_ctrl(sdmmc, 1);
+	sdmmc_card_clock_ctrl(sdmmc, SDMMC_AUTO_CAL_ENABLE);
 
 	return 1;
 }

source/storage/sdmmc.h

@@ -21,7 +21,17 @@
 #include "../utils/types.h"
 #include "sdmmc_driver.h"
 
-u32 sd_power_cycle_time_start;
+extern u32 sd_power_cycle_time_start;
+
+typedef enum _sdmmc_type
+{
+	MMC_SD   = 0,
+	MMC_EMMC = 1,
+
+	EMMC_GPP   = 0,
+	EMMC_BOOT0 = 1,
+	EMMC_BOOT1 = 2
+} sdmmc_type;
 
 typedef struct _mmc_cid
 {
@@ -107,10 +117,10 @@ typedef struct _sdmmc_storage_t
 int sdmmc_storage_end(sdmmc_storage_t *storage);
 int sdmmc_storage_read(sdmmc_storage_t *storage, u32 sector, u32 num_sectors, void *buf);
 int sdmmc_storage_write(sdmmc_storage_t *storage, u32 sector, u32 num_sectors, void *buf);
-int sdmmc_storage_init_mmc(sdmmc_storage_t *storage, sdmmc_t *sdmmc, u32 id, u32 bus_width, u32 type);
+int sdmmc_storage_init_mmc(sdmmc_storage_t *storage, sdmmc_t *sdmmc, u32 bus_width, u32 type);
 int sdmmc_storage_set_mmc_partition(sdmmc_storage_t *storage, u32 partition);
 void sdmmc_storage_init_wait_sd();
-int sdmmc_storage_init_sd(sdmmc_storage_t *storage, sdmmc_t *sdmmc, u32 id, u32 bus_width, u32 type);
+int sdmmc_storage_init_sd(sdmmc_storage_t *storage, sdmmc_t *sdmmc, u32 bus_width, u32 type);
 int sdmmc_storage_init_gc(sdmmc_storage_t *storage, sdmmc_t *sdmmc);
 
 #endif

source/storage/sdmmc_driver.h

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2018 naehrwert
+ * Copyright (c) 2018-2019 CTCaer
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -49,24 +50,158 @@
 #define SDMMC_MASKINT_NOERROR -1
 #define SDMMC_MASKINT_ERROR   -2
 
-/*! SDMMC host control 2 */
+/*! SDMMC present state. */
-#define SDHCI_CTRL_UHS_MASK			0xFFF8
+#define SDHCI_CMD_INHIBIT      0x1
-#define SDHCI_CTRL_VDD_330			0xFFF7
+#define SDHCI_DATA_INHIBIT     0x2
-#define SDHCI_CTRL_VDD_180			8
+#define SDHCI_DOING_WRITE      0x100
-#define SDHCI_CTRL_EXEC_TUNING		0x40
+#define SDHCI_DOING_READ       0x200
-#define SDHCI_CTRL_TUNED_CLK		0x80
+#define SDHCI_SPACE_AVAILABLE  0x400
-#define SDHCI_HOST_VERSION_4_EN		0x1000
+#define SDHCI_DATA_AVAILABLE   0x800
-#define SDHCI_ADDRESSING_64BIT_EN	0x2000
+#define SDHCI_CARD_PRESENT     0x10000
-#define SDHCI_CTRL_PRESET_VAL_EN	0x8000
+#define SDHCI_CD_STABLE        0x20000
+#define SDHCI_CD_LVL           0x40000
+#define SDHCI_WRITE_PROTECT    0x80000
+#define SDHCI_DATA_LVL_MASK    0xF00000
+#define  SDHCI_DATA_0_LVL_MASK 0x100000
+#define SDHCI_CMD_LVL          0x1000000
+
+/*! SDMMC transfer mode. */
+#define SDHCI_TRNS_DMA        0x01
+#define SDHCI_TRNS_BLK_CNT_EN 0x02
+#define SDHCI_TRNS_AUTO_CMD12 0x04
+#define SDHCI_TRNS_AUTO_CMD23 0x08
+#define SDHCI_TRNS_AUTO_SEL   0x0C
+#define SDHCI_TRNS_WRITE      0x00
+#define SDHCI_TRNS_READ       0x10
+#define SDHCI_TRNS_MULTI      0x20
+
+/*! SDMMC command. */
+#define SDHCI_CMD_RESP_MASK       0x3
+#define SDHCI_CMD_RESP_NO_RESP    0x0
+#define SDHCI_CMD_RESP_LEN136     0x1
+#define SDHCI_CMD_RESP_LEN48      0x2
+#define SDHCI_CMD_RESP_LEN48_BUSY 0x3
+#define SDHCI_CMD_CRC       0x08
+#define SDHCI_CMD_INDEX     0x10
+#define SDHCI_CMD_DATA      0x20
+#define SDHCI_CMD_ABORTCMD  0xC0
+
+/*! SDMMC host control. */
+#define SDHCI_CTRL_LED        0x01
+#define SDHCI_CTRL_4BITBUS    0x02
+#define SDHCI_CTRL_HISPD      0x04
+#define SDHCI_CTRL_DMA_MASK   0x18
+#define  SDHCI_CTRL_SDMA      0x00
+#define  SDHCI_CTRL_ADMA1     0x08
+#define  SDHCI_CTRL_ADMA32    0x10
+#define  SDHCI_CTRL_ADMA64    0x18
+#define  SDHCI_CTRL_8BITBUS   0x20
+#define SDHCI_CTRL_CDTEST_INS 0x40
+#define SDHCI_CTRL_CDTEST_EN  0x80
+
+/*! SDMMC host control 2. */
+#define SDHCI_CTRL_UHS_MASK       0xFFF8
+#define SDHCI_CTRL_VDD_180        8
+#define SDHCI_CTRL_DRV_TYPE_B     0x00
+#define SDHCI_CTRL_DRV_TYPE_A     0x10
+#define SDHCI_CTRL_DRV_TYPE_C     0x20
+#define SDHCI_CTRL_DRV_TYPE_D     0x30
+#define SDHCI_CTRL_EXEC_TUNING    0x40
+#define SDHCI_CTRL_TUNED_CLK      0x80
+#define SDHCI_HOST_VERSION_4_EN   0x1000
+#define SDHCI_ADDRESSING_64BIT_EN 0x2000
+#define SDHCI_CTRL_PRESET_VAL_EN  0x8000
+
+/*! SDMMC power control. */
+#define SDHCI_POWER_ON   0x01
+#define SDHCI_POWER_180  0x0A
+#define SDHCI_POWER_300  0x0C
+#define SDHCI_POWER_330  0x0E
+#define SDHCI_POWER_MASK 0xF1
+
+// /*! SDMMC max current. */
+// #define SDHCI_MAX_CURRENT_330_MASK   0xFF
+// #define SDHCI_MAX_CURRENT_180_MASK   0xFF0000
+// #define SDHCI_MAX_CURRENT_MULTIPLIER 4
+
+/*! SDMMC clock control. */
+#define SDHCI_DIVIDER_SHIFT    8
+#define SDHCI_DIVIDER_HI_SHIFT 6
+#define SDHCI_DIV_MASK         0xFF00
+#define SDHCI_DIV_HI_MASK      0xC0
+#define SDHCI_PROG_CLOCK_MODE  0x20
+#define SDHCI_CLOCK_CARD_EN    0x4
+#define SDHCI_CLOCK_INT_STABLE 0x2
+#define SDHCI_CLOCK_INT_EN     0x1
+
+/*! SDMMC software reset. */
+#define SDHCI_RESET_ALL  0x01
+#define SDHCI_RESET_CMD  0x02
+#define SDHCI_RESET_DATA 0x04
+
+/*! SDMMC interrupt status and control. */
+#define SDHCI_INT_RESPONSE     0x1
+#define SDHCI_INT_DATA_END     0x2
+#define SDHCI_INT_BLK_GAP      0x4
+#define SDHCI_INT_DMA_END      0x8
+#define SDHCI_INT_SPACE_AVAIL  0x10
+#define SDHCI_INT_DATA_AVAIL   0x20
+#define SDHCI_INT_CARD_INSERT  0x40
+#define SDHCI_INT_CARD_REMOVE  0x80
+#define SDHCI_INT_CARD_INT     0x100
+#define SDHCI_INT_RETUNE       0x1000
+#define SDHCI_INT_CQE          0x4000
+#define SDHCI_INT_ERROR        0x8000
+
+/*! SDMMC error interrupt status and control. */
+#define SDHCI_ERR_INT_TIMEOUT      0x1
+#define SDHCI_ERR_INT_CRC          0x2
+#define SDHCI_ERR_INT_END_BIT      0x4
+#define SDHCI_ERR_INT_INDEX        0x8
+#define SDHCI_ERR_INT_DATA_TIMEOUT 0x10
+#define SDHCI_ERR_INT_DATA_CRC     0x20
+#define SDHCI_ERR_INT_DATA_END_BIT 0x40
+#define SDHCI_ERR_INT_BUS_POWER    0x80
+#define SDHCI_ERR_INT_AUTO_CMD_ERR 0x100
+#define SDHCI_ERR_INT_ADMA_ERROR   0x200
+
+#define SDHCI_ERR_INT_ALL_EXCEPT_ADMA_BUSPWR \
+	(SDHCI_ERR_INT_AUTO_CMD_ERR | SDHCI_ERR_INT_DATA_END_BIT | \
+	 SDHCI_ERR_INT_DATA_CRC | SDHCI_ERR_INT_DATA_TIMEOUT | \
+	 SDHCI_ERR_INT_INDEX | SDHCI_ERR_INT_END_BIT | \
+	 SDHCI_ERR_INT_CRC | SDHCI_ERR_INT_TIMEOUT)
 
 /*! SD bus speeds. */
-#define UHS_SDR12_BUS_SPEED		0
+#define UHS_SDR12_BUS_SPEED  0
-#define HIGH_SPEED_BUS_SPEED	1
+#define HIGH_SPEED_BUS_SPEED 1
-#define UHS_SDR25_BUS_SPEED		1
+#define UHS_SDR25_BUS_SPEED  1
-#define UHS_SDR50_BUS_SPEED		2
+#define UHS_SDR50_BUS_SPEED  2
-#define UHS_SDR104_BUS_SPEED	3
+#define UHS_SDR104_BUS_SPEED 3
-#define UHS_DDR50_BUS_SPEED		4
+#define UHS_DDR50_BUS_SPEED  4
-#define HS400_BUS_SPEED 		5
+#define HS400_BUS_SPEED      5
+
+/*! SDMMC timmings. */
+#define SDHCI_TIMING_MMC_ID     0
+#define SDHCI_TIMING_MMC_LS26   1
+#define SDHCI_TIMING_MMC_HS52   2
+#define SDHCI_TIMING_MMC_HS200  3
+#define SDHCI_TIMING_MMC_HS400  4
+#define SDHCI_TIMING_SD_ID      5
+#define SDHCI_TIMING_SD_DS12    6
+#define SDHCI_TIMING_SD_HS25    7
+#define SDHCI_TIMING_UHS_SDR12  8
+#define SDHCI_TIMING_UHS_SDR25  9
+#define SDHCI_TIMING_UHS_SDR50  10
+#define SDHCI_TIMING_UHS_SDR104 11
+#define SDHCI_TIMING_UHS_SDR82  12 // SDR104 with a 163.2MHz -> 81.6MHz clock.
+#define SDHCI_TIMING_UHS_DDR50  13
+#define SDHCI_TIMING_MMC_DDR52  14
+
+#define SDHCI_CAN_64BIT 0x10000000
+
+/*! SDMMC Low power features. */
+#define SDMMC_AUTO_CAL_DISABLE 0
+#define SDMMC_AUTO_CAL_ENABLE  1
 
 /*! Helper for SWITCH command argument. */
 #define SDMMC_SWITCH(mode, index, value) (((mode) << 24) | ((index) << 16) | ((value) << 8))
@@ -78,8 +213,8 @@ typedef struct _sdmmc_t
 	u32 id;
 	u32 divisor;
 	u32 clock_stopped;
-	int no_sd;
+	int auto_cal_enabled;
-	int sd_clock_enabled;
+	int card_clock_enabled;
 	int venclkctl_set;
 	u32 venclkctl_tap;
 	u32 expected_rsp_type;
@@ -108,19 +243,20 @@ typedef struct _sdmmc_req_t
 	int is_auto_cmd12;
 } sdmmc_req_t;
 
-int sdmmc_get_voltage(sdmmc_t *sdmmc);
+int  sdmmc_get_io_power(sdmmc_t *sdmmc);
-u32 sdmmc_get_bus_width(sdmmc_t *sdmmc);
+u32  sdmmc_get_bus_width(sdmmc_t *sdmmc);
 void sdmmc_set_bus_width(sdmmc_t *sdmmc, u32 bus_width);
-void sdmmc_get_venclkctl(sdmmc_t *sdmmc);
+void sdmmc_set_tap_value(sdmmc_t *sdmmc);
-int sdmmc_setup_clock(sdmmc_t *sdmmc, u32 type);
+int  sdmmc_setup_clock(sdmmc_t *sdmmc, u32 type);
-void sdmmc_sd_clock_ctrl(sdmmc_t *sdmmc, int no_sd);
+void sdmmc_card_clock_ctrl(sdmmc_t *sdmmc, int auto_cal_enable);
-int sdmmc_get_rsp(sdmmc_t *sdmmc, u32 *rsp, u32 size, u32 type);
+int  sdmmc_get_rsp(sdmmc_t *sdmmc, u32 *rsp, u32 size, u32 type);
-int sdmmc_config_tuning(sdmmc_t *sdmmc, u32 type, u32 cmd);
+int  sdmmc_tuning_execute(sdmmc_t *sdmmc, u32 type, u32 cmd);
-int sdmmc_stop_transmission(sdmmc_t *sdmmc, u32 *rsp);
+int  sdmmc_stop_transmission(sdmmc_t *sdmmc, u32 *rsp);
-int sdmmc_init(sdmmc_t *sdmmc, u32 id, u32 power, u32 bus_width, u32 type, int no_sd);
+bool sdmmc_get_sd_inserted();
+int  sdmmc_init(sdmmc_t *sdmmc, u32 id, u32 power, u32 bus_width, u32 type, int auto_cal_enable);
 void sdmmc_end(sdmmc_t *sdmmc);
 void sdmmc_init_cmd(sdmmc_cmd_t *cmdbuf, u16 cmd, u32 arg, u32 rsp_type, u32 check_busy);
-int sdmmc_execute_cmd(sdmmc_t *sdmmc, sdmmc_cmd_t *cmd, sdmmc_req_t *req, u32 *blkcnt_out);
+int  sdmmc_execute_cmd(sdmmc_t *sdmmc, sdmmc_cmd_t *cmd, sdmmc_req_t *req, u32 *blkcnt_out);
-int sdmmc_enable_low_voltage(sdmmc_t *sdmmc);
+int  sdmmc_enable_low_voltage(sdmmc_t *sdmmc);
 
 #endif

source/storage/sdmmc_t210.h

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2018 naehrwert
+ * Copyright (c) 2018-2019 CTCaer
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -19,49 +20,14 @@
 
 #include "../utils/types.h"
 
-#define TEGRA_MMC_PWRCTL_SD_BUS_POWER 0x1
+#define TEGRA_MMC_VNDR_TUN_CTRL0_TAP_VAL_UPDATED_BY_HW 0x20000
-#define TEGRA_MMC_PWRCTL_SD_BUS_VOLTAGE_V1_8 0xA
+#define TEGRA_MMC_DLLCAL_CFG_EN_CALIBRATE 0x80000000
-#define TEGRA_MMC_PWRCTL_SD_BUS_VOLTAGE_V3_0 0xC
+#define TEGRA_MMC_DLLCAL_CFG_STATUS_DLL_ACTIVE 0x80000000
-#define TEGRA_MMC_PWRCTL_SD_BUS_VOLTAGE_V3_3 0xE
+#define TEGRA_MMC_SDMEMCOMPPADCTRL_PAD_E_INPUT_PWRD 0x80000000
-#define TEGRA_MMC_PWRCTL_SD_BUS_VOLTAGE_MASK 0xF1
+#define TEGRA_MMC_SDMEMCOMPPADCTRL_COMP_VREF_SEL_MASK 0xFFFFFFF0
-
+#define TEGRA_MMC_AUTOCALCFG_AUTO_CAL_ENABLE 0x20000000
-#define TEGRA_MMC_HOSTCTL_1BIT 0x00
+#define TEGRA_MMC_AUTOCALCFG_AUTO_CAL_START 0x80000000
-#define TEGRA_MMC_HOSTCTL_4BIT 0x02
+#define TEGRA_MMC_AUTOCALSTS_AUTO_CAL_ACTIVE 0x80000000
-#define TEGRA_MMC_HOSTCTL_8BIT 0x20
-
-#define TEGRA_MMC_CLKCON_INTERNAL_CLOCK_ENABLE 0x1
-#define TEGRA_MMC_CLKCON_INTERNAL_CLOCK_STABLE 0x2
-#define TEGRA_MMC_CLKCON_SD_CLOCK_ENABLE 0x4
-#define TEGRA_MMC_CLKCON_CLKGEN_SELECT 0x20
-
-#define TEGRA_MMC_SWRST_SW_RESET_FOR_ALL 0x1
-#define TEGRA_MMC_SWRST_SW_RESET_FOR_CMD_LINE 0x2
-#define TEGRA_MMC_SWRST_SW_RESET_FOR_DAT_LINE 0x4
-
-#define TEGRA_MMC_TRNMOD_DMA_ENABLE 0x1
-#define TEGRA_MMC_TRNMOD_BLOCK_COUNT_ENABLE 0x2
-#define TEGRA_MMC_TRNMOD_AUTO_CMD12 0x4
-#define TEGRA_MMC_TRNMOD_DATA_XFER_DIR_SEL_WRITE 0x0
-#define TEGRA_MMC_TRNMOD_DATA_XFER_DIR_SEL_READ 0x10
-#define TEGRA_MMC_TRNMOD_MULTI_BLOCK_SELECT 0x20
-
-#define TEGRA_MMC_TRNMOD_CMD_CRC_CHECK 0x8
-#define TEGRA_MMC_TRNMOD_CMD_INDEX_CHECK 0x10
-#define TEGRA_MMC_TRNMOD_DATA_PRESENT_SELECT_DATA_TRANSFER 0x20
-
-#define TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_MASK 0x3
-#define TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_NO_RESPONSE 0x0
-#define TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_LENGTH_136 0x1
-#define TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_LENGTH_48 0x2
-#define TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_LENGTH_48_BUSY 0x3
-
-#define TEGRA_MMC_NORINTSTS_CMD_COMPLETE 0x1
-#define TEGRA_MMC_NORINTSTS_XFER_COMPLETE 0x2
-#define TEGRA_MMC_NORINTSTS_DMA_INTERRUPT 0x8
-#define TEGRA_MMC_NORINTSTS_ERR_INTERRUPT 0x8000
-#define TEGRA_MMC_NORINTSTS_CMD_TIMEOUT 0x10000
-
-#define TEGRA_MMC_NORINTSTSEN_BUFFER_READ_READY 0x20
 
 typedef struct _t210_sdmmc_t
 {
@@ -77,56 +43,66 @@ typedef struct _t210_sdmmc_t
 	vu32 rspreg3;
 	vu32 bdata;
 	vu32 prnsts;
-	vu8 hostctl;
+	vu8  hostctl;
-	vu8 pwrcon;
+	vu8  pwrcon;
-	vu8 blkgap;
+	vu8  blkgap;
-	vu8 wakcon;
+	vu8  wakcon;
 	vu16 clkcon;
-	vu8 timeoutcon;
+	vu8  timeoutcon;
-	vu8 swrst;
+	vu8  swrst;
 	vu16 norintsts;
 	vu16 errintsts;
-	vu16 norintstsen;
+	vu16 norintstsen; // Enable irq status.
-	vu16 errintstsen;
+	vu16 errintstsen; // Enable irq status.
-	vu16 norintsigen;
+	vu16 norintsigen; // Enable irq signal to LIC/GIC.
-	vu16 errintsigen;
+	vu16 errintsigen; // Enable irq signal to LIC/GIC.
 	vu16 acmd12errsts;
 	vu16 hostctl2;
 	vu32 capareg;
 	vu32 capareg_1;
 	vu32 maxcurr;
-	vu8 res3[4];
+	vu8  rsvd0[4]; // 4C-4F reserved for more max current.
 	vu16 setacmd12err;
 	vu16 setinterr;
-	vu8 admaerr;
+	vu8  admaerr;
-	vu8 res4[3];
+	vu8  rsvd1[3]; // 55-57 reserved.
 	vu32 admaaddr;
 	vu32 admaaddr_hi;
-	vu8 res5[156];
+	vu8  rsvd2[156]; // 60-FB reserved.
-	vu16 slotintstatus;
+	vu16 slotintsts;
 	vu16 hcver;
 	vu32 venclkctl;
-	vu32 venspictl;
+	vu32 vensysswctl;
-	vu32 venspiintsts;
+	vu32 venerrintsts;
-	vu32 venceatactl;
+	vu32 vencapover;
 	vu32 venbootctl;
 	vu32 venbootacktout;
 	vu32 venbootdattout;
 	vu32 vendebouncecnt;
 	vu32 venmiscctl;
-	vu32 res6[34];
+	vu32 maxcurrover;
+	vu32 maxcurrover_hi;
+	vu32 unk0[32]; // 0x12C
 	vu32 veniotrimctl;
-	vu32 vendllcal;
+	vu32 vendllcalcfg;
-	vu8 res7[8];
+	vu32 vendllctl0;
-	vu32 dllcfgstatus;
+	vu32 vendllctl1;
+	vu32 vendllcalcfgsts;
 	vu32 ventunctl0;
-	vu32 field_1C4;
+	vu32 ventunctl1;
-	vu8 field_1C8[24];
+	vu32 ventunsts0;
+	vu32 ventunsts1;
+	vu32 venclkgatehystcnt;
+	vu32 venpresetval0;
+	vu32 venpresetval1;
+	vu32 venpresetval2;
 	vu32 sdmemcmppadctl;
 	vu32 autocalcfg;
 	vu32 autocalintval;
 	vu32 autocalsts;
 	vu32 iospare;
+	vu32 mcciffifoctl;
+	vu32 timeoutwcoal;
 } t210_sdmmc_t;
 
 #endif

source/tegraexplorer/common/common.h

@@ -21,9 +21,11 @@ enum utils_err_codes_te_call {
     ERR_EMMC_WRITE_FAILED,
     ERR_FILE_TOO_BIG_FOR_DEST,
     ERR_SD_EJECTED,
-    ERR_PARSE_FAIL,
+    ERR_SCRIPT_LOOKUP_FAIL,
     ERR_CANNOT_COPY_FILE_TO_FS_PART,
-    ERR_NO_DESTENATION
+    ERR_NO_DESTINATION,
+    ERR_INI_PARSE_FAIL,
+    ERR_IN_FUNC
 };
 
 extern const char *utils_err_codes_te[];
@@ -58,8 +60,7 @@ extern menu_entry mainmenu_shutdown[];
 enum mainmenu_tools_return {
     TOOLS_DISPLAY_INFO = 1,
     TOOLS_DISPLAY_GPIO,
-    TOOLS_DUMPFIRMWARE,
+    TOOLS_DUMPFIRMWARE
-    TOOLS_DUMPUSERSAVE
 };
 
 extern menu_entry mainmenu_tools[];
@@ -81,11 +82,13 @@ extern menu_entry utils_mmcChoice[];
 enum fs_menu_file_return {
     FILE_COPY = 4,
     FILE_MOVE,
+    FILE_RENAME,
     FILE_DELETE,
     FILE_PAYLOAD,
     FILE_SCRIPT,
     FILE_HEXVIEW,
-    FILE_DUMPBIS
+    FILE_DUMPBIS,
+    FILE_SIGN
 };
 
 extern menu_entry fs_menu_file[];
@@ -93,7 +96,9 @@ extern menu_entry fs_menu_file[];
 enum fs_menu_folder_return {
     DIR_EXITFOLDER = 2,
     DIR_COPYFOLDER,
-    DIR_DELETEFOLDER
+    DIR_DELETEFOLDER,
+    DIR_RENAME,
+    DIR_CREATE
 };
 
 extern menu_entry fs_menu_folder[];
@@ -111,3 +116,5 @@ extern gpt_entry_rule gpt_fs_rules[];
 extern menu_entry mmcmenu_start[];
 
 extern menu_entry mmcmenu_filemenu[];
+
+extern menu_entry fwDump_typeMenu[];

source/tegraexplorer/common/strings.c

@@ -50,9 +50,11 @@ const char *utils_err_codes_te[] = { // these start at 50
     "EMMC WRITE FAILED",
     "FILE TOO BIG FOR DEST",
     "SD EJECTED",
-    "PARSING FAILED",
+    "FUNC LOOKUP FAIL",
     "CANNOT COPY FILE TO FS PART",
-    "NO DESTENATION"
+    "NO DESTINATION",
+    "INI PARSE FAIL",
+    "ERR IN FUNC"
 };
 /*
 const char *pkg2names[] = {

source/tegraexplorer/common/structs.c

@@ -2,71 +2,74 @@
 #include "types.h"
 
 menu_entry mainmenu_main[] = {
-    {"[SD:/] SD CARD", COLOR_GREEN, ISMENU},
+    {"[SD:/] SD CARD", COLOR_GREEN, {ISMENU}},
-    {"[EMMC:/] EMMC", COLOR_ORANGE, ISMENU},
+    {"[EMMC:/] EMMC", COLOR_ORANGE, {ISMENU}},
-    {"[EMMC:/] EMUMMC", COLOR_BLUE, ISMENU},
+    {"[EMMC:/] EMUMMC", COLOR_BLUE, {ISMENU}},
-    {"\nMount/Unmount SD", COLOR_WHITE, ISMENU},
+    {"\nMount/Unmount SD", COLOR_WHITE, {ISMENU}},
-    {"Tools", COLOR_VIOLET, ISMENU},
+    {"Tools", COLOR_VIOLET, {ISMENU}},
-    {"SD format", COLOR_VIOLET, ISMENU},
+    {"SD format", COLOR_VIOLET, {ISMENU}},
-    {"\nCredits", COLOR_WHITE, ISMENU},
+    {"\nCredits", COLOR_WHITE, {ISMENU}},
-    {"Exit", COLOR_WHITE, ISMENU}
+    {"Exit", COLOR_WHITE, {ISMENU}}
 };
 
 menu_entry mainmenu_shutdown[] = {
-    {"Back", COLOR_WHITE, ISMENU},
+    {"Back", COLOR_WHITE, {ISMENU}},
-    {"\nReboot to RCM", COLOR_VIOLET, ISMENU},
+    {"\nReboot to RCM", COLOR_VIOLET, {ISMENU}},
-    {"Reboot normally", COLOR_ORANGE, ISMENU},
+    {"Reboot normally", COLOR_ORANGE, {ISMENU}},
-    {"Power off\n", COLOR_BLUE, ISMENU},
+    {"Power off\n", COLOR_BLUE, {ISMENU}},
-    {"Reboot to Hekate", COLOR_GREEN, ISMENU},
+    {"Reboot to Hekate", COLOR_GREEN, {ISMENU}},
-    {"Reboot to Atmosphere", COLOR_GREEN, ISMENU}
+    {"Reboot to Atmosphere", COLOR_GREEN, {ISMENU}}
 };
 
 menu_entry mainmenu_tools[] = {
-    {"Back", COLOR_WHITE, ISMENU},
+    {"Back", COLOR_WHITE, {ISMENU}},
-    {"\nDisplay Console Info", COLOR_GREEN, ISMENU},
+    {"\nDisplay Console Info", COLOR_GREEN, {ISMENU}},
-    {"Display GPIO pins", COLOR_VIOLET, ISMENU},
+    {"Display GPIO pins", COLOR_VIOLET, {ISMENU}},
-    {"Dump Firmware", COLOR_BLUE, ISMENU},
+    {"Dump Firmware", COLOR_BLUE, {ISMENU}}
-    {"Dump User Saves", COLOR_YELLOW, ISMENU}
 };
 
 menu_entry mainmenu_format[] = {
-    {"Back\n", COLOR_WHITE, ISMENU},
+    {"Back\n", COLOR_WHITE, {ISMENU}},
-    {"Format entire SD to FAT32", COLOR_RED, ISMENU},
+    {"Format entire SD to FAT32", COLOR_RED, {ISMENU}},
-    {"Format for EmuMMC setup (FAT32/RAW)", COLOR_RED, ISMENU}
+    {"Format for EmuMMC setup (FAT32/RAW)", COLOR_RED, {ISMENU}}
 };
 
 menu_entry utils_mmcChoice[] = {
-    {"Back\n", COLOR_WHITE, ISMENU},
+    {"Back\n", COLOR_WHITE, {ISMENU}},
-    {"SysMMC", COLOR_ORANGE, ISMENU},
+    {"SysMMC", COLOR_ORANGE, {ISMENU}},
-    {"EmuMMC", COLOR_BLUE, ISMENU}
+    {"EmuMMC", COLOR_BLUE, {ISMENU}}
 };
 
 menu_entry fs_menu_file[] = {
-    {NULL, COLOR_GREEN, ISMENU | ISSKIP},
+    {NULL, COLOR_GREEN, {ISMENU | ISSKIP}},
-    {NULL, COLOR_VIOLET, ISMENU | ISSKIP},
+    {NULL, COLOR_VIOLET, {ISMENU | ISSKIP}},
-    {NULL, COLOR_VIOLET, ISMENU | ISSKIP},
+    {NULL, COLOR_VIOLET, {ISMENU | ISSKIP}},
-    {"\n\n\nBack", COLOR_WHITE, ISMENU},
+    {"\n\n\nBack", COLOR_WHITE, {ISMENU}},
-    {"\nCopy to clipboard", COLOR_BLUE, ISMENU},
+    {"\nCopy to clipboard", COLOR_BLUE, {ISMENU}},
-    {"Move to clipboard", COLOR_BLUE, ISMENU},
+    {"Move to clipboard", COLOR_BLUE, {ISMENU}},
-    {"\nDelete file\n", COLOR_RED, ISMENU},
+    {"Rename file", COLOR_BLUE, {ISMENU}},
-    {"Launch Payload", COLOR_ORANGE, ISMENU},
+    {"\nDelete file\n", COLOR_RED, {ISMENU}},
-    {"Launch Script", COLOR_YELLOW, ISMENU},
+    {"Launch Payload", COLOR_ORANGE, {ISMENU}},
-    {"View Hex", COLOR_GREEN, ISMENU},
+    {"Launch Script", COLOR_YELLOW, {ISMENU}},
-    {"\nExtract BIS", COLOR_YELLOW, ISMENU}
+    {"View Hex", COLOR_GREEN, {ISMENU}},
+    {"\nExtract BIS", COLOR_YELLOW, {ISMENU}},
+    {"Sign Save", COLOR_ORANGE, {ISMENU}}
 };
 
 menu_entry fs_menu_folder[] = {
-    {NULL, COLOR_VIOLET, ISMENU | ISSKIP},
+    {NULL, COLOR_VIOLET, {ISMENU | ISSKIP}},
-    {"\nBack", COLOR_WHITE, ISMENU},
+    {"\nBack", COLOR_WHITE, {ISMENU}},
-    {"Return to main menu\n", COLOR_BLUE, ISMENU},
+    {"Return to main menu\n", COLOR_BLUE, {ISMENU}},
-    {"Copy to clipboard", COLOR_VIOLET, ISMENU},
+    {"Copy to clipboard", COLOR_VIOLET, {ISMENU}},
-    {"Delete folder", COLOR_RED, ISMENU}
+    {"Delete folder\n", COLOR_RED, {ISMENU}},
+    {"Rename folder", COLOR_BLUE, {ISMENU}},
+    {"Create folder", COLOR_BLUE, {ISMENU}}
 };
 
 menu_entry fs_menu_startdir[] = {
-    {"Folder -> previous folder  ", COLOR_ORANGE, ISMENU},
+    {"Folder -> previous folder  ", COLOR_ORANGE, {ISMENU}},
-    {"Clipboard -> Current folder", COLOR_ORANGE, ISMENU},
+    {"Clipboard -> Current folder", COLOR_ORANGE, {ISMENU}},
-    {"Current folder menu        ", COLOR_ORANGE, ISMENU}
+    {"Current folder menu        ", COLOR_ORANGE, {ISMENU}}
 };
 
 gpt_entry_rule gpt_fs_rules[] = {
@@ -78,15 +81,22 @@ gpt_entry_rule gpt_fs_rules[] = {
 };
 
 menu_entry mmcmenu_start[] = {
-    {"Back", COLOR_ORANGE, ISMENU},
+    {"Back", COLOR_ORANGE, {ISMENU}},
-    {"Dump File Partitions", COLOR_ORANGE, ISMENU},
+    {"Dump File Partitions", COLOR_ORANGE, {ISMENU}},
-    {"Clipboard -> Partition\n", COLOR_ORANGE, ISMENU},
+    {"Clipboard -> Partition\n", COLOR_ORANGE, {ISMENU}},
-    {"BOOT0/1", COLOR_BLUE, isBOOT | ISMENU}
+    {"BOOT0/1", COLOR_BLUE, {ISNULL | ISMENU}}
 };
 
 menu_entry mmcmenu_filemenu[] = {
-    {"Part:", COLOR_ORANGE, ISSKIP | ISMENU},
+    {"Part:", COLOR_ORANGE, {ISSKIP | ISMENU}},
-    {NULL, COLOR_VIOLET, ISSKIP | ISMENU},
+    {NULL, COLOR_VIOLET, {ISSKIP | ISMENU}},
-    {"\nBack", COLOR_WHITE, ISMENU},
+    {"\nBack", COLOR_WHITE, {ISMENU}},
-    {"Dump to SD", COLOR_YELLOW, ISMENU}
+    {"Dump to SD", COLOR_YELLOW, {ISMENU}}
+};
+
+menu_entry fwDump_typeMenu[] = {
+	{"Back\n", COLOR_WHITE, {ISMENU}},
+	{"Firmware format type:", COLOR_WHITE, {ISMENU | ISSKIP}},
+	{"Daybreak (prod.keys required!)", COLOR_BLUE, {ISMENU}},
+	{"ChoiNX", COLOR_VIOLET, {ISMENU}}
 };

source/tegraexplorer/common/types.h

@@ -1,17 +1,14 @@
 #pragma once
 #include "../../utils/types.h"
 
-#define ISDIR (1 << 0)
+#define BIT(n) (1U << n)
-#define ISARC (1 << 1)
 
-#define ISHIDE (1 << 8)
+#define ISDIR BIT(0)
-#define ISMENU (1 << 9)
+#define ISMENU BIT(1)
-#define ISSKIP (1 << 10)
+#define SETSIZE(x) (x << 2)
-
+#define ISNULL BIT(4)
-#define ISGB (1 << 7)
+#define ISHIDE BIT(5)
-#define ISMB (1 << 6)
+#define ISSKIP BIT(6)
-#define ISKB (1 << 5)
-#define ISB  (1 << 4)
 
 #define SETBIT(object, shift, value) ((value) ? (object |= shift) : (object &= ~shift))
 
@@ -26,7 +23,7 @@
 
 #define COPY_MODE_PRINT 0x1
 #define COPY_MODE_CANCEL 0x2
-#define BUFSIZE 32768
+#define BUFSIZE 65536 //32768
 
 #define OPERATIONCOPY 0x2
 #define OPERATIONMOVE 0x4
@@ -42,7 +39,17 @@
 typedef struct {
     char *name;
     u32 storage;
-    u16 property;
+    union {
+        u8 property;
+        struct {
+            u8 isDir:1;
+            u8 isMenu:1;
+            u8 size:2;
+            u8 isNull:1;
+            u8 isHide:1;
+            u8 isSkip:1;
+        };
+    };
 } menu_entry; 
 
 typedef struct {

source/tegraexplorer/emmc/emmc.c

@@ -4,7 +4,6 @@
 #include "../../utils/types.h"
 #include "../../libs/fatfs/ff.h"
 #include "../../utils/sprintf.h"
-#include "../../utils/btn.h"
 #include "../../gfx/gfx.h"
 #include "../../utils/util.h"
 #include "../../hos/pkg1.h"
@@ -100,7 +99,7 @@ void connect_mmc(short mmctype){
         h_cfg.emummc_force_disable = 0;
         switch (mmctype){
             case SYSMMC:
-                sdmmc_storage_init_mmc(&storage, &sdmmc, SDMMC_4, SDMMC_BUS_WIDTH_8, 4);
+                sdmmc_storage_init_mmc(&storage, &sdmmc, SDMMC_BUS_WIDTH_8, SDHCI_TIMING_MMC_HS400);
                 h_cfg.emummc_force_disable = 1;
                 currentlyMounted = SYSMMC;
                 break;
@@ -219,8 +218,6 @@ int dump_biskeys(){
     //sdmmc_storage_set_mmc_partition(&storage, 0);
     //nx_emmc_gpt_parse(&sys_gpt, &storage);
     
-    se_aes_key_set(8, bis_key[2] + 0x00, 0x10);
-    se_aes_key_set(9, bis_key[2] + 0x10, 0x10);
     
     pkg1inf.ver = pkg1_id->kb;
     strcpy(pkg1inf.id, pkg1_id->id);

source/tegraexplorer/emmc/emmcdumppart.c

@@ -8,7 +8,6 @@
 #include "../common/common.h"
 #include "../../libs/fatfs/ff.h"
 #include "../../utils/sprintf.h"
-#include "../../utils/btn.h"
 #include "../../mem/heap.h"
 #include "../../storage/nx_emmc.h"
 #include "../common/types.h"
@@ -46,7 +45,7 @@ int emmcDumpPart(char *path, sdmmc_storage_t *mmcstorage, emmc_part_t *part){
     f_lseek(&fp, 0);
 
     while (totalSectors > 0){
-        num = MIN(totalSectors, 64);
+        num = MIN(totalSectors, 128);
         if (!emummc_storage_read(mmcstorage, lba_curr, num, buf)){
             gfx_errDisplay("dump_emmc_part", ERR_EMMC_READ_FAILED, 3);
             return -1;
@@ -72,8 +71,8 @@ int existsCheck(char *path){
     int res = 0;
 
     if (fsutil_checkfile(path)){
-        gfx_printf("File already exists! Overwrite?\nVol +/- to cancel\n");
+        gfx_printf("File already exists! Overwrite?\nBto cancel\n");
-        res = gfx_makewaitmenu("Power to continue", 3);
+        res = gfx_makewaitmenu("A to continue", 3);
         gfx_printf("\r                 \r");
         return res;
     }

source/tegraexplorer/emmc/emmcmenu.c

@@ -3,7 +3,7 @@
 #include "../../mem/heap.h"
 #include "../../utils/types.h"
 #include "../../libs/fatfs/ff.h"
-#include "../../utils/btn.h"
+#include "../../hid/hid.h"
 #include "../../gfx/gfx.h"
 #include "../../utils/util.h"
 #include "../../storage/nx_emmc.h"
@@ -16,12 +16,12 @@
 #include "../../utils/list.h"
 #include "../../mem/heap.h"
 #include "emmcmenu.h"
-#include "../fs/fsreader.h"
 #include "../utils/utils.h"
 #include "../gfx/menu.h"
 #include "../fs/fsmenu.h"
 #include "emmcoperations.h"
 #include "../fs/fsutils.h"
+#include "../utils/menuUtils.h"
 
 menu_entry *mmcMenuEntries = NULL;
 extern sdmmc_storage_t storage;
@@ -30,21 +30,18 @@ extern char *clipboard;
 extern u8 clipboardhelper;
 
 
-void addEntry(emmc_part_t *part, u8 property, int spot){
+void addEntry(emmc_part_t *part, u8 property_GPT, int spot){
-    if (mmcMenuEntries[spot].name != NULL){
+    u32 storage = 0;
-        free(mmcMenuEntries[spot].name);
+    u8 property = 0;
-    }
 
-    utils_copystring(part->name, &mmcMenuEntries[spot].name);
+    if (property_GPT & isFS){
-
+        storage = (u32)(property_GPT & 0x7F);
-    if (property & isFS){
+        property = ISDIR;
-        mmcMenuEntries[spot].storage = (u32)(property & 0x7F);
-        mmcMenuEntries[spot].property = ISDIR;
     }
     else {
         u64 size = 0;
-        int sizes = 0;
+        u32 sizes = 0;
-        mmcMenuEntries[spot].property = 0;
+
         size = (u64)(part->lba_end + 1 - part->lba_start);
         size *= (u64)NX_EMMC_BLOCKSIZE;
 
@@ -54,31 +51,30 @@ void addEntry(emmc_part_t *part, u8 property, int spot){
         }
 
         if (sizes > 3)
-            sizes = 0;
+            sizes = 3;
 
-        mmcMenuEntries[spot].property |= (1 << (4 + sizes));
+        property |= SETSIZE(sizes);
-        mmcMenuEntries[spot].storage = (u32)size;
+        storage = (u32)size;
     }
+
+    mu_copySingle(part->name, storage, property, &mmcMenuEntries[spot]);
 }
 
 int fillMmcMenu(short mmcType){
     int count = 4, i;
 
     if (mmcMenuEntries != NULL)
-        clearfileobjects(&mmcMenuEntries);
+        mu_clearObjects(&mmcMenuEntries);
 
     link_t *gpt = selectGpt(mmcType);
 
     LIST_FOREACH_ENTRY(emmc_part_t, part, gpt, link)
         count++;
 
-    createfileobjects(count, &mmcMenuEntries);
+    mu_createObjects(count, &mmcMenuEntries);
 
-    for (i = 0; i < 4; i++){
+    for (i = 0; i < 4; i++)
-        utils_copystring(mmcmenu_start[i].name, &mmcMenuEntries[i].name);
+        mu_copySingle(mmcmenu_start[i].name, mmcmenu_start[i].storage, mmcmenu_start[i].property, &mmcMenuEntries[i]);
-        mmcMenuEntries[i].property = mmcmenu_start[i].property;
-        mmcMenuEntries[i].storage = mmcmenu_start[i].storage;
-    }
 
     LIST_FOREACH_ENTRY(emmc_part_t, part, gpt, link){
         addEntry(part, checkGptRules(part->name), i++);
@@ -99,10 +95,14 @@ int handleEntries(short mmcType, menu_entry part){
             fileexplorer("emmc:/", 1);  
     }
     else {
+        /*
         if (mmcmenu_filemenu[1].name != NULL)
             free(mmcmenu_filemenu[1].name);
                     
         utils_copystring(part.name, &mmcmenu_filemenu[1].name);
+        */
+
+        mu_copySingle(part.name, mmcmenu_filemenu[1].storage, mmcmenu_filemenu[1].property, &mmcmenu_filemenu[1]);
 
         if ((menu_make(mmcmenu_filemenu, 4, "-- RAW PARTITION --")) < 3)
             return 0;
@@ -112,7 +112,7 @@ int handleEntries(short mmcType, menu_entry part){
 
         gfx_clearscreen();
 
-        if (part.property & isBOOT){
+        if (part.isNull){
             res = emmcDumpBoot("sd:/tegraexplorer/partition_dumps");
         }
         else {
@@ -122,7 +122,7 @@ int handleEntries(short mmcType, menu_entry part){
 
         if (!res){
             gfx_printf("\nDone!");
-            btn_wait();
+            hidWait();
         }
     }
 
@@ -146,7 +146,7 @@ int makeMmcMenu(short mmcType){
                 f_mkdir("sd:/tegraexplorer/partition_dumps");
 
                 for (int i = 0; i < count; i++){
-                    if (mmcMenuEntries[i].property & ISMENU || mmcMenuEntries[i].property & ISDIR)
+                    if (mmcMenuEntries[i].property & (ISMENU | ISDIR))
                         continue;
 
                     //gfx_printf("Dumping %s...\n", mmcMenuEntries[i].name);
@@ -154,14 +154,14 @@ int makeMmcMenu(short mmcType){
                 }
 
                 gfx_printf("\nDone!");
-                btn_wait();
+                hidWait();
                 break;
             case 2:
                 if (!(clipboardhelper & ISDIR) && (clipboardhelper & OPERATIONCOPY)){
                     gfx_clearscreen();
-                    if (!mmcFlashFile(clipboard, mmcType)){
+                    if (!mmcFlashFile(clipboard, mmcType, true)){
                         gfx_printf("\nDone!");
-                        btn_wait();
+                        hidWait();
                     }   
                     clipboardhelper = 0;
                 }

source/tegraexplorer/emmc/emmcoperations.h

@@ -4,7 +4,7 @@
 
 int emmcDumpSpecific(char *part, char *path);
 int emmcDumpBoot(char *basePath);
-int mmcFlashFile(char *path, short mmcType);
+int mmcFlashFile(char *path, short mmcType, bool warnings);
 
 int emmcDumpPart(char *path, sdmmc_storage_t *mmcstorage, emmc_part_t *part);
-int emmcRestorePart(char *path, sdmmc_storage_t *mmcstorage, emmc_part_t *part);
+int emmcRestorePart(char *path, sdmmc_storage_t *mmcstorage, emmc_part_t *part, bool warnings);

source/tegraexplorer/emmc/emmcrestorepart.c

@@ -8,7 +8,6 @@
 #include "../common/common.h"
 #include "../../libs/fatfs/ff.h"
 #include "../../utils/sprintf.h"
-#include "../../utils/btn.h"
 #include "../../mem/heap.h"
 #include "../../storage/nx_emmc.h"
 #include "../common/types.h"
@@ -18,7 +17,7 @@
 extern sdmmc_storage_t storage;
 extern emmc_part_t *system_part;
 
-int emmcRestorePart(char *path, sdmmc_storage_t *mmcstorage, emmc_part_t *part){
+int emmcRestorePart(char *path, sdmmc_storage_t *mmcstorage, emmc_part_t *part, bool warnings){
     FIL fp;
     FILINFO fno;
     u8 *buf;
@@ -33,7 +32,7 @@ int emmcRestorePart(char *path, sdmmc_storage_t *mmcstorage, emmc_part_t *part){
 
     gfx_printf("Initializing\r");
 
-    buf = calloc(16384, sizeof(u8));
+    buf = calloc(BUFSIZE, sizeof(u8));
 
     if (!buf){
         gfx_errDisplay("restore_emmc_part", ERR_MEM_ALLOC_FAILED, 1);
@@ -55,12 +54,12 @@ int emmcRestorePart(char *path, sdmmc_storage_t *mmcstorage, emmc_part_t *part){
 
     gfx_printf("Flashing %s\n", part->name);
 
-    if (totalSize < totalSizeDest){
+    if (totalSize < totalSizeDest && warnings){
         SWAPCOLOR(COLOR_ORANGE);
-        gfx_printf("File is too small for destenation.\nDo you want to flash it anyway?\n\nVol +/- to Cancel\n");
+        gfx_printf("File is too small for destination.\nDo you want to flash it anyway?\n\nB to Cancel\n");
-        u8 btnres = gfx_makewaitmenu(
+        u32 btnres = gfx_makewaitmenu(
-            "Power to Confirm",
+            "A to Confirm",
-            2
+            3
         );
 
         RESETCOLOR;
@@ -79,7 +78,7 @@ int emmcRestorePart(char *path, sdmmc_storage_t *mmcstorage, emmc_part_t *part){
     }
 
     while (totalSectors > 0){
-        num = MIN(totalSectors, 32);
+        num = MIN(totalSectors, 128);
 
         if ((res = f_read(&fp, buf, num * NX_EMMC_BLOCKSIZE, NULL))){
             gfx_errDisplay("restore_emmc_part", res, 5);
@@ -210,18 +209,18 @@ emmc_part_t *mmcFindPart(char *path, short mmcType){
 
     //gfx_printf("Path: %s\nFilename: %s", path, filename);
     //btn_wait();
-    gfx_errDisplay("mmcFindPart", ERR_NO_DESTENATION, 2);
+    gfx_errDisplay("mmcFindPart", ERR_NO_DESTINATION, 2);
     free(path_local);
     return NULL;
 }
 
-int mmcFlashFile(char *path, short mmcType){
+int mmcFlashFile(char *path, short mmcType, bool warnings){
     emmc_part_t *part;
     int res;
 
     part = mmcFindPart(path, mmcType);
     if (part != NULL){
-        res = emmcRestorePart(path, &storage, part);
+        res = emmcRestorePart(path, &storage, part, warnings);
         emummc_storage_set_mmc_partition(&storage, 0);
         return res;
     }

source/tegraexplorer/fs/filemenu.c

@@ -2,7 +2,6 @@
 #include "entrymenu.h"
 #include "../common/common.h"
 #include "../../libs/fatfs/ff.h"
-#include "../../utils/btn.h"
 #include "../../gfx/gfx.h"
 #include "fsutils.h"
 #include "fsactions.h"
@@ -15,6 +14,9 @@
 #include "../../utils/sprintf.h"
 #include "../script/parser.h"
 #include "../emmc/emmcoperations.h"
+#include "../../hid/hid.h"
+#include "../utils/menuUtils.h"
+#include "savesign.h"
 
 extern char *currentpath;
 extern char *clipboard;
@@ -24,8 +26,8 @@ extern int launch_payload(char *path);
 int delfile(const char *path, const char *filename){
     gfx_clearscreen();
     SWAPCOLOR(COLOR_ORANGE);
-    gfx_printf("Are you sure you want to delete:\n%s\n\nPress vol+/- to cancel\n", filename);
+    gfx_printf("Are you sure you want to delete:\n%s\n\nPress B to cancel\n", filename);
-    if (gfx_makewaitmenu("Press power to delete", 3)){
+    if (gfx_makewaitmenu("Press A to delete", 2)){
         f_unlink(path);
         fsreader_readfolder(currentpath);
         return 0;
@@ -36,23 +38,27 @@ int delfile(const char *path, const char *filename){
 
 void viewbytes(char *path){
     FIL in;
-    u8 print[2048];
+    u8 *print;
     u32 size;
     QWORD offset = 0;
     int res;
+    Inputs *input = hidRead();
+
+    while (input->buttons & (KEY_POW | KEY_B))
+        hidRead();
 
     gfx_clearscreen();
+    print = malloc (1024);
+
     if ((res = f_open(&in, path, FA_READ | FA_OPEN_EXISTING))){
         gfx_errDisplay("viewbytes", res, 1);
         return;
     }
 
-    while (btn_read() & BTN_POWER);
-
     while (1){
         f_lseek(&in, offset * 16);
 
-        if ((res = f_read(&in, &print, 2048 * sizeof(u8), &size))){
+        if ((res = f_read(&in, print, 1024 * sizeof(u8), &size))){
             gfx_errDisplay("viewbytes", res, 2);
             return;
         }
@@ -60,19 +66,20 @@ void viewbytes(char *path){
         gfx_con_setpos(0, 31);
         gfx_hexdump(offset * 16, print, size * sizeof(u8));
 
-        res = btn_read();
+        input = hidRead();
 
-        if (!res)
+        if (!(input->buttons))
-            res = btn_wait();
+            input = hidWait();
 
-        if (res & BTN_VOL_DOWN && 2048 * sizeof(u8) == size)
+        if (input->Ldown && 1024 * sizeof(u8) == size)
             offset++;
-        if (res & BTN_VOL_UP && offset > 0)
+        if (input->Lup && offset > 0)
             offset--;
-        if (res & BTN_POWER)
+        if (input->buttons & (KEY_POW | KEY_B))
             break;
     }
     f_close(&in);
+    free(print);
 }
 
 void copyfile(const char *src_in, const char *outfolder){
@@ -115,40 +122,45 @@ void copyfile(const char *src_in, const char *outfolder){
 
 int filemenu(menu_entry file){
     int temp;
-    FILINFO attribs;
+    char *tempchar;
 
-    for (int i = 0; i < 3; i++)
+    /*
+    for (int i = 0; i < 2; i++)
         if (fs_menu_file[i].name != NULL)
             free(fs_menu_file[i].name);
     
     utils_copystring(file.name, &fs_menu_file[0].name);
+    */
+    mu_copySingle(file.name, fs_menu_file[0].storage, fs_menu_file[0].property, &fs_menu_file[0]);
+
+
+    if (fs_menu_file[1].name != NULL)
+        free(fs_menu_file[1].name);
+
     fs_menu_file[1].name = malloc(16);
-    fs_menu_file[2].name = malloc(16);
+    sprintf(fs_menu_file[1].name, "\nSize: %d %s", file.storage, gfx_file_size_names[file.size]);
 
-    for (temp = 4; temp < 8; temp++)
+    if ((tempchar = fsutil_formatFileAttribs(fsutil_getnextloc(currentpath, file.name))) == NULL)
-        if ((file.property & (1 << temp)))
+        fs_menu_file[2].isHide = 1;
-            break;
-
-    
-    sprintf(fs_menu_file[1].name, "\nSize: %d %s", file.storage, gfx_file_size_names[temp - 4]);
-
-    if (f_stat(fsutil_getnextloc(currentpath, file.name), &attribs))
-        SETBIT(fs_menu_file[2].property, ISHIDE, 1);
     else {
-        SETBIT(fs_menu_file[2].property, ISHIDE, 0);
+        fs_menu_file[2].isHide = 0;
-        sprintf(fs_menu_file[2].name, "Attribs: %c%c%c%c",
+        mu_copySingle(tempchar, fs_menu_file[2].storage, fs_menu_file[2].property, &fs_menu_file[2]);
-        (attribs.fattrib & AM_RDO) ? 'R' : '-',
-        (attribs.fattrib & AM_SYS) ? 'S' : '-',
-        (attribs.fattrib & AM_HID) ? 'H' : '-',
-        (attribs.fattrib & AM_ARC) ? 'A' : '-');
     }
 
-    SETBIT(fs_menu_file[7].property, ISHIDE, !(strstr(file.name, ".bin") != NULL && file.property & ISKB) && strstr(file.name, ".rom") == NULL);
+    fs_menu_file[6].isHide = !hidConnected();
-    SETBIT(fs_menu_file[8].property, ISHIDE, strstr(file.name, ".te") == NULL);
+    fs_menu_file[8].isHide = (!(strstr(file.name, ".bin") != NULL && file.size == 1) && strstr(file.name, ".rom") == NULL);
-    SETBIT(fs_menu_file[10].property, ISHIDE, strstr(file.name, ".bis") == NULL);
+    fs_menu_file[9].isHide = (strstr(file.name, ".te") == NULL);
+    fs_menu_file[11].isHide = (strstr(file.name, ".bis") == NULL);
+    fs_menu_file[12].isHide = (!!strcmp(currentpath, "emmc:/save"));
 
-    temp = menu_make(fs_menu_file, 11, "-- File Menu --");
+    /*
+    SETBIT(fs_menu_file[6].property, ISHIDE, !hidConnected());
+    SETBIT(fs_menu_file[8].property, ISHIDE, !(strstr(file.name, ".bin") != NULL && file.size == 1) && strstr(file.name, ".rom") == NULL);
+    SETBIT(fs_menu_file[9].property, ISHIDE, strstr(file.name, ".te") == NULL);
+    SETBIT(fs_menu_file[11].property, ISHIDE, strstr(file.name, ".bis") == NULL);
+    */
 
+    temp = menu_make(fs_menu_file, 13, "-- File Menu --");
     switch (temp){
         case FILE_COPY:
             fsreader_writeclipboard(fsutil_getnextloc(currentpath, file.name), OPERATIONCOPY);
@@ -159,11 +171,39 @@ int filemenu(menu_entry file){
         case FILE_DELETE:
             delfile(fsutil_getnextloc(currentpath, file.name), file.name);
             break;
+        case FILE_RENAME:;
+            char *name, *curPath;
+            gfx_clearscreen();
+            gfx_printf("Renaming %s...\n\n", file.name);
+            name = utils_InputText(file.name, 39);
+            if (name == NULL)
+                break;
+            
+            utils_copystring(fsutil_getnextloc(currentpath, file.name), &curPath);
+
+            temp = f_rename(curPath, fsutil_getnextloc(currentpath, name));
+            
+            free(curPath);
+            free(name);
+
+            if (temp){
+                gfx_errDisplay("fileMenu", temp, 0);
+                break;
+            }
+
+            fsreader_readfolder(currentpath);
+            break;
         case FILE_PAYLOAD:
             launch_payload(fsutil_getnextloc(currentpath, file.name));
             break;
         case FILE_SCRIPT:
             //ParseScript(fsutil_getnextloc(currentpath, file.name));
+            /*
+            gfx_printf(" %kRelease any buttons if held!", COLOR_RED);
+
+            while (hidRead()->buttons);
+            */
+
             runScript(fsutil_getnextloc(currentpath, file.name));
             fsreader_readfolder(currentpath);
             break;
@@ -174,7 +214,18 @@ int filemenu(menu_entry file){
             gfx_clearscreen();
             extract_bis_file(fsutil_getnextloc(currentpath, file.name), currentpath);
             fsreader_readfolder(currentpath);
-            btn_wait();
+            hidWait();
+            break;
+        case FILE_SIGN:
+            if (gfx_defaultWaitMenu("WARNING!\n\nThis should only be used if you know what signing and a save is\nDo not do this if you don't know what this does\n\nRequires you to have a prod.keys located in the switch folder\n", 5)){
+                gfx_clearscreen();
+                gfx_printf("Signing save...\n");
+                if (save_sign("sd:/switch/prod.keys", fsutil_getnextloc(currentpath, file.name))){
+                    gfx_printf("Done!\nPress any key to exit");
+                    hidWait();
+                }
+            }
+
             break;
         case -1:
             return -1;

source/tegraexplorer/fs/foldermenu.c

@@ -9,6 +9,9 @@
 #include "fsactions.h"
 #include "fsutils.h"
 #include "../../utils/sprintf.h"
+#include "../utils/utils.h"
+#include "../../hid/hid.h"
+#include "../utils/menuUtils.h"
 
 extern char *currentpath;
 extern char *clipboard;
@@ -38,18 +41,24 @@ void copyfolder(char *in, char *out){
 }
 
 int foldermenu(){
-    int res;
+    int res, hidConn;
-    FILINFO attribs;
+    char *name;
 
-    if (fs_menu_folder[0].name != NULL)
+    hidConn = hidConnected();
-        free(fs_menu_folder[0].name);
-
-    fs_menu_folder[0].name = malloc(16);
 
     res = strlen(currentpath);
 
+    fs_menu_folder[3].isHide = (*(currentpath + res - 1) == '/');
+    fs_menu_folder[4].isHide = (*(currentpath + res - 1) == '/');
+    fs_menu_folder[5].isHide = (*(currentpath + res - 1) == '/' || !hidConn);
+    fs_menu_folder[6].isHide = !hidConn;
+
+    /*
+
     SETBIT(fs_menu_folder[3].property, ISHIDE, (*(currentpath + res - 1) == '/'));
     SETBIT(fs_menu_folder[4].property, ISHIDE, (*(currentpath + res - 1) == '/'));
+    SETBIT(fs_menu_folder[5].property, ISHIDE, (*(currentpath + res - 1) == '/') || !hidConn);
+    SETBIT(fs_menu_folder[6].property, ISHIDE, !hidConn);
     
     if (f_stat(currentpath, &attribs))
         SETBIT(fs_menu_folder[0].property, ISHIDE, 1);
@@ -61,8 +70,19 @@ int foldermenu(){
         (attribs.fattrib & AM_HID) ? 'H' : '-',
         (attribs.fattrib & AM_ARC) ? 'A' : '-');
     }
+    */
 
-    res = menu_make(fs_menu_folder, 5, currentpath);
+    if ((name = fsutil_formatFileAttribs(currentpath)) == NULL){
+        fs_menu_folder[0].isHide = 1;
+    }
+    else {
+        fs_menu_folder[0].isHide = 0;
+        mu_copySingle(name, fs_menu_folder[0].storage, fs_menu_folder[0].property, &fs_menu_folder[0]);
+    }
+
+
+
+    res = menu_make(fs_menu_folder, 7, currentpath);
 
     switch (res){
         case DIR_EXITFOLDER:
@@ -73,8 +93,7 @@ int foldermenu(){
             break;
         case DIR_DELETEFOLDER:
             gfx_clearscreen();
-            gfx_printf("Do you want to delete this folder?\nThe entire folder, with all subcontents\n     will be deleted!!!\n\nPress vol+/- to cancel\n");
+            if (gfx_defaultWaitMenu("Do you want to delete this folder?\nThe entire folder, with all subcontents will be deleted!", 2)){
-            if (gfx_makewaitmenu("Press power to contine...", 3)){
                 gfx_clearscreen();
                 gfx_printf("\nDeleting folder, please wait...\n");
 
@@ -84,6 +103,49 @@ int foldermenu(){
                 fsreader_readfolder(currentpath);
             }
             break;
+        case DIR_RENAME:;
+            char *prevLoc, *dirName;
+
+            dirName = strrchr(currentpath, '/') + 1;
+
+            gfx_clearscreen();
+            gfx_printf("Renaming %s...\n\n", dirName); 
+            name = utils_InputText(dirName, 39);
+            if (name == NULL)
+                break;
+            
+            utils_copystring(fsutil_getprevloc(currentpath), &prevLoc);
+            res = f_rename(currentpath, fsutil_getnextloc(prevLoc, name));
+
+            free(prevLoc);
+            free(name);
+
+            if (res){
+                gfx_errDisplay("folderMenu", res, 1);
+                break;
+            }
+
+            fsreader_writecurpath(fsutil_getprevloc(currentpath));
+            fsreader_readfolder(currentpath);
+
+            break;
+        case DIR_CREATE:;
+            gfx_clearscreen();
+            gfx_printf("Give a name for your new folder\n\n");
+            name = utils_InputText("New Folder", 39);
+            if (name == NULL)
+                break;
+
+            res = f_mkdir(fsutil_getnextloc(currentpath, name));
+            free(name);
+
+            if (res){
+                gfx_errDisplay("folderMenu", res, 1);
+                break;
+            }
+
+            fsreader_readfolder(currentpath);
+            break;
     }
 
     return 0;

source/tegraexplorer/fs/fsactions.c

@@ -7,16 +7,16 @@
 #include "../gfx/gfxutils.h"
 #include "../utils/utils.h"
 #include "../../mem/heap.h"
+#include "../../hid/hid.h"
 #include "../../utils/btn.h"
 #include "fsutils.h"
 
 int fsact_copy(const char *locin, const char *locout, u8 options){
     FIL in, out;
     FILINFO in_info;
-    u64 sizeoffile, sizecopied = 0, totalsize;
+    u64 sizeRemaining, toCopy;
-    UINT temp1, temp2;
+    u8 *buff, toPrint = options & COPY_MODE_PRINT, toCancel = options & COPY_MODE_CANCEL;
-    u8 *buff;
+    u32 x, y, i = 11;
-    unsigned int x, y, i = 0;
     int res;
 
     gfx_con_getpos(&x, &y);
@@ -31,64 +31,73 @@ int fsact_copy(const char *locin, const char *locout, u8 options){
         return 1;
     }
 
-    if (f_stat(locin, &in_info)){
+    if ((res = f_stat(locin, &in_info))){
         gfx_errDisplay("copy", res, 3);
         return 1;
     }
        
-    if (f_open(&out, locout, FA_CREATE_ALWAYS | FA_WRITE)){
+    if ((res = f_open(&out, locout, FA_CREATE_ALWAYS | FA_WRITE))){
         gfx_errDisplay("copy", res, 4);
         return 1;
     }
 
+    if (toPrint){
+        SWAPCOLOR(COLOR_GREEN);
+        gfx_printf("[    ]");
+        x += 16;
+        gfx_con_setpos(x, y);
+    }
+
     buff = malloc (BUFSIZE);
-    sizeoffile = f_size(&in);
+    sizeRemaining = f_size(&in);
-    totalsize = sizeoffile;
+    const u64 totalsize = sizeRemaining;
 
-    while (sizeoffile > 0){
+    while (sizeRemaining > 0){
-        if ((res = f_read(&in, buff, (sizeoffile > BUFSIZE) ? BUFSIZE : sizeoffile, &temp1))){
+        toCopy = MIN(sizeRemaining, BUFSIZE);
+
+        if ((res = f_read(&in, buff, toCopy, NULL))){
             gfx_errDisplay("copy", res, 5);
-            return 1;
+            break;
         }
             
-        if ((res = f_write(&out, buff, (sizeoffile > BUFSIZE) ? BUFSIZE : sizeoffile, &temp2))){
+        if ((res = f_write(&out, buff, toCopy, NULL))){
             gfx_errDisplay("copy", res, 6);
-            return 1;
+            break;
         }
 
-        if (temp1 != temp2){
+        sizeRemaining -= toCopy;
-            gfx_errDisplay("copy", ERR_DISK_WRITE_FAILED, 7);
-            return 1;
-        }
 
-        sizeoffile -= temp1;
+        if (toPrint && (i > 16 || !sizeRemaining)){
-        sizecopied += temp1;
+            gfx_printf("%3d%%",  (u32)(((totalsize - sizeRemaining) * 100) / totalsize));
-
-        if (options & COPY_MODE_PRINT && 10 > i++){
-            gfx_printf("%k[%d%%]%k", COLOR_GREEN, ((sizecopied * 100) / totalsize) ,COLOR_WHITE);
             gfx_con_setpos(x, y);
-            
-            i = 0;
-
-            if (options & COPY_MODE_CANCEL)
-                if (btn_read() & BTN_VOL_DOWN){
-                    f_unlink(locout);
-                    break;
-                }
         }
+
+        if (toCancel && i > 16){
+            if (btn_read() & (BTN_VOL_DOWN | BTN_VOL_UP)){
+                f_unlink(locout);
+                break;
+            }
+        }
+
+        if (options){
+            if (i++ > 16)
+                i = 0;
+        }
+    }
+
+    if (toPrint){
+        RESETCOLOR;
+        gfx_con_setpos(x - 16, y);
     }
 
     f_close(&in);
     f_close(&out);
     free(buff);
 
-    if ((res = f_chmod(locout, in_info.fattrib, 0x3A))){
+    f_chmod(locout, in_info.fattrib, 0x3A);
-        gfx_errDisplay("copy", res, 8);
-        return 1;
-    }
 
     f_stat(locin, &in_info); //somehow stops fatfs from being weird
-    return 0;
+    return res;
 }
 
 int fsact_del_recursive(char *path){
@@ -113,7 +122,7 @@ int fsact_del_recursive(char *path){
         else {
             SWAPCOLOR(COLOR_RED);
             gfx_printf("\r");
-            gfx_printandclear(fno.fname, 37);
+            gfx_printandclear(fno.fname, 37, 720);
 
             if ((res = f_unlink(fsutil_getnextloc(localpath, fno.fname)))){
                 gfx_errDisplay("del_recursive", res, 2);
@@ -160,7 +169,7 @@ int fsact_copy_recursive(char *path, char *dstpath){
         else {
             SWAPCOLOR(COLOR_GREEN);
             gfx_printf("\r");
-            gfx_printandclear(fno.fname, 37);
+            gfx_printandclear(fno.fname, 37, 720);
 
             utils_copystring(fsutil_getnextloc(startpath, fno.fname), &temp);
 

source/tegraexplorer/fs/fsextractbis.c

@@ -7,32 +7,21 @@
 #include "../common/common.h"
 #include "../../libs/fatfs/ff.h"
 #include "../../utils/sprintf.h"
-#include "../../utils/btn.h"
 #include "../../mem/heap.h"
 #include "../../storage/nx_emmc.h"
 #include "../common/types.h"
 #include "../utils/utils.h"
 #include "fsactions.h"
 
-u32 DecodeInt(u8* data) {
-    u32 out = 0;
-
-    for (int i = 0; i < 4; i++) {
-        out |= (data[i] << ((3 - i) * 8));
-    }
-
-    return out;
-}
-
 void copy_fil_size(FIL* in_src, FIL* out_src, int size_src){
     u8* buff;
-    buff = calloc(16384, sizeof(u8));
+    buff = calloc(BUFSIZE, sizeof(u8));
 
     int size = size_src;
     int copysize;
 
     while (size > 0){
-        copysize = MIN(16834, size);
+        copysize = MIN(BUFSIZE, size);
         f_read(in_src, buff, copysize, NULL);
         f_write(out_src, buff, copysize, NULL);
         size -= copysize;
@@ -49,56 +38,50 @@ void gen_part(int size, FIL* in, char *path){
     f_close(&out);
 }
 
+const char *filenames[] = {
+    "BOOT0.bin",
+    "BOOT1.bin",
+    "BCPKG2-1-Normal-Main",
+    "BCPKG2-3-SafeMode-Main",
+    "BCPKG2-2-Normal-Sub",
+    "BCPKG2-4-SafeMode-Sub"
+};
+
 int extract_bis_file(char *path, char *outfolder){
     FIL in;
     int res;
-    u8 version[0x10];
-    u8 args;
-    u8 temp[0x4];
-    u32 filesizes[4];
     char *tempPath;
+    BisFile header;
 
     if ((res = f_open(&in, path, FA_READ | FA_OPEN_EXISTING))){
         gfx_errDisplay("extract_bis_file", res, 0);
         return -1;
     }
 
-    f_read(&in, version, 0x10, NULL);
+    f_read(&in, &header, sizeof(BisFile), NULL);
-    f_read(&in, &args, 1, NULL);
     
+    for (int i = 0; i < 4; i++)
+        header.sizes[i] = FLIPU32(header.sizes[i]);
+
+    gfx_printf("Version: %s\n\n", header.version);
+
+    // Loop to actually extract stuff
     for (int i = 0; i < 4; i++){
-        f_read(&in, temp, 4, NULL);
+        if (!(header.args & (BIT((7 - i)))))
-        filesizes[i] = DecodeInt(temp);
+            continue;
+
+        gfx_printf("Extracting %s\n", filenames[i]);
+        gen_part(header.sizes[i], &in, fsutil_getnextloc(outfolder, filenames[i]));
     }
 
-    gfx_printf("Version: %s\n\n", version);
+    // Loop to copy pkg2_1->2 and pkg2_3->4
+    for (int i = 4; i < 6; i++){
+        if (!(header.args & BIT((9 - i))))
+            continue;
 
-    if (args & BOOT0_ARG){
+        utils_copystring(fsutil_getnextloc(outfolder, filenames[i - 2]), &tempPath);
-        gfx_printf("\nExtracting BOOT0\n");
+        gfx_printf("Copying %s\n", filenames[i]);
-        gen_part(filesizes[0], &in, fsutil_getnextloc(outfolder, "BOOT0.bin"));
+        fsact_copy(tempPath, fsutil_getnextloc(outfolder, filenames[i]), COPY_MODE_PRINT);
-    }
-        
-    if (args & BOOT1_ARG){
-        gfx_printf("Extracting BOOT1\n");
-        gen_part(filesizes[1], &in, fsutil_getnextloc(outfolder, "BOOT1.bin"));
-    }
-
-    if (args & BCPKG2_1_ARG){
-        utils_copystring(fsutil_getnextloc(outfolder, "BCPKG2-1-Normal-Main"), &tempPath);
-        gfx_printf("Extracting BCPKG2_1/2\n");
-
-        gen_part(filesizes[2], &in, tempPath);
-        fsact_copy(tempPath, fsutil_getnextloc(outfolder, "BCPKG2-2-Normal-Sub"), COPY_MODE_PRINT);
-        RESETCOLOR;
-        free(tempPath);
-    }   
-    
-    if (args & BCPKG2_3_ARG){
-        utils_copystring(fsutil_getnextloc(outfolder, "BCPKG2-3-SafeMode-Main"), &tempPath);
-        gfx_printf("Extracting BCPKG2_3/4\n");
-
-        gen_part(filesizes[3], &in, tempPath);
-        fsact_copy(tempPath, fsutil_getnextloc(outfolder, "BCPKG2-4-SafeMode-Sub"), COPY_MODE_PRINT);
         RESETCOLOR;
         free(tempPath);
     }

source/tegraexplorer/fs/fsmenu.c

@@ -7,6 +7,7 @@
 #include "../common/common.h"
 #include "../../libs/fatfs/ff.h"
 #include "entrymenu.h"
+#include "../utils/menuUtils.h"
 
 extern char *currentpath;
 extern char *clipboard;
@@ -35,7 +36,7 @@ void fileexplorer(const char *startpath, int type){
     */
 
     while (1){
-        res = menu_make(fsreader_files, fsutil_getfileobjamount(fsreader_files), currentpath);
+        res = menu_make(fsreader_files, mu_countObjects(fsreader_files, 0, 0), currentpath);
         switch (res){
             case FILEMENU_RETURN:
                 if (!strcmp(startpath, currentpath))
@@ -55,7 +56,7 @@ void fileexplorer(const char *startpath, int type){
                 break;
             
             case FILEMENU_CURFOLDER:
-                if (foldermenu())
+                if (foldermenu() < 0)
                     return;
                 break;
             case -1:

source/tegraexplorer/fs/fsreader.c

@@ -7,6 +7,7 @@
 #include "../gfx/gfxutils.h"
 #include "../utils/utils.h"
 #include "../../mem/heap.h"
+#include "../utils/menuUtils.h"
 
 menu_entry *fsreader_files = NULL;
 char *currentpath = NULL;
@@ -29,53 +30,16 @@ void fsreader_writeclipboard(const char *in, u8 args){
     utils_copystring(in, &clipboard);
 }
 
-void clearfileobjects(menu_entry **menu){
-    if ((*menu) != NULL){
-        for (int i = 0; (*menu)[i].name != NULL; i++){
-            free((*menu)[i].name);
-            (*menu)[i].name = NULL;
-        }
-        free((*menu));
-        (*menu) = NULL;
-    }
-}
-
-void createfileobjects(int size, menu_entry **menu){
-    (*menu) = calloc (size + 1, sizeof(menu_entry));
-    (*menu)[size].name = NULL;
-}
 
 void addobject(char* name, int spot, u8 attribs){
-    u64 size = 0;
+    u8 property = 0;
-    int sizes = 0;
-    fsreader_files[spot].property = 0;
-
-    if (fsreader_files[spot].name != NULL){
-        free(fsreader_files[spot].name);
-        fsreader_files[spot].name = NULL;
-    }
-
-    utils_copystring(name, &(fsreader_files[spot].name));
 
     if (attribs & AM_DIR)
-        fsreader_files[spot].property |= (ISDIR);
+        property |= ISDIR;
-    else {
+    else
-        size = fsutil_getfilesize(fsutil_getnextloc(currentpath, name));
+        property |= ISNULL;
 
-        while (size > 1024){
+    mu_copySingle(name, 0, property, &fsreader_files[spot]);
-            size /= 1024;
-            sizes++;
-        }
-
-        if (sizes > 3)
-            sizes = 0;
-
-        fsreader_files[spot].property |= (1 << (4 + sizes));
-        fsreader_files[spot].storage = size;
-    }
-
-    if (attribs & AM_ARC)
-        fsreader_files[spot].property |= (ISARC);
 }
 
 int fsreader_readfolder(const char *path){
@@ -83,14 +47,13 @@ int fsreader_readfolder(const char *path){
     FILINFO fno;
     int folderamount, res;
     
-    clearfileobjects(&fsreader_files);
+    mu_clearObjects(&fsreader_files);
-    createfileobjects(fsutil_getfolderentryamount(path) + 3, &fsreader_files);
+    mu_createObjects(fsutil_getfolderentryamount(path) + 3, &fsreader_files);
 
-    for (folderamount = 0; folderamount < 3; folderamount++){
+
-        utils_copystring(fs_menu_startdir[folderamount].name, &(fsreader_files[folderamount].name));
+
-        fsreader_files[folderamount].storage = fs_menu_startdir[folderamount].storage;
+    for (folderamount = 0; folderamount < 3; folderamount++)
-        fsreader_files[folderamount].property = fs_menu_startdir[folderamount].property;
+        mu_copySingle(fs_menu_startdir[folderamount].name, fs_menu_startdir[folderamount].storage, fs_menu_startdir[folderamount].property, &fsreader_files[folderamount]);
-    }
 
     if ((res = f_opendir(&dir, path))){
         gfx_errDisplay("readfolder", res, 0);

source/tegraexplorer/fs/fsutils.c

@@ -47,15 +47,6 @@ char *fsutil_getprevloc(char *current){
     return ret;
 }
 
-int fsutil_getfileobjamount(menu_entry *entries){
-    int amount = 0;
-
-    while (entries[amount].name != NULL)
-        amount++;
-
-    return amount;
-}
-
 bool fsutil_checkfile(char* path){
     FRESULT fr;
     FILINFO fno;
@@ -88,3 +79,20 @@ int fsutil_getfolderentryamount(const char *path){
     f_closedir(&dir);
     return folderamount;
 }
+
+char *fsutil_formatFileAttribs(char *path){
+    FILINFO attribs;
+    char *out;
+    out = malloc(16);
+
+    if (f_stat(path, &attribs))
+        return NULL;
+
+    sprintf(out, "Attribs: %c%c%c%c",
+        (attribs.fattrib & AM_RDO) ? 'R' : '-',
+        (attribs.fattrib & AM_SYS) ? 'S' : '-',
+        (attribs.fattrib & AM_HID) ? 'H' : '-',
+        (attribs.fattrib & AM_ARC) ? 'A' : '-');
+
+    return out;
+}

source/tegraexplorer/fs/fsutils.h

@@ -2,10 +2,18 @@
 #include "../common/types.h"
 #include "../../utils/types.h"
 
+typedef struct {
+    u8 version[0x10];
+    u8 args;
+    u32 sizes[4];
+} __attribute__((__packed__)) BisFile;
+
+#define FLIPU32(in) ((in >> 24) & 0xFF) | ((in >> 8) & 0xFF00) | ((in << 8) & 0xFF0000) | ((in << 24) & 0xFF000000)
+
 char *fsutil_getnextloc(const char *current, const char *add);
 char *fsutil_getprevloc(char *current);
-int fsutil_getfileobjamount(menu_entry *entries);
 bool fsutil_checkfile(char* path);
 u64 fsutil_getfilesize(char *path);
 int fsutil_getfolderentryamount(const char *path);
 int extract_bis_file(char *path, char *outfolder);
+char *fsutil_formatFileAttribs(char *path);

source/tegraexplorer/fs/keys.c

@@ -0,0 +1,62 @@
+#include "keys.h"
+#include "../../utils/types.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../sec/se.h"
+#include "../../mem/heap.h"
+#include "../gfx/gfxutils.h"
+#include "../../config/ini.h"
+#include "../common/common.h"
+#include <string.h>
+
+char *getKey(const char *search, link_t *inilist){
+    LIST_FOREACH_ENTRY(ini_sec_t, ini_sec, inilist, link){
+        if (ini_sec->type == INI_CHOICE){
+            LIST_FOREACH_ENTRY(ini_kv_t, kv, &ini_sec->kvs, link)
+	    	{
+                if (!strcmp(search, kv->key))
+                    return kv->val;
+	    	}
+        }   
+    }
+    return NULL;
+}
+
+u8 getHexSingle(const char c) {
+    if (c >= '0' && c <= '9')
+        return c - '0';
+    if (c >= 'a' && c <= 'f')
+        return c - 'a' + 10;
+}
+
+u8 *getHex(const char *in){
+    u32 len = strlen(in), count = 0;
+    u8 *out = calloc(len / 2, sizeof(u8));
+
+    for (u32 i = 0; i < len; i += 2){
+        out[count++] = (u8)(getHexSingle(in[i]) << 4) | (getHexSingle(in[i + 1]));
+    }
+
+    return out;
+}
+
+u8 *GetKey(const char *keypath, const char *keyName){
+    LIST_INIT(inilist);
+    char *key;
+    u8 *hex = NULL;
+
+    if (!ini_parse(&inilist, keypath, false)){
+        gfx_errDisplay("GetKey", ERR_INI_PARSE_FAIL, 1);
+        goto out_free;
+    }
+
+    if ((key = getKey(keyName, &inilist)) == NULL){
+        gfx_errDisplay("GetKey", ERR_INI_PARSE_FAIL, 2);
+        goto out_free;
+    }
+
+    hex = getHex(key);
+
+out_free:;
+    list_empty(&inilist);
+    return hex;
+}

source/tegraexplorer/fs/keys.h

@@ -0,0 +1,4 @@
+#pragma once
+#include "../../utils/types.h"
+
+u8 *GetKey(const char *keypath, const char *keyName);

source/tegraexplorer/fs/nca.c

@@ -0,0 +1,46 @@
+#include "nca.h"
+#include "keys.h"
+#include "../../utils/types.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../sec/se.h"
+#include "../../mem/heap.h"
+#include "../gfx/gfxutils.h"
+#include "../../config/ini.h"
+#include "../common/common.h"
+#include <string.h>
+
+int SetHeaderKey(){
+    u8 *header_key = GetKey("sd:/switch/prod.keys", "header_key");
+
+    if (header_key == NULL)
+        return -1;
+
+    se_aes_key_set(4, header_key + 0x00, 0x10);
+    se_aes_key_set(5, header_key + 0x10, 0x10);
+
+    return 0;
+}
+
+int GetNcaType(char *ncaPath){
+    FIL fp;
+    u32 read_bytes = 0;
+
+    if (f_open(&fp, ncaPath, FA_READ | FA_OPEN_EXISTING))
+        return -1;
+
+    u8 *dec_header = (u8*)malloc(0x600);
+
+    if (f_lseek(&fp, 0x200) || f_read(&fp, dec_header, 32, &read_bytes) || read_bytes != 32){
+        f_close(&fp);
+        free(dec_header);
+        return -1;
+    }
+
+    se_aes_xts_crypt(5,4,0,1,dec_header + 0x200, dec_header, 32, 1);
+
+    u8 ContentType = dec_header[0x205];
+    
+    f_close(&fp);
+    free(dec_header);
+    return ContentType;
+}

source/tegraexplorer/fs/nca.h

@@ -0,0 +1,4 @@
+#pragma once
+
+int GetNcaType(char *ncaPath);
+int SetHeaderKey();

source/tegraexplorer/fs/savesign.c

@@ -0,0 +1,77 @@
+#include "savesign.h"
+#include "keys.h"
+#include "../../utils/types.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../sec/se.h"
+#include "../../mem/heap.h"
+#include "../gfx/gfxutils.h"
+#include "../../config/ini.h"
+#include "../common/common.h"
+#include <string.h>
+
+bool save_commit(const char *path, u8 *save_mac_key){
+    FIL file;
+    int res;
+    u8 *buf, hash[0x20], *cmac_data, cmac[0x10];
+    const u32 hashed_data_size = 0x3D00, cmac_data_size = 0x200;
+    bool success = false;
+    
+    buf = malloc(hashed_data_size);
+    cmac_data = malloc(cmac_data_size);
+
+    if ((res = f_open(&file, path, FA_OPEN_EXISTING | FA_READ | FA_WRITE))){
+        gfx_errDisplay("save_commit", res, 1);
+        goto out_free;
+    }
+
+    f_lseek(&file, 0x300);
+    if ((res = f_read(&file, buf, hashed_data_size, NULL))){
+        gfx_errDisplay("save_commit", res, 2);
+        goto out_free;
+    }
+
+    se_calc_sha256(hash, buf, hashed_data_size);
+
+    f_lseek(&file, 0x108);
+    if ((res = f_write(&file, hash, sizeof(hash), NULL))){
+        gfx_errDisplay("save_commit", res, 3);
+        goto out_free;
+    }
+
+    f_lseek(&file, 0x100);
+    if ((res = f_read(&file, cmac_data, cmac_data_size, NULL))){
+        gfx_errDisplay("save_commit", res, 4);
+        goto out_free;
+    }
+
+    se_aes_key_set(3, save_mac_key, 0x10);
+    se_aes_cmac(3, cmac, 0x10, cmac_data, cmac_data_size);
+
+    f_lseek(&file, 0);
+
+    if ((res = f_write(&file, cmac, sizeof(cmac), NULL))){
+        gfx_errDisplay("save_commit", res, 5);
+        goto out_free;
+    }
+
+    success = true;
+
+out_free:;
+    free(buf);
+    free(cmac_data);
+    f_close(&file);
+    return success;
+}
+
+bool save_sign(const char *keypath, const char *savepath){
+    u8 *key = GetKey(keypath, "save_mac_key");
+
+    if (key == NULL){
+        return false;
+    }
+
+    if (!save_commit(savepath, key))
+        return false;
+
+    return true;
+}

source/tegraexplorer/fs/savesign.h

@@ -0,0 +1,4 @@
+#pragma once
+#include "../../utils/types.h"
+
+bool save_sign(const char *keypath, const char *savepath);