From 1d623eacf957d73564428beeb1576cd384e2bb54 Mon Sep 17 00:00:00 2001
From: Kostas Missos <ctcaer@gmail.com>
Date: Tue, 21 Aug 2018 04:14:31 +0300
Subject: [PATCH] Our 1st module. LP0 configuration.

---
 Makefile                                      |    4 +-
 bootloader/main.c                             |    5 +-
 modules/hekate_libsys_lp0/Makefile            |   32 +
 modules/hekate_libsys_lp0/pmc_lp0_t210.h      |  563 ++++++++
 .../hekate_libsys_lp0/sdram_lp0_param_t210.h  |  964 ++++++++++++++
 modules/hekate_libsys_lp0/sys_sdramlp0.c      | 1132 +++++++++++++++++
 modules/hekate_libsys_lp0/t210.h              |  110 ++
 modules/hekate_libsys_lp0/types.h             |   54 +
 modules/simple_sample/Makefile                |    8 +-
 modules/simple_sample/module_sample.c         |    6 +-
 10 files changed, 2869 insertions(+), 9 deletions(-)
 create mode 100644 modules/hekate_libsys_lp0/Makefile
 create mode 100644 modules/hekate_libsys_lp0/pmc_lp0_t210.h
 create mode 100644 modules/hekate_libsys_lp0/sdram_lp0_param_t210.h
 create mode 100644 modules/hekate_libsys_lp0/sys_sdramlp0.c
 create mode 100644 modules/hekate_libsys_lp0/t210.h
 create mode 100644 modules/hekate_libsys_lp0/types.h

diff --git a/Makefile b/Makefile
index 86ec266..2b83ea7 100755
--- a/Makefile
+++ b/Makefile
@@ -31,7 +31,6 @@ OBJS = $(addprefix $(BUILD)/$(TARGET)/, \
 	sdmmc.o \
 	sdmmc_driver.o \
 	sdram.o \
-	sdram_lp0.o \
 	tui.o \
 	util.o \
 	di.o \
@@ -43,6 +42,7 @@ OBJS = $(addprefix $(BUILD)/$(TARGET)/, \
 	tsec.o \
 	uart.o \
 	ini.o \
+	ianos.o \
 )
 
 OBJS += $(addprefix $(BUILD)/$(TARGET)/, \
@@ -53,7 +53,7 @@ OBJS += $(addprefix $(BUILD)/$(TARGET)/, \
 
 ARCH := -march=armv4t -mtune=arm7tdmi -mthumb -mthumb-interwork
 CUSTOMDEFINES := -DMENU_LOGO_ENABLE #-DDEBUG
-CFLAGS = $(ARCH) -O2 -nostdlib -flto -ffunction-sections -fdata-sections -fomit-frame-pointer -fno-inline -std=gnu11 -Wall $(CUSTOMDEFINES)
+CFLAGS = $(ARCH) -O2 -nostdlib -ffunction-sections -fdata-sections -fomit-frame-pointer -fno-inline -std=gnu11 -Wall $(CUSTOMDEFINES)
 LDFLAGS = $(ARCH) -nostartfiles -lgcc -Wl,--nmagic,--gc-sections
 
 MODULEDIRS := $(wildcard modules/*)
diff --git a/bootloader/main.c b/bootloader/main.c
index 15ec5f4..452fafc 100644
--- a/bootloader/main.c
+++ b/bootloader/main.c
@@ -391,8 +391,6 @@ void config_hw()
 	mc_config_carveout();
 
 	sdram_init();
-
-	sdram_lp0_save_params(sdram_get_params());
 }
 
 void reconfig_hw_workaround(bool extra_reconfig)
@@ -2615,6 +2613,9 @@ void ipl_main()
 	//uart_send(UART_C, (u8 *)0x40000000, 0x10000);
 	//uart_wait_idle(UART_C, UART_TX_IDLE);
 
+	// Save sdram lp0 config.
+	ianos_loader(true, "bootloader/sys/libsys_lp0.bso", DRAM_LIB, (void *)sdram_get_params());
+
 	display_init();
 	//display_color_screen(0xAABBCCDD);
 	u32 *fb = display_init_framebuffer();
diff --git a/modules/hekate_libsys_lp0/Makefile b/modules/hekate_libsys_lp0/Makefile
new file mode 100644
index 0000000..b789d38
--- /dev/null
+++ b/modules/hekate_libsys_lp0/Makefile
@@ -0,0 +1,32 @@
+ifeq ($(strip $(DEVKITARM)),)
+$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
+endif
+
+include $(DEVKITARM)/base_rules
+
+TARGET := libsys_lp0
+BUILD := ../../build/$(TARGET)
+OUTPUT := ../../output
+VPATH = $(dir $(wildcard ./*/)) $(dir $(wildcard ./*/*/))
+
+OBJS = $(addprefix $(BUILD)/,\
+	sys_sdramlp0.o \
+)
+
+ARCH := -march=armv4t -mtune=arm7tdmi -mthumb-interwork
+CFLAGS = $(ARCH) -O2 -nostdlib -fpie -ffunction-sections -fdata-sections -fomit-frame-pointer -fno-inline -std=gnu11 -Wall $(CUSTOMDEFINES)
+LDFLAGS = $(ARCH) -fpie -pie -nostartfiles -lgcc
+
+.PHONY: clean all
+
+all: $(TARGET).bso
+$(BUILD)/%.o: ./%.c
+	@mkdir -p "$(BUILD)"
+	$(CC) $(CFLAGS) -c $< -o $@
+	
+$(TARGET).bso: $(OBJS)
+	$(CC) $(LDFLAGS) -e _modInit $^ -o $(OUTPUT)/$(TARGET).bso
+	$(STRIP) -g $(OUTPUT)/$(TARGET).bso
+
+clean:
+	@rm -rf $(OUTPUT)/$(TARGET).bso
diff --git a/modules/hekate_libsys_lp0/pmc_lp0_t210.h b/modules/hekate_libsys_lp0/pmc_lp0_t210.h
new file mode 100644
index 0000000..95dd033
--- /dev/null
+++ b/modules/hekate_libsys_lp0/pmc_lp0_t210.h
@@ -0,0 +1,563 @@
+/*
+ * Copyright (c) 2010-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * 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.
+ */
+
+#ifndef _TEGRA210_PMC_H_
+#define _TEGRA210_PMC_H_
+
+#include "types.h"
+
+struct tegra_pmc_regs {
+	u32 cntrl;
+	u32 sec_disable;
+	u32 pmc_swrst;
+	u32 wake_mask;
+	u32 wake_lvl;
+	u32 wake_status;
+	u32 sw_wake_status;
+	u32 dpd_pads_oride;
+	u32 dpd_sample;
+	u32 dpd_enable;
+	u32 pwrgate_timer_off;
+	u32 clamp_status;
+	u32 pwrgate_toggle;
+	u32 remove_clamping_cmd;
+	u32 pwrgate_status;
+	u32 pwrgood_timer;
+	u32 blink_timer;
+	u32 no_iopower;
+	u32 pwr_det;
+	u32 pwr_det_latch;
+	u32 scratch0;
+	u32 scratch1;
+	u32 scratch2;
+	u32 scratch3;
+	u32 scratch4;
+	u32 scratch5;
+	u32 scratch6;
+	u32 scratch7;
+	u32 scratch8;
+	u32 scratch9;
+	u32 scratch10;
+	u32 scratch11;
+	u32 scratch12;
+	u32 scratch13;
+	u32 scratch14;
+	u32 scratch15;
+	u32 scratch16;
+	u32 scratch17;
+	u32 scratch18;
+	u32 scratch19;
+	u32 odmdata;
+	u32 scratch21;
+	u32 scratch22;
+	u32 scratch23;
+	u32 secure_scratch0;
+	u32 secure_scratch1;
+	u32 secure_scratch2;
+	u32 secure_scratch3;
+	u32 secure_scratch4;
+	u32 secure_scratch5;
+	u32 cpupwrgood_timer;
+	u32 cpupwroff_timer;
+	u32 pg_mask;
+	u32 pg_mask_1;
+	u32 auto_wake_lvl;
+	u32 auto_wake_lvl_mask;
+	u32 wake_delay;
+	u32 pwr_det_val;
+	u32 ddr_pwr;
+	u32 usb_debounce_del;
+	u32 usb_a0;
+	u32 crypto_op;
+	u32 pllp_wb0_override;
+	u32 scratch24;
+	u32 scratch25;
+	u32 scratch26;
+	u32 scratch27;
+	u32 scratch28;
+	u32 scratch29;
+	u32 scratch30;
+	u32 scratch31;
+	u32 scratch32;
+	u32 scratch33;
+	u32 scratch34;
+	u32 scratch35;
+	u32 scratch36;
+	u32 scratch37;
+	u32 scratch38;
+	u32 scratch39;
+	u32 scratch40;
+	u32 scratch41;
+	u32 scratch42;
+	u32 bondout_mirror[3];
+	u32 sys_33v_en;
+	u32 bondout_mirror_access;
+	u32 gate;
+	u32 wake2_mask;
+	u32 wake2_lvl;
+	u32 wake2_status;
+	u32 sw_wake2_status;
+	u32 auto_wake2_lvl_mask;
+	u32 pg_mask_2;
+	u32 pg_mask_ce1;
+	u32 pg_mask_ce2;
+	u32 pg_mask_ce3;
+	u32 pwrgate_timer_ce[7];
+	u32 pcx_edpd_cntrl;
+	u32 osc_edpd_over;
+	u32 clk_out_cntrl;
+	u32 sata_pwrgt;
+	u32 sensor_ctrl;
+	u32 rst_status;
+	u32 io_dpd_req;
+	u32 io_dpd_status;
+	u32 io_dpd2_req;
+	u32 io_dpd2_status;
+	u32 sel_dpd_tim;
+	u32 vddp_sel;
+	u32 ddr_cfg;
+	u32 e_no_vttgen;
+	u8 _rsv0[4];
+	u32 pllm_wb0_override_freq;
+	u32 test_pwrgate;
+	u32 pwrgate_timer_mult;
+	u32 dis_sel_dpd;
+	u32 utmip_uhsic_triggers;
+	u32 utmip_uhsic_saved_state;
+	u32 utmip_pad_cfg;
+	u32 utmip_term_pad_cfg;
+	u32 utmip_uhsic_sleep_cfg;
+	u32 utmip_uhsic_sleepwalk_cfg;
+	u32 utmip_sleepwalk_p[3];
+	u32 uhsic_sleepwalk_p0;
+	u32 utmip_uhsic_status;
+	u32 utmip_uhsic_fake;
+	u32 bondout_mirror3[5 - 3];
+	u32 secure_scratch6;
+	u32 secure_scratch7;
+	u32 scratch43;
+	u32 scratch44;
+	u32 scratch45;
+	u32 scratch46;
+	u32 scratch47;
+	u32 scratch48;
+	u32 scratch49;
+	u32 scratch50;
+	u32 scratch51;
+	u32 scratch52;
+	u32 scratch53;
+	u32 scratch54;
+	u32 scratch55;
+	u32 scratch0_eco;
+	u32 por_dpd_ctrl;
+	u32 scratch2_eco;
+	u32 utmip_uhsic_line_wakeup;
+	u32 utmip_bias_master_cntrl;
+	u32 utmip_master_config;
+	u32 td_pwrgate_inter_part_timer;
+	u32 utmip_uhsic2_triggers;
+	u32 utmip_uhsic2_saved_state;
+	u32 utmip_uhsic2_sleep_cfg;
+	u32 utmip_uhsic2_sleepwalk_cfg;
+	u32 uhsic2_sleepwalk_p1;
+	u32 utmip_uhsic2_status;
+	u32 utmip_uhsic2_fake;
+	u32 utmip_uhsic2_line_wakeup;
+	u32 utmip_master2_config;
+	u32 utmip_uhsic_rpd_cfg;
+	u32 pg_mask_ce0;
+	u32 pg_mask3[5 - 3];
+	u32 pllm_wb0_override2;
+	u32 tsc_mult;
+	u32 cpu_vsense_override;
+	u32 glb_amap_cfg;
+	u32 sticky_bits;
+	u32 sec_disable2;
+	u32 weak_bias;
+	u32 reg_short;
+	u32 pg_mask_andor;
+	u8 _rsv1[0x2c];
+	u32 secure_scratch8;	/* offset 0x300 */
+	u32 secure_scratch9;
+	u32 secure_scratch10;
+	u32 secure_scratch11;
+	u32 secure_scratch12;
+	u32 secure_scratch13;
+	u32 secure_scratch14;
+	u32 secure_scratch15;
+	u32 secure_scratch16;
+	u32 secure_scratch17;
+	u32 secure_scratch18;
+	u32 secure_scratch19;
+	u32 secure_scratch20;
+	u32 secure_scratch21;
+	u32 secure_scratch22;
+	u32 secure_scratch23;
+	u32 secure_scratch24;
+	u32 secure_scratch25;
+	u32 secure_scratch26;
+	u32 secure_scratch27;
+	u32 secure_scratch28;
+	u32 secure_scratch29;
+	u32 secure_scratch30;
+	u32 secure_scratch31;
+	u32 secure_scratch32;
+	u32 secure_scratch33;
+	u32 secure_scratch34;
+	u32 secure_scratch35;
+	u32 secure_scratch36;
+	u32 secure_scratch37;
+	u32 secure_scratch38;
+	u32 secure_scratch39;
+	u32 secure_scratch40;
+	u32 secure_scratch41;
+	u32 secure_scratch42;
+	u32 secure_scratch43;
+	u32 secure_scratch44;
+	u32 secure_scratch45;
+	u32 secure_scratch46;
+	u32 secure_scratch47;
+	u32 secure_scratch48;
+	u32 secure_scratch49;
+	u32 secure_scratch50;
+	u32 secure_scratch51;
+	u32 secure_scratch52;
+	u32 secure_scratch53;
+	u32 secure_scratch54;
+	u32 secure_scratch55;
+	u32 secure_scratch56;
+	u32 secure_scratch57;
+	u32 secure_scratch58;
+	u32 secure_scratch59;
+	u32 secure_scratch60;
+	u32 secure_scratch61;
+	u32 secure_scratch62;
+	u32 secure_scratch63;
+	u32 secure_scratch64;
+	u32 secure_scratch65;
+	u32 secure_scratch66;
+	u32 secure_scratch67;
+	u32 secure_scratch68;
+	u32 secure_scratch69;
+	u32 secure_scratch70;
+	u32 secure_scratch71;
+	u32 secure_scratch72;
+	u32 secure_scratch73;
+	u32 secure_scratch74;
+	u32 secure_scratch75;
+	u32 secure_scratch76;
+	u32 secure_scratch77;
+	u32 secure_scratch78;
+	u32 secure_scratch79;
+	u32 _rsv0x420[8];
+	u32 cntrl2;			/* 0x440 */
+	u32 _rsv0x444[2];
+	u32 event_counter;	/* 0x44C */
+	u32 fuse_control;
+	u32 scratch1_eco;
+	u32 _rsv0x458[1];
+	u32 io_dpd3_req;	/* 0x45C */
+	u32 io_dpd3_status;
+	u32 io_dpd4_req;
+	u32 io_dpd4_status;
+	u32 _rsv0x46C[30];
+	u32 ddr_cntrl;		/* 0x4E4 */
+	u32 _rsv0x4E8[70];
+	u32 scratch56;		/* 0x600 */
+	u32 scratch57;
+	u32 scratch58;
+	u32 scratch59;
+	u32 scratch60;
+	u32 scratch61;
+	u32 scratch62;
+	u32 scratch63;
+	u32 scratch64;
+	u32 scratch65;
+	u32 scratch66;
+	u32 scratch67;
+	u32 scratch68;
+	u32 scratch69;
+	u32 scratch70;
+	u32 scratch71;
+	u32 scratch72;
+	u32 scratch73;
+	u32 scratch74;
+	u32 scratch75;
+	u32 scratch76;
+	u32 scratch77;
+	u32 scratch78;
+	u32 scratch79;
+	u32 scratch80;
+	u32 scratch81;
+	u32 scratch82;
+	u32 scratch83;
+	u32 scratch84;
+	u32 scratch85;
+	u32 scratch86;
+	u32 scratch87;
+	u32 scratch88;
+	u32 scratch89;
+	u32 scratch90;
+	u32 scratch91;
+	u32 scratch92;
+	u32 scratch93;
+	u32 scratch94;
+	u32 scratch95;
+	u32 scratch96;
+	u32 scratch97;
+	u32 scratch98;
+	u32 scratch99;
+	u32 scratch100;
+	u32 scratch101;
+	u32 scratch102;
+	u32 scratch103;
+	u32 scratch104;
+	u32 scratch105;
+	u32 scratch106;
+	u32 scratch107;
+	u32 scratch108;
+	u32 scratch109;
+	u32 scratch110;
+	u32 scratch111;
+	u32 scratch112;
+	u32 scratch113;
+	u32 scratch114;
+	u32 scratch115;
+	u32 scratch116;
+	u32 scratch117;
+	u32 scratch118;
+	u32 scratch119;
+	u32 scratch120;		/* 0x700 */
+	u32 scratch121;
+	u32 scratch122;
+	u32 scratch123;
+	u32 scratch124;
+	u32 scratch125;
+	u32 scratch126;
+	u32 scratch127;
+	u32 scratch128;
+	u32 scratch129;
+	u32 scratch130;
+	u32 scratch131;
+	u32 scratch132;
+	u32 scratch133;
+	u32 scratch134;
+	u32 scratch135;
+	u32 scratch136;
+	u32 scratch137;
+	u32 scratch138;
+	u32 scratch139;
+	u32 scratch140;
+	u32 scratch141;
+	u32 scratch142;
+	u32 scratch143;
+	u32 scratch144;
+	u32 scratch145;
+	u32 scratch146;
+	u32 scratch147;
+	u32 scratch148;
+	u32 scratch149;
+	u32 scratch150;
+	u32 scratch151;
+	u32 scratch152;
+	u32 scratch153;
+	u32 scratch154;
+	u32 scratch155;
+	u32 scratch156;
+	u32 scratch157;
+	u32 scratch158;
+	u32 scratch159;
+	u32 scratch160;
+	u32 scratch161;
+	u32 scratch162;
+	u32 scratch163;
+	u32 scratch164;
+	u32 scratch165;
+	u32 scratch166;
+	u32 scratch167;
+	u32 scratch168;
+	u32 scratch169;
+	u32 scratch170;
+	u32 scratch171;
+	u32 scratch172;
+	u32 scratch173;
+	u32 scratch174;
+	u32 scratch175;
+	u32 scratch176;
+	u32 scratch177;
+	u32 scratch178;
+	u32 scratch179;
+	u32 scratch180;
+	u32 scratch181;
+	u32 scratch182;
+	u32 scratch183;
+	u32 scratch184;
+	u32 scratch185;
+	u32 scratch186;
+	u32 scratch187;
+	u32 scratch188;
+	u32 scratch189;
+	u32 scratch190;
+	u32 scratch191;
+	u32 scratch192;
+	u32 scratch193;
+	u32 scratch194;
+	u32 scratch195;
+	u32 scratch196;
+	u32 scratch197;
+	u32 scratch198;
+	u32 scratch199;
+	u32 scratch200;
+	u32 scratch201;
+	u32 scratch202;
+	u32 scratch203;
+	u32 scratch204;
+	u32 scratch205;
+	u32 scratch206;
+	u32 scratch207;
+	u32 scratch208;
+	u32 scratch209;
+	u32 scratch210;
+	u32 scratch211;
+	u32 scratch212;
+	u32 scratch213;
+	u32 scratch214;
+	u32 scratch215;
+	u32 scratch216;
+	u32 scratch217;
+	u32 scratch218;
+	u32 scratch219;
+	u32 scratch220;
+	u32 scratch221;
+	u32 scratch222;
+	u32 scratch223;
+	u32 scratch224;
+	u32 scratch225;
+	u32 scratch226;
+	u32 scratch227;
+	u32 scratch228;
+	u32 scratch229;
+	u32 scratch230;
+	u32 scratch231;
+	u32 scratch232;
+	u32 scratch233;
+	u32 scratch234;
+	u32 scratch235;
+	u32 scratch236;
+	u32 scratch237;
+	u32 scratch238;
+	u32 scratch239;
+	u32 scratch240;
+	u32 scratch241;
+	u32 scratch242;
+	u32 scratch243;
+	u32 scratch244;
+	u32 scratch245;
+	u32 scratch246;
+	u32 scratch247;
+	u32 scratch248;
+	u32 scratch249;
+	u32 scratch250;
+	u32 scratch251;
+	u32 scratch252;
+	u32 scratch253;
+	u32 scratch254;
+	u32 scratch255;
+	u32 scratch256;
+	u32 scratch257;
+	u32 scratch258;
+	u32 scratch259;
+	u32 scratch260;
+	u32 scratch261;
+	u32 scratch262;
+	u32 scratch263;
+	u32 scratch264;
+	u32 scratch265;
+	u32 scratch266;
+	u32 scratch267;
+	u32 scratch268;
+	u32 scratch269;
+	u32 scratch270;
+	u32 scratch271;
+	u32 scratch272;
+	u32 scratch273;
+	u32 scratch274;
+	u32 scratch275;
+	u32 scratch276;
+	u32 scratch277;
+	u32 scratch278;
+	u32 scratch279;
+	u32 scratch280;
+	u32 scratch281;
+	u32 scratch282;
+	u32 scratch283;
+	u32 scratch284;
+	u32 scratch285;
+	u32 scratch286;
+	u32 scratch287;
+	u32 scratch288;
+	u32 scratch289;
+	u32 scratch290;
+	u32 scratch291;
+	u32 scratch292;
+	u32 scratch293;
+	u32 scratch294;
+	u32 scratch295;
+	u32 scratch296;
+	u32 scratch297;
+	u32 scratch298;
+	u32 scratch299;			/* 0x9CC */
+	u32 _rsv0x9D0[50];
+	u32 secure_scratch80;	/* 0xa98 */
+	u32 secure_scratch81;
+	u32 secure_scratch82;
+	u32 secure_scratch83;
+	u32 secure_scratch84;
+	u32 secure_scratch85;
+	u32 secure_scratch86;
+	u32 secure_scratch87;
+	u32 secure_scratch88;
+	u32 secure_scratch89;
+	u32 secure_scratch90;
+	u32 secure_scratch91;
+	u32 secure_scratch92;
+	u32 secure_scratch93;
+	u32 secure_scratch94;
+	u32 secure_scratch95;
+	u32 secure_scratch96;
+	u32 secure_scratch97;
+	u32 secure_scratch98;
+	u32 secure_scratch99;
+	u32 secure_scratch100;
+	u32 secure_scratch101;
+	u32 secure_scratch102;
+	u32 secure_scratch103;
+	u32 secure_scratch104;
+	u32 secure_scratch105;
+	u32 secure_scratch106;
+	u32 secure_scratch107;
+	u32 secure_scratch108;
+	u32 secure_scratch109;
+	u32 secure_scratch110;
+	u32 secure_scratch111;
+	u32 secure_scratch112;
+	u32 secure_scratch113;
+	u32 secure_scratch114;
+	u32 secure_scratch115;
+	u32 secure_scratch116;
+	u32 secure_scratch117;
+	u32 secure_scratch118;
+	u32 secure_scratch119;
+};
+
+#endif	/* _TEGRA210_PMC_H_ */
diff --git a/modules/hekate_libsys_lp0/sdram_lp0_param_t210.h b/modules/hekate_libsys_lp0/sdram_lp0_param_t210.h
new file mode 100644
index 0000000..523a50f
--- /dev/null
+++ b/modules/hekate_libsys_lp0/sdram_lp0_param_t210.h
@@ -0,0 +1,964 @@
+/*
+ * Copyright (c) 2013-2015, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright 2014 Google Inc.
+ * 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.
+ */
+
+/**
+ * Defines the SDRAM parameter structure.
+ *
+ * Note that PLLM is used by EMC. The field names are in camel case to ease
+ * directly converting BCT config files (*.cfg) into C structure.
+ */
+
+#ifndef __SOC_NVIDIA_TEGRA210_SDRAM_PARAM_H__
+#define __SOC_NVIDIA_TEGRA210_SDRAM_PARAM_H__
+
+#include "types.h"
+
+enum
+{
+	/* Specifies the memory type to be undefined */
+	NvBootMemoryType_None = 0,
+
+	/* Specifies the memory type to be DDR SDRAM */
+	NvBootMemoryType_Ddr = 0,
+
+	/* Specifies the memory type to be LPDDR SDRAM */
+	NvBootMemoryType_LpDdr = 0,
+
+	/* Specifies the memory type to be DDR2 SDRAM */
+	NvBootMemoryType_Ddr2 = 0,
+
+	/* Specifies the memory type to be LPDDR2 SDRAM */
+	NvBootMemoryType_LpDdr2,
+
+	/* Specifies the memory type to be DDR3 SDRAM */
+	NvBootMemoryType_Ddr3,
+
+	/* Specifies the memory type to be LPDDR4 SDRAM */
+	NvBootMemoryType_LpDdr4,
+
+	NvBootMemoryType_Num,
+
+	/* Specifies an entry in the ram_code table that's not in use */
+	NvBootMemoryType_Unused = 0X7FFFFFF,
+};
+
+/**
+ * Defines the SDRAM parameter structure
+ */
+struct sdram_params
+{
+
+	/* Specifies the type of memory device */
+	u32 MemoryType;
+
+	/* MC/EMC clock source configuration */
+
+	/* Specifies the M value for PllM */
+	u32 PllMInputDivider;
+	/* Specifies the N value for PllM */
+	u32 PllMFeedbackDivider;
+	/* Specifies the time to wait for PLLM to lock (in microseconds) */
+	u32 PllMStableTime;
+	/* Specifies misc. control bits */
+	u32 PllMSetupControl;
+	/* Specifies the P value for PLLM */
+	u32 PllMPostDivider;
+	/* Specifies value for Charge Pump Gain Control */
+	u32 PllMKCP;
+	/* Specifies VCO gain */
+	u32 PllMKVCO;
+	/* Spare BCT param */
+	u32 EmcBctSpare0;
+	/* Spare BCT param */
+	u32 EmcBctSpare1;
+	/* Spare BCT param */
+	u32 EmcBctSpare2;
+	/* Spare BCT param */
+	u32 EmcBctSpare3;
+	/* Spare BCT param */
+	u32 EmcBctSpare4;
+	/* Spare BCT param */
+	u32 EmcBctSpare5;
+	/* Spare BCT param */
+	u32 EmcBctSpare6;
+	/* Spare BCT param */
+	u32 EmcBctSpare7;
+	/* Spare BCT param */
+	u32 EmcBctSpare8;
+	/* Spare BCT param */
+	u32 EmcBctSpare9;
+	/* Spare BCT param */
+	u32 EmcBctSpare10;
+	/* Spare BCT param */
+	u32 EmcBctSpare11;
+	/* Spare BCT param */
+	u32 EmcBctSpare12;
+	/* Spare BCT param */
+	u32 EmcBctSpare13;
+
+	/* Defines EMC_2X_CLK_SRC, EMC_2X_CLK_DIVISOR, EMC_INVERT_DCD */
+	u32 EmcClockSource;
+	u32 EmcClockSourceDll;
+
+	/* Defines possible override for PLLLM_MISC2 */
+	u32 ClkRstControllerPllmMisc2Override;
+	/* enables override for PLLLM_MISC2 */
+	u32 ClkRstControllerPllmMisc2OverrideEnable;
+	/* defines CLK_ENB_MC1 in register clk_rst_controller_clk_enb_w_clr */
+	u32 ClearClk2Mc1;
+
+	/* Auto-calibration of EMC pads */
+
+	/* Specifies the value for EMC_AUTO_CAL_INTERVAL */
+	u32 EmcAutoCalInterval;
+	/*
+	 * Specifies the value for EMC_AUTO_CAL_CONFIG
+	 * Note: Trigger bits are set by the SDRAM code.
+	 */
+	u32 EmcAutoCalConfig;
+
+	/* Specifies the value for EMC_AUTO_CAL_CONFIG2 */
+	u32 EmcAutoCalConfig2;
+
+	/* Specifies the value for EMC_AUTO_CAL_CONFIG3 */
+	u32 EmcAutoCalConfig3;
+
+	/* Specifies the values for EMC_AUTO_CAL_CONFIG4-8 */
+	u32 EmcAutoCalConfig4;
+	u32 EmcAutoCalConfig5;
+	u32 EmcAutoCalConfig6;
+	u32 EmcAutoCalConfig7;
+	u32 EmcAutoCalConfig8;
+
+	/* Specifies the value for EMC_AUTO_CAL_VREF_SEL_0 */
+	u32 EmcAutoCalVrefSel0;
+	u32 EmcAutoCalVrefSel1;
+
+	/* Specifies the value for EMC_AUTO_CAL_CHANNEL */
+	u32 EmcAutoCalChannel;
+
+	/* Specifies the value for EMC_PMACRO_AUTOCAL_CFG_0 */
+	u32 EmcPmacroAutocalCfg0;
+	u32 EmcPmacroAutocalCfg1;
+	u32 EmcPmacroAutocalCfg2;
+	u32 EmcPmacroRxTerm;
+	u32 EmcPmacroDqTxDrv;
+	u32 EmcPmacroCaTxDrv;
+	u32 EmcPmacroCmdTxDrv;
+	u32 EmcPmacroAutocalCfgCommon;
+	u32 EmcPmacroZctrl;
+
+	/*
+	 * Specifies the time for the calibration
+	 * to stabilize (in microseconds)
+	 */
+	u32 EmcAutoCalWait;
+
+	u32 EmcXm2CompPadCtrl;
+	u32 EmcXm2CompPadCtrl2;
+	u32 EmcXm2CompPadCtrl3;
+
+	/*
+	 * DRAM size information
+	 * Specifies the value for EMC_ADR_CFG
+	 */
+	u32 EmcAdrCfg;
+
+	/*
+	 * Specifies the time to wait after asserting pin
+	 * CKE (in microseconds)
+	 */
+	u32 EmcPinProgramWait;
+	/* Specifies the extra delay before/after pin RESET/CKE command */
+	u32 EmcPinExtraWait;
+
+	u32 EmcPinGpioEn;
+	u32 EmcPinGpio;
+
+	/*
+	 * Specifies the extra delay after the first writing
+	 * of EMC_TIMING_CONTROL
+	 */
+	u32 EmcTimingControlWait;
+
+	/* Timing parameters required for the SDRAM */
+
+	/* Specifies the value for EMC_RC */
+	u32 EmcRc;
+	/* Specifies the value for EMC_RFC */
+	u32 EmcRfc;
+	/* Specifies the value for EMC_RFC_PB */
+	u32 EmcRfcPb;
+	/* Specifies the value for EMC_RFC_CTRL2 */
+	u32 EmcRefctrl2;
+	/* Specifies the value for EMC_RFC_SLR */
+	u32 EmcRfcSlr;
+	/* Specifies the value for EMC_RAS */
+	u32 EmcRas;
+	/* Specifies the value for EMC_RP */
+	u32 EmcRp;
+	/* Specifies the value for EMC_R2R */
+	u32 EmcR2r;
+	/* Specifies the value for EMC_W2W */
+	u32 EmcW2w;
+	/* Specifies the value for EMC_R2W */
+	u32 EmcR2w;
+	/* Specifies the value for EMC_W2R */
+	u32 EmcW2r;
+	/* Specifies the value for EMC_R2P */
+	u32 EmcR2p;
+	/* Specifies the value for EMC_W2P */
+	u32 EmcW2p;
+
+	u32 EmcTppd;
+	u32 EmcCcdmw;
+
+	/* Specifies the value for EMC_RD_RCD */
+	u32 EmcRdRcd;
+	/* Specifies the value for EMC_WR_RCD */
+	u32 EmcWrRcd;
+	/* Specifies the value for EMC_RRD */
+	u32 EmcRrd;
+	/* Specifies the value for EMC_REXT */
+	u32 EmcRext;
+	/* Specifies the value for EMC_WEXT */
+	u32 EmcWext;
+	/* Specifies the value for EMC_WDV */
+	u32 EmcWdv;
+
+	u32 EmcWdvChk;
+	u32 EmcWsv;
+	u32 EmcWev;
+
+	/* Specifies the value for EMC_WDV_MASK */
+	u32 EmcWdvMask;
+
+	u32 EmcWsDuration;
+	u32 EmcWeDuration;
+
+	/* Specifies the value for EMC_QUSE */
+	u32 EmcQUse;
+	/* Specifies the value for EMC_QUSE_WIDTH */
+	u32 EmcQuseWidth;
+	/* Specifies the value for EMC_IBDLY */
+	u32 EmcIbdly;
+	/* Specifies the value for EMC_OBDLY */
+	u32 EmcObdly;
+	/* Specifies the value for EMC_EINPUT */
+	u32 EmcEInput;
+	/* Specifies the value for EMC_EINPUT_DURATION */
+	u32 EmcEInputDuration;
+	/* Specifies the value for EMC_PUTERM_EXTRA */
+	u32 EmcPutermExtra;
+	/* Specifies the value for EMC_PUTERM_WIDTH */
+	u32 EmcPutermWidth;
+	/* Specifies the value for EMC_PUTERM_ADJ */
+	////u32 EmcPutermAdj;
+
+	/* Specifies the value for EMC_QRST */
+	u32 EmcQRst;
+	/* Specifies the value for EMC_QSAFE */
+	u32 EmcQSafe;
+	/* Specifies the value for EMC_RDV */
+	u32 EmcRdv;
+	/* Specifies the value for EMC_RDV_MASK */
+	u32 EmcRdvMask;
+	/* Specifies the value for EMC_RDV_EARLY */
+	u32 EmcRdvEarly;
+	/* Specifies the value for EMC_RDV_EARLY_MASK */
+	u32 EmcRdvEarlyMask;
+	/* Specifies the value for EMC_QPOP */
+	u32 EmcQpop;
+
+	/* Specifies the value for EMC_REFRESH */
+	u32 EmcRefresh;
+	/* Specifies the value for EMC_BURST_REFRESH_NUM */
+	u32 EmcBurstRefreshNum;
+	/* Specifies the value for EMC_PRE_REFRESH_REQ_CNT */
+	u32 EmcPreRefreshReqCnt;
+	/* Specifies the value for EMC_PDEX2WR */
+	u32 EmcPdEx2Wr;
+	/* Specifies the value for EMC_PDEX2RD */
+	u32 EmcPdEx2Rd;
+	/* Specifies the value for EMC_PCHG2PDEN */
+	u32 EmcPChg2Pden;
+	/* Specifies the value for EMC_ACT2PDEN */
+	u32 EmcAct2Pden;
+	/* Specifies the value for EMC_AR2PDEN */
+	u32 EmcAr2Pden;
+	/* Specifies the value for EMC_RW2PDEN */
+	u32 EmcRw2Pden;
+	/* Specifies the value for EMC_CKE2PDEN */
+	u32 EmcCke2Pden;
+	/* Specifies the value for EMC_PDEX2CKE */
+	u32 EmcPdex2Cke;
+	/* Specifies the value for EMC_PDEX2MRR */
+	u32 EmcPdex2Mrr;
+	/* Specifies the value for EMC_TXSR */
+	u32 EmcTxsr;
+	/* Specifies the value for EMC_TXSRDLL */
+	u32 EmcTxsrDll;
+	/* Specifies the value for EMC_TCKE */
+	u32 EmcTcke;
+	/* Specifies the value for EMC_TCKESR */
+	u32 EmcTckesr;
+	/* Specifies the value for EMC_TPD */
+	u32 EmcTpd;
+	/* Specifies the value for EMC_TFAW */
+	u32 EmcTfaw;
+	/* Specifies the value for EMC_TRPAB */
+	u32 EmcTrpab;
+	/* Specifies the value for EMC_TCLKSTABLE */
+	u32 EmcTClkStable;
+	/* Specifies the value for EMC_TCLKSTOP */
+	u32 EmcTClkStop;
+	/* Specifies the value for EMC_TREFBW */
+	u32 EmcTRefBw;
+
+	/* FBIO configuration values */
+
+	/* Specifies the value for EMC_FBIO_CFG5 */
+	u32 EmcFbioCfg5;
+	/* Specifies the value for EMC_FBIO_CFG7 */
+	u32 EmcFbioCfg7;
+	/* Specifies the value for EMC_FBIO_CFG8 */
+	u32 EmcFbioCfg8;
+
+	/* Command mapping for CMD brick 0 */
+	u32 EmcCmdMappingCmd0_0;
+	u32 EmcCmdMappingCmd0_1;
+	u32 EmcCmdMappingCmd0_2;
+	u32 EmcCmdMappingCmd1_0;
+	u32 EmcCmdMappingCmd1_1;
+	u32 EmcCmdMappingCmd1_2;
+	u32 EmcCmdMappingCmd2_0;
+	u32 EmcCmdMappingCmd2_1;
+	u32 EmcCmdMappingCmd2_2;
+	u32 EmcCmdMappingCmd3_0;
+	u32 EmcCmdMappingCmd3_1;
+	u32 EmcCmdMappingCmd3_2;
+	u32 EmcCmdMappingByte;
+
+	/* Specifies the value for EMC_FBIO_SPARE */
+	u32 EmcFbioSpare;
+
+	/* Specifies the value for EMC_CFG_RSV */
+	u32 EmcCfgRsv;
+
+	/* MRS command values */
+
+	/* Specifies the value for EMC_MRS */
+	u32 EmcMrs;
+	/* Specifies the MP0 command to initialize mode registers */
+	u32 EmcEmrs;
+	/* Specifies the MP2 command to initialize mode registers */
+	u32 EmcEmrs2;
+	/* Specifies the MP3 command to initialize mode registers */
+	u32 EmcEmrs3;
+	/* Specifies the programming to LPDDR2 Mode Register 1 at cold boot */
+	u32 EmcMrw1;
+	/* Specifies the programming to LPDDR2 Mode Register 2 at cold boot */
+	u32 EmcMrw2;
+	/* Specifies the programming to LPDDR2 Mode Register 3 at cold boot */
+	u32 EmcMrw3;
+	/* Specifies the programming to LPDDR2 Mode Register 11 at cold boot */
+	u32 EmcMrw4;
+	/* Specifies the programming to LPDDR2 Mode Register 3? at cold boot */
+	u32 EmcMrw6;
+	/* Specifies the programming to LPDDR2 Mode Register 11 at cold boot */
+	u32 EmcMrw8;
+	/* Specifies the programming to LPDDR2 Mode Register 11? at cold boot */
+	u32 EmcMrw9;
+	/* Specifies the programming to LPDDR2 Mode Register 12 at cold boot */
+	u32 EmcMrw10;
+	/* Specifies the programming to LPDDR2 Mode Register 14 at cold boot */
+	u32 EmcMrw12;
+	/* Specifies the programming to LPDDR2 Mode Register 14? at cold boot */
+	u32 EmcMrw13;
+	/* Specifies the programming to LPDDR2 Mode Register 22 at cold boot */
+	u32 EmcMrw14;
+	/*
+	 * Specifies the programming to extra LPDDR2 Mode Register
+	 * at cold boot
+	 */
+	u32 EmcMrwExtra;
+	/*
+	 * Specifies the programming to extra LPDDR2 Mode Register
+	 * at warm boot
+	 */
+	u32 EmcWarmBootMrwExtra;
+	/*
+	 * Specify the enable of extra Mode Register programming at
+	 * warm boot
+	 */
+	u32 EmcWarmBootExtraModeRegWriteEnable;
+	/*
+	 * Specify the enable of extra Mode Register programming at
+	 * cold boot
+	 */
+	u32 EmcExtraModeRegWriteEnable;
+
+	/* Specifies the EMC_MRW reset command value */
+	u32 EmcMrwResetCommand;
+	/* Specifies the EMC Reset wait time (in microseconds) */
+	u32 EmcMrwResetNInitWait;
+	/* Specifies the value for EMC_MRS_WAIT_CNT */
+	u32 EmcMrsWaitCnt;
+	/* Specifies the value for EMC_MRS_WAIT_CNT2 */
+	u32 EmcMrsWaitCnt2;
+
+	/* EMC miscellaneous configurations */
+
+	/* Specifies the value for EMC_CFG */
+	u32 EmcCfg;
+	/* Specifies the value for EMC_CFG_2 */
+	u32 EmcCfg2;
+	/* Specifies the pipe bypass controls */
+	u32 EmcCfgPipe;
+	u32 EmcCfgPipeClk;
+	u32 EmcFdpdCtrlCmdNoRamp;
+	u32 EmcCfgUpdate;
+
+	/* Specifies the value for EMC_DBG */
+	u32 EmcDbg;
+	u32 EmcDbgWriteMux;
+
+	/* Specifies the value for EMC_CMDQ */
+	u32 EmcCmdQ;
+	/* Specifies the value for EMC_MC2EMCQ */
+	u32 EmcMc2EmcQ;
+	/* Specifies the value for EMC_DYN_SELF_REF_CONTROL */
+	u32 EmcDynSelfRefControl;
+
+	/* Specifies the value for MEM_INIT_DONE */
+	u32 AhbArbitrationXbarCtrlMemInitDone;
+
+	/* Specifies the value for EMC_CFG_DIG_DLL */
+	u32 EmcCfgDigDll;
+	u32 EmcCfgDigDll_1;
+	/* Specifies the value for EMC_CFG_DIG_DLL_PERIOD */
+	u32 EmcCfgDigDllPeriod;
+	/* Specifies the value of *DEV_SELECTN of various EMC registers */
+	u32 EmcDevSelect;
+
+	/* Specifies the value for EMC_SEL_DPD_CTRL */
+	u32 EmcSelDpdCtrl;
+
+	/* Pads trimmer delays */
+	u32 EmcFdpdCtrlDq;
+	u32 EmcFdpdCtrlCmd;
+	u32 EmcPmacroIbVrefDq_0;
+	u32 EmcPmacroIbVrefDq_1;
+	u32 EmcPmacroIbVrefDqs_0;
+	u32 EmcPmacroIbVrefDqs_1;
+	u32 EmcPmacroIbRxrt;
+	u32 EmcCfgPipe1;
+	u32 EmcCfgPipe2;
+
+	/* Specifies the value for EMC_PMACRO_QUSE_DDLL_RANK0_0 */
+	u32 EmcPmacroQuseDdllRank0_0;
+	u32 EmcPmacroQuseDdllRank0_1;
+	u32 EmcPmacroQuseDdllRank0_2;
+	u32 EmcPmacroQuseDdllRank0_3;
+	u32 EmcPmacroQuseDdllRank0_4;
+	u32 EmcPmacroQuseDdllRank0_5;
+	u32 EmcPmacroQuseDdllRank1_0;
+	u32 EmcPmacroQuseDdllRank1_1;
+	u32 EmcPmacroQuseDdllRank1_2;
+	u32 EmcPmacroQuseDdllRank1_3;
+	u32 EmcPmacroQuseDdllRank1_4;
+	u32 EmcPmacroQuseDdllRank1_5;
+
+	u32 EmcPmacroObDdllLongDqRank0_0;
+	u32 EmcPmacroObDdllLongDqRank0_1;
+	u32 EmcPmacroObDdllLongDqRank0_2;
+	u32 EmcPmacroObDdllLongDqRank0_3;
+	u32 EmcPmacroObDdllLongDqRank0_4;
+	u32 EmcPmacroObDdllLongDqRank0_5;
+	u32 EmcPmacroObDdllLongDqRank1_0;
+	u32 EmcPmacroObDdllLongDqRank1_1;
+	u32 EmcPmacroObDdllLongDqRank1_2;
+	u32 EmcPmacroObDdllLongDqRank1_3;
+	u32 EmcPmacroObDdllLongDqRank1_4;
+	u32 EmcPmacroObDdllLongDqRank1_5;
+
+	u32 EmcPmacroObDdllLongDqsRank0_0;
+	u32 EmcPmacroObDdllLongDqsRank0_1;
+	u32 EmcPmacroObDdllLongDqsRank0_2;
+	u32 EmcPmacroObDdllLongDqsRank0_3;
+	u32 EmcPmacroObDdllLongDqsRank0_4;
+	u32 EmcPmacroObDdllLongDqsRank0_5;
+	u32 EmcPmacroObDdllLongDqsRank1_0;
+	u32 EmcPmacroObDdllLongDqsRank1_1;
+	u32 EmcPmacroObDdllLongDqsRank1_2;
+	u32 EmcPmacroObDdllLongDqsRank1_3;
+	u32 EmcPmacroObDdllLongDqsRank1_4;
+	u32 EmcPmacroObDdllLongDqsRank1_5;
+
+	u32 EmcPmacroIbDdllLongDqsRank0_0;
+	u32 EmcPmacroIbDdllLongDqsRank0_1;
+	u32 EmcPmacroIbDdllLongDqsRank0_2;
+	u32 EmcPmacroIbDdllLongDqsRank0_3;
+	u32 EmcPmacroIbDdllLongDqsRank1_0;
+	u32 EmcPmacroIbDdllLongDqsRank1_1;
+	u32 EmcPmacroIbDdllLongDqsRank1_2;
+	u32 EmcPmacroIbDdllLongDqsRank1_3;
+
+	u32 EmcPmacroDdllLongCmd_0;
+	u32 EmcPmacroDdllLongCmd_1;
+	u32 EmcPmacroDdllLongCmd_2;
+	u32 EmcPmacroDdllLongCmd_3;
+	u32 EmcPmacroDdllLongCmd_4;
+	u32 EmcPmacroDdllShortCmd_0;
+	u32 EmcPmacroDdllShortCmd_1;
+	u32 EmcPmacroDdllShortCmd_2;
+
+	/*
+	 * Specifies the delay after asserting CKE pin during a WarmBoot0
+	 * sequence (in microseconds)
+	 */
+	u32 WarmBootWait;
+
+	/* Specifies the value for EMC_ODT_WRITE */
+	u32 EmcOdtWrite;
+
+	/* Periodic ZQ calibration */
+
+	/*
+	 * Specifies the value for EMC_ZCAL_INTERVAL
+	 * Value 0 disables ZQ calibration
+	 */
+	u32 EmcZcalInterval;
+	/* Specifies the value for EMC_ZCAL_WAIT_CNT */
+	u32 EmcZcalWaitCnt;
+	/* Specifies the value for EMC_ZCAL_MRW_CMD */
+	u32 EmcZcalMrwCmd;
+
+	/* DRAM initialization sequence flow control */
+
+	/* Specifies the MRS command value for resetting DLL */
+	u32 EmcMrsResetDll;
+	/* Specifies the command for ZQ initialization of device 0 */
+	u32 EmcZcalInitDev0;
+	/* Specifies the command for ZQ initialization of device 1 */
+	u32 EmcZcalInitDev1;
+	/*
+	 * Specifies the wait time after programming a ZQ initialization
+	 * command (in microseconds)
+	 */
+	u32 EmcZcalInitWait;
+	/*
+	 * Specifies the enable for ZQ calibration at cold boot [bit 0]
+	 * and warm boot [bit 1]
+	 */
+	u32 EmcZcalWarmColdBootEnables;
+
+	/*
+	 * Specifies the MRW command to LPDDR2 for ZQ calibration
+	 * on warmboot
+	 */
+	/* Is issued to both devices separately */
+	u32 EmcMrwLpddr2ZcalWarmBoot;
+	/*
+	 * Specifies the ZQ command to DDR3 for ZQ calibration on warmboot
+	 * Is issued to both devices separately
+	 */
+	u32 EmcZqCalDdr3WarmBoot;
+	u32 EmcZqCalLpDdr4WarmBoot;
+	/*
+	 * Specifies the wait time for ZQ calibration on warmboot
+	 * (in microseconds)
+	 */
+	u32 EmcZcalWarmBootWait;
+	/*
+	 * Specifies the enable for DRAM Mode Register programming
+	 * at warm boot
+	 */
+	u32 EmcMrsWarmBootEnable;
+	/*
+	 * Specifies the wait time after sending an MRS DLL reset command
+	 * in microseconds)
+	 */
+	u32 EmcMrsResetDllWait;
+	/* Specifies the extra MRS command to initialize mode registers */
+	u32 EmcMrsExtra;
+	/* Specifies the extra MRS command at warm boot */
+	u32 EmcWarmBootMrsExtra;
+	/* Specifies the EMRS command to enable the DDR2 DLL */
+	u32 EmcEmrsDdr2DllEnable;
+	/* Specifies the MRS command to reset the DDR2 DLL */
+	u32 EmcMrsDdr2DllReset;
+	/* Specifies the EMRS command to set OCD calibration */
+	u32 EmcEmrsDdr2OcdCalib;
+	/*
+	 * Specifies the wait between initializing DDR and setting OCD
+	 * calibration (in microseconds)
+	 */
+	u32 EmcDdr2Wait;
+	/* Specifies the value for EMC_CLKEN_OVERRIDE */
+	u32 EmcClkenOverride;
+
+	/*
+	 * Specifies LOG2 of the extra refresh numbers after booting
+	 * Program 0 to disable
+	 */
+	u32 EmcExtraRefreshNum;
+	/* Specifies the master override for all EMC clocks */
+	u32 EmcClkenOverrideAllWarmBoot;
+	/* Specifies the master override for all MC clocks */
+	u32 McClkenOverrideAllWarmBoot;
+	/* Specifies digital dll period, choosing between 4 to 64 ms */
+	u32 EmcCfgDigDllPeriodWarmBoot;
+
+	/* Pad controls */
+
+	/* Specifies the value for PMC_VDDP_SEL */
+	u32 PmcVddpSel;
+	/* Specifies the wait time after programming PMC_VDDP_SEL */
+	u32 PmcVddpSelWait;
+	/* Specifies the value for PMC_DDR_PWR */
+	u32 PmcDdrPwr;
+	/* Specifies the value for PMC_DDR_CFG */
+	u32 PmcDdrCfg;
+	/* Specifies the value for PMC_IO_DPD3_REQ */
+	u32 PmcIoDpd3Req;
+	/* Specifies the wait time after programming PMC_IO_DPD3_REQ */
+	u32 PmcIoDpd3ReqWait;
+	u32 PmcIoDpd4ReqWait;
+
+	/* Specifies the value for PMC_REG_SHORT */
+	u32 PmcRegShort;
+	/* Specifies the value for PMC_NO_IOPOWER */
+	u32 PmcNoIoPower;
+
+	u32 PmcDdrCntrlWait;
+	u32 PmcDdrCntrl;
+
+	/* Specifies the value for EMC_ACPD_CONTROL */
+	u32 EmcAcpdControl;
+
+	/* Specifies the value for EMC_SWIZZLE_RANK0_BYTE_CFG */
+	////u32 EmcSwizzleRank0ByteCfg;
+	/* Specifies the value for EMC_SWIZZLE_RANK0_BYTE0 */
+	u32 EmcSwizzleRank0Byte0;
+	/* Specifies the value for EMC_SWIZZLE_RANK0_BYTE1 */
+	u32 EmcSwizzleRank0Byte1;
+	/* Specifies the value for EMC_SWIZZLE_RANK0_BYTE2 */
+	u32 EmcSwizzleRank0Byte2;
+	/* Specifies the value for EMC_SWIZZLE_RANK0_BYTE3 */
+	u32 EmcSwizzleRank0Byte3;
+	/* Specifies the value for EMC_SWIZZLE_RANK1_BYTE_CFG */
+	////u32 EmcSwizzleRank1ByteCfg;
+	/* Specifies the value for EMC_SWIZZLE_RANK1_BYTE0 */
+	u32 EmcSwizzleRank1Byte0;
+	/* Specifies the value for EMC_SWIZZLE_RANK1_BYTE1 */
+	u32 EmcSwizzleRank1Byte1;
+	/* Specifies the value for EMC_SWIZZLE_RANK1_BYTE2 */
+	u32 EmcSwizzleRank1Byte2;
+	/* Specifies the value for EMC_SWIZZLE_RANK1_BYTE3 */
+	u32 EmcSwizzleRank1Byte3;
+
+	/* Specifies the value for EMC_TXDSRVTTGEN */
+	u32 EmcTxdsrvttgen;
+
+	/* Specifies the value for EMC_DATA_BRLSHFT_0 */
+	u32 EmcDataBrlshft0;
+	u32 EmcDataBrlshft1;
+
+	u32 EmcDqsBrlshft0;
+	u32 EmcDqsBrlshft1;
+
+	u32 EmcCmdBrlshft0;
+	u32 EmcCmdBrlshft1;
+	u32 EmcCmdBrlshft2;
+	u32 EmcCmdBrlshft3;
+
+	u32 EmcQuseBrlshft0;
+	u32 EmcQuseBrlshft1;
+	u32 EmcQuseBrlshft2;
+	u32 EmcQuseBrlshft3;
+
+	u32 EmcDllCfg0;
+	u32 EmcDllCfg1;
+
+	u32 EmcPmcScratch1;
+	u32 EmcPmcScratch2;
+	u32 EmcPmcScratch3;
+
+	u32 EmcPmacroPadCfgCtrl;
+
+	u32 EmcPmacroVttgenCtrl0;
+	u32 EmcPmacroVttgenCtrl1;
+	u32 EmcPmacroVttgenCtrl2;
+
+	u32 EmcPmacroBrickCtrlRfu1;
+	u32 EmcPmacroCmdBrickCtrlFdpd;
+	u32 EmcPmacroBrickCtrlRfu2;
+	u32 EmcPmacroDataBrickCtrlFdpd;
+	u32 EmcPmacroBgBiasCtrl0;
+	u32 EmcPmacroDataPadRxCtrl;
+	u32 EmcPmacroCmdPadRxCtrl;
+	u32 EmcPmacroDataRxTermMode;
+	u32 EmcPmacroCmdRxTermMode;
+	u32 EmcPmacroDataPadTxCtrl;
+	u32 EmcPmacroCommonPadTxCtrl;
+	u32 EmcPmacroCmdPadTxCtrl;
+	u32 EmcCfg3;
+
+	u32 EmcPmacroTxPwrd0;
+	u32 EmcPmacroTxPwrd1;
+	u32 EmcPmacroTxPwrd2;
+	u32 EmcPmacroTxPwrd3;
+	u32 EmcPmacroTxPwrd4;
+	u32 EmcPmacroTxPwrd5;
+
+	u32 EmcConfigSampleDelay;
+
+	u32 EmcPmacroBrickMapping0;
+	u32 EmcPmacroBrickMapping1;
+	u32 EmcPmacroBrickMapping2;
+
+	u32 EmcPmacroTxSelClkSrc0;
+	u32 EmcPmacroTxSelClkSrc1;
+	u32 EmcPmacroTxSelClkSrc2;
+	u32 EmcPmacroTxSelClkSrc3;
+	u32 EmcPmacroTxSelClkSrc4;
+	u32 EmcPmacroTxSelClkSrc5;
+
+	u32 EmcPmacroDdllBypass;
+
+	u32 EmcPmacroDdllPwrd0;
+	u32 EmcPmacroDdllPwrd1;
+	u32 EmcPmacroDdllPwrd2;
+
+	u32 EmcPmacroCmdCtrl0;
+	u32 EmcPmacroCmdCtrl1;
+	u32 EmcPmacroCmdCtrl2;
+
+	/* DRAM size information */
+
+	/* Specifies the value for MC_EMEM_ADR_CFG */
+	u32 McEmemAdrCfg;
+	/* Specifies the value for MC_EMEM_ADR_CFG_DEV0 */
+	u32 McEmemAdrCfgDev0;
+	/* Specifies the value for MC_EMEM_ADR_CFG_DEV1 */
+	u32 McEmemAdrCfgDev1;
+	u32 McEmemAdrCfgChannelMask;
+
+	/* Specifies the value for MC_EMEM_BANK_SWIZZLECfg0 */
+	u32 McEmemAdrCfgBankMask0;
+	/* Specifies the value for MC_EMEM_BANK_SWIZZLE_CFG1 */
+	u32 McEmemAdrCfgBankMask1;
+	/* Specifies the value for MC_EMEM_BANK_SWIZZLE_CFG2 */
+	u32 McEmemAdrCfgBankMask2;
+
+	/*
+	 * Specifies the value for MC_EMEM_CFG which holds the external memory
+	 * size (in KBytes)
+	 */
+	u32 McEmemCfg;
+
+	/* MC arbitration configuration */
+
+	/* Specifies the value for MC_EMEM_ARB_CFG */
+	u32 McEmemArbCfg;
+	/* Specifies the value for MC_EMEM_ARB_OUTSTANDING_REQ */
+	u32 McEmemArbOutstandingReq;
+
+	u32 McEmemArbRefpbHpCtrl;
+	u32 McEmemArbRefpbBankCtrl;
+
+	/* Specifies the value for MC_EMEM_ARB_TIMING_RCD */
+	u32 McEmemArbTimingRcd;
+	/* Specifies the value for MC_EMEM_ARB_TIMING_RP */
+	u32 McEmemArbTimingRp;
+	/* Specifies the value for MC_EMEM_ARB_TIMING_RC */
+	u32 McEmemArbTimingRc;
+	/* Specifies the value for MC_EMEM_ARB_TIMING_RAS */
+	u32 McEmemArbTimingRas;
+	/* Specifies the value for MC_EMEM_ARB_TIMING_FAW */
+	u32 McEmemArbTimingFaw;
+	/* Specifies the value for MC_EMEM_ARB_TIMING_RRD */
+	u32 McEmemArbTimingRrd;
+	/* Specifies the value for MC_EMEM_ARB_TIMING_RAP2PRE */
+	u32 McEmemArbTimingRap2Pre;
+	/* Specifies the value for MC_EMEM_ARB_TIMING_WAP2PRE */
+	u32 McEmemArbTimingWap2Pre;
+	/* Specifies the value for MC_EMEM_ARB_TIMING_R2R */
+	u32 McEmemArbTimingR2R;
+	/* Specifies the value for MC_EMEM_ARB_TIMING_W2W */
+	u32 McEmemArbTimingW2W;
+	/* Specifies the value for MC_EMEM_ARB_TIMING_R2W */
+	u32 McEmemArbTimingR2W;
+	/* Specifies the value for MC_EMEM_ARB_TIMING_W2R */
+	u32 McEmemArbTimingW2R;
+
+	u32 McEmemArbTimingRFCPB;
+
+	/* Specifies the value for MC_EMEM_ARB_DA_TURNS */
+	u32 McEmemArbDaTurns;
+	/* Specifies the value for MC_EMEM_ARB_DA_COVERS */
+	u32 McEmemArbDaCovers;
+	/* Specifies the value for MC_EMEM_ARB_MISC0 */
+	u32 McEmemArbMisc0;
+	/* Specifies the value for MC_EMEM_ARB_MISC1 */
+	u32 McEmemArbMisc1;
+	u32 McEmemArbMisc2;
+
+	/* Specifies the value for MC_EMEM_ARB_RING1_THROTTLE */
+	u32 McEmemArbRing1Throttle;
+	/* Specifies the value for MC_EMEM_ARB_OVERRIDE */
+	u32 McEmemArbOverride;
+	/* Specifies the value for MC_EMEM_ARB_OVERRIDE_1 */
+	u32 McEmemArbOverride1;
+	/* Specifies the value for MC_EMEM_ARB_RSV */
+	u32 McEmemArbRsv;
+
+	u32 McDaCfg0;
+	u32 McEmemArbTimingCcdmw;
+
+	/* Specifies the value for MC_CLKEN_OVERRIDE */
+	u32 McClkenOverride;
+
+	/* Specifies the value for MC_STAT_CONTROL */
+	u32 McStatControl;
+
+	/* Specifies the value for MC_VIDEO_PROTECT_BOM */
+	u32 McVideoProtectBom;
+	/* Specifies the value for MC_VIDEO_PROTECT_BOM_ADR_HI */
+	u32 McVideoProtectBomAdrHi;
+	/* Specifies the value for MC_VIDEO_PROTECT_SIZE_MB */
+	u32 McVideoProtectSizeMb;
+	/* Specifies the value for MC_VIDEO_PROTECT_VPR_OVERRIDE */
+	u32 McVideoProtectVprOverride;
+	/* Specifies the value for MC_VIDEO_PROTECT_VPR_OVERRIDE1 */
+	u32 McVideoProtectVprOverride1;
+	/* Specifies the value for MC_VIDEO_PROTECT_GPU_OVERRIDE_0 */
+	u32 McVideoProtectGpuOverride0;
+	/* Specifies the value for MC_VIDEO_PROTECT_GPU_OVERRIDE_1 */
+	u32 McVideoProtectGpuOverride1;
+	/* Specifies the value for MC_SEC_CARVEOUT_BOM */
+	u32 McSecCarveoutBom;
+	/* Specifies the value for MC_SEC_CARVEOUT_ADR_HI */
+	u32 McSecCarveoutAdrHi;
+	/* Specifies the value for MC_SEC_CARVEOUT_SIZE_MB */
+	u32 McSecCarveoutSizeMb;
+	/* Specifies the value for MC_VIDEO_PROTECT_REG_CTRL.
+	   VIDEO_PROTECT_WRITEAccess */
+	u32 McVideoProtectWriteAccess;
+	/* Specifies the value for MC_SEC_CARVEOUT_REG_CTRL.
+	   SEC_CARVEOUT_WRITEAccess */
+	u32 McSecCarveoutProtectWriteAccess;
+
+	/* Write-Protect Regions (WPR) */
+	u32 McGeneralizedCarveout1Bom;
+	u32 McGeneralizedCarveout1BomHi;
+	u32 McGeneralizedCarveout1Size128kb;
+	u32 McGeneralizedCarveout1Access0;
+	u32 McGeneralizedCarveout1Access1;
+	u32 McGeneralizedCarveout1Access2;
+	u32 McGeneralizedCarveout1Access3;
+	u32 McGeneralizedCarveout1Access4;
+	u32 McGeneralizedCarveout1ForceInternalAccess0;
+	u32 McGeneralizedCarveout1ForceInternalAccess1;
+	u32 McGeneralizedCarveout1ForceInternalAccess2;
+	u32 McGeneralizedCarveout1ForceInternalAccess3;
+	u32 McGeneralizedCarveout1ForceInternalAccess4;
+	u32 McGeneralizedCarveout1Cfg0;
+
+	u32 McGeneralizedCarveout2Bom;
+	u32 McGeneralizedCarveout2BomHi;
+	u32 McGeneralizedCarveout2Size128kb;
+	u32 McGeneralizedCarveout2Access0;
+	u32 McGeneralizedCarveout2Access1;
+	u32 McGeneralizedCarveout2Access2;
+	u32 McGeneralizedCarveout2Access3;
+	u32 McGeneralizedCarveout2Access4;
+	u32 McGeneralizedCarveout2ForceInternalAccess0;
+	u32 McGeneralizedCarveout2ForceInternalAccess1;
+	u32 McGeneralizedCarveout2ForceInternalAccess2;
+	u32 McGeneralizedCarveout2ForceInternalAccess3;
+	u32 McGeneralizedCarveout2ForceInternalAccess4;
+	u32 McGeneralizedCarveout2Cfg0;
+
+	u32 McGeneralizedCarveout3Bom;
+	u32 McGeneralizedCarveout3BomHi;
+	u32 McGeneralizedCarveout3Size128kb;
+	u32 McGeneralizedCarveout3Access0;
+	u32 McGeneralizedCarveout3Access1;
+	u32 McGeneralizedCarveout3Access2;
+	u32 McGeneralizedCarveout3Access3;
+	u32 McGeneralizedCarveout3Access4;
+	u32 McGeneralizedCarveout3ForceInternalAccess0;
+	u32 McGeneralizedCarveout3ForceInternalAccess1;
+	u32 McGeneralizedCarveout3ForceInternalAccess2;
+	u32 McGeneralizedCarveout3ForceInternalAccess3;
+	u32 McGeneralizedCarveout3ForceInternalAccess4;
+	u32 McGeneralizedCarveout3Cfg0;
+
+	u32 McGeneralizedCarveout4Bom;
+	u32 McGeneralizedCarveout4BomHi;
+	u32 McGeneralizedCarveout4Size128kb;
+	u32 McGeneralizedCarveout4Access0;
+	u32 McGeneralizedCarveout4Access1;
+	u32 McGeneralizedCarveout4Access2;
+	u32 McGeneralizedCarveout4Access3;
+	u32 McGeneralizedCarveout4Access4;
+	u32 McGeneralizedCarveout4ForceInternalAccess0;
+	u32 McGeneralizedCarveout4ForceInternalAccess1;
+	u32 McGeneralizedCarveout4ForceInternalAccess2;
+	u32 McGeneralizedCarveout4ForceInternalAccess3;
+	u32 McGeneralizedCarveout4ForceInternalAccess4;
+	u32 McGeneralizedCarveout4Cfg0;
+
+	u32 McGeneralizedCarveout5Bom;
+	u32 McGeneralizedCarveout5BomHi;
+	u32 McGeneralizedCarveout5Size128kb;
+	u32 McGeneralizedCarveout5Access0;
+	u32 McGeneralizedCarveout5Access1;
+	u32 McGeneralizedCarveout5Access2;
+	u32 McGeneralizedCarveout5Access3;
+	u32 McGeneralizedCarveout5Access4;
+	u32 McGeneralizedCarveout5ForceInternalAccess0;
+	u32 McGeneralizedCarveout5ForceInternalAccess1;
+	u32 McGeneralizedCarveout5ForceInternalAccess2;
+	u32 McGeneralizedCarveout5ForceInternalAccess3;
+	u32 McGeneralizedCarveout5ForceInternalAccess4;
+	u32 McGeneralizedCarveout5Cfg0;
+
+	/* Specifies enable for CA training */
+	u32 EmcCaTrainingEnable;
+
+	/* Set if bit 6 select is greater than bit 7 select; uses aremc.
+	   spec packet SWIZZLE_BIT6_GT_BIT7 */
+	u32 SwizzleRankByteEncode;
+	/* Specifies enable and offset for patched boot ROM write */
+	u32 BootRomPatchControl;
+	/* Specifies data for patched boot ROM write */
+	u32 BootRomPatchData;
+
+	/* Specifies the value for MC_MTS_CARVEOUT_BOM */
+	u32 McMtsCarveoutBom;
+	/* Specifies the value for MC_MTS_CARVEOUT_ADR_HI */
+	u32 McMtsCarveoutAdrHi;
+	/* Specifies the value for MC_MTS_CARVEOUT_SIZE_MB */
+	u32 McMtsCarveoutSizeMb;
+	/* Specifies the value for MC_MTS_CARVEOUT_REG_CTRL */
+	u32 McMtsCarveoutRegCtrl;
+
+	/* End */
+};
+
+#endif /* __SOC_NVIDIA_TEGRA210_SDRAM_PARAM_H__ */
diff --git a/modules/hekate_libsys_lp0/sys_sdramlp0.c b/modules/hekate_libsys_lp0/sys_sdramlp0.c
new file mode 100644
index 0000000..52e85a7
--- /dev/null
+++ b/modules/hekate_libsys_lp0/sys_sdramlp0.c
@@ -0,0 +1,1132 @@
+/*
+ * Copyright (c) 2013, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright 2014 Google Inc.
+ * Copyright (C) 2018 naehrwert
+ * 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.
+ */
+
+#include "t210.h"
+#include "pmc_lp0_t210.h"
+#include "sdram_lp0_param_t210.h"
+#include "../../common/common_module.h"
+
+/*
+ * This function reads SDRAM parameters from the common BCT format and
+ * writes them into PMC scratch registers (where the BootROM expects them
+ * on LP0 resume).
+ */
+void sdram_lp0_save_params(const void *params)
+{
+	struct sdram_params *sdram = (struct sdram_params *)params;
+	struct tegra_pmc_regs *pmc = (struct tegra_pmc_regs *)PMC_BASE;
+
+#define pack(src, src_bits, dst, dst_bits) { \
+	u32 mask = 0xffffffff >> (31 - ((1 ? src_bits) - (0 ? src_bits))); \
+	dst &= ~(mask << (0 ? dst_bits)); \
+	dst |= ((src >> (0 ? src_bits)) & mask) << (0 ? dst_bits); \
+}
+
+#define s(param, src_bits, pmcreg, dst_bits) \
+	pack(sdram->param, src_bits, pmc->pmcreg, dst_bits)
+
+#define c(value, pmcreg, dst_bits) \
+	pack(value, (1 ? dst_bits) - (0 ? dst_bits) : 0, pmc->pmcreg, dst_bits)
+
+/* 32 bits version of s macro */
+#define s32(param, pmcreg) pmc->pmcreg = sdram->param
+
+/* 32 bits version c macro */
+#define c32(value, pmcreg) pmc->pmcreg = value
+
+	//TODO: pkg1.1 (1.X - 3.X) reads them from MC.
+	// Patch carveout parameters.
+	/*sdram->McGeneralizedCarveout1Bom = 0;
+	sdram->McGeneralizedCarveout1BomHi = 0;
+	sdram->McGeneralizedCarveout1Size128kb = 0;
+	sdram->McGeneralizedCarveout1Access0 = 0;
+	sdram->McGeneralizedCarveout1Access1 = 0;
+	sdram->McGeneralizedCarveout1Access2 = 0;
+	sdram->McGeneralizedCarveout1Access3 = 0;
+	sdram->McGeneralizedCarveout1Access4 = 0;
+	sdram->McGeneralizedCarveout1ForceInternalAccess0 = 0;
+	sdram->McGeneralizedCarveout1ForceInternalAccess1 = 0;
+	sdram->McGeneralizedCarveout1ForceInternalAccess2 = 0;
+	sdram->McGeneralizedCarveout1ForceInternalAccess3 = 0;
+	sdram->McGeneralizedCarveout1ForceInternalAccess4 = 0;
+	sdram->McGeneralizedCarveout1Cfg0 = 0;
+	sdram->McGeneralizedCarveout2Bom = 0x80020000;
+	sdram->McGeneralizedCarveout2BomHi = 0;
+	sdram->McGeneralizedCarveout2Size128kb = 2;
+	sdram->McGeneralizedCarveout2Access0 = 0;
+	sdram->McGeneralizedCarveout2Access1 = 0;
+	sdram->McGeneralizedCarveout2Access2 = 0x3000000;
+	sdram->McGeneralizedCarveout2Access3 = 0;
+	sdram->McGeneralizedCarveout2Access4 = 0x300;
+	sdram->McGeneralizedCarveout2ForceInternalAccess0 = 0;
+	sdram->McGeneralizedCarveout2ForceInternalAccess1 = 0;
+	sdram->McGeneralizedCarveout2ForceInternalAccess2 = 0;
+	sdram->McGeneralizedCarveout2ForceInternalAccess3 = 0;
+	sdram->McGeneralizedCarveout2ForceInternalAccess4 = 0;
+	sdram->McGeneralizedCarveout2Cfg0 = 0x440167E;
+	sdram->McGeneralizedCarveout3Bom = 0;
+	sdram->McGeneralizedCarveout3BomHi = 0;
+	sdram->McGeneralizedCarveout3Size128kb = 0;
+	sdram->McGeneralizedCarveout3Access0 = 0;
+	sdram->McGeneralizedCarveout3Access1 = 0;
+	sdram->McGeneralizedCarveout3Access2 = 0x3000000;
+	sdram->McGeneralizedCarveout3Access3 = 0;
+	sdram->McGeneralizedCarveout3Access4 = 0x300;
+	sdram->McGeneralizedCarveout3ForceInternalAccess0 = 0;
+	sdram->McGeneralizedCarveout3ForceInternalAccess1 = 0;
+	sdram->McGeneralizedCarveout3ForceInternalAccess2 = 0;
+	sdram->McGeneralizedCarveout3ForceInternalAccess3 = 0;
+	sdram->McGeneralizedCarveout3ForceInternalAccess4 = 0;
+	sdram->McGeneralizedCarveout3Cfg0 = 0x4401E7E;
+	sdram->McGeneralizedCarveout4Bom = 0;
+	sdram->McGeneralizedCarveout4BomHi = 0;
+	sdram->McGeneralizedCarveout4Size128kb = 0;
+	sdram->McGeneralizedCarveout4Access0 = 0;
+	sdram->McGeneralizedCarveout4Access1 = 0;
+	sdram->McGeneralizedCarveout4Access2 = 0;
+	sdram->McGeneralizedCarveout4Access3 = 0;
+	sdram->McGeneralizedCarveout4Access4 = 0;
+	sdram->McGeneralizedCarveout4ForceInternalAccess0 = 0;
+	sdram->McGeneralizedCarveout4ForceInternalAccess1 = 0;
+	sdram->McGeneralizedCarveout4ForceInternalAccess2 = 0;
+	sdram->McGeneralizedCarveout4ForceInternalAccess3 = 0;
+	sdram->McGeneralizedCarveout4ForceInternalAccess4 = 0;
+	sdram->McGeneralizedCarveout4Cfg0 = 0x8F;
+	sdram->McGeneralizedCarveout5Bom = 0;
+	sdram->McGeneralizedCarveout5BomHi = 0;
+	sdram->McGeneralizedCarveout5Size128kb = 0;
+	sdram->McGeneralizedCarveout5Access0 = 0;
+	sdram->McGeneralizedCarveout5Access1 = 0;
+	sdram->McGeneralizedCarveout5Access2 = 0;
+	sdram->McGeneralizedCarveout5Access3 = 0;
+	sdram->McGeneralizedCarveout5Access4 = 0;
+	sdram->McGeneralizedCarveout5ForceInternalAccess0 = 0;
+	sdram->McGeneralizedCarveout5ForceInternalAccess1 = 0;
+	sdram->McGeneralizedCarveout5ForceInternalAccess2 = 0;
+	sdram->McGeneralizedCarveout5ForceInternalAccess3 = 0;
+	sdram->McGeneralizedCarveout5ForceInternalAccess4 = 0;
+	sdram->McGeneralizedCarveout5Cfg0 = 0x8F;*/
+
+	//TODO: this is 4.X+ behaviour which seems to work fine for < 4.X.
+	// Patch carveout parameters.
+	sdram->McGeneralizedCarveout1Cfg0 = 0;
+	sdram->McGeneralizedCarveout2Cfg0 = 0;
+	sdram->McGeneralizedCarveout3Cfg0 = 0;
+	sdram->McGeneralizedCarveout4Cfg0 = 0;
+	sdram->McGeneralizedCarveout5Cfg0 = 0;
+
+	// Patch SDRAM parameters.
+	u32 t0 = sdram->EmcSwizzleRank0Byte0 << 5 >> 29 > sdram->EmcSwizzleRank0Byte0 << 1 >> 29;
+	u32 t1 = (t0 & 0xFFFFFFEF) | ((sdram->EmcSwizzleRank1Byte0 << 5 >> 29 > sdram->EmcSwizzleRank1Byte0 << 1 >> 29) << 4);
+	u32 t2 = (t1 & 0xFFFFFFFD) | ((sdram->EmcSwizzleRank0Byte1 << 5 >> 29 > sdram->EmcSwizzleRank0Byte1 << 1 >> 29) << 1);
+	u32 t3 = (t2 & 0xFFFFFFDF) | ((sdram->EmcSwizzleRank1Byte1 << 5 >> 29 > sdram->EmcSwizzleRank1Byte1 << 1 >> 29) << 5);
+	u32 t4 = (t3 & 0xFFFFFFFB) | ((sdram->EmcSwizzleRank0Byte2 << 5 >> 29 > sdram->EmcSwizzleRank0Byte2 << 1 >> 29) << 2);
+	u32 t5 = (t4 & 0xFFFFFFBF) | ((sdram->EmcSwizzleRank1Byte2 << 5 >> 29 > sdram->EmcSwizzleRank1Byte2 << 1 >> 29) << 6);
+	u32 t6 = (t5 & 0xFFFFFFF7) | ((sdram->EmcSwizzleRank0Byte3 << 5 >> 29 > sdram->EmcSwizzleRank0Byte3 << 1 >> 29) << 3);
+	u32 t7 = (t6 & 0xFFFFFF7F) | ((sdram->EmcSwizzleRank1Byte3 << 5 >> 29 > sdram->EmcSwizzleRank1Byte3 << 1 >> 29) << 7);
+	sdram->SwizzleRankByteEncode = t7;
+	sdram->EmcBctSpare2 = 0x40000DD8;
+	sdram->EmcBctSpare3 = t7;
+
+	s(EmcClockSource, 7:0, scratch6, 15:8);
+	s(EmcClockSourceDll, 7:0, scratch6, 23:16);
+	s(EmcClockSource, 31:29, scratch6, 26:24);
+	s(EmcClockSourceDll, 31:29, scratch6, 29:27);
+	s(EmcClockSourceDll, 11:10, scratch6, 31:30);
+	s(ClkRstControllerPllmMisc2Override, 9:8, scratch7, 1:0);
+	s(ClkRstControllerPllmMisc2Override, 2:1, scratch7, 3:2);
+	s(EmcZqCalLpDdr4WarmBoot, 31:30, scratch7, 5:4);
+	s(EmcClockSource, 15:15, scratch7, 6:6);
+	s(EmcClockSource, 26:26, scratch7, 7:7);
+	s(EmcClockSource, 20:20, scratch7, 8:8);
+	s(EmcClockSource, 19:19, scratch7, 9:9);
+	s(ClkRstControllerPllmMisc2Override, 13:13, scratch7, 10:10);
+	s(ClkRstControllerPllmMisc2Override, 12:12, scratch7, 11:11);
+	s(ClkRstControllerPllmMisc2Override, 11:11, scratch7, 12:12);
+	s(ClkRstControllerPllmMisc2Override, 10:10, scratch7, 13:13);
+	s(ClkRstControllerPllmMisc2Override, 5:5, scratch7, 14:14);
+	s(ClkRstControllerPllmMisc2Override, 4:4, scratch7, 15:15);
+	s(ClkRstControllerPllmMisc2Override, 3:3, scratch7, 16:16);
+	s(ClkRstControllerPllmMisc2Override, 0:0, scratch7, 17:17);
+	s(EmcZqCalLpDdr4WarmBoot, 1:0, scratch7, 19:18);
+	s(EmcZqCalLpDdr4WarmBoot, 4:4, scratch7, 20:20);
+	s(EmcOdtWrite, 5:0, scratch7, 26:21);
+	s(EmcOdtWrite, 11:8, scratch7, 30:27);
+	s(EmcOdtWrite, 31:31, scratch7, 31:31);
+	s(EmcFdpdCtrlCmdNoRamp, 0:0, scratch13, 30:30);
+	s(EmcCfgPipeClk, 0:0, scratch13, 31:31);
+	s(McEmemArbMisc2, 0:0, scratch14, 30:30);
+	s(McDaCfg0, 0:0, scratch14, 31:31);
+	s(EmcQRst, 6:0, scratch15, 26:20);
+	s(EmcQRst, 20:16, scratch15, 31:27);
+	s(EmcPmacroCmdTxDrv, 5:0, scratch16, 25:20);
+	s(EmcPmacroCmdTxDrv, 13:8, scratch16, 31:26);
+	s(EmcPmacroAutocalCfg0, 2:0, scratch17, 22:20);
+	s(EmcPmacroAutocalCfg0, 10:8, scratch17, 25:23);
+	s(EmcPmacroAutocalCfg0, 18:16, scratch17, 28:26);
+	s(EmcPmacroAutocalCfg0, 26:24, scratch17, 31:29);
+	s(EmcPmacroAutocalCfg1, 2:0, scratch18, 22:20);
+	s(EmcPmacroAutocalCfg1, 10:8, scratch18, 25:23);
+	s(EmcPmacroAutocalCfg1, 18:16, scratch18, 28:26);
+	s(EmcPmacroAutocalCfg1, 26:24, scratch18, 31:29);
+	s(EmcPmacroAutocalCfg2, 2:0, scratch19, 22:20);
+	s(EmcPmacroAutocalCfg2, 10:8, scratch19, 25:23);
+	s(EmcPmacroAutocalCfg2, 18:16, scratch19, 28:26);
+	s(EmcPmacroAutocalCfg2, 26:24, scratch19, 31:29);
+	s32(EmcCfgRsv,scratch22);
+	s32(EmcAutoCalConfig, scratch23);
+	s32(EmcAutoCalVrefSel0, scratch24);
+	s32(EmcPmacroBrickCtrlRfu1, scratch25);
+	s32(EmcPmacroBrickCtrlRfu2, scratch26);
+	s32(EmcPmcScratch1, scratch27);
+	s32(EmcPmcScratch2, scratch28);
+	s32(EmcPmcScratch3, scratch29);
+	s32(McEmemArbDaTurns, scratch30);
+	s(EmcFbioSpare, 31:24, scratch58, 7:0);
+	s(EmcFbioSpare, 23:16, scratch58, 15:8);
+	s(EmcFbioSpare, 15:8, scratch58, 23:16);
+	s(EmcFbioSpare, 7:2, scratch58, 29:24);
+	s(EmcFbioSpare, 0:0, scratch58, 30:30);
+	s(EmcDllCfg0, 29:0, scratch59, 29:0);
+	s(EmcPmacroDdllBypass, 11:0, scratch60, 11:0);
+	s(EmcPmacroDdllBypass, 27:13, scratch60, 26:12);
+	s(EmcPmacroDdllBypass, 31:29, scratch60, 29:27);
+	s(McEmemArbMisc0, 14:0, scratch61, 14:0);
+	s(McEmemArbMisc0, 30:16, scratch61, 29:15);
+	s(EmcFdpdCtrlCmd, 16:0, scratch62, 16:0);
+	s(EmcFdpdCtrlCmd, 31:20, scratch62, 28:17);
+	s(EmcAutoCalConfig2, 27:0, scratch63, 27:0);
+	s(EmcBurstRefreshNum, 3:0, scratch63, 31:28);
+	s(EmcPmacroZctrl, 27:0, scratch64, 27:0);
+	s(EmcTppd, 3:0, scratch64, 31:28);
+	s(EmcCfgDigDll, 10:0, scratch65, 10:0);
+	s(EmcCfgDigDll, 25:12, scratch65, 24:11);
+	s(EmcCfgDigDll, 27:27, scratch65, 25:25);
+	s(EmcCfgDigDll, 31:30, scratch65, 27:26);
+	s(EmcR2r, 3:0, scratch65, 31:28);
+	s(EmcFdpdCtrlDq, 16:0, scratch66, 16:0);
+	s(EmcFdpdCtrlDq, 28:20, scratch66, 25:17);
+	s(EmcFdpdCtrlDq, 31:30, scratch66, 27:26);
+	s(EmcW2w, 3:0, scratch66, 31:28);
+	s(EmcPmacroTxPwrd4, 13:0, scratch67, 13:0);
+	s(EmcPmacroTxPwrd4, 29:16, scratch67, 27:14);
+	s(EmcPmacroCommonPadTxCtrl, 3:0, scratch67, 31:28);
+	s(EmcPmacroTxPwrd5, 13:0, scratch68, 13:0);
+	s(EmcPmacroTxPwrd5, 29:16, scratch68, 27:14);
+	s(EmcPmacroDdllPwrd0, 4:0, scratch69, 4:0);
+	s(EmcPmacroDdllPwrd0, 12:6, scratch69, 11:5);
+	s(EmcPmacroDdllPwrd0, 20:14, scratch69, 18:12);
+	s(EmcPmacroDdllPwrd0, 28:22, scratch69, 25:19);
+	s(EmcPmacroDdllPwrd0, 31:30, scratch69, 27:26);
+	s(EmcCfg, 4:4, scratch69, 31:31);
+	s(EmcPmacroDdllPwrd1, 4:0, scratch70, 4:0);
+	s(EmcPmacroDdllPwrd1, 12:6, scratch70, 11:5);
+	s(EmcPmacroDdllPwrd1, 20:14, scratch70, 18:12);
+	s(EmcPmacroDdllPwrd1, 28:22, scratch70, 25:19);
+	s(EmcPmacroDdllPwrd1, 31:30, scratch70, 27:26);
+	s(EmcCfg, 5:5, scratch70, 31:31);
+	s(EmcPmacroDdllPwrd2, 4:0, scratch71, 4:0);
+	s(EmcPmacroDdllPwrd2, 12:6, scratch71, 11:5);
+	s(EmcPmacroDdllPwrd2, 20:14, scratch71, 18:12);
+	s(EmcPmacroDdllPwrd2, 28:22, scratch71, 25:19);
+	s(EmcPmacroDdllPwrd2, 31:30, scratch71, 27:26);
+	s(EmcFbioCfg5, 23:20, scratch71, 31:28);
+	s(EmcPmacroIbVrefDq_0, 6:0, scratch72, 6:0);
+	s(EmcPmacroIbVrefDq_0, 14:8, scratch72, 13:7);
+	s(EmcPmacroIbVrefDq_0, 22:16, scratch72, 20:14);
+	s(EmcPmacroIbVrefDq_0, 30:24, scratch72, 27:21);
+	s(EmcFbioCfg5, 15:13, scratch72, 30:28);
+	s(EmcCfg, 6:6, scratch72, 31:31);
+	s(EmcPmacroIbVrefDq_1, 6:0, scratch73, 6:0);
+	s(EmcPmacroIbVrefDq_1, 14:8, scratch73, 13:7);
+	s(EmcPmacroIbVrefDq_1, 22:16, scratch73, 20:14);
+	s(EmcPmacroIbVrefDq_1, 30:24, scratch73, 27:21);
+	s(EmcCfg2, 5:3, scratch73, 30:28);
+	s(EmcCfg, 7:7, scratch73, 31:31);
+	s(EmcPmacroIbVrefDqs_0, 6:0, scratch74, 6:0);
+	s(EmcPmacroIbVrefDqs_0, 14:8, scratch74, 13:7);
+	s(EmcPmacroIbVrefDqs_0, 22:16, scratch74, 20:14);
+	s(EmcPmacroIbVrefDqs_0, 30:24, scratch74, 27:21);
+	s(EmcCfg, 17:16, scratch74, 29:28);
+	s(EmcFbioCfg5, 1:0, scratch74, 31:30);
+	s(EmcPmacroIbVrefDqs_1, 6:0, scratch75, 6:0);
+	s(EmcPmacroIbVrefDqs_1, 14:8, scratch75, 13:7);
+	s(EmcPmacroIbVrefDqs_1, 22:16, scratch75, 20:14);
+	s(EmcPmacroIbVrefDqs_1, 30:24, scratch75, 27:21);
+	s(EmcFbioCfg5, 3:2, scratch75, 29:28);
+	s(EmcCfg2, 27:26, scratch75, 31:30);
+	s(EmcPmacroDdllShortCmd_0, 6:0, scratch76, 6:0);
+	s(EmcPmacroDdllShortCmd_0, 14:8, scratch76, 13:7);
+	s(EmcPmacroDdllShortCmd_0, 22:16, scratch76, 20:14);
+	s(EmcPmacroDdllShortCmd_0, 30:24, scratch76, 27:21);
+	s(EmcPmacroCmdPadTxCtrl, 3:2, scratch76, 29:28);
+	s(EmcPmacroCmdPadTxCtrl, 7:6, scratch76, 31:30);
+	s(EmcPmacroDdllShortCmd_1, 6:0, scratch77, 6:0);
+	s(EmcPmacroDdllShortCmd_1, 14:8, scratch77, 13:7);
+	s(EmcPmacroDdllShortCmd_1, 22:16, scratch77, 20:14);
+	s(EmcPmacroDdllShortCmd_1, 30:24, scratch77, 27:21);
+	s(EmcPmacroCmdPadTxCtrl, 11:10, scratch77, 29:28);
+	s(EmcPmacroCmdPadTxCtrl, 15:14, scratch77, 31:30);
+	s(EmcAutoCalChannel, 5:0, scratch78, 5:0);
+	s(EmcAutoCalChannel, 11:8, scratch78, 9:6);
+	s(EmcAutoCalChannel, 27:16, scratch78, 21:10);
+	s(EmcAutoCalChannel, 31:29, scratch78, 24:22);
+	s(EmcConfigSampleDelay, 6:0, scratch78, 31:25);
+	s(EmcPmacroRxTerm, 5:0, scratch79, 5:0);
+	s(EmcPmacroRxTerm, 13:8, scratch79, 11:6);
+	s(EmcPmacroRxTerm, 21:16, scratch79, 17:12);
+	s(EmcPmacroRxTerm, 29:24, scratch79, 23:18);
+	s(EmcRc, 7:0, scratch79, 31:24);
+	s(EmcPmacroDqTxDrv, 5:0, scratch80, 5:0);
+	s(EmcPmacroDqTxDrv, 13:8, scratch80, 11:6);
+	s(EmcPmacroDqTxDrv, 21:16, scratch80, 17:12);
+	s(EmcPmacroDqTxDrv, 29:24, scratch80, 23:18);
+	s(EmcSelDpdCtrl, 5:2, scratch80, 27:24);
+	s(EmcSelDpdCtrl, 8:8, scratch80, 28:28);
+	s(EmcSelDpdCtrl, 18:16, scratch80, 31:29);
+	s(EmcPmacroCaTxDrv, 5:0, scratch81, 5:0);
+	s(EmcPmacroCaTxDrv, 13:8, scratch81, 11:6);
+	s(EmcPmacroCaTxDrv, 21:16, scratch81, 17:12);
+	s(EmcPmacroCaTxDrv, 29:24, scratch81, 23:18);
+	s(EmcObdly, 5:0, scratch81, 29:24);
+	s(EmcObdly, 29:28, scratch81, 31:30);
+	s(EmcZcalInterval, 23:10, scratch82, 13:0);
+	s(EmcZcalInterval, 9:0, scratch82, 23:14);
+	s(EmcPmacroCmdRxTermMode, 1:0, scratch82, 25:24);
+	s(EmcPmacroCmdRxTermMode, 5:4, scratch82, 27:26);
+	s(EmcPmacroCmdRxTermMode, 9:8, scratch82, 29:28);
+	s(EmcPmacroCmdRxTermMode, 13:12, scratch82, 31:30);
+	s(EmcDataBrlshft0, 23:0, scratch83, 23:0);
+	s(EmcPmacroDataRxTermMode, 1:0, scratch83, 25:24);
+	s(EmcPmacroDataRxTermMode, 5:4, scratch83, 27:26);
+	s(EmcPmacroDataRxTermMode, 9:8, scratch83, 29:28);
+	s(EmcPmacroDataRxTermMode, 13:12, scratch83, 31:30);
+	s(EmcDataBrlshft1, 23:0, scratch84, 23:0);
+	s(McEmemArbTimingRc, 7:0, scratch84, 31:24);
+	s(EmcDqsBrlshft0, 23:0, scratch85, 23:0);
+	s(McEmemArbRsv, 7:0, scratch85, 31:24);
+	s(EmcDqsBrlshft1, 23:0, scratch86, 23:0);
+	s(EmcCfgPipe2, 11:0, scratch87, 11:0);
+	s(EmcCfgPipe2, 27:16, scratch87, 23:12);
+	s(EmcCfgPipe1, 11:0, scratch88, 11:0);
+	s(EmcCfgPipe1, 27:16, scratch88, 23:12);
+	s(EmcPmacroCmdCtrl0, 5:0, scratch89, 5:0);
+	s(EmcPmacroCmdCtrl0, 13:8, scratch89, 11:6);
+	s(EmcPmacroCmdCtrl0, 21:16, scratch89, 17:12);
+	s(EmcPmacroCmdCtrl0, 29:24, scratch89, 23:18);
+	s(EmcPmacroCmdCtrl1, 5:0, scratch90, 5:0);
+	s(EmcPmacroCmdCtrl1, 13:8, scratch90, 11:6);
+	s(EmcPmacroCmdCtrl1, 21:16, scratch90, 17:12);
+	s(EmcPmacroCmdCtrl1, 29:24, scratch90, 23:18);
+	s(EmcRas, 6:0, scratch90, 30:24);
+	s(EmcCfg, 8:8, scratch90, 31:31);
+	s(EmcPmacroVttgenCtrl2, 23:0, scratch91, 23:0);
+	s(EmcW2p, 6:0, scratch91, 30:24);
+	s(EmcCfg, 9:9, scratch91, 31:31);
+	s(EmcPmacroCmdPadRxCtrl, 2:0, scratch92, 2:0);
+	s(EmcPmacroCmdPadRxCtrl, 5:4, scratch92, 4:3);
+	s(EmcPmacroCmdPadRxCtrl, 10:8, scratch92, 7:5);
+	s(EmcPmacroCmdPadRxCtrl, 22:12, scratch92, 18:8);
+	s(EmcPmacroCmdPadRxCtrl, 28:24, scratch92, 23:19);
+	s(EmcQSafe, 6:0, scratch92, 30:24);
+	s(EmcCfg, 18:18, scratch92, 31:31);
+	s(EmcPmacroDataPadRxCtrl, 2:0, scratch93, 2:0);
+	s(EmcPmacroDataPadRxCtrl, 5:4, scratch93, 4:3);
+	s(EmcPmacroDataPadRxCtrl, 10:8, scratch93, 7:5);
+	s(EmcPmacroDataPadRxCtrl, 22:12, scratch93, 18:8);
+	s(EmcPmacroDataPadRxCtrl, 28:24, scratch93, 23:19);
+	s(EmcRdv, 6:0, scratch93, 30:24);
+	s(EmcCfg, 21:21, scratch93, 31:31);
+	s(McEmemArbDaCovers, 23:0, scratch94, 23:0);
+	s(EmcRw2Pden, 6:0, scratch94, 30:24);
+	s(EmcCfg, 22:22, scratch94, 31:31);
+	s(EmcPmacroCmdCtrl2, 5:0, scratch95, 5:0);
+	s(EmcPmacroCmdCtrl2, 13:9, scratch95, 10:6);
+	s(EmcPmacroCmdCtrl2, 21:16, scratch95, 16:11);
+	s(EmcPmacroCmdCtrl2, 29:24, scratch95, 22:17);
+	s(EmcRfcPb, 8:0, scratch95, 31:23);
+	s(EmcPmacroQuseDdllRank0_0, 10:0, scratch96, 10:0);
+	s(EmcPmacroQuseDdllRank0_0, 26:16, scratch96, 21:11);
+	s(EmcCfgUpdate, 2:0, scratch96, 24:22);
+	s(EmcCfgUpdate, 10:8, scratch96, 27:25);
+	s(EmcCfgUpdate, 31:28, scratch96, 31:28);
+	s(EmcPmacroQuseDdllRank0_1, 10:0, scratch97, 10:0);
+	s(EmcPmacroQuseDdllRank0_1, 26:16, scratch97, 21:11);
+	s(EmcRfc, 9:0, scratch97, 31:22);
+	s(EmcPmacroQuseDdllRank0_2, 10:0, scratch98, 10:0);
+	s(EmcPmacroQuseDdllRank0_2, 26:16, scratch98, 21:11);
+	s(EmcTxsr, 9:0, scratch98, 31:22);
+	s(EmcPmacroQuseDdllRank0_3, 10:0, scratch99, 10:0);
+	s(EmcPmacroQuseDdllRank0_3, 26:16, scratch99, 21:11);
+	s(EmcMc2EmcQ, 2:0, scratch99, 24:22);
+	s(EmcMc2EmcQ, 10:8, scratch99, 27:25);
+	s(EmcMc2EmcQ, 27:24, scratch99, 31:28);
+	s(EmcPmacroQuseDdllRank0_4, 10:0, scratch100, 10:0);
+	s(EmcPmacroQuseDdllRank0_4, 26:16, scratch100, 21:11);
+	s(McEmemArbRing1Throttle, 4:0, scratch100, 26:22);
+	s(McEmemArbRing1Throttle, 20:16, scratch100, 31:27);
+	s(EmcPmacroQuseDdllRank0_5, 10:0, scratch101, 10:0);
+	s(EmcPmacroQuseDdllRank0_5, 26:16, scratch101, 21:11);
+	s(EmcPmacroQuseDdllRank1_0, 10:0, scratch102, 10:0);
+	s(EmcPmacroQuseDdllRank1_0, 26:16, scratch102, 21:11);
+	s(EmcAr2Pden, 8:0, scratch102, 30:22);
+	s(EmcCfg, 23:23, scratch102, 31:31);
+	s(EmcPmacroQuseDdllRank1_1, 10:0, scratch103, 10:0);
+	s(EmcPmacroQuseDdllRank1_1, 26:16, scratch103, 21:11);
+	s(EmcRfcSlr, 8:0, scratch103, 30:22);
+	s(EmcCfg, 24:24, scratch103, 31:31);
+	s(EmcPmacroQuseDdllRank1_2, 10:0, scratch104, 10:0);
+	s(EmcPmacroQuseDdllRank1_2, 26:16, scratch104, 21:11);
+	s(EmcIbdly, 6:0, scratch104, 28:22);
+	s(EmcIbdly, 29:28, scratch104, 30:29);
+	s(EmcCfg, 25:25, scratch104, 31:31);
+	s(EmcPmacroQuseDdllRank1_3, 10:0, scratch105, 10:0);
+	s(EmcPmacroQuseDdllRank1_3, 26:16, scratch105, 21:11);
+	s(McEmemArbTimingRFCPB, 8:0, scratch105, 30:22);
+	s(EmcCfg, 26:26, scratch105, 31:31);
+	s(EmcPmacroQuseDdllRank1_4, 10:0, scratch106, 10:0);
+	s(EmcPmacroQuseDdllRank1_4, 26:16, scratch106, 21:11);
+	s(EmcTfaw, 6:0, scratch106, 28:22);
+	s(EmcPmacroDataPadTxCtrl, 3:2, scratch106, 30:29);
+	s(EmcCfg, 28:28, scratch106, 31:31);
+	s(EmcPmacroQuseDdllRank1_5, 10:0, scratch107, 10:0);
+	s(EmcPmacroQuseDdllRank1_5, 26:16, scratch107, 21:11);
+	s(EmcTClkStable, 6:0, scratch107, 28:22);
+	s(EmcPmacroDataPadTxCtrl, 7:6, scratch107, 30:29);
+	s(EmcCfg, 29:29, scratch107, 31:31);
+	s(EmcPmacroObDdllLongDqRank0_0, 10:0, scratch108, 10:0);
+	s(EmcPmacroObDdllLongDqRank0_0, 26:16, scratch108, 21:11);
+	s(EmcPdex2Mrr, 6:0, scratch108, 28:22);
+	s(EmcPmacroDataPadTxCtrl, 11:10, scratch108, 30:29);
+	s(EmcCfg, 30:30, scratch108, 31:31);
+	s(EmcPmacroObDdllLongDqRank0_1, 10:0, scratch109, 10:0);
+	s(EmcPmacroObDdllLongDqRank0_1, 26:16, scratch109, 21:11);
+	s(EmcRdvMask, 6:0, scratch109, 28:22);
+	s(EmcPmacroDataPadTxCtrl, 15:14, scratch109, 30:29);
+	s(EmcCfg, 31:31, scratch109, 31:31);
+	s(EmcPmacroObDdllLongDqRank0_2, 10:0, scratch110, 10:0);
+	s(EmcPmacroObDdllLongDqRank0_2, 26:16, scratch110, 21:11);
+	s(EmcRdvEarlyMask, 6:0, scratch110, 28:22);
+	s(EmcFbioCfg5, 4:4, scratch110, 29:29);
+	s(EmcFbioCfg5, 8:8, scratch110, 30:30);
+	s(EmcFbioCfg5, 10:10, scratch110, 31:31);
+	s(EmcPmacroObDdllLongDqRank0_3, 10:0, scratch111, 10:0);
+	s(EmcPmacroObDdllLongDqRank0_3, 26:16, scratch111, 21:11);
+	s(EmcRdvEarly, 6:0, scratch111, 28:22);
+	s(EmcFbioCfg5, 12:12, scratch111, 29:29);
+	s(EmcFbioCfg5, 25:24, scratch111, 31:30);
+	s(EmcPmacroObDdllLongDqRank0_4, 10:0, scratch112, 10:0);
+	s(EmcPmacroObDdllLongDqRank0_4, 26:16, scratch112, 21:11);
+	s(EmcPmacroDdllShortCmd_2, 6:0, scratch112, 28:22);
+	s(EmcFbioCfg5, 28:26, scratch112, 31:29);
+	s(EmcPmacroObDdllLongDqRank0_5, 10:0, scratch113, 10:0);
+	s(EmcPmacroObDdllLongDqRank0_5, 26:16, scratch113, 21:11);
+	s(McEmemArbTimingRp, 6:0, scratch113, 28:22);
+	s(EmcFbioCfg5, 31:30, scratch113, 30:29);
+	s(EmcCfg2, 0:0, scratch113, 31:31);
+	s(EmcPmacroObDdllLongDqRank1_0, 10:0, scratch114, 10:0);
+	s(EmcPmacroObDdllLongDqRank1_0, 26:16, scratch114, 21:11);
+	s(McEmemArbTimingRas, 6:0, scratch114, 28:22);
+	s(EmcCfg2, 2:1, scratch114, 30:29);
+	s(EmcCfg2, 7:7, scratch114, 31:31);
+	s(EmcPmacroObDdllLongDqRank1_1, 10:0, scratch115, 10:0);
+	s(EmcPmacroObDdllLongDqRank1_1, 26:16, scratch115, 21:11);
+	s(McEmemArbTimingFaw, 6:0, scratch115, 28:22);
+	s(EmcCfg2, 11:10, scratch115, 30:29);
+	s(EmcCfg2, 14:14, scratch115, 31:31);
+	s(EmcPmacroObDdllLongDqRank1_2, 10:0, scratch123, 10:0);
+	s(EmcPmacroObDdllLongDqRank1_2, 26:16, scratch123, 21:11);
+	s(McEmemArbTimingRap2Pre, 6:0, scratch123, 28:22);
+	s(EmcCfg2, 16:15, scratch123, 30:29);
+	s(EmcCfg2, 20:20, scratch123, 31:31);
+	s(EmcPmacroObDdllLongDqRank1_3, 10:0, scratch124, 10:0);
+	s(EmcPmacroObDdllLongDqRank1_3, 26:16, scratch124, 21:11);
+	s(McEmemArbTimingWap2Pre, 6:0, scratch124, 28:22);
+	s(EmcCfg2, 24:22, scratch124, 31:29);
+	s(EmcPmacroObDdllLongDqRank1_4, 10:0, scratch125, 10:0);
+	s(EmcPmacroObDdllLongDqRank1_4, 26:16, scratch125, 21:11);
+	s(McEmemArbTimingR2W, 6:0, scratch125, 28:22);
+	s(EmcCfg2, 25:25, scratch125, 29:29);
+	s(EmcCfg2, 29:28, scratch125, 31:30);
+	s(EmcPmacroObDdllLongDqRank1_5, 10:0, scratch126, 10:0);
+	s(EmcPmacroObDdllLongDqRank1_5, 26:16, scratch126, 21:11);
+	s(McEmemArbTimingW2R, 6:0, scratch126, 28:22);
+	s(EmcCfg2, 31:30, scratch126, 30:29);
+	s(EmcCfgPipe, 0:0, scratch126, 31:31);
+	s(EmcPmacroObDdllLongDqsRank0_0, 10:0, scratch127, 10:0);
+	s(EmcPmacroObDdllLongDqsRank0_0, 26:16, scratch127, 21:11);
+	s(EmcRp, 5:0, scratch127, 27:22);
+	s(EmcCfgPipe, 4:1, scratch127, 31:28);
+	s(EmcPmacroObDdllLongDqsRank0_1, 10:0, scratch128, 10:0);
+	s(EmcPmacroObDdllLongDqsRank0_1, 26:16, scratch128, 21:11);
+	s(EmcR2w, 5:0, scratch128, 27:22);
+	s(EmcCfgPipe, 8:5, scratch128, 31:28);
+	s(EmcPmacroObDdllLongDqsRank0_2, 10:0, scratch129, 10:0);
+	s(EmcPmacroObDdllLongDqsRank0_2, 26:16, scratch129, 21:11);
+	s(EmcW2r, 5:0, scratch129, 27:22);
+	s(EmcCfgPipe, 11:9, scratch129, 30:28);
+	s(EmcCfgPipe, 16:16, scratch129, 31:31);
+	s(EmcPmacroObDdllLongDqsRank0_3, 10:0, scratch130, 10:0);
+	s(EmcPmacroObDdllLongDqsRank0_3, 26:16, scratch130, 21:11);
+	s(EmcR2p, 5:0, scratch130, 27:22);
+	s(EmcCfgPipe, 20:17, scratch130, 31:28);
+	s(EmcPmacroObDdllLongDqsRank0_4, 10:0, scratch131, 10:0);
+	s(EmcPmacroObDdllLongDqsRank0_4, 26:16, scratch131, 21:11);
+	s(EmcCcdmw, 5:0, scratch131, 27:22);
+	s(EmcCfgPipe, 24:21, scratch131, 31:28);
+	s(EmcPmacroObDdllLongDqsRank0_5, 10:0, scratch132, 10:0);
+	s(EmcPmacroObDdllLongDqsRank0_5, 26:16, scratch132, 21:11);
+	s(EmcRdRcd, 5:0, scratch132, 27:22);
+	s(EmcCfgPipe, 27:25, scratch132, 30:28);
+	s(EmcPmacroTxPwrd0, 0:0, scratch132, 31:31);
+	s(EmcPmacroObDdllLongDqsRank1_0, 10:0, scratch133, 10:0);
+	s(EmcPmacroObDdllLongDqsRank1_0, 26:16, scratch133, 21:11);
+	s(EmcWrRcd, 5:0, scratch133, 27:22);
+	s(EmcPmacroTxPwrd0, 4:1, scratch133, 31:28);
+	s(EmcPmacroObDdllLongDqsRank1_1, 10:0, scratch134, 10:0);
+	s(EmcPmacroObDdllLongDqsRank1_1, 26:16, scratch134, 21:11);
+	s(EmcWdv, 5:0, scratch134, 27:22);
+	s(EmcPmacroTxPwrd0, 8:5, scratch134, 31:28);
+	s(EmcPmacroObDdllLongDqsRank1_2, 10:0, scratch135, 10:0);
+	s(EmcPmacroObDdllLongDqsRank1_2, 26:16, scratch135, 21:11);
+	s(EmcQUse, 5:0, scratch135, 27:22);
+	s(EmcPmacroTxPwrd0, 12:9, scratch135, 31:28);
+	s(EmcPmacroObDdllLongDqsRank1_3, 10:0, scratch136, 10:0);
+	s(EmcPmacroObDdllLongDqsRank1_3, 26:16, scratch136, 21:11);
+	s(EmcPdEx2Wr, 5:0, scratch136, 27:22);
+	s(EmcPmacroTxPwrd0, 13:13, scratch136, 28:28);
+	s(EmcPmacroTxPwrd0, 18:16, scratch136, 31:29);
+	s(EmcPmacroObDdllLongDqsRank1_4, 10:0, scratch137, 10:0);
+	s(EmcPmacroObDdllLongDqsRank1_4, 26:16, scratch137, 21:11);
+	s(EmcPdEx2Rd, 5:0, scratch137, 27:22);
+	s(EmcPmacroTxPwrd0, 22:19, scratch137, 31:28);
+	s(EmcPmacroObDdllLongDqsRank1_5, 10:0, scratch138, 10:0);
+	s(EmcPmacroObDdllLongDqsRank1_5, 26:16, scratch138, 21:11);
+	s(EmcPdex2Cke, 5:0, scratch138, 27:22);
+	s(EmcPmacroTxPwrd0, 26:23, scratch138, 31:28);
+	s(EmcPmacroIbDdllLongDqsRank0_0, 10:0, scratch139, 10:0);
+	s(EmcPmacroIbDdllLongDqsRank0_0, 26:16, scratch139, 21:11);
+	s(EmcPChg2Pden, 5:0, scratch139, 27:22);
+	s(EmcPmacroTxPwrd0, 29:27, scratch139, 30:28);
+	s(EmcPmacroTxPwrd1, 0:0, scratch139, 31:31);
+	s(EmcPmacroIbDdllLongDqsRank0_1, 10:0, scratch140, 10:0);
+	s(EmcPmacroIbDdllLongDqsRank0_1, 26:16, scratch140, 21:11);
+	s(EmcAct2Pden, 5:0, scratch140, 27:22);
+	s(EmcPmacroTxPwrd1, 4:1, scratch140, 31:28);
+	s(EmcPmacroIbDdllLongDqsRank0_2, 10:0, scratch141, 10:0);
+	s(EmcPmacroIbDdllLongDqsRank0_2, 26:16, scratch141, 21:11);
+	s(EmcCke2Pden, 5:0, scratch141, 27:22);
+	s(EmcPmacroTxPwrd1, 8:5, scratch141, 31:28);
+	s(EmcPmacroIbDdllLongDqsRank0_3, 10:0, scratch142, 10:0);
+	s(EmcPmacroIbDdllLongDqsRank0_3, 26:16, scratch142, 21:11);
+	s(EmcTcke, 5:0, scratch142, 27:22);
+	s(EmcPmacroTxPwrd1, 12:9, scratch142, 31:28);
+	s(EmcPmacroIbDdllLongDqsRank1_0, 10:0, scratch143, 10:0);
+	s(EmcPmacroIbDdllLongDqsRank1_0, 26:16, scratch143, 21:11);
+	s(EmcTrpab, 5:0, scratch143, 27:22);
+	s(EmcPmacroTxPwrd1, 13:13, scratch143, 28:28);
+	s(EmcPmacroTxPwrd1, 18:16, scratch143, 31:29);
+	s(EmcPmacroIbDdllLongDqsRank1_1, 10:0, scratch144, 10:0);
+	s(EmcPmacroIbDdllLongDqsRank1_1, 26:16, scratch144, 21:11);
+	s(EmcClkenOverride, 3:1, scratch144, 24:22);
+	s(EmcClkenOverride, 8:6, scratch144, 27:25);
+	s(EmcPmacroTxPwrd1, 22:19, scratch144, 31:28);
+	s(EmcPmacroIbDdllLongDqsRank1_2, 10:0, scratch145, 10:0);
+	s(EmcPmacroIbDdllLongDqsRank1_2, 26:16, scratch145, 21:11);
+	s(EmcEInput, 5:0, scratch145, 27:22);
+	s(EmcPmacroTxPwrd1, 26:23, scratch145, 31:28);
+	s(EmcPmacroIbDdllLongDqsRank1_3, 10:0, scratch146, 10:0);
+	s(EmcPmacroIbDdllLongDqsRank1_3, 26:16, scratch146, 21:11);
+	s(EmcEInputDuration, 5:0, scratch146, 27:22);
+	s(EmcPmacroTxPwrd1, 29:27, scratch146, 30:28);
+	s(EmcPmacroTxPwrd2, 0:0, scratch146, 31:31);
+	s(EmcPmacroDdllLongCmd_0, 10:0, scratch147, 10:0);
+	s(EmcPmacroDdllLongCmd_0, 26:16, scratch147, 21:11);
+	s(EmcPutermExtra, 5:0, scratch147, 27:22);
+	s(EmcPmacroTxPwrd2, 4:1, scratch147, 31:28);
+	s(EmcPmacroDdllLongCmd_1, 10:0, scratch148, 10:0);
+	s(EmcPmacroDdllLongCmd_1, 26:16, scratch148, 21:11);
+	s(EmcTckesr, 5:0, scratch148, 27:22);
+	s(EmcPmacroTxPwrd2, 8:5, scratch148, 31:28);
+	s(EmcPmacroDdllLongCmd_2, 10:0, scratch149, 10:0);
+	s(EmcPmacroDdllLongCmd_2, 26:16, scratch149, 21:11);
+	s(EmcTpd, 5:0, scratch149, 27:22);
+	s(EmcPmacroTxPwrd2, 12:9, scratch149, 31:28);
+	s(EmcPmacroDdllLongCmd_3, 10:0, scratch150, 10:0);
+	s(EmcPmacroDdllLongCmd_3, 26:16, scratch150, 21:11);
+	s(EmcWdvMask, 5:0, scratch150, 27:22);
+	s(EmcPmacroTxPwrd2, 13:13, scratch150, 28:28);
+	s(EmcPmacroTxPwrd2, 18:16, scratch150, 31:29);
+	s(McEmemArbCfg, 8:0, scratch151, 8:0);
+	s(McEmemArbCfg, 20:16, scratch151, 13:9);
+	s(McEmemArbCfg, 31:24, scratch151, 21:14);
+	s(EmcWdvChk, 5:0, scratch151, 27:22);
+	s(EmcPmacroTxPwrd2, 22:19, scratch151, 31:28);
+	s(McEmemArbMisc1, 12:0, scratch152, 12:0);
+	s(McEmemArbMisc1, 25:21, scratch152, 17:13);
+	s(McEmemArbMisc1, 31:28, scratch152, 21:18);
+	s(EmcCmdBrlshft0, 5:0, scratch152, 27:22);
+	s(EmcPmacroTxPwrd2, 26:23, scratch152, 31:28);
+	s(EmcMrsWaitCnt2, 9:0, scratch153, 9:0);
+	s(EmcMrsWaitCnt2, 26:16, scratch153, 20:10);
+	s(EmcPmacroIbRxrt, 10:0, scratch153, 31:21);
+	s(EmcMrsWaitCnt, 9:0, scratch154, 9:0);
+	s(EmcMrsWaitCnt, 26:16, scratch154, 20:10);
+	s(EmcPmacroDdllLongCmd_4, 10:0, scratch154, 31:21);
+	s(EmcAutoCalInterval, 20:0, scratch155, 20:0);
+	s(McEmemArbOutstandingReq, 8:0, scratch155, 29:21);
+	s(McEmemArbOutstandingReq, 31:30, scratch155, 31:30);
+	s(McEmemArbRefpbHpCtrl, 6:0, scratch156, 6:0);
+	s(McEmemArbRefpbHpCtrl, 14:8, scratch156, 13:7);
+	s(McEmemArbRefpbHpCtrl, 22:16, scratch156, 20:14);
+	s(EmcCmdBrlshft1, 5:0, scratch156, 26:21);
+	s(EmcRrd, 4:0, scratch156, 31:27);
+	s(EmcQuseBrlshft0, 19:0, scratch157, 19:0);
+	s(EmcFbioCfg8, 27:16, scratch157, 31:20);
+	s(EmcQuseBrlshft1, 19:0, scratch158, 19:0);
+	s(EmcTxsrDll, 11:0, scratch158, 31:20);
+	s(EmcQuseBrlshft2, 19:0, scratch159, 19:0);
+	s(EmcTxdsrvttgen, 11:0, scratch159, 31:20);
+	s(EmcQuseBrlshft3, 19:0, scratch160, 19:0);
+	s(EmcPmacroVttgenCtrl0, 3:0, scratch160, 23:20);
+	s(EmcPmacroVttgenCtrl0, 11:8, scratch160, 27:24);
+	s(EmcPmacroVttgenCtrl0, 19:16, scratch160, 31:28);
+	s(EmcPmacroVttgenCtrl1, 19:0, scratch161, 19:0);
+	s(EmcCmdBrlshft2, 5:0, scratch161, 25:20);
+	s(EmcCmdBrlshft3, 5:0, scratch161, 31:26);
+	s(EmcAutoCalConfig3, 5:0, scratch162, 5:0);
+	s(EmcAutoCalConfig3, 13:8, scratch162, 11:6);
+	s(EmcAutoCalConfig3, 18:16, scratch162, 14:12);
+	s(EmcAutoCalConfig3, 22:20, scratch162, 17:15);
+	s(EmcTRefBw, 13:0, scratch162, 31:18);
+	s(EmcAutoCalConfig4, 5:0, scratch163, 5:0);
+	s(EmcAutoCalConfig4, 13:8, scratch163, 11:6);
+	s(EmcAutoCalConfig4, 18:16, scratch163, 14:12);
+	s(EmcAutoCalConfig4, 22:20, scratch163, 17:15);
+	s(EmcQpop, 6:0, scratch163, 24:18);
+	s(EmcQpop, 22:16, scratch163, 31:25);
+	s(EmcAutoCalConfig5, 5:0, scratch164, 5:0);
+	s(EmcAutoCalConfig5, 13:8, scratch164, 11:6);
+	s(EmcAutoCalConfig5, 18:16, scratch164, 14:12);
+	s(EmcAutoCalConfig5, 22:20, scratch164, 17:15);
+	s(EmcPmacroAutocalCfgCommon, 5:0, scratch164, 23:18);
+	s(EmcPmacroAutocalCfgCommon, 13:8, scratch164, 29:24);
+	s(EmcPmacroAutocalCfgCommon, 16:16, scratch164, 30:30);
+	s(EmcPmacroTxPwrd2, 27:27, scratch164, 31:31);
+	s(EmcAutoCalConfig6, 5:0, scratch165, 5:0);
+	s(EmcAutoCalConfig6, 13:8, scratch165, 11:6);
+	s(EmcAutoCalConfig6, 18:16, scratch165, 14:12);
+	s(EmcAutoCalConfig6, 22:20, scratch165, 17:15);
+	s(EmcWev, 5:0, scratch165, 23:18);
+	s(EmcWsv, 5:0, scratch165, 29:24);
+	s(EmcPmacroTxPwrd2, 29:28, scratch165, 31:30);
+	s(EmcAutoCalConfig7, 5:0, scratch166, 5:0);
+	s(EmcAutoCalConfig7, 13:8, scratch166, 11:6);
+	s(EmcAutoCalConfig7, 18:16, scratch166, 14:12);
+	s(EmcAutoCalConfig7, 22:20, scratch166, 17:15);
+	s(EmcCfg3, 2:0, scratch166, 20:18);
+	s(EmcCfg3, 6:4, scratch166, 23:21);
+	s(EmcQuseWidth, 3:0, scratch166, 27:24);
+	s(EmcQuseWidth, 29:28, scratch166, 29:28);
+	s(EmcPmacroTxPwrd3, 1:0, scratch166, 31:30);
+	s(EmcAutoCalConfig8, 5:0, scratch167, 5:0);
+	s(EmcAutoCalConfig8, 13:8, scratch167, 11:6);
+	s(EmcAutoCalConfig8, 18:16, scratch167, 14:12);
+	s(EmcAutoCalConfig8, 22:20, scratch167, 17:15);
+	s(EmcPmacroBgBiasCtrl0, 2:0, scratch167, 20:18);
+	s(EmcPmacroBgBiasCtrl0, 6:4, scratch167, 23:21);
+	s(McEmemArbTimingRcd, 5:0, scratch167, 29:24);
+	s(EmcPmacroTxPwrd3, 3:2, scratch167, 31:30);
+	s(EmcXm2CompPadCtrl2, 17:0, scratch168, 17:0);
+	s(McEmemArbTimingCcdmw, 5:0, scratch168, 23:18);
+	s(McEmemArbOverride, 27:27, scratch168, 24:24);
+	s(McEmemArbOverride, 26:26, scratch168, 25:25);
+	s(McEmemArbOverride, 16:16, scratch168, 26:26);
+	s(McEmemArbOverride, 10:10, scratch168, 27:27);
+	s(McEmemArbOverride, 4:4, scratch168, 28:28);
+	s(McEmemArbOverride, 3:3, scratch168, 29:29);
+	s(EmcPmacroTxPwrd3, 5:4, scratch168, 31:30);
+	s(EmcXm2CompPadCtrl3, 17:0, scratch169, 17:0);
+	s(EmcRext, 4:0, scratch169, 22:18);
+	s(EmcTClkStop, 4:0, scratch169, 27:23);
+	s(EmcPmacroTxPwrd3, 9:6, scratch169, 31:28);
+	s(EmcZcalWaitCnt, 10:0, scratch170, 10:0);
+	s(EmcZcalWaitCnt, 21:16, scratch170, 16:11);
+	s(EmcZcalWaitCnt, 31:31, scratch170, 17:17);
+	s(EmcWext, 4:0, scratch170, 22:18);
+	s(EmcRefctrl2, 0:0, scratch170, 23:23);
+	s(EmcRefctrl2, 26:24, scratch170, 26:24);
+	s(EmcRefctrl2, 31:31, scratch170, 27:27);
+	s(EmcPmacroTxPwrd3, 13:10, scratch170, 31:28);
+	s(EmcZcalMrwCmd, 7:0, scratch171, 7:0);
+	s(EmcZcalMrwCmd, 23:16, scratch171, 15:8);
+	s(EmcZcalMrwCmd, 31:30, scratch171, 17:16);
+	s(EmcWeDuration, 4:0, scratch171, 22:18);
+	s(EmcWsDuration, 4:0, scratch171, 27:23);
+	s(EmcPmacroTxPwrd3, 19:16, scratch171, 31:28);
+	s(EmcSwizzleRank0Byte0, 2:0, scratch172, 2:0);
+	s(EmcSwizzleRank0Byte0, 6:4, scratch172, 5:3);
+	s(EmcSwizzleRank0Byte0, 10:8, scratch172, 8:6);
+	s(EmcSwizzleRank0Byte0, 14:12, scratch172, 11:9);
+	s(EmcSwizzleRank0Byte0, 18:16, scratch172, 14:12);
+	s(EmcSwizzleRank0Byte0, 22:20, scratch172, 17:15);
+	s(EmcPutermWidth, 31:31, scratch172, 18:18);
+	s(EmcPutermWidth, 3:0, scratch172, 22:19);
+	s(McEmemArbTimingRrd, 4:0, scratch172, 27:23);
+	s(EmcPmacroTxPwrd3, 23:20, scratch172, 31:28);
+	s(EmcSwizzleRank0Byte1, 2:0, scratch173, 2:0);
+	s(EmcSwizzleRank0Byte1, 6:4, scratch173, 5:3);
+	s(EmcSwizzleRank0Byte1, 10:8, scratch173, 8:6);
+	s(EmcSwizzleRank0Byte1, 14:12, scratch173, 11:9);
+	s(EmcSwizzleRank0Byte1, 18:16, scratch173, 14:12);
+	s(EmcSwizzleRank0Byte1, 22:20, scratch173, 17:15);
+	s(McEmemArbTimingR2R, 4:0, scratch173, 22:18);
+	s(McEmemArbTimingW2W, 4:0, scratch173, 27:23);
+	s(EmcPmacroTxPwrd3, 27:24, scratch173, 31:28);
+	s(EmcSwizzleRank0Byte2, 2:0, scratch174, 2:0);
+	s(EmcSwizzleRank0Byte2, 6:4, scratch174, 5:3);
+	s(EmcSwizzleRank0Byte2, 10:8, scratch174, 8:6);
+	s(EmcSwizzleRank0Byte2, 14:12, scratch174, 11:9);
+	s(EmcSwizzleRank0Byte2, 18:16, scratch174, 14:12);
+	s(EmcSwizzleRank0Byte2, 22:20, scratch174, 17:15);
+	s(EmcPmacroTxPwrd3, 29:28, scratch174, 19:18);
+	s(EmcPmacroTxSelClkSrc0, 11:0, scratch174, 31:20);
+	s(EmcSwizzleRank0Byte3, 2:0, scratch175, 2:0);
+	s(EmcSwizzleRank0Byte3, 6:4, scratch175, 5:3);
+	s(EmcSwizzleRank0Byte3, 10:8, scratch175, 8:6);
+	s(EmcSwizzleRank0Byte3, 14:12, scratch175, 11:9);
+	s(EmcSwizzleRank0Byte3, 18:16, scratch175, 14:12);
+	s(EmcSwizzleRank0Byte3, 22:20, scratch175, 17:15);
+	s(EmcPmacroTxSelClkSrc0, 27:16, scratch175, 29:18);
+	s(EmcPmacroTxSelClkSrc1, 1:0, scratch175, 31:30);
+	s(EmcSwizzleRank1Byte0, 2:0, scratch176, 2:0);
+	s(EmcSwizzleRank1Byte0, 6:4, scratch176, 5:3);
+	s(EmcSwizzleRank1Byte0, 10:8, scratch176, 8:6);
+	s(EmcSwizzleRank1Byte0, 14:12, scratch176, 11:9);
+	s(EmcSwizzleRank1Byte0, 18:16, scratch176, 14:12);
+	s(EmcSwizzleRank1Byte0, 22:20, scratch176, 17:15);
+	s(EmcPmacroTxSelClkSrc1, 11:2, scratch176, 27:18);
+	s(EmcPmacroTxSelClkSrc1, 19:16, scratch176, 31:28);
+	s(EmcSwizzleRank1Byte1, 2:0, scratch177, 2:0);
+	s(EmcSwizzleRank1Byte1, 6:4, scratch177, 5:3);
+	s(EmcSwizzleRank1Byte1, 10:8, scratch177, 8:6);
+	s(EmcSwizzleRank1Byte1, 14:12, scratch177, 11:9);
+	s(EmcSwizzleRank1Byte1, 18:16, scratch177, 14:12);
+	s(EmcSwizzleRank1Byte1, 22:20, scratch177, 17:15);
+	s(EmcPmacroTxSelClkSrc1, 27:20, scratch177, 25:18);
+	s(EmcPmacroTxSelClkSrc3, 5:0, scratch177, 31:26);
+	s(EmcSwizzleRank1Byte2, 2:0, scratch178, 2:0);
+	s(EmcSwizzleRank1Byte2, 6:4, scratch178, 5:3);
+	s(EmcSwizzleRank1Byte2, 10:8, scratch178, 8:6);
+	s(EmcSwizzleRank1Byte2, 14:12, scratch178, 11:9);
+	s(EmcSwizzleRank1Byte2, 18:16, scratch178, 14:12);
+	s(EmcSwizzleRank1Byte2, 22:20, scratch178, 17:15);
+	s(EmcPmacroTxSelClkSrc3, 11:6, scratch178, 23:18);
+	s(EmcPmacroTxSelClkSrc3, 23:16, scratch178, 31:24);
+	s(EmcSwizzleRank1Byte3, 2:0, scratch179, 2:0);
+	s(EmcSwizzleRank1Byte3, 6:4, scratch179, 5:3);
+	s(EmcSwizzleRank1Byte3, 10:8, scratch179, 8:6);
+	s(EmcSwizzleRank1Byte3, 14:12, scratch179, 11:9);
+	s(EmcSwizzleRank1Byte3, 18:16, scratch179, 14:12);
+	s(EmcSwizzleRank1Byte3, 22:20, scratch179, 17:15);
+	s(EmcPmacroTxSelClkSrc3, 27:24, scratch179, 21:18);
+	s(EmcPmacroTxSelClkSrc2, 9:0, scratch179, 31:22);
+	s(EmcPmacroCmdBrickCtrlFdpd, 17:0, scratch180, 17:0);
+	s(EmcPmacroTxSelClkSrc2, 11:10, scratch180, 19:18);
+	s(EmcPmacroTxSelClkSrc2, 27:16, scratch180, 31:20);
+	s(EmcPmacroDataBrickCtrlFdpd, 17:0, scratch181, 17:0);
+	s(EmcPmacroTxSelClkSrc4, 11:0, scratch181, 29:18);
+	s(EmcPmacroTxSelClkSrc4, 17:16, scratch181, 31:30);
+	s(EmcFbioCfg7, 16:0, scratch182, 16:0);
+	s(McEmemArbRefpbBankCtrl, 6:0, scratch182, 23:17);
+	s(McEmemArbRefpbBankCtrl, 14:8, scratch182, 30:24);
+	s(McEmemArbRefpbBankCtrl, 31:31, scratch182, 31:31);
+	s(EmcDynSelfRefControl, 15:0, scratch183, 15:0);
+	s(EmcDynSelfRefControl, 31:31, scratch183, 16:16);
+	s(EmcPmacroTxSelClkSrc4, 27:18, scratch183, 26:17);
+	s(EmcPmacroTxSelClkSrc5, 4:0, scratch183, 31:27);
+	s(EmcDllCfg1, 16:0, scratch184, 16:0);
+	s(EmcPmacroTxSelClkSrc5, 11:5, scratch184, 23:17);
+	s(EmcPmacroTxSelClkSrc5, 23:16, scratch184, 31:24);
+	s(EmcPmacroPadCfgCtrl, 1:0, scratch185, 1:0);
+	s(EmcPmacroPadCfgCtrl, 6:5, scratch185, 3:2);
+	s(EmcPmacroPadCfgCtrl, 11:9, scratch185, 6:4);
+	s(EmcPmacroPadCfgCtrl, 13:13, scratch185, 7:7);
+	s(EmcPmacroPadCfgCtrl, 17:16, scratch185, 9:8);
+	s(EmcPmacroPadCfgCtrl, 21:20, scratch185, 11:10);
+	s(EmcPmacroPadCfgCtrl, 25:24, scratch185, 13:12);
+	s(EmcPmacroPadCfgCtrl, 30:28, scratch185, 16:14);
+	s(EmcPmacroTxSelClkSrc5, 27:24, scratch185, 20:17);
+	s(EmcPmacroCmdPadTxCtrl, 1:0, scratch185, 22:21);
+	s(EmcPmacroCmdPadTxCtrl, 5:4, scratch185, 24:23);
+	s(EmcPmacroCmdPadTxCtrl, 9:8, scratch185, 26:25);
+	s(EmcPmacroCmdPadTxCtrl, 13:12, scratch185, 28:27);
+	s(EmcPmacroCmdPadTxCtrl, 16:16, scratch185, 29:29);
+	s(EmcPmacroCmdPadTxCtrl, 21:20, scratch185, 31:30);
+	s(EmcRefresh, 15:0, scratch186, 15:0);
+	s(EmcCmdQ, 4:0, scratch186, 20:16);
+	s(EmcCmdQ, 10:8, scratch186, 23:21);
+	s(EmcCmdQ, 14:12, scratch186, 26:24);
+	s(EmcCmdQ, 28:24, scratch186, 31:27);
+	s(EmcAcpdControl, 15:0, scratch187, 15:0);
+	s(EmcAutoCalVrefSel1, 15:0, scratch187, 31:16);
+	s(EmcXm2CompPadCtrl, 1:0, scratch188, 1:0);
+	s(EmcXm2CompPadCtrl, 6:3, scratch188, 5:2);
+	s(EmcXm2CompPadCtrl, 9:9, scratch188, 6:6);
+	s(EmcXm2CompPadCtrl, 19:11, scratch188, 15:7);
+	s(EmcCfgDigDllPeriod, 15:0, scratch188, 31:16);
+	s(EmcCfgDigDll_1, 15:0, scratch189, 15:0);
+	s(EmcPreRefreshReqCnt, 15:0, scratch189, 31:16);
+	s(EmcPmacroCmdPadTxCtrl, 27:24, scratch190, 19:16);
+	s(EmcPmacroDataPadTxCtrl, 1:0, scratch190, 21:20);
+	s(EmcPmacroDataPadTxCtrl, 5:4, scratch190, 23:22);
+	s(EmcPmacroDataPadTxCtrl, 9:8, scratch190, 25:24);
+	s(EmcPmacroDataPadTxCtrl, 13:12, scratch190, 27:26);
+	s(EmcPmacroDataPadTxCtrl, 16:16, scratch190, 28:28);
+	s(EmcPmacroDataPadTxCtrl, 21:20, scratch190, 30:29);
+	s(EmcPmacroDataPadTxCtrl, 24:24, scratch190, 31:31);
+	s(EmcPmacroDataPadTxCtrl, 27:25, scratch191, 2:0);
+
+	s(EmcPinGpio, 1:0, scratch8, 31:30);
+	s(EmcPinGpioEn, 1:0, scratch9, 31:30);
+	s(EmcDevSelect, 1:0, scratch10, 31:30);
+	s(EmcZcalWarmColdBootEnables, 1:0, scratch11, 31:30);
+	s(EmcCfgDigDllPeriodWarmBoot, 1:0, scratch12, 31:30);
+	s32(EmcBctSpare13, scratch31);
+	s32(EmcBctSpare12, scratch32);
+	s32(EmcBctSpare7, scratch33);
+	s32(EmcBctSpare6, scratch40);
+	s32(EmcBctSpare5, scratch42);
+	s32(EmcBctSpare4, scratch44);
+	s32(EmcBctSpare3, scratch45);
+	s32(EmcBctSpare2, scratch46);
+	s32(EmcBctSpare1, scratch47);
+	s32(EmcBctSpare0, scratch48);
+	s32(EmcBctSpare9, scratch50);
+	s32(EmcBctSpare8, scratch51);
+	s32(BootRomPatchData, scratch56);
+	s32(BootRomPatchControl, scratch57);
+	s(McClkenOverrideAllWarmBoot, 0:0, scratch58, 31:31);
+	s(EmcClkenOverrideAllWarmBoot, 0:0, scratch59, 30:30);
+	s(EmcMrsWarmBootEnable, 0:0, scratch59, 31:31);
+	s(ClearClk2Mc1, 0:0, scratch60, 30:30);
+	s(EmcWarmBootExtraModeRegWriteEnable, 0:0, scratch60, 31:31);
+	s(ClkRstControllerPllmMisc2OverrideEnable, 0:0, scratch61, 30:30);
+	s(EmcDbgWriteMux, 0:0, scratch61, 31:31);
+	s(EmcExtraRefreshNum, 2:0, scratch62, 31:29);
+	s(PmcIoDpd3ReqWait, 2:0, scratch68, 30:28);
+	s(AhbArbitrationXbarCtrlMemInitDone, 0:0, scratch68, 31:31);
+	s(MemoryType, 2:0, scratch69, 30:28);
+	s(PmcIoDpd4ReqWait, 2:0, scratch70, 30:28);
+	s(EmcTimingControlWait, 7:0, scratch86, 31:24);
+	s(EmcZcalWarmBootWait, 7:0, scratch87, 31:24);
+	s(WarmBootWait, 7:0, scratch88, 31:24);
+	s(EmcPinProgramWait, 7:0, scratch89, 31:24);
+	s(EmcAutoCalWait, 9:0, scratch101, 31:22);
+	s(SwizzleRankByteEncode, 15:0, scratch190, 15:0);
+
+	switch (sdram->MemoryType)
+	{
+	case NvBootMemoryType_LpDdr2:
+	case NvBootMemoryType_LpDdr4:
+		s(EmcMrwLpddr2ZcalWarmBoot, 23:16, scratch5, 7:0);
+		s(EmcMrwLpddr2ZcalWarmBoot, 7:0, scratch5, 15:8);
+		s(EmcWarmBootMrwExtra, 23:16, scratch5, 23:16);
+		s(EmcWarmBootMrwExtra, 7:0, scratch5, 31:24);
+		s(EmcMrwLpddr2ZcalWarmBoot, 31:30, scratch6, 1:0);
+		s(EmcWarmBootMrwExtra, 31:30, scratch6, 3:2);
+		s(EmcMrwLpddr2ZcalWarmBoot, 27:26, scratch6, 5:4);
+		s(EmcWarmBootMrwExtra, 27:26, scratch6, 7:6);
+		s(EmcMrw6, 27:0, scratch8, 27:0);
+		s(EmcMrw6, 31:30, scratch8, 29:28);
+		s(EmcMrw8, 27:0, scratch9, 27:0);
+		s(EmcMrw8, 31:30, scratch9, 29:28);
+		s(EmcMrw9, 27:0, scratch10, 27:0);
+		s(EmcMrw9, 31:30, scratch10, 29:28);
+		s(EmcMrw10, 27:0, scratch11, 27:0);
+		s(EmcMrw10, 31:30, scratch11, 29:28);
+		s(EmcMrw12, 27:0, scratch12, 27:0);
+		s(EmcMrw12, 31:30, scratch12, 29:28);
+		s(EmcMrw13, 27:0, scratch13, 27:0);
+		s(EmcMrw13, 31:30, scratch13, 29:28);
+		s(EmcMrw14, 27:0, scratch14, 27:0);
+		s(EmcMrw14, 31:30, scratch14, 29:28);
+		s(EmcMrw1, 7:0, scratch15, 7:0);
+		s(EmcMrw1, 23:16, scratch15, 15:8);
+		s(EmcMrw1, 27:26, scratch15, 17:16);
+		s(EmcMrw1, 31:30, scratch15, 19:18);
+		s(EmcWarmBootMrwExtra, 7:0, scratch16, 7:0);
+		s(EmcWarmBootMrwExtra, 23:16, scratch16, 15:8);
+		s(EmcWarmBootMrwExtra, 27:26, scratch16, 17:16);
+		s(EmcWarmBootMrwExtra, 31:30, scratch16, 19:18);
+		s(EmcMrw2, 7:0, scratch17, 7:0);
+		s(EmcMrw2, 23:16, scratch17, 15:8);
+		s(EmcMrw2, 27:26, scratch17, 17:16);
+		s(EmcMrw2, 31:30, scratch17, 19:18);
+		s(EmcMrw3, 7:0, scratch18, 7:0);
+		s(EmcMrw3, 23:16, scratch18, 15:8);
+		s(EmcMrw3, 27:26, scratch18, 17:16);
+		s(EmcMrw3, 31:30, scratch18, 19:18);
+		s(EmcMrw4, 7:0, scratch19, 7:0);
+		s(EmcMrw4, 23:16, scratch19, 15:8);
+		s(EmcMrw4, 27:26, scratch19, 17:16);
+		s(EmcMrw4, 31:30, scratch19, 19:18);
+		break;
+	case NvBootMemoryType_Ddr3:
+		s(EmcMrs, 13:0, scratch5, 13:0);
+		s(EmcEmrs, 13:0, scratch5, 27:14);
+		s(EmcMrs, 21:20, scratch5, 29:28);
+		s(EmcMrs, 31:30, scratch5, 31:30);
+		s(EmcEmrs2, 13:0, scratch8, 13:0);
+		s(EmcEmrs3, 13:0, scratch8, 27:14);
+		s(EmcEmrs, 21:20, scratch8, 29:28);
+		s(EmcWarmBootMrsExtra, 13:0, scratch9, 13:0);
+		s(EmcEmrs, 31:30, scratch9, 15:14);
+		s(EmcEmrs2, 21:20, scratch9, 17:16);
+		s(EmcEmrs2, 31:30, scratch9, 19:18);
+		s(EmcEmrs3, 21:20, scratch9, 21:20);
+		s(EmcEmrs3, 31:30, scratch9, 23:22);
+		s(EmcWarmBootMrsExtra, 31:30, scratch9, 25:24);
+		s(EmcWarmBootMrsExtra, 21:20, scratch9, 27:26);
+		s(EmcZqCalDdr3WarmBoot, 31:30, scratch9, 29:28);
+		s(EmcMrs, 27:26, scratch10, 1:0);
+		s(EmcEmrs, 27:26, scratch10, 3:2);
+		s(EmcEmrs2, 27:26, scratch10, 5:4);
+		s(EmcEmrs3, 27:26, scratch10, 7:6);
+		s(EmcWarmBootMrsExtra, 27:27, scratch10, 8:8);
+		s(EmcWarmBootMrsExtra, 26:26, scratch10, 9:9);
+		s(EmcZqCalDdr3WarmBoot, 0:0, scratch10, 10:10);
+		s(EmcZqCalDdr3WarmBoot, 4:4, scratch10, 11:11);
+		break;
+	}
+
+	s32(EmcCmdMappingByte, secure_scratch8);
+	s32(EmcPmacroBrickMapping0, secure_scratch9);
+	s32(EmcPmacroBrickMapping1, secure_scratch10);
+	s32(EmcPmacroBrickMapping2, secure_scratch11);
+	s32(McVideoProtectGpuOverride0, secure_scratch12);
+	s(EmcCmdMappingCmd0_0, 6:0, secure_scratch13, 6:0);
+	s(EmcCmdMappingCmd0_0, 14:8, secure_scratch13, 13:7);
+	s(EmcCmdMappingCmd0_0, 22:16, secure_scratch13, 20:14);
+	s(EmcCmdMappingCmd0_0, 30:24, secure_scratch13, 27:21);
+	s(McVideoProtectBomAdrHi, 1:0, secure_scratch13, 29:28);
+	s(McVideoProtectWriteAccess, 1:0, secure_scratch13, 31:30);
+	s(EmcCmdMappingCmd0_1, 6:0, secure_scratch14, 6:0);
+	s(EmcCmdMappingCmd0_1, 14:8, secure_scratch14, 13:7);
+	s(EmcCmdMappingCmd0_1, 22:16, secure_scratch14, 20:14);
+	s(EmcCmdMappingCmd0_1, 30:24, secure_scratch14, 27:21);
+	s(McSecCarveoutAdrHi, 1:0, secure_scratch14, 29:28);
+	s(McMtsCarveoutAdrHi, 1:0, secure_scratch14, 31:30);
+	s(EmcCmdMappingCmd1_0, 6:0, secure_scratch15, 6:0);
+	s(EmcCmdMappingCmd1_0, 14:8, secure_scratch15, 13:7);
+	s(EmcCmdMappingCmd1_0, 22:16, secure_scratch15, 20:14);
+	s(EmcCmdMappingCmd1_0, 30:24, secure_scratch15, 27:21);
+	s(McGeneralizedCarveout5BomHi, 1:0, secure_scratch15, 29:28);
+	s(McGeneralizedCarveout3BomHi, 1:0, secure_scratch15, 31:30);
+	s(EmcCmdMappingCmd1_1, 6:0, secure_scratch16, 6:0);
+	s(EmcCmdMappingCmd1_1, 14:8, secure_scratch16, 13:7);
+	s(EmcCmdMappingCmd1_1, 22:16, secure_scratch16, 20:14);
+	s(EmcCmdMappingCmd1_1, 30:24, secure_scratch16, 27:21);
+	s(McGeneralizedCarveout2BomHi, 1:0, secure_scratch16, 29:28);
+	s(McGeneralizedCarveout4BomHi, 1:0, secure_scratch16, 31:30);
+	s(EmcCmdMappingCmd2_0, 6:0, secure_scratch17, 6:0);
+	s(EmcCmdMappingCmd2_0, 14:8, secure_scratch17, 13:7);
+	s(EmcCmdMappingCmd2_0, 22:16, secure_scratch17, 20:14);
+	s(EmcCmdMappingCmd2_0, 30:24, secure_scratch17, 27:21);
+	s(McGeneralizedCarveout1BomHi, 1:0, secure_scratch17, 29:28);
+	s(EmcAdrCfg, 0:0, secure_scratch17, 30:30);
+	s(EmcFbioSpare, 1:1, secure_scratch17, 31:31);
+	s(EmcCmdMappingCmd2_1, 6:0, secure_scratch18, 6:0);
+	s(EmcCmdMappingCmd2_1, 14:8, secure_scratch18, 13:7);
+	s(EmcCmdMappingCmd2_1, 22:16, secure_scratch18, 20:14);
+	s(EmcCmdMappingCmd2_1, 30:24, secure_scratch18, 27:21);
+	s(EmcFbioCfg8, 15:15, secure_scratch18, 28:28);
+	s(McEmemAdrCfg, 0:0, secure_scratch18, 29:29);
+	s(McSecCarveoutProtectWriteAccess, 0:0, secure_scratch18, 30:30);
+	s(McMtsCarveoutRegCtrl, 0:0, secure_scratch18, 31:31);
+	s(EmcCmdMappingCmd3_0, 6:0, secure_scratch19, 6:0);
+	s(EmcCmdMappingCmd3_0, 14:8, secure_scratch19, 13:7);
+	s(EmcCmdMappingCmd3_0, 22:16, secure_scratch19, 20:14);
+	s(EmcCmdMappingCmd3_0, 30:24, secure_scratch19, 27:21);
+	s(McGeneralizedCarveout2Cfg0, 6:3, secure_scratch19, 31:28);
+	s(EmcCmdMappingCmd3_1, 6:0, secure_scratch20, 6:0);
+	s(EmcCmdMappingCmd3_1, 14:8, secure_scratch20, 13:7);
+	s(EmcCmdMappingCmd3_1, 22:16, secure_scratch20, 20:14);
+	s(EmcCmdMappingCmd3_1, 30:24, secure_scratch20, 27:21);
+	s(McGeneralizedCarveout2Cfg0, 10:7, secure_scratch20, 31:28);
+	s(McGeneralizedCarveout4Cfg0, 26:0, secure_scratch39, 26:0);
+	s(McGeneralizedCarveout2Cfg0, 17:14, secure_scratch39, 30:27);
+	s(McVideoProtectVprOverride, 0:0, secure_scratch39, 31:31);
+	s(McGeneralizedCarveout5Cfg0, 26:0, secure_scratch40, 26:0);
+	s(McGeneralizedCarveout2Cfg0, 21:18, secure_scratch40, 30:27);
+	s(McVideoProtectVprOverride, 1:1, secure_scratch40, 31:31);
+	s(EmcCmdMappingCmd0_2, 6:0, secure_scratch41, 6:0);
+	s(EmcCmdMappingCmd0_2, 14:8, secure_scratch41, 13:7);
+	s(EmcCmdMappingCmd0_2, 22:16, secure_scratch41, 20:14);
+	s(EmcCmdMappingCmd0_2, 27:24, secure_scratch41, 24:21);
+	s(McGeneralizedCarveout1Cfg0, 6:3, secure_scratch41, 28:25);
+	s(McGeneralizedCarveout2Cfg0, 13:11, secure_scratch41, 31:29);
+	s(EmcCmdMappingCmd1_2, 6:0, secure_scratch42, 6:0);
+	s(EmcCmdMappingCmd1_2, 14:8, secure_scratch42, 13:7);
+	s(EmcCmdMappingCmd1_2, 22:16, secure_scratch42, 20:14);
+	s(EmcCmdMappingCmd1_2, 27:24, secure_scratch42, 24:21);
+	s(McGeneralizedCarveout1Cfg0, 13:7, secure_scratch42, 31:25);
+	s(EmcCmdMappingCmd2_2, 6:0, secure_scratch43, 6:0);
+	s(EmcCmdMappingCmd2_2, 14:8, secure_scratch43, 13:7);
+	s(EmcCmdMappingCmd2_2, 22:16, secure_scratch43, 20:14);
+	s(EmcCmdMappingCmd2_2, 27:24, secure_scratch43, 24:21);
+	s(McGeneralizedCarveout1Cfg0, 17:14, secure_scratch43, 28:25);
+	s(McGeneralizedCarveout3Cfg0, 13:11, secure_scratch43, 31:29);
+	s(EmcCmdMappingCmd3_2, 6:0, secure_scratch44, 6:0);
+	s(EmcCmdMappingCmd3_2, 14:8, secure_scratch44, 13:7);
+	s(EmcCmdMappingCmd3_2, 22:16, secure_scratch44, 20:14);
+	s(EmcCmdMappingCmd3_2, 27:24, secure_scratch44, 24:21);
+	s(McGeneralizedCarveout1Cfg0, 21:18, secure_scratch44, 28:25);
+	s(McVideoProtectVprOverride, 3:2, secure_scratch44, 30:29);
+	s(McVideoProtectVprOverride, 6:6, secure_scratch44, 31:31);
+	s(McEmemAdrCfgChannelMask, 31:9, secure_scratch45, 22:0);
+	s(McEmemAdrCfgDev0, 2:0, secure_scratch45, 25:23);
+	s(McEmemAdrCfgDev0, 9:8, secure_scratch45, 27:26);
+	s(McEmemAdrCfgDev0, 19:16, secure_scratch45, 31:28);
+	s(McEmemAdrCfgBankMask0, 31:10, secure_scratch46, 21:0);
+	s(McEmemAdrCfgDev1, 2:0, secure_scratch46, 24:22);
+	s(McEmemAdrCfgDev1, 9:8, secure_scratch46, 26:25);
+	s(McEmemAdrCfgDev1, 19:16, secure_scratch46, 30:27);
+	s(McVideoProtectVprOverride, 7:7, secure_scratch46, 31:31);
+	s(McEmemAdrCfgBankMask1, 31:10, secure_scratch47, 21:0);
+	s(McGeneralizedCarveout3Cfg0, 10:3, secure_scratch47, 29:22);
+	s(McVideoProtectVprOverride, 9:8, secure_scratch47, 31:30);
+	s(McEmemAdrCfgBankMask2, 31:10, secure_scratch48, 21:0);
+	s(McGeneralizedCarveout3Cfg0, 21:14, secure_scratch48, 29:22);
+	s(McVideoProtectVprOverride, 11:11, secure_scratch48, 30:30);
+	s(McVideoProtectVprOverride, 14:14, secure_scratch48, 31:31);
+	s(McVideoProtectGpuOverride1, 15:0, secure_scratch49, 15:0);
+	s(McEmemCfg, 13:0, secure_scratch49, 29:16);
+	s(McEmemCfg, 31:31, secure_scratch49, 30:30);
+	s(McVideoProtectVprOverride, 15:15, secure_scratch49, 31:31);
+	s(McGeneralizedCarveout3Bom, 31:17, secure_scratch50, 14:0);
+	s(McGeneralizedCarveout1Bom, 31:17, secure_scratch50, 29:15);
+	s(McVideoProtectVprOverride, 18:17, secure_scratch50, 31:30);
+	s(McGeneralizedCarveout4Bom, 31:17, secure_scratch51, 14:0);
+	s(McGeneralizedCarveout2Bom, 31:17, secure_scratch51, 29:15);
+	s(McVideoProtectVprOverride, 20:19, secure_scratch51, 31:30);
+	s(McGeneralizedCarveout5Bom, 31:17, secure_scratch52, 14:0);
+	s(McVideoProtectBom, 31:20, secure_scratch52, 26:15);
+	s(McVideoProtectVprOverride, 23:21, secure_scratch52, 29:27);
+	s(McVideoProtectVprOverride, 26:26, secure_scratch52, 30:30);
+	s(McVideoProtectVprOverride, 29:29, secure_scratch52, 31:31);
+	s(McVideoProtectSizeMb, 11:0, secure_scratch53, 11:0);
+	s(McSecCarveoutBom, 31:20, secure_scratch53, 23:12);
+	s(McVideoProtectVprOverride, 31:30, secure_scratch53, 25:24);
+	s(McVideoProtectVprOverride1, 1:0, secure_scratch53, 27:26);
+	s(McVideoProtectVprOverride1, 7:4, secure_scratch53, 31:28);
+	s(McSecCarveoutSizeMb, 11:0, secure_scratch54, 11:0);
+	s(McMtsCarveoutBom, 31:20, secure_scratch54, 23:12);
+	s(McVideoProtectVprOverride1, 15:8, secure_scratch54, 31:24);
+	s(McMtsCarveoutSizeMb, 11:0, secure_scratch55, 11:0);
+	s(McGeneralizedCarveout4Size128kb, 11:0, secure_scratch55, 23:12);
+	s(McVideoProtectVprOverride1, 16:16, secure_scratch55, 24:24);
+	s(McGeneralizedCarveout2Cfg0, 2:0, secure_scratch55, 27:25);
+	s(McGeneralizedCarveout2Cfg0, 25:22, secure_scratch55, 31:28);
+	s(McGeneralizedCarveout3Size128kb, 11:0, secure_scratch56, 11:0);
+	s(McGeneralizedCarveout2Size128kb, 11:0, secure_scratch56, 23:12);
+	s(McGeneralizedCarveout2Cfg0, 26:26, secure_scratch56, 24:24);
+	s(McGeneralizedCarveout1Cfg0, 2:0, secure_scratch56, 27:25);
+	s(McGeneralizedCarveout1Cfg0, 25:22, secure_scratch56, 31:28);
+	s(McGeneralizedCarveout1Size128kb, 11:0, secure_scratch57, 11:0);
+	s(McGeneralizedCarveout5Size128kb, 11:0, secure_scratch57, 23:12);
+	s(McGeneralizedCarveout1Cfg0, 26:26, secure_scratch57, 24:24);
+	s(McGeneralizedCarveout3Cfg0, 2:0, secure_scratch57, 27:25);
+	s(McGeneralizedCarveout3Cfg0, 25:22, secure_scratch57, 31:28);
+	s(McGeneralizedCarveout3Cfg0, 26:26, secure_scratch58, 0:0);
+
+	s32(McGeneralizedCarveout1Access0, secure_scratch59);
+	s32(McGeneralizedCarveout1Access1, secure_scratch60);
+	s32(McGeneralizedCarveout1Access2, secure_scratch61);
+	s32(McGeneralizedCarveout1Access3, secure_scratch62);
+	s32(McGeneralizedCarveout1Access4, secure_scratch63);
+	s32(McGeneralizedCarveout2Access0, secure_scratch64);
+	s32(McGeneralizedCarveout2Access1, secure_scratch65);
+	s32(McGeneralizedCarveout2Access2, secure_scratch66);
+	s32(McGeneralizedCarveout2Access3, secure_scratch67);
+	s32(McGeneralizedCarveout2Access4, secure_scratch68);
+	s32(McGeneralizedCarveout3Access0, secure_scratch69);
+	s32(McGeneralizedCarveout3Access1, secure_scratch70);
+	s32(McGeneralizedCarveout3Access2, secure_scratch71);
+	s32(McGeneralizedCarveout3Access3, secure_scratch72);
+	s32(McGeneralizedCarveout3Access4, secure_scratch73);
+	s32(McGeneralizedCarveout4Access0, secure_scratch74);
+	s32(McGeneralizedCarveout4Access1, secure_scratch75);
+	s32(McGeneralizedCarveout4Access2, secure_scratch76);
+	s32(McGeneralizedCarveout4Access3, secure_scratch77);
+	s32(McGeneralizedCarveout4Access4, secure_scratch78);
+	s32(McGeneralizedCarveout5Access0, secure_scratch79);
+	s32(McGeneralizedCarveout5Access1, secure_scratch80);
+	s32(McGeneralizedCarveout5Access2, secure_scratch81);
+	s32(McGeneralizedCarveout5Access3, secure_scratch82);
+	s32(McGeneralizedCarveout1ForceInternalAccess0, secure_scratch84);
+	s32(McGeneralizedCarveout1ForceInternalAccess1, secure_scratch85);
+	s32(McGeneralizedCarveout1ForceInternalAccess2, secure_scratch86);
+	s32(McGeneralizedCarveout1ForceInternalAccess3, secure_scratch87);
+	s32(McGeneralizedCarveout1ForceInternalAccess4, secure_scratch88);
+	s32(McGeneralizedCarveout2ForceInternalAccess0, secure_scratch89);
+	s32(McGeneralizedCarveout2ForceInternalAccess1, secure_scratch90);
+	s32(McGeneralizedCarveout2ForceInternalAccess2, secure_scratch91);
+	s32(McGeneralizedCarveout2ForceInternalAccess3, secure_scratch92);
+	s32(McGeneralizedCarveout2ForceInternalAccess4, secure_scratch93);
+	s32(McGeneralizedCarveout3ForceInternalAccess0, secure_scratch94);
+	s32(McGeneralizedCarveout3ForceInternalAccess1, secure_scratch95);
+	s32(McGeneralizedCarveout3ForceInternalAccess2, secure_scratch96);
+	s32(McGeneralizedCarveout3ForceInternalAccess3, secure_scratch97);
+	s32(McGeneralizedCarveout3ForceInternalAccess4, secure_scratch98);
+	s32(McGeneralizedCarveout4ForceInternalAccess0, secure_scratch99);
+	s32(McGeneralizedCarveout4ForceInternalAccess1, secure_scratch100);
+	s32(McGeneralizedCarveout4ForceInternalAccess2, secure_scratch101);
+	s32(McGeneralizedCarveout4ForceInternalAccess3, secure_scratch102);
+	s32(McGeneralizedCarveout4ForceInternalAccess4, secure_scratch103);
+	s32(McGeneralizedCarveout5ForceInternalAccess0, secure_scratch104);
+	s32(McGeneralizedCarveout5ForceInternalAccess1, secure_scratch105);
+	s32(McGeneralizedCarveout5ForceInternalAccess2, secure_scratch106);
+	s32(McGeneralizedCarveout5ForceInternalAccess3, secure_scratch107);
+
+	c32(0, scratch2);
+	s(PllMInputDivider, 7:0, scratch2, 7:0);
+	s(PllMFeedbackDivider, 7:0, scratch2, 15:8);
+	s(PllMPostDivider, 4:0, scratch2, 20:16);
+	s(PllMKVCO, 0:0, scratch2, 21:21);
+	s(PllMKCP, 1:0, scratch2, 23:22);
+
+	c32(0, scratch35);
+	s(PllMSetupControl, 15:0, scratch35, 15:0);
+
+	c32(0, scratch3);
+	s(PllMInputDivider, 7:0, scratch3, 7:0);
+	c(0x3e, scratch3, 15:8);
+	c(0, scratch3, 20:16);
+	s(PllMKVCO, 0:0, scratch3, 21:21);
+	s(PllMKCP, 1:0, scratch3, 23:22);
+
+	c32(0, scratch36);
+	s(PllMSetupControl, 23:0, scratch36, 23:0);
+
+	c32(0, scratch4);
+	s(PllMStableTime, 9:0, scratch4, 9:0);
+}
+
+void _modInit(void *sdram_config, bdkParams_t bp)
+{
+	sdram_lp0_save_params(sdram_config);
+}
diff --git a/modules/hekate_libsys_lp0/t210.h b/modules/hekate_libsys_lp0/t210.h
new file mode 100644
index 0000000..cb20e5e
--- /dev/null
+++ b/modules/hekate_libsys_lp0/t210.h
@@ -0,0 +1,110 @@
+/*
+* Copyright (c) 2018 naehrwert
+*
+* 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 _T210_H_
+#define _T210_H_
+
+#include "types.h"
+
+#define HOST1X_BASE 0x50000000
+#define DISPLAY_A_BASE 0x54200000
+#define DSI_BASE 0x54300000
+#define VIC_BASE 0x54340000
+#define TSEC_BASE 0x54500000
+#define SOR1_BASE 0x54580000
+#define TMR_BASE 0x60005000
+#define CLOCK_BASE 0x60006000
+#define FLOW_CTLR_BASE 0x60007000
+#define SYSREG_BASE 0x6000C000
+#define SB_BASE (SYSREG_BASE + 0x200)
+#define GPIO_BASE 0x6000D000
+#define GPIO_1_BASE (GPIO_BASE)
+#define GPIO_2_BASE (GPIO_BASE + 0x100)
+#define GPIO_3_BASE (GPIO_BASE + 0x200)
+#define GPIO_4_BASE (GPIO_BASE + 0x300)
+#define GPIO_5_BASE (GPIO_BASE + 0x400)
+#define GPIO_6_BASE (GPIO_BASE + 0x500)
+#define GPIO_7_BASE (GPIO_BASE + 0x600)
+#define GPIO_8_BASE (GPIO_BASE + 0x700)
+#define EXCP_VEC_BASE 0x6000F000
+#define APB_MISC_BASE 0x70000000
+#define PINMUX_AUX_BASE 0x70003000
+#define UART_BASE 0x70006000
+#define RTC_BASE 0x7000E000
+#define PMC_BASE 0x7000E400
+#define SYSCTR0_BASE 0x7000F000
+#define FUSE_BASE 0x7000F800
+#define KFUSE_BASE 0x7000FC00
+#define SE_BASE 0x70012000
+#define MC_BASE 0x70019000
+#define EMC_BASE 0x7001B000
+#define MIPI_CAL_BASE 0x700E3000
+#define I2S_BASE 0x702D1000
+
+#define _REG(base, off) *(vu32 *)((base) + (off))
+
+#define HOST1X(off) _REG(HOST1X_BASE, off)
+#define DISPLAY_A(off) _REG(DISPLAY_A_BASE, off)
+#define DSI(off) _REG(DSI_BASE, off)
+#define VIC(off) _REG(VIC_BASE, off)
+#define TSEC(off) _REG(TSEC_BASE, off)
+#define SOR1(off) _REG(SOR1_BASE, 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 SB(off) _REG(SB_BASE, off)
+#define GPIO(off) _REG(GPIO_BASE, off)
+#define GPIO_1(off) _REG(GPIO_1_BASE, off)
+#define GPIO_2(off) _REG(GPIO_2_BASE, off)
+#define GPIO_3(off) _REG(GPIO_3_BASE, off)
+#define GPIO_4(off) _REG(GPIO_4_BASE, off)
+#define GPIO_5(off) _REG(GPIO_5_BASE, off)
+#define GPIO_6(off) _REG(GPIO_6_BASE, off)
+#define GPIO_7(off) _REG(GPIO_7_BASE, off)
+#define GPIO_8(off) _REG(GPIO_8_BASE, off)
+#define EXCP_VEC(off) _REG(EXCP_VEC_BASE, off)
+#define APB_MISC(off) _REG(APB_MISC_BASE, off)
+#define PINMUX_AUX(off) _REG(PINMUX_AUX_BASE, off)
+#define RTC(off) _REG(RTC_BASE, off)
+#define PMC(off) _REG(PMC_BASE, off)
+#define SYSCTR0(off) _REG(SYSCTR0_BASE, off)
+#define FUSE(off) _REG(FUSE_BASE, off)
+#define KFUSE(off) _REG(KFUSE_BASE, off)
+#define SE(off) _REG(SE_BASE, off)
+#define MC(off) _REG(MC_BASE, off)
+#define EMC(off) _REG(EMC_BASE, off)
+#define MIPI_CAL(off) _REG(MIPI_CAL_BASE, off)
+#define I2S(off) _REG(I2S_BASE, off)
+
+/*! Misc registers. */
+#define APB_MISC_PP_PINMUX_GLOBAL 0x40
+#define APB_MISC_GP_WIFI_EN_CFGPADCTRL 0xB64
+#define APB_MISC_GP_WIFI_RST_CFGPADCTRL 0xB68
+
+/*! System registers. */
+#define AHB_ARBITRATION_XBAR_CTRL 0xE0
+#define AHB_AHB_SPARE_REG 0x110
+
+/*! Secure boot registers. */
+#define SB_CSR 0x0
+#define SB_AA64_RESET_LOW 0x30
+#define SB_AA64_RESET_HIGH 0x34
+
+/*! SYSCTR0 registers. */
+#define SYSCTR0_CNTFID0 0x20
+
+#endif
diff --git a/modules/hekate_libsys_lp0/types.h b/modules/hekate_libsys_lp0/types.h
new file mode 100644
index 0000000..9a4d414
--- /dev/null
+++ b/modules/hekate_libsys_lp0/types.h
@@ -0,0 +1,54 @@
+/*
+* Copyright (c) 2018 naehrwert
+*
+* 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 _TYPES_H_
+#define _TYPES_H_
+
+#define NULL ((void *)0)
+
+#define ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
+#define OFFSET_OF(t, m) ((u32)&((t *)NULL)->m)
+#define CONTAINER_OF(mp, t, mn) ((t *)((u32)mp - OFFSET_OF(t, mn)))
+
+typedef char s8;
+typedef short s16;
+typedef short SHORT;
+typedef int s32;
+typedef int INT;
+typedef long LONG;
+typedef long long int s64;
+typedef unsigned char u8;
+typedef unsigned char BYTE;
+typedef unsigned short u16;
+typedef unsigned short WORD;
+typedef unsigned short WCHAR;
+typedef unsigned int u32;
+typedef unsigned int UINT;
+typedef unsigned long DWORD;
+typedef unsigned long long QWORD;
+typedef unsigned long long int u64;
+typedef volatile unsigned char vu8;
+typedef volatile unsigned short vu16;
+typedef volatile unsigned int vu32;
+
+typedef int bool;
+#define true  1
+#define false 0
+
+#endif
diff --git a/modules/simple_sample/Makefile b/modules/simple_sample/Makefile
index 8ff56d6..a12130e 100644
--- a/modules/simple_sample/Makefile
+++ b/modules/simple_sample/Makefile
@@ -11,11 +11,12 @@ VPATH = $(dir $(wildcard ./*/)) $(dir $(wildcard ./*/*/))
 
 OBJS = $(addprefix $(BUILD)/,\
 	module_sample.o \
+	gfx.o \
 )
 
-ARCH := -march=armv4t -mtune=arm7tdmi -mthumb -mthumb-interwork
+ARCH := -march=armv4t -mtune=arm7tdmi -mthumb-interwork
 CFLAGS = $(ARCH) -O2 -nostdlib -fpie -ffunction-sections -fdata-sections -fomit-frame-pointer -fno-inline -std=gnu11 -Wall $(CUSTOMDEFINES)
-LDFLAGS = $(ARCH) -nostartfiles -lgcc -Wl,--nmagic,--gc-sections
+LDFLAGS = $(ARCH) -fpie -pie -nostartfiles -lgcc
 
 .PHONY: clean all
 
@@ -25,7 +26,8 @@ $(BUILD)/%.o: ./%.c
 	$(CC) $(CFLAGS) -c $< -o $@
 	
 $(TARGET).bso: $(OBJS)
-	$(CC) $(LDLAGS) -pie -e _modInit $^ -o $(OUTPUT)/$(TARGET).bso
+	$(CC) $(LDFLAGS) -e _modInit $^ -o $(OUTPUT)/$(TARGET).bso
+	$(STRIP) -g $(OUTPUT)/$(TARGET).bso
 
 clean:
 	@rm -rf $(OUTPUT)/$(TARGET).bso
diff --git a/modules/simple_sample/module_sample.c b/modules/simple_sample/module_sample.c
index 063ecff..51b3681 100644
--- a/modules/simple_sample/module_sample.c
+++ b/modules/simple_sample/module_sample.c
@@ -3,8 +3,10 @@
 */
 
 #include "../../common/common_module.h"
+#include "../../common/common_gfx.h"
+#include "gfx/gfx.h"
 
-void _modInit(cbMainModule_t cb, pmoduleConfiguration_t mc)
+void _modInit(void *moduleConfig, bdkParams_t bp)
 {
-	cb("Hello World!");
+	gfx_puts(bp->gfxCon, "Hello World!");
 }